1 /* Parse expressions for GDB.
2 Copyright (C) 1986, 89, 90, 91, 94, 98, 1999 Free Software Foundation, Inc.
3 Modified from expread.y by the Department of Computer Science at the
4 State University of New York at Buffalo, 1991.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Parse an expression from text in a string,
24 and return the result as a struct expression pointer.
25 That structure contains arithmetic operations in reverse polish,
26 with constants represented by operations that are followed by special data.
27 See expression.h for the details of the format.
28 What is important here is that it can be built up sequentially
29 during the process of parsing; the lower levels of the tree always
30 come first in the result. */
35 #include "gdb_string.h"
39 #include "expression.h"
43 #include "parser-defs.h"
45 #include "symfile.h" /* for overlay functions */
46 #include "inferior.h" /* for NUM_PSEUDO_REGS. NOTE: replace
47 with "gdbarch.h" when appropriate. */
50 /* Symbols which architectures can redefine. */
52 /* Some systems have routines whose names start with `$'. Giving this
53 macro a non-zero value tells GDB's expression parser to check for
54 such routines when parsing tokens that begin with `$'.
56 On HP-UX, certain system routines (millicode) have names beginning
57 with `$' or `$$'. For example, `$$dyncall' is a millicode routine
58 that handles inter-space procedure calls on PA-RISC. */
59 #ifndef SYMBOLS_CAN_START_WITH_DOLLAR
60 #define SYMBOLS_CAN_START_WITH_DOLLAR (0)
65 /* Global variables declared in parser-defs.h (and commented there). */
66 struct expression *expout;
69 struct block *expression_context_block;
70 struct block *innermost_block;
72 union type_stack_elt *type_stack;
73 int type_stack_depth, type_stack_size;
79 static int expressiondebug = 0;
81 extern int hp_som_som_object_present;
83 static void free_funcalls (void *ignore);
85 static void prefixify_expression (struct expression *);
88 prefixify_subexp (struct expression *, struct expression *, int, int);
90 void _initialize_parse (void);
92 /* Data structure for saving values of arglist_len for function calls whose
93 arguments contain other function calls. */
101 static struct funcall *funcall_chain;
103 /* Assign machine-independent names to certain registers
104 (unless overridden by the REGISTER_NAMES table) */
106 unsigned num_std_regs = 0;
107 struct std_regs *std_regs;
109 /* The generic method for targets to specify how their registers are
110 named. The mapping can be derived from three sources:
111 REGISTER_NAME; std_regs; or a target specific alias hook. */
114 target_map_name_to_register (char *str, int len)
118 /* First try target specific aliases. We try these first because on some
119 systems standard names can be context dependent (eg. $pc on a
120 multiprocessor can be could be any of several PCs). */
121 #ifdef REGISTER_NAME_ALIAS_HOOK
122 i = REGISTER_NAME_ALIAS_HOOK (str, len);
127 /* Search architectural register name space. */
128 for (i = 0; i < NUM_REGS; i++)
129 if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
130 && STREQN (str, REGISTER_NAME (i), len))
135 /* Try pseudo-registers, if any. */
136 for (i = NUM_REGS; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
137 if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
138 && STREQN (str, REGISTER_NAME (i), len))
143 /* Try standard aliases. */
144 for (i = 0; i < num_std_regs; i++)
145 if (std_regs[i].name && len == strlen (std_regs[i].name)
146 && STREQN (str, std_regs[i].name, len))
148 return std_regs[i].regnum;
154 /* Begin counting arguments for a function call,
155 saving the data about any containing call. */
160 register struct funcall *new;
162 new = (struct funcall *) xmalloc (sizeof (struct funcall));
163 new->next = funcall_chain;
164 new->arglist_len = arglist_len;
169 /* Return the number of arguments in a function call just terminated,
170 and restore the data for the containing function call. */
175 register int val = arglist_len;
176 register struct funcall *call = funcall_chain;
177 funcall_chain = call->next;
178 arglist_len = call->arglist_len;
183 /* Free everything in the funcall chain.
184 Used when there is an error inside parsing. */
187 free_funcalls (void *ignore)
189 register struct funcall *call, *next;
191 for (call = funcall_chain; call; call = next)
198 /* This page contains the functions for adding data to the struct expression
199 being constructed. */
201 /* Add one element to the end of the expression. */
203 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
204 a register through here */
207 write_exp_elt (union exp_element expelt)
209 if (expout_ptr >= expout_size)
212 expout = (struct expression *)
213 xrealloc ((char *) expout, sizeof (struct expression)
214 + EXP_ELEM_TO_BYTES (expout_size));
216 expout->elts[expout_ptr++] = expelt;
220 write_exp_elt_opcode (enum exp_opcode expelt)
222 union exp_element tmp;
230 write_exp_elt_sym (struct symbol *expelt)
232 union exp_element tmp;
240 write_exp_elt_block (struct block *b)
242 union exp_element tmp;
248 write_exp_elt_longcst (LONGEST expelt)
250 union exp_element tmp;
252 tmp.longconst = expelt;
258 write_exp_elt_dblcst (DOUBLEST expelt)
260 union exp_element tmp;
262 tmp.doubleconst = expelt;
268 write_exp_elt_type (struct type *expelt)
270 union exp_element tmp;
278 write_exp_elt_intern (struct internalvar *expelt)
280 union exp_element tmp;
282 tmp.internalvar = expelt;
287 /* Add a string constant to the end of the expression.
289 String constants are stored by first writing an expression element
290 that contains the length of the string, then stuffing the string
291 constant itself into however many expression elements are needed
292 to hold it, and then writing another expression element that contains
293 the length of the string. I.E. an expression element at each end of
294 the string records the string length, so you can skip over the
295 expression elements containing the actual string bytes from either
296 end of the string. Note that this also allows gdb to handle
297 strings with embedded null bytes, as is required for some languages.
299 Don't be fooled by the fact that the string is null byte terminated,
300 this is strictly for the convenience of debugging gdb itself. Gdb
301 Gdb does not depend up the string being null terminated, since the
302 actual length is recorded in expression elements at each end of the
303 string. The null byte is taken into consideration when computing how
304 many expression elements are required to hold the string constant, of
309 write_exp_string (struct stoken str)
311 register int len = str.length;
313 register char *strdata;
315 /* Compute the number of expression elements required to hold the string
316 (including a null byte terminator), along with one expression element
317 at each end to record the actual string length (not including the
318 null byte terminator). */
320 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
322 /* Ensure that we have enough available expression elements to store
325 if ((expout_ptr + lenelt) >= expout_size)
327 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
328 expout = (struct expression *)
329 xrealloc ((char *) expout, (sizeof (struct expression)
330 + EXP_ELEM_TO_BYTES (expout_size)));
333 /* Write the leading length expression element (which advances the current
334 expression element index), then write the string constant followed by a
335 terminating null byte, and then write the trailing length expression
338 write_exp_elt_longcst ((LONGEST) len);
339 strdata = (char *) &expout->elts[expout_ptr];
340 memcpy (strdata, str.ptr, len);
341 *(strdata + len) = '\0';
342 expout_ptr += lenelt - 2;
343 write_exp_elt_longcst ((LONGEST) len);
346 /* Add a bitstring constant to the end of the expression.
348 Bitstring constants are stored by first writing an expression element
349 that contains the length of the bitstring (in bits), then stuffing the
350 bitstring constant itself into however many expression elements are
351 needed to hold it, and then writing another expression element that
352 contains the length of the bitstring. I.E. an expression element at
353 each end of the bitstring records the bitstring length, so you can skip
354 over the expression elements containing the actual bitstring bytes from
355 either end of the bitstring. */
358 write_exp_bitstring (struct stoken str)
360 register int bits = str.length; /* length in bits */
361 register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
363 register char *strdata;
365 /* Compute the number of expression elements required to hold the bitstring,
366 along with one expression element at each end to record the actual
367 bitstring length in bits. */
369 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
371 /* Ensure that we have enough available expression elements to store
374 if ((expout_ptr + lenelt) >= expout_size)
376 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
377 expout = (struct expression *)
378 xrealloc ((char *) expout, (sizeof (struct expression)
379 + EXP_ELEM_TO_BYTES (expout_size)));
382 /* Write the leading length expression element (which advances the current
383 expression element index), then write the bitstring constant, and then
384 write the trailing length expression element. */
386 write_exp_elt_longcst ((LONGEST) bits);
387 strdata = (char *) &expout->elts[expout_ptr];
388 memcpy (strdata, str.ptr, len);
389 expout_ptr += lenelt - 2;
390 write_exp_elt_longcst ((LONGEST) bits);
393 /* Add the appropriate elements for a minimal symbol to the end of
394 the expression. The rationale behind passing in text_symbol_type and
395 data_symbol_type was so that Modula-2 could pass in WORD for
396 data_symbol_type. Perhaps it still is useful to have those types vary
397 based on the language, but they no longer have names like "int", so
398 the initial rationale is gone. */
400 static struct type *msym_text_symbol_type;
401 static struct type *msym_data_symbol_type;
402 static struct type *msym_unknown_symbol_type;
405 write_exp_msymbol (struct minimal_symbol *msymbol,
406 struct type *text_symbol_type, struct type *data_symbol_type)
410 write_exp_elt_opcode (OP_LONG);
411 write_exp_elt_type (lookup_pointer_type (builtin_type_void));
413 addr = SYMBOL_VALUE_ADDRESS (msymbol);
414 if (overlay_debugging)
415 addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
416 write_exp_elt_longcst ((LONGEST) addr);
418 write_exp_elt_opcode (OP_LONG);
420 write_exp_elt_opcode (UNOP_MEMVAL);
421 switch (msymbol->type)
425 case mst_solib_trampoline:
426 write_exp_elt_type (msym_text_symbol_type);
433 write_exp_elt_type (msym_data_symbol_type);
437 write_exp_elt_type (msym_unknown_symbol_type);
440 write_exp_elt_opcode (UNOP_MEMVAL);
443 /* Recognize tokens that start with '$'. These include:
445 $regname A native register name or a "standard
448 $variable A convenience variable with a name chosen
451 $digits Value history with index <digits>, starting
452 from the first value which has index 1.
454 $$digits Value history with index <digits> relative
455 to the last value. I.E. $$0 is the last
456 value, $$1 is the one previous to that, $$2
457 is the one previous to $$1, etc.
459 $ | $0 | $$0 The last value in the value history.
461 $$ An abbreviation for the second to the last
462 value in the value history, I.E. $$1
467 write_dollar_variable (struct stoken str)
469 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
470 and $$digits (equivalent to $<-digits> if you could type that). */
474 /* Double dollar means negate the number and add -1 as well.
475 Thus $$ alone means -1. */
476 if (str.length >= 2 && str.ptr[1] == '$')
483 /* Just dollars (one or two) */
487 /* Is the rest of the token digits? */
488 for (; i < str.length; i++)
489 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
493 i = atoi (str.ptr + 1 + negate);
499 /* Handle tokens that refer to machine registers:
500 $ followed by a register name. */
501 i = target_map_name_to_register (str.ptr + 1, str.length - 1);
503 goto handle_register;
505 if (SYMBOLS_CAN_START_WITH_DOLLAR)
507 struct symbol *sym = NULL;
508 struct minimal_symbol *msym = NULL;
510 /* On HP-UX, certain system routines (millicode) have names beginning
511 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
512 calls on PA-RISC. Check for those, first. */
514 /* This code is not enabled on non HP-UX systems, since worst case
515 symbol table lookup performance is awful, to put it mildly. */
517 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
518 VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
521 write_exp_elt_opcode (OP_VAR_VALUE);
522 write_exp_elt_block (block_found); /* set by lookup_symbol */
523 write_exp_elt_sym (sym);
524 write_exp_elt_opcode (OP_VAR_VALUE);
527 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
530 write_exp_msymbol (msym,
531 lookup_function_type (builtin_type_int),
537 /* Any other names starting in $ are debugger internal variables. */
539 write_exp_elt_opcode (OP_INTERNALVAR);
540 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
541 write_exp_elt_opcode (OP_INTERNALVAR);
544 write_exp_elt_opcode (OP_LAST);
545 write_exp_elt_longcst ((LONGEST) i);
546 write_exp_elt_opcode (OP_LAST);
549 write_exp_elt_opcode (OP_REGISTER);
550 write_exp_elt_longcst (i);
551 write_exp_elt_opcode (OP_REGISTER);
556 /* Parse a string that is possibly a namespace / nested class
557 specification, i.e., something of the form A::B::C::x. Input
558 (NAME) is the entire string; LEN is the current valid length; the
559 output is a string, TOKEN, which points to the largest recognized
560 prefix which is a series of namespaces or classes. CLASS_PREFIX is
561 another output, which records whether a nested class spec was
562 recognized (= 1) or a fully qualified variable name was found (=
563 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
564 string recognized and consumed by this routine.
566 The return value is a pointer to the symbol for the base class or
567 variable if found, or NULL if not found. Callers must check this
568 first -- if NULL, the outputs may not be correct.
570 This function is used c-exp.y. This is used specifically to get
571 around HP aCC (and possibly other compilers), which insists on
572 generating names with embedded colons for namespace or nested class
575 (Argument LEN is currently unused. 1997-08-27)
577 Callers must free memory allocated for the output string TOKEN. */
579 static const char coloncolon[2] =
583 parse_nested_classes_for_hpacc (char *name, int len, char **token,
584 int *class_prefix, char **argptr)
586 /* Comment below comes from decode_line_1 which has very similar
587 code, which is called for "break" command parsing. */
589 /* We have what looks like a class or namespace
590 scope specification (A::B), possibly with many
591 levels of namespaces or classes (A::B::C::D).
593 Some versions of the HP ANSI C++ compiler (as also possibly
594 other compilers) generate class/function/member names with
595 embedded double-colons if they are inside namespaces. To
596 handle this, we loop a few times, considering larger and
597 larger prefixes of the string as though they were single
598 symbols. So, if the initially supplied string is
599 A::B::C::D::foo, we have to look up "A", then "A::B",
600 then "A::B::C", then "A::B::C::D", and finally
601 "A::B::C::D::foo" as single, monolithic symbols, because
602 A, B, C or D may be namespaces.
604 Note that namespaces can nest only inside other
605 namespaces, and not inside classes. So we need only
606 consider *prefixes* of the string; there is no need to look up
607 "B::C" separately as a symbol in the previous example. */
613 struct symbol *sym_class = NULL;
614 struct symbol *sym_var = NULL;
620 /* Check for HP-compiled executable -- in other cases
621 return NULL, and caller must default to standard GDB
624 if (!hp_som_som_object_present)
625 return (struct symbol *) NULL;
629 /* Skip over whitespace and possible global "::" */
630 while (*p && (*p == ' ' || *p == '\t'))
632 if (p[0] == ':' && p[1] == ':')
634 while (*p && (*p == ' ' || *p == '\t'))
639 /* Get to the end of the next namespace or class spec. */
640 /* If we're looking at some non-token, fail immediately */
642 if (!(isalpha (*p) || *p == '$' || *p == '_'))
643 return (struct symbol *) NULL;
645 while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
650 /* If we have the start of a template specification,
651 scan right ahead to its end */
652 q = find_template_name_end (p);
659 /* Skip over "::" and whitespace for next time around */
660 while (*p && (*p == ' ' || *p == '\t'))
662 if (p[0] == ':' && p[1] == ':')
664 while (*p && (*p == ' ' || *p == '\t'))
667 /* Done with tokens? */
668 if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
671 tmp = (char *) alloca (prefix_len + end - start + 3);
674 memcpy (tmp, prefix, prefix_len);
675 memcpy (tmp + prefix_len, coloncolon, 2);
676 memcpy (tmp + prefix_len + 2, start, end - start);
677 tmp[prefix_len + 2 + end - start] = '\000';
681 memcpy (tmp, start, end - start);
682 tmp[end - start] = '\000';
686 prefix_len = strlen (prefix);
688 /* See if the prefix we have now is something we know about */
692 /* More tokens to process, so this must be a class/namespace */
693 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
694 0, (struct symtab **) NULL);
698 /* No more tokens, so try as a variable first */
699 sym_var = lookup_symbol (prefix, 0, VAR_NAMESPACE,
700 0, (struct symtab **) NULL);
701 /* If failed, try as class/namespace */
703 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
704 0, (struct symtab **) NULL);
709 (t = check_typedef (SYMBOL_TYPE (sym_class)),
710 (TYPE_CODE (t) == TYPE_CODE_STRUCT
711 || TYPE_CODE (t) == TYPE_CODE_UNION))))
713 /* We found a valid token */
714 *token = (char *) xmalloc (prefix_len + 1);
715 memcpy (*token, prefix, prefix_len);
716 (*token)[prefix_len] = '\000';
720 /* No variable or class/namespace found, no more tokens */
722 return (struct symbol *) NULL;
725 /* Out of loop, so we must have found a valid token */
732 *argptr = done ? p : end;
734 return sym_var ? sym_var : sym_class; /* found */
738 find_template_name_end (char *p)
741 int just_seen_right = 0;
742 int just_seen_colon = 0;
743 int just_seen_space = 0;
745 if (!p || (*p != '<'))
756 /* In future, may want to allow these?? */
759 depth++; /* start nested template */
760 if (just_seen_colon || just_seen_right || just_seen_space)
761 return 0; /* but not after : or :: or > or space */
764 if (just_seen_colon || just_seen_right)
765 return 0; /* end a (nested?) template */
766 just_seen_right = 1; /* but not after : or :: */
767 if (--depth == 0) /* also disallow >>, insist on > > */
768 return ++p; /* if outermost ended, return */
771 if (just_seen_space || (just_seen_colon > 1))
772 return 0; /* nested class spec coming up */
773 just_seen_colon++; /* we allow :: but not :::: */
778 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
779 (*p >= 'A' && *p <= 'Z') ||
780 (*p >= '0' && *p <= '9') ||
781 (*p == '_') || (*p == ',') || /* commas for template args */
782 (*p == '&') || (*p == '*') || /* pointer and ref types */
783 (*p == '(') || (*p == ')') || /* function types */
784 (*p == '[') || (*p == ']'))) /* array types */
799 /* Return a null-terminated temporary copy of the name
800 of a string token. */
803 copy_name (struct stoken token)
805 memcpy (namecopy, token.ptr, token.length);
806 namecopy[token.length] = 0;
810 /* Reverse an expression from suffix form (in which it is constructed)
811 to prefix form (in which we can conveniently print or execute it). */
814 prefixify_expression (register struct expression *expr)
817 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
818 register struct expression *temp;
819 register int inpos = expr->nelts, outpos = 0;
821 temp = (struct expression *) alloca (len);
823 /* Copy the original expression into temp. */
824 memcpy (temp, expr, len);
826 prefixify_subexp (temp, expr, inpos, outpos);
829 /* Return the number of exp_elements in the subexpression of EXPR
830 whose last exp_element is at index ENDPOS - 1 in EXPR. */
833 length_of_subexp (register struct expression *expr, register int endpos)
835 register int oplen = 1;
836 register int args = 0;
840 error ("?error in length_of_subexp");
842 i = (int) expr->elts[endpos - 1].opcode;
848 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
849 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
872 case OP_F77_UNDETERMINED_ARGLIST:
874 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
902 case STRUCTOP_STRUCT:
910 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
911 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
915 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
916 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
917 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
922 args = longest_to_int (expr->elts[endpos - 2].longconst);
923 args -= longest_to_int (expr->elts[endpos - 3].longconst);
929 case TERNOP_SLICE_COUNT:
934 case MULTI_SUBSCRIPT:
936 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
939 case BINOP_ASSIGN_MODIFY:
950 args = 1 + (i < (int) BINOP_END);
955 oplen += length_of_subexp (expr, endpos - oplen);
962 /* Copy the subexpression ending just before index INEND in INEXPR
963 into OUTEXPR, starting at index OUTBEG.
964 In the process, convert it from suffix to prefix form. */
967 prefixify_subexp (register struct expression *inexpr,
968 struct expression *outexpr, register int inend, int outbeg)
970 register int oplen = 1;
971 register int args = 0;
974 enum exp_opcode opcode;
976 /* Compute how long the last operation is (in OPLEN),
977 and also how many preceding subexpressions serve as
978 arguments for it (in ARGS). */
980 opcode = inexpr->elts[inend - 1].opcode;
985 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
986 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
1009 case OP_F77_UNDETERMINED_ARGLIST:
1011 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1037 case STRUCTOP_STRUCT:
1046 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1047 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
1051 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1052 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
1053 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
1058 args = longest_to_int (inexpr->elts[inend - 2].longconst);
1059 args -= longest_to_int (inexpr->elts[inend - 3].longconst);
1065 case TERNOP_SLICE_COUNT:
1069 case BINOP_ASSIGN_MODIFY:
1075 case MULTI_SUBSCRIPT:
1077 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1086 args = 1 + ((int) opcode < (int) BINOP_END);
1089 /* Copy the final operator itself, from the end of the input
1090 to the beginning of the output. */
1092 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1093 EXP_ELEM_TO_BYTES (oplen));
1096 /* Find the lengths of the arg subexpressions. */
1097 arglens = (int *) alloca (args * sizeof (int));
1098 for (i = args - 1; i >= 0; i--)
1100 oplen = length_of_subexp (inexpr, inend);
1105 /* Now copy each subexpression, preserving the order of
1106 the subexpressions, but prefixifying each one.
1107 In this loop, inend starts at the beginning of
1108 the expression this level is working on
1109 and marches forward over the arguments.
1110 outbeg does similarly in the output. */
1111 for (i = 0; i < args; i++)
1115 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1120 /* This page contains the two entry points to this file. */
1122 /* Read an expression from the string *STRINGPTR points to,
1123 parse it, and return a pointer to a struct expression that we malloc.
1124 Use block BLOCK as the lexical context for variable names;
1125 if BLOCK is zero, use the block of the selected stack frame.
1126 Meanwhile, advance *STRINGPTR to point after the expression,
1127 at the first nonwhite character that is not part of the expression
1128 (possibly a null character).
1130 If COMMA is nonzero, stop if a comma is reached. */
1133 parse_exp_1 (char **stringptr, struct block *block, int comma)
1135 struct cleanup *old_chain;
1137 lexptr = *stringptr;
1140 type_stack_depth = 0;
1142 comma_terminates = comma;
1144 if (lexptr == 0 || *lexptr == 0)
1145 error_no_arg ("expression to compute");
1147 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1150 expression_context_block = block ? block : get_selected_block ();
1152 namecopy = (char *) alloca (strlen (lexptr) + 1);
1155 expout = (struct expression *)
1156 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1157 expout->language_defn = current_language;
1158 make_cleanup (free_current_contents, &expout);
1160 if (current_language->la_parser ())
1161 current_language->la_error (NULL);
1163 discard_cleanups (old_chain);
1165 /* Record the actual number of expression elements, and then
1166 reallocate the expression memory so that we free up any
1169 expout->nelts = expout_ptr;
1170 expout = (struct expression *)
1171 xrealloc ((char *) expout,
1172 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1174 /* Convert expression from postfix form as generated by yacc
1175 parser, to a prefix form. */
1177 if (expressiondebug)
1178 dump_prefix_expression (expout, gdb_stdlog,
1179 "before conversion to prefix form");
1181 prefixify_expression (expout);
1183 if (expressiondebug)
1184 dump_postfix_expression (expout, gdb_stdlog,
1185 "after conversion to prefix form");
1187 *stringptr = lexptr;
1191 /* Parse STRING as an expression, and complain if this fails
1192 to use up all of the contents of STRING. */
1195 parse_expression (char *string)
1197 register struct expression *exp;
1198 exp = parse_exp_1 (&string, 0, 0);
1200 error ("Junk after end of expression.");
1204 /* Stuff for maintaining a stack of types. Currently just used by C, but
1205 probably useful for any language which declares its types "backwards". */
1208 push_type (enum type_pieces tp)
1210 if (type_stack_depth == type_stack_size)
1212 type_stack_size *= 2;
1213 type_stack = (union type_stack_elt *)
1214 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1216 type_stack[type_stack_depth++].piece = tp;
1220 push_type_int (int n)
1222 if (type_stack_depth == type_stack_size)
1224 type_stack_size *= 2;
1225 type_stack = (union type_stack_elt *)
1226 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1228 type_stack[type_stack_depth++].int_val = n;
1234 if (type_stack_depth)
1235 return type_stack[--type_stack_depth].piece;
1242 if (type_stack_depth)
1243 return type_stack[--type_stack_depth].int_val;
1244 /* "Can't happen". */
1248 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1249 as modified by all the stuff on the stack. */
1251 follow_types (struct type *follow_type)
1255 struct type *range_type;
1258 switch (pop_type ())
1264 follow_type = lookup_pointer_type (follow_type);
1267 follow_type = lookup_reference_type (follow_type);
1270 array_size = pop_type_int ();
1271 /* FIXME-type-allocation: need a way to free this type when we are
1274 create_range_type ((struct type *) NULL,
1275 builtin_type_int, 0,
1276 array_size >= 0 ? array_size - 1 : 0);
1278 create_array_type ((struct type *) NULL,
1279 follow_type, range_type);
1281 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1282 = BOUND_CANNOT_BE_DETERMINED;
1285 /* FIXME-type-allocation: need a way to free this type when we are
1287 follow_type = lookup_function_type (follow_type);
1293 static void build_parse (void);
1299 msym_text_symbol_type =
1300 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1301 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1302 msym_data_symbol_type =
1303 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1304 "<data variable, no debug info>", NULL);
1305 msym_unknown_symbol_type =
1306 init_type (TYPE_CODE_INT, 1, 0,
1307 "<variable (not text or data), no debug info>",
1310 /* create the std_regs table */
1329 /* create an empty table */
1330 std_regs = xmalloc ((num_std_regs + 1) * sizeof *std_regs);
1336 std_regs[i].name = "pc";
1337 std_regs[i].regnum = PC_REGNUM;
1344 std_regs[i].name = "fp";
1345 std_regs[i].regnum = FP_REGNUM;
1352 std_regs[i].name = "sp";
1353 std_regs[i].regnum = SP_REGNUM;
1360 std_regs[i].name = "ps";
1361 std_regs[i].regnum = PS_REGNUM;
1365 memset (&std_regs[i], 0, sizeof (std_regs[i]));
1369 _initialize_parse (void)
1371 type_stack_size = 80;
1372 type_stack_depth = 0;
1373 type_stack = (union type_stack_elt *)
1374 xmalloc (type_stack_size * sizeof (*type_stack));
1378 /* FIXME - For the moment, handle types by swapping them in and out.
1379 Should be using the per-architecture data-pointer and a large
1381 register_gdbarch_swap (&msym_text_symbol_type, sizeof (msym_text_symbol_type), NULL);
1382 register_gdbarch_swap (&msym_data_symbol_type, sizeof (msym_data_symbol_type), NULL);
1383 register_gdbarch_swap (&msym_unknown_symbol_type, sizeof (msym_unknown_symbol_type), NULL);
1385 register_gdbarch_swap (&num_std_regs, sizeof (std_regs), NULL);
1386 register_gdbarch_swap (&std_regs, sizeof (std_regs), NULL);
1387 register_gdbarch_swap (NULL, 0, build_parse);
1390 add_set_cmd ("expression", class_maintenance, var_zinteger,
1391 (char *) &expressiondebug,
1392 "Set expression debugging.\n\
1393 When non-zero, the internal representation of expressions will be printed.",