1 /* Parse expressions for GDB.
2 Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 Modified from expread.y by the Department of Computer Science at the
5 State University of New York at Buffalo, 1991.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Parse an expression from text in a string,
25 and return the result as a struct expression pointer.
26 That structure contains arithmetic operations in reverse polish,
27 with constants represented by operations that are followed by special data.
28 See expression.h for the details of the format.
29 What is important here is that it can be built up sequentially
30 during the process of parsing; the lower levels of the tree always
31 come first in the result. */
36 #include "gdb_string.h"
40 #include "expression.h"
44 #include "parser-defs.h"
47 #include "symfile.h" /* for overlay functions */
48 #include "inferior.h" /* for NUM_PSEUDO_REGS. NOTE: replace
49 with "gdbarch.h" when appropriate. */
52 /* Symbols which architectures can redefine. */
54 /* Some systems have routines whose names start with `$'. Giving this
55 macro a non-zero value tells GDB's expression parser to check for
56 such routines when parsing tokens that begin with `$'.
58 On HP-UX, certain system routines (millicode) have names beginning
59 with `$' or `$$'. For example, `$$dyncall' is a millicode routine
60 that handles inter-space procedure calls on PA-RISC. */
61 #ifndef SYMBOLS_CAN_START_WITH_DOLLAR
62 #define SYMBOLS_CAN_START_WITH_DOLLAR (0)
67 /* Global variables declared in parser-defs.h (and commented there). */
68 struct expression *expout;
71 struct block *expression_context_block;
72 struct block *innermost_block;
74 union type_stack_elt *type_stack;
75 int type_stack_depth, type_stack_size;
81 static int expressiondebug = 0;
83 extern int hp_som_som_object_present;
85 static void free_funcalls (void *ignore);
87 static void prefixify_expression (struct expression *);
90 prefixify_subexp (struct expression *, struct expression *, int, int);
92 void _initialize_parse (void);
94 /* Data structure for saving values of arglist_len for function calls whose
95 arguments contain other function calls. */
103 static struct funcall *funcall_chain;
105 /* Assign machine-independent names to certain registers
106 (unless overridden by the REGISTER_NAMES table) */
108 unsigned num_std_regs = 0;
109 struct std_regs *std_regs;
111 /* The generic method for targets to specify how their registers are
112 named. The mapping can be derived from three sources:
113 REGISTER_NAME; std_regs; or a target specific alias hook. */
116 target_map_name_to_register (char *str, int len)
120 /* First try target specific aliases. We try these first because on some
121 systems standard names can be context dependent (eg. $pc on a
122 multiprocessor can be could be any of several PCs). */
123 #ifdef REGISTER_NAME_ALIAS_HOOK
124 i = REGISTER_NAME_ALIAS_HOOK (str, len);
129 /* Search architectural register name space. */
130 for (i = 0; i < NUM_REGS; i++)
131 if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
132 && STREQN (str, REGISTER_NAME (i), len))
137 /* Try pseudo-registers, if any. */
138 for (i = NUM_REGS; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
139 if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
140 && STREQN (str, REGISTER_NAME (i), len))
145 /* Try standard aliases. */
146 for (i = 0; i < num_std_regs; i++)
147 if (std_regs[i].name && len == strlen (std_regs[i].name)
148 && STREQN (str, std_regs[i].name, len))
150 return std_regs[i].regnum;
156 /* Begin counting arguments for a function call,
157 saving the data about any containing call. */
162 register struct funcall *new;
164 new = (struct funcall *) xmalloc (sizeof (struct funcall));
165 new->next = funcall_chain;
166 new->arglist_len = arglist_len;
171 /* Return the number of arguments in a function call just terminated,
172 and restore the data for the containing function call. */
177 register int val = arglist_len;
178 register struct funcall *call = funcall_chain;
179 funcall_chain = call->next;
180 arglist_len = call->arglist_len;
185 /* Free everything in the funcall chain.
186 Used when there is an error inside parsing. */
189 free_funcalls (void *ignore)
191 register struct funcall *call, *next;
193 for (call = funcall_chain; call; call = next)
200 /* This page contains the functions for adding data to the struct expression
201 being constructed. */
203 /* Add one element to the end of the expression. */
205 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
206 a register through here */
209 write_exp_elt (union exp_element expelt)
211 if (expout_ptr >= expout_size)
214 expout = (struct expression *)
215 xrealloc ((char *) expout, sizeof (struct expression)
216 + EXP_ELEM_TO_BYTES (expout_size));
218 expout->elts[expout_ptr++] = expelt;
222 write_exp_elt_opcode (enum exp_opcode expelt)
224 union exp_element tmp;
232 write_exp_elt_sym (struct symbol *expelt)
234 union exp_element tmp;
242 write_exp_elt_block (struct block *b)
244 union exp_element tmp;
250 write_exp_elt_longcst (LONGEST expelt)
252 union exp_element tmp;
254 tmp.longconst = expelt;
260 write_exp_elt_dblcst (DOUBLEST expelt)
262 union exp_element tmp;
264 tmp.doubleconst = expelt;
270 write_exp_elt_type (struct type *expelt)
272 union exp_element tmp;
280 write_exp_elt_intern (struct internalvar *expelt)
282 union exp_element tmp;
284 tmp.internalvar = expelt;
289 /* Add a string constant to the end of the expression.
291 String constants are stored by first writing an expression element
292 that contains the length of the string, then stuffing the string
293 constant itself into however many expression elements are needed
294 to hold it, and then writing another expression element that contains
295 the length of the string. I.E. an expression element at each end of
296 the string records the string length, so you can skip over the
297 expression elements containing the actual string bytes from either
298 end of the string. Note that this also allows gdb to handle
299 strings with embedded null bytes, as is required for some languages.
301 Don't be fooled by the fact that the string is null byte terminated,
302 this is strictly for the convenience of debugging gdb itself. Gdb
303 Gdb does not depend up the string being null terminated, since the
304 actual length is recorded in expression elements at each end of the
305 string. The null byte is taken into consideration when computing how
306 many expression elements are required to hold the string constant, of
311 write_exp_string (struct stoken str)
313 register int len = str.length;
315 register char *strdata;
317 /* Compute the number of expression elements required to hold the string
318 (including a null byte terminator), along with one expression element
319 at each end to record the actual string length (not including the
320 null byte terminator). */
322 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
324 /* Ensure that we have enough available expression elements to store
327 if ((expout_ptr + lenelt) >= expout_size)
329 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
330 expout = (struct expression *)
331 xrealloc ((char *) expout, (sizeof (struct expression)
332 + EXP_ELEM_TO_BYTES (expout_size)));
335 /* Write the leading length expression element (which advances the current
336 expression element index), then write the string constant followed by a
337 terminating null byte, and then write the trailing length expression
340 write_exp_elt_longcst ((LONGEST) len);
341 strdata = (char *) &expout->elts[expout_ptr];
342 memcpy (strdata, str.ptr, len);
343 *(strdata + len) = '\0';
344 expout_ptr += lenelt - 2;
345 write_exp_elt_longcst ((LONGEST) len);
348 /* Add a bitstring constant to the end of the expression.
350 Bitstring constants are stored by first writing an expression element
351 that contains the length of the bitstring (in bits), then stuffing the
352 bitstring constant itself into however many expression elements are
353 needed to hold it, and then writing another expression element that
354 contains the length of the bitstring. I.E. an expression element at
355 each end of the bitstring records the bitstring length, so you can skip
356 over the expression elements containing the actual bitstring bytes from
357 either end of the bitstring. */
360 write_exp_bitstring (struct stoken str)
362 register int bits = str.length; /* length in bits */
363 register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
365 register char *strdata;
367 /* Compute the number of expression elements required to hold the bitstring,
368 along with one expression element at each end to record the actual
369 bitstring length in bits. */
371 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
373 /* Ensure that we have enough available expression elements to store
376 if ((expout_ptr + lenelt) >= expout_size)
378 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
379 expout = (struct expression *)
380 xrealloc ((char *) expout, (sizeof (struct expression)
381 + EXP_ELEM_TO_BYTES (expout_size)));
384 /* Write the leading length expression element (which advances the current
385 expression element index), then write the bitstring constant, and then
386 write the trailing length expression element. */
388 write_exp_elt_longcst ((LONGEST) bits);
389 strdata = (char *) &expout->elts[expout_ptr];
390 memcpy (strdata, str.ptr, len);
391 expout_ptr += lenelt - 2;
392 write_exp_elt_longcst ((LONGEST) bits);
395 /* Add the appropriate elements for a minimal symbol to the end of
396 the expression. The rationale behind passing in text_symbol_type and
397 data_symbol_type was so that Modula-2 could pass in WORD for
398 data_symbol_type. Perhaps it still is useful to have those types vary
399 based on the language, but they no longer have names like "int", so
400 the initial rationale is gone. */
402 static struct type *msym_text_symbol_type;
403 static struct type *msym_data_symbol_type;
404 static struct type *msym_unknown_symbol_type;
407 write_exp_msymbol (struct minimal_symbol *msymbol,
408 struct type *text_symbol_type,
409 struct type *data_symbol_type)
413 write_exp_elt_opcode (OP_LONG);
414 /* Let's make the type big enough to hold a 64-bit address. */
415 write_exp_elt_type (builtin_type_CORE_ADDR);
417 addr = SYMBOL_VALUE_ADDRESS (msymbol);
418 if (overlay_debugging)
419 addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
420 write_exp_elt_longcst ((LONGEST) addr);
422 write_exp_elt_opcode (OP_LONG);
424 write_exp_elt_opcode (UNOP_MEMVAL);
425 switch (msymbol->type)
429 case mst_solib_trampoline:
430 write_exp_elt_type (msym_text_symbol_type);
437 write_exp_elt_type (msym_data_symbol_type);
441 write_exp_elt_type (msym_unknown_symbol_type);
444 write_exp_elt_opcode (UNOP_MEMVAL);
447 /* Recognize tokens that start with '$'. These include:
449 $regname A native register name or a "standard
452 $variable A convenience variable with a name chosen
455 $digits Value history with index <digits>, starting
456 from the first value which has index 1.
458 $$digits Value history with index <digits> relative
459 to the last value. I.E. $$0 is the last
460 value, $$1 is the one previous to that, $$2
461 is the one previous to $$1, etc.
463 $ | $0 | $$0 The last value in the value history.
465 $$ An abbreviation for the second to the last
466 value in the value history, I.E. $$1
471 write_dollar_variable (struct stoken str)
473 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
474 and $$digits (equivalent to $<-digits> if you could type that). */
478 /* Double dollar means negate the number and add -1 as well.
479 Thus $$ alone means -1. */
480 if (str.length >= 2 && str.ptr[1] == '$')
487 /* Just dollars (one or two) */
491 /* Is the rest of the token digits? */
492 for (; i < str.length; i++)
493 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
497 i = atoi (str.ptr + 1 + negate);
503 /* Handle tokens that refer to machine registers:
504 $ followed by a register name. */
505 i = target_map_name_to_register (str.ptr + 1, str.length - 1);
507 goto handle_register;
509 if (SYMBOLS_CAN_START_WITH_DOLLAR)
511 struct symbol *sym = NULL;
512 struct minimal_symbol *msym = NULL;
514 /* On HP-UX, certain system routines (millicode) have names beginning
515 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
516 calls on PA-RISC. Check for those, first. */
518 /* This code is not enabled on non HP-UX systems, since worst case
519 symbol table lookup performance is awful, to put it mildly. */
521 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
522 VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
525 write_exp_elt_opcode (OP_VAR_VALUE);
526 write_exp_elt_block (block_found); /* set by lookup_symbol */
527 write_exp_elt_sym (sym);
528 write_exp_elt_opcode (OP_VAR_VALUE);
531 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
534 write_exp_msymbol (msym,
535 lookup_function_type (builtin_type_int),
541 /* Any other names starting in $ are debugger internal variables. */
543 write_exp_elt_opcode (OP_INTERNALVAR);
544 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
545 write_exp_elt_opcode (OP_INTERNALVAR);
548 write_exp_elt_opcode (OP_LAST);
549 write_exp_elt_longcst ((LONGEST) i);
550 write_exp_elt_opcode (OP_LAST);
553 write_exp_elt_opcode (OP_REGISTER);
554 write_exp_elt_longcst (i);
555 write_exp_elt_opcode (OP_REGISTER);
560 /* Parse a string that is possibly a namespace / nested class
561 specification, i.e., something of the form A::B::C::x. Input
562 (NAME) is the entire string; LEN is the current valid length; the
563 output is a string, TOKEN, which points to the largest recognized
564 prefix which is a series of namespaces or classes. CLASS_PREFIX is
565 another output, which records whether a nested class spec was
566 recognized (= 1) or a fully qualified variable name was found (=
567 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
568 string recognized and consumed by this routine.
570 The return value is a pointer to the symbol for the base class or
571 variable if found, or NULL if not found. Callers must check this
572 first -- if NULL, the outputs may not be correct.
574 This function is used c-exp.y. This is used specifically to get
575 around HP aCC (and possibly other compilers), which insists on
576 generating names with embedded colons for namespace or nested class
579 (Argument LEN is currently unused. 1997-08-27)
581 Callers must free memory allocated for the output string TOKEN. */
583 static const char coloncolon[2] =
587 parse_nested_classes_for_hpacc (char *name, int len, char **token,
588 int *class_prefix, char **argptr)
590 /* Comment below comes from decode_line_1 which has very similar
591 code, which is called for "break" command parsing. */
593 /* We have what looks like a class or namespace
594 scope specification (A::B), possibly with many
595 levels of namespaces or classes (A::B::C::D).
597 Some versions of the HP ANSI C++ compiler (as also possibly
598 other compilers) generate class/function/member names with
599 embedded double-colons if they are inside namespaces. To
600 handle this, we loop a few times, considering larger and
601 larger prefixes of the string as though they were single
602 symbols. So, if the initially supplied string is
603 A::B::C::D::foo, we have to look up "A", then "A::B",
604 then "A::B::C", then "A::B::C::D", and finally
605 "A::B::C::D::foo" as single, monolithic symbols, because
606 A, B, C or D may be namespaces.
608 Note that namespaces can nest only inside other
609 namespaces, and not inside classes. So we need only
610 consider *prefixes* of the string; there is no need to look up
611 "B::C" separately as a symbol in the previous example. */
617 struct symbol *sym_class = NULL;
618 struct symbol *sym_var = NULL;
624 /* Check for HP-compiled executable -- in other cases
625 return NULL, and caller must default to standard GDB
628 if (!hp_som_som_object_present)
629 return (struct symbol *) NULL;
633 /* Skip over whitespace and possible global "::" */
634 while (*p && (*p == ' ' || *p == '\t'))
636 if (p[0] == ':' && p[1] == ':')
638 while (*p && (*p == ' ' || *p == '\t'))
643 /* Get to the end of the next namespace or class spec. */
644 /* If we're looking at some non-token, fail immediately */
646 if (!(isalpha (*p) || *p == '$' || *p == '_'))
647 return (struct symbol *) NULL;
649 while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
654 /* If we have the start of a template specification,
655 scan right ahead to its end */
656 q = find_template_name_end (p);
663 /* Skip over "::" and whitespace for next time around */
664 while (*p && (*p == ' ' || *p == '\t'))
666 if (p[0] == ':' && p[1] == ':')
668 while (*p && (*p == ' ' || *p == '\t'))
671 /* Done with tokens? */
672 if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
675 tmp = (char *) alloca (prefix_len + end - start + 3);
678 memcpy (tmp, prefix, prefix_len);
679 memcpy (tmp + prefix_len, coloncolon, 2);
680 memcpy (tmp + prefix_len + 2, start, end - start);
681 tmp[prefix_len + 2 + end - start] = '\000';
685 memcpy (tmp, start, end - start);
686 tmp[end - start] = '\000';
690 prefix_len = strlen (prefix);
692 /* See if the prefix we have now is something we know about */
696 /* More tokens to process, so this must be a class/namespace */
697 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
698 0, (struct symtab **) NULL);
702 /* No more tokens, so try as a variable first */
703 sym_var = lookup_symbol (prefix, 0, VAR_NAMESPACE,
704 0, (struct symtab **) NULL);
705 /* If failed, try as class/namespace */
707 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
708 0, (struct symtab **) NULL);
713 (t = check_typedef (SYMBOL_TYPE (sym_class)),
714 (TYPE_CODE (t) == TYPE_CODE_STRUCT
715 || TYPE_CODE (t) == TYPE_CODE_UNION))))
717 /* We found a valid token */
718 *token = (char *) xmalloc (prefix_len + 1);
719 memcpy (*token, prefix, prefix_len);
720 (*token)[prefix_len] = '\000';
724 /* No variable or class/namespace found, no more tokens */
726 return (struct symbol *) NULL;
729 /* Out of loop, so we must have found a valid token */
736 *argptr = done ? p : end;
738 return sym_var ? sym_var : sym_class; /* found */
742 find_template_name_end (char *p)
745 int just_seen_right = 0;
746 int just_seen_colon = 0;
747 int just_seen_space = 0;
749 if (!p || (*p != '<'))
760 /* In future, may want to allow these?? */
763 depth++; /* start nested template */
764 if (just_seen_colon || just_seen_right || just_seen_space)
765 return 0; /* but not after : or :: or > or space */
768 if (just_seen_colon || just_seen_right)
769 return 0; /* end a (nested?) template */
770 just_seen_right = 1; /* but not after : or :: */
771 if (--depth == 0) /* also disallow >>, insist on > > */
772 return ++p; /* if outermost ended, return */
775 if (just_seen_space || (just_seen_colon > 1))
776 return 0; /* nested class spec coming up */
777 just_seen_colon++; /* we allow :: but not :::: */
782 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
783 (*p >= 'A' && *p <= 'Z') ||
784 (*p >= '0' && *p <= '9') ||
785 (*p == '_') || (*p == ',') || /* commas for template args */
786 (*p == '&') || (*p == '*') || /* pointer and ref types */
787 (*p == '(') || (*p == ')') || /* function types */
788 (*p == '[') || (*p == ']'))) /* array types */
803 /* Return a null-terminated temporary copy of the name
804 of a string token. */
807 copy_name (struct stoken token)
809 memcpy (namecopy, token.ptr, token.length);
810 namecopy[token.length] = 0;
814 /* Reverse an expression from suffix form (in which it is constructed)
815 to prefix form (in which we can conveniently print or execute it). */
818 prefixify_expression (register struct expression *expr)
821 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
822 register struct expression *temp;
823 register int inpos = expr->nelts, outpos = 0;
825 temp = (struct expression *) alloca (len);
827 /* Copy the original expression into temp. */
828 memcpy (temp, expr, len);
830 prefixify_subexp (temp, expr, inpos, outpos);
833 /* Return the number of exp_elements in the subexpression of EXPR
834 whose last exp_element is at index ENDPOS - 1 in EXPR. */
837 length_of_subexp (register struct expression *expr, register int endpos)
839 register int oplen = 1;
840 register int args = 0;
844 error ("?error in length_of_subexp");
846 i = (int) expr->elts[endpos - 1].opcode;
852 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
853 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
876 case OP_F77_UNDETERMINED_ARGLIST:
878 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
906 case STRUCTOP_STRUCT:
914 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
915 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
919 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
920 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
921 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
926 args = longest_to_int (expr->elts[endpos - 2].longconst);
927 args -= longest_to_int (expr->elts[endpos - 3].longconst);
933 case TERNOP_SLICE_COUNT:
938 case MULTI_SUBSCRIPT:
940 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
943 case BINOP_ASSIGN_MODIFY:
954 args = 1 + (i < (int) BINOP_END);
959 oplen += length_of_subexp (expr, endpos - oplen);
966 /* Copy the subexpression ending just before index INEND in INEXPR
967 into OUTEXPR, starting at index OUTBEG.
968 In the process, convert it from suffix to prefix form. */
971 prefixify_subexp (register struct expression *inexpr,
972 struct expression *outexpr, register int inend, int outbeg)
974 register int oplen = 1;
975 register int args = 0;
978 enum exp_opcode opcode;
980 /* Compute how long the last operation is (in OPLEN),
981 and also how many preceding subexpressions serve as
982 arguments for it (in ARGS). */
984 opcode = inexpr->elts[inend - 1].opcode;
989 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
990 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
1003 case OP_INTERNALVAR:
1013 case OP_F77_UNDETERMINED_ARGLIST:
1015 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1041 case STRUCTOP_STRUCT:
1050 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1051 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
1055 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1056 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
1057 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
1062 args = longest_to_int (inexpr->elts[inend - 2].longconst);
1063 args -= longest_to_int (inexpr->elts[inend - 3].longconst);
1069 case TERNOP_SLICE_COUNT:
1073 case BINOP_ASSIGN_MODIFY:
1079 case MULTI_SUBSCRIPT:
1081 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1090 args = 1 + ((int) opcode < (int) BINOP_END);
1093 /* Copy the final operator itself, from the end of the input
1094 to the beginning of the output. */
1096 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1097 EXP_ELEM_TO_BYTES (oplen));
1100 /* Find the lengths of the arg subexpressions. */
1101 arglens = (int *) alloca (args * sizeof (int));
1102 for (i = args - 1; i >= 0; i--)
1104 oplen = length_of_subexp (inexpr, inend);
1109 /* Now copy each subexpression, preserving the order of
1110 the subexpressions, but prefixifying each one.
1111 In this loop, inend starts at the beginning of
1112 the expression this level is working on
1113 and marches forward over the arguments.
1114 outbeg does similarly in the output. */
1115 for (i = 0; i < args; i++)
1119 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1124 /* This page contains the two entry points to this file. */
1126 /* Read an expression from the string *STRINGPTR points to,
1127 parse it, and return a pointer to a struct expression that we malloc.
1128 Use block BLOCK as the lexical context for variable names;
1129 if BLOCK is zero, use the block of the selected stack frame.
1130 Meanwhile, advance *STRINGPTR to point after the expression,
1131 at the first nonwhite character that is not part of the expression
1132 (possibly a null character).
1134 If COMMA is nonzero, stop if a comma is reached. */
1137 parse_exp_1 (char **stringptr, struct block *block, int comma)
1139 struct cleanup *old_chain;
1141 lexptr = *stringptr;
1144 type_stack_depth = 0;
1146 comma_terminates = comma;
1148 if (lexptr == 0 || *lexptr == 0)
1149 error_no_arg ("expression to compute");
1151 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1154 expression_context_block = block ? block : get_selected_block ();
1156 namecopy = (char *) alloca (strlen (lexptr) + 1);
1159 expout = (struct expression *)
1160 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1161 expout->language_defn = current_language;
1162 make_cleanup (free_current_contents, &expout);
1164 if (current_language->la_parser ())
1165 current_language->la_error (NULL);
1167 discard_cleanups (old_chain);
1169 /* Record the actual number of expression elements, and then
1170 reallocate the expression memory so that we free up any
1173 expout->nelts = expout_ptr;
1174 expout = (struct expression *)
1175 xrealloc ((char *) expout,
1176 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1178 /* Convert expression from postfix form as generated by yacc
1179 parser, to a prefix form. */
1181 if (expressiondebug)
1182 dump_prefix_expression (expout, gdb_stdlog,
1183 "before conversion to prefix form");
1185 prefixify_expression (expout);
1187 if (expressiondebug)
1188 dump_postfix_expression (expout, gdb_stdlog,
1189 "after conversion to prefix form");
1191 *stringptr = lexptr;
1195 /* Parse STRING as an expression, and complain if this fails
1196 to use up all of the contents of STRING. */
1199 parse_expression (char *string)
1201 register struct expression *exp;
1202 exp = parse_exp_1 (&string, 0, 0);
1204 error ("Junk after end of expression.");
1208 /* Stuff for maintaining a stack of types. Currently just used by C, but
1209 probably useful for any language which declares its types "backwards". */
1212 push_type (enum type_pieces tp)
1214 if (type_stack_depth == type_stack_size)
1216 type_stack_size *= 2;
1217 type_stack = (union type_stack_elt *)
1218 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1220 type_stack[type_stack_depth++].piece = tp;
1224 push_type_int (int n)
1226 if (type_stack_depth == type_stack_size)
1228 type_stack_size *= 2;
1229 type_stack = (union type_stack_elt *)
1230 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1232 type_stack[type_stack_depth++].int_val = n;
1238 if (type_stack_depth)
1239 return type_stack[--type_stack_depth].piece;
1246 if (type_stack_depth)
1247 return type_stack[--type_stack_depth].int_val;
1248 /* "Can't happen". */
1252 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1253 as modified by all the stuff on the stack. */
1255 follow_types (struct type *follow_type)
1259 struct type *range_type;
1262 switch (pop_type ())
1268 follow_type = lookup_pointer_type (follow_type);
1271 follow_type = lookup_reference_type (follow_type);
1274 array_size = pop_type_int ();
1275 /* FIXME-type-allocation: need a way to free this type when we are
1278 create_range_type ((struct type *) NULL,
1279 builtin_type_int, 0,
1280 array_size >= 0 ? array_size - 1 : 0);
1282 create_array_type ((struct type *) NULL,
1283 follow_type, range_type);
1285 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1286 = BOUND_CANNOT_BE_DETERMINED;
1289 /* FIXME-type-allocation: need a way to free this type when we are
1291 follow_type = lookup_function_type (follow_type);
1297 static void build_parse (void);
1303 msym_text_symbol_type =
1304 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1305 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1306 msym_data_symbol_type =
1307 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1308 "<data variable, no debug info>", NULL);
1309 msym_unknown_symbol_type =
1310 init_type (TYPE_CODE_INT, 1, 0,
1311 "<variable (not text or data), no debug info>",
1314 /* create the std_regs table */
1333 /* create an empty table */
1334 std_regs = xmalloc ((num_std_regs + 1) * sizeof *std_regs);
1340 std_regs[i].name = "pc";
1341 std_regs[i].regnum = PC_REGNUM;
1348 std_regs[i].name = "fp";
1349 std_regs[i].regnum = FP_REGNUM;
1356 std_regs[i].name = "sp";
1357 std_regs[i].regnum = SP_REGNUM;
1364 std_regs[i].name = "ps";
1365 std_regs[i].regnum = PS_REGNUM;
1369 memset (&std_regs[i], 0, sizeof (std_regs[i]));
1373 _initialize_parse (void)
1375 type_stack_size = 80;
1376 type_stack_depth = 0;
1377 type_stack = (union type_stack_elt *)
1378 xmalloc (type_stack_size * sizeof (*type_stack));
1382 /* FIXME - For the moment, handle types by swapping them in and out.
1383 Should be using the per-architecture data-pointer and a large
1385 register_gdbarch_swap (&msym_text_symbol_type, sizeof (msym_text_symbol_type), NULL);
1386 register_gdbarch_swap (&msym_data_symbol_type, sizeof (msym_data_symbol_type), NULL);
1387 register_gdbarch_swap (&msym_unknown_symbol_type, sizeof (msym_unknown_symbol_type), NULL);
1389 register_gdbarch_swap (&num_std_regs, sizeof (std_regs), NULL);
1390 register_gdbarch_swap (&std_regs, sizeof (std_regs), NULL);
1391 register_gdbarch_swap (NULL, 0, build_parse);
1394 add_set_cmd ("expression", class_maintenance, var_zinteger,
1395 (char *) &expressiondebug,
1396 "Set expression debugging.\n\
1397 When non-zero, the internal representation of expressions will be printed.",