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"
46 #include "symfile.h" /* for overlay functions */
47 #include "inferior.h" /* for NUM_PSEUDO_REGS. NOTE: replace
48 with "gdbarch.h" when appropriate. */
50 #include "builtin-regs.h"
51 #include "gdb_assert.h"
54 /* Symbols which architectures can redefine. */
56 /* Some systems have routines whose names start with `$'. Giving this
57 macro a non-zero value tells GDB's expression parser to check for
58 such routines when parsing tokens that begin with `$'.
60 On HP-UX, certain system routines (millicode) have names beginning
61 with `$' or `$$'. For example, `$$dyncall' is a millicode routine
62 that handles inter-space procedure calls on PA-RISC. */
63 #ifndef SYMBOLS_CAN_START_WITH_DOLLAR
64 #define SYMBOLS_CAN_START_WITH_DOLLAR (0)
69 /* Global variables declared in parser-defs.h (and commented there). */
70 struct expression *expout;
73 struct block *expression_context_block;
74 CORE_ADDR expression_context_pc;
75 struct block *innermost_block;
77 union type_stack_elt *type_stack;
78 int type_stack_depth, type_stack_size;
85 static int expressiondebug = 0;
87 extern int hp_som_som_object_present;
89 static void free_funcalls (void *ignore);
91 static void prefixify_expression (struct expression *);
94 prefixify_subexp (struct expression *, struct expression *, int, int);
96 void _initialize_parse (void);
98 /* Data structure for saving values of arglist_len for function calls whose
99 arguments contain other function calls. */
103 struct funcall *next;
107 static struct funcall *funcall_chain;
109 /* The generic method for targets to specify how their registers are
110 named. The mapping can be derived from two sources: REGISTER_NAME;
114 target_map_name_to_register (char *str, int len)
118 /* Search register name space. */
119 for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
120 if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
121 && STREQN (str, REGISTER_NAME (i), len))
126 /* Try builtin registers. */
127 i = builtin_reg_map_name_to_regnum (str, len);
130 gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
134 /* Try builtin registers. */
135 i = builtin_reg_map_name_to_regnum (str, len);
138 gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
145 /* Begin counting arguments for a function call,
146 saving the data about any containing call. */
151 register struct funcall *new;
153 new = (struct funcall *) xmalloc (sizeof (struct funcall));
154 new->next = funcall_chain;
155 new->arglist_len = arglist_len;
160 /* Return the number of arguments in a function call just terminated,
161 and restore the data for the containing function call. */
166 register int val = arglist_len;
167 register struct funcall *call = funcall_chain;
168 funcall_chain = call->next;
169 arglist_len = call->arglist_len;
174 /* Free everything in the funcall chain.
175 Used when there is an error inside parsing. */
178 free_funcalls (void *ignore)
180 register struct funcall *call, *next;
182 for (call = funcall_chain; call; call = next)
189 /* This page contains the functions for adding data to the struct expression
190 being constructed. */
192 /* Add one element to the end of the expression. */
194 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
195 a register through here */
198 write_exp_elt (union exp_element expelt)
200 if (expout_ptr >= expout_size)
203 expout = (struct expression *)
204 xrealloc ((char *) expout, sizeof (struct expression)
205 + EXP_ELEM_TO_BYTES (expout_size));
207 expout->elts[expout_ptr++] = expelt;
211 write_exp_elt_opcode (enum exp_opcode expelt)
213 union exp_element tmp;
221 write_exp_elt_sym (struct symbol *expelt)
223 union exp_element tmp;
231 write_exp_elt_block (struct block *b)
233 union exp_element tmp;
239 write_exp_elt_longcst (LONGEST expelt)
241 union exp_element tmp;
243 tmp.longconst = expelt;
249 write_exp_elt_dblcst (DOUBLEST expelt)
251 union exp_element tmp;
253 tmp.doubleconst = expelt;
259 write_exp_elt_type (struct type *expelt)
261 union exp_element tmp;
269 write_exp_elt_intern (struct internalvar *expelt)
271 union exp_element tmp;
273 tmp.internalvar = expelt;
278 /* Add a string constant to the end of the expression.
280 String constants are stored by first writing an expression element
281 that contains the length of the string, then stuffing the string
282 constant itself into however many expression elements are needed
283 to hold it, and then writing another expression element that contains
284 the length of the string. I.E. an expression element at each end of
285 the string records the string length, so you can skip over the
286 expression elements containing the actual string bytes from either
287 end of the string. Note that this also allows gdb to handle
288 strings with embedded null bytes, as is required for some languages.
290 Don't be fooled by the fact that the string is null byte terminated,
291 this is strictly for the convenience of debugging gdb itself. Gdb
292 Gdb does not depend up the string being null terminated, since the
293 actual length is recorded in expression elements at each end of the
294 string. The null byte is taken into consideration when computing how
295 many expression elements are required to hold the string constant, of
300 write_exp_string (struct stoken str)
302 register int len = str.length;
304 register char *strdata;
306 /* Compute the number of expression elements required to hold the string
307 (including a null byte terminator), along with one expression element
308 at each end to record the actual string length (not including the
309 null byte terminator). */
311 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
313 /* Ensure that we have enough available expression elements to store
316 if ((expout_ptr + lenelt) >= expout_size)
318 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
319 expout = (struct expression *)
320 xrealloc ((char *) expout, (sizeof (struct expression)
321 + EXP_ELEM_TO_BYTES (expout_size)));
324 /* Write the leading length expression element (which advances the current
325 expression element index), then write the string constant followed by a
326 terminating null byte, and then write the trailing length expression
329 write_exp_elt_longcst ((LONGEST) len);
330 strdata = (char *) &expout->elts[expout_ptr];
331 memcpy (strdata, str.ptr, len);
332 *(strdata + len) = '\0';
333 expout_ptr += lenelt - 2;
334 write_exp_elt_longcst ((LONGEST) len);
337 /* Add a bitstring constant to the end of the expression.
339 Bitstring constants are stored by first writing an expression element
340 that contains the length of the bitstring (in bits), then stuffing the
341 bitstring constant itself into however many expression elements are
342 needed to hold it, and then writing another expression element that
343 contains the length of the bitstring. I.E. an expression element at
344 each end of the bitstring records the bitstring length, so you can skip
345 over the expression elements containing the actual bitstring bytes from
346 either end of the bitstring. */
349 write_exp_bitstring (struct stoken str)
351 register int bits = str.length; /* length in bits */
352 register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
354 register char *strdata;
356 /* Compute the number of expression elements required to hold the bitstring,
357 along with one expression element at each end to record the actual
358 bitstring length in bits. */
360 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
362 /* Ensure that we have enough available expression elements to store
365 if ((expout_ptr + lenelt) >= expout_size)
367 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
368 expout = (struct expression *)
369 xrealloc ((char *) expout, (sizeof (struct expression)
370 + EXP_ELEM_TO_BYTES (expout_size)));
373 /* Write the leading length expression element (which advances the current
374 expression element index), then write the bitstring constant, and then
375 write the trailing length expression element. */
377 write_exp_elt_longcst ((LONGEST) bits);
378 strdata = (char *) &expout->elts[expout_ptr];
379 memcpy (strdata, str.ptr, len);
380 expout_ptr += lenelt - 2;
381 write_exp_elt_longcst ((LONGEST) bits);
384 /* Add the appropriate elements for a minimal symbol to the end of
385 the expression. The rationale behind passing in text_symbol_type and
386 data_symbol_type was so that Modula-2 could pass in WORD for
387 data_symbol_type. Perhaps it still is useful to have those types vary
388 based on the language, but they no longer have names like "int", so
389 the initial rationale is gone. */
391 static struct type *msym_text_symbol_type;
392 static struct type *msym_data_symbol_type;
393 static struct type *msym_unknown_symbol_type;
396 write_exp_msymbol (struct minimal_symbol *msymbol,
397 struct type *text_symbol_type,
398 struct type *data_symbol_type)
402 write_exp_elt_opcode (OP_LONG);
403 /* Let's make the type big enough to hold a 64-bit address. */
404 write_exp_elt_type (builtin_type_CORE_ADDR);
406 addr = SYMBOL_VALUE_ADDRESS (msymbol);
407 if (overlay_debugging)
408 addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
409 write_exp_elt_longcst ((LONGEST) addr);
411 write_exp_elt_opcode (OP_LONG);
413 write_exp_elt_opcode (UNOP_MEMVAL);
414 switch (msymbol->type)
418 case mst_solib_trampoline:
419 write_exp_elt_type (msym_text_symbol_type);
426 write_exp_elt_type (msym_data_symbol_type);
430 write_exp_elt_type (msym_unknown_symbol_type);
433 write_exp_elt_opcode (UNOP_MEMVAL);
436 /* Recognize tokens that start with '$'. These include:
438 $regname A native register name or a "standard
441 $variable A convenience variable with a name chosen
444 $digits Value history with index <digits>, starting
445 from the first value which has index 1.
447 $$digits Value history with index <digits> relative
448 to the last value. I.E. $$0 is the last
449 value, $$1 is the one previous to that, $$2
450 is the one previous to $$1, etc.
452 $ | $0 | $$0 The last value in the value history.
454 $$ An abbreviation for the second to the last
455 value in the value history, I.E. $$1
460 write_dollar_variable (struct stoken str)
462 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
463 and $$digits (equivalent to $<-digits> if you could type that). */
467 /* Double dollar means negate the number and add -1 as well.
468 Thus $$ alone means -1. */
469 if (str.length >= 2 && str.ptr[1] == '$')
476 /* Just dollars (one or two) */
480 /* Is the rest of the token digits? */
481 for (; i < str.length; i++)
482 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
486 i = atoi (str.ptr + 1 + negate);
492 /* Handle tokens that refer to machine registers:
493 $ followed by a register name. */
494 i = target_map_name_to_register (str.ptr + 1, str.length - 1);
496 goto handle_register;
498 if (SYMBOLS_CAN_START_WITH_DOLLAR)
500 struct symbol *sym = NULL;
501 struct minimal_symbol *msym = NULL;
503 /* On HP-UX, certain system routines (millicode) have names beginning
504 with $ or $$, e.g. $$dyncall, which handles inter-space procedure
505 calls on PA-RISC. Check for those, first. */
507 /* This code is not enabled on non HP-UX systems, since worst case
508 symbol table lookup performance is awful, to put it mildly. */
510 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
511 VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
514 write_exp_elt_opcode (OP_VAR_VALUE);
515 write_exp_elt_block (block_found); /* set by lookup_symbol */
516 write_exp_elt_sym (sym);
517 write_exp_elt_opcode (OP_VAR_VALUE);
520 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
523 write_exp_msymbol (msym,
524 lookup_function_type (builtin_type_int),
530 /* Any other names starting in $ are debugger internal variables. */
532 write_exp_elt_opcode (OP_INTERNALVAR);
533 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
534 write_exp_elt_opcode (OP_INTERNALVAR);
537 write_exp_elt_opcode (OP_LAST);
538 write_exp_elt_longcst ((LONGEST) i);
539 write_exp_elt_opcode (OP_LAST);
542 write_exp_elt_opcode (OP_REGISTER);
543 write_exp_elt_longcst (i);
544 write_exp_elt_opcode (OP_REGISTER);
549 /* Parse a string that is possibly a namespace / nested class
550 specification, i.e., something of the form A::B::C::x. Input
551 (NAME) is the entire string; LEN is the current valid length; the
552 output is a string, TOKEN, which points to the largest recognized
553 prefix which is a series of namespaces or classes. CLASS_PREFIX is
554 another output, which records whether a nested class spec was
555 recognized (= 1) or a fully qualified variable name was found (=
556 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
557 string recognized and consumed by this routine.
559 The return value is a pointer to the symbol for the base class or
560 variable if found, or NULL if not found. Callers must check this
561 first -- if NULL, the outputs may not be correct.
563 This function is used c-exp.y. This is used specifically to get
564 around HP aCC (and possibly other compilers), which insists on
565 generating names with embedded colons for namespace or nested class
568 (Argument LEN is currently unused. 1997-08-27)
570 Callers must free memory allocated for the output string TOKEN. */
572 static const char coloncolon[2] =
576 parse_nested_classes_for_hpacc (char *name, int len, char **token,
577 int *class_prefix, char **argptr)
579 /* Comment below comes from decode_line_1 which has very similar
580 code, which is called for "break" command parsing. */
582 /* We have what looks like a class or namespace
583 scope specification (A::B), possibly with many
584 levels of namespaces or classes (A::B::C::D).
586 Some versions of the HP ANSI C++ compiler (as also possibly
587 other compilers) generate class/function/member names with
588 embedded double-colons if they are inside namespaces. To
589 handle this, we loop a few times, considering larger and
590 larger prefixes of the string as though they were single
591 symbols. So, if the initially supplied string is
592 A::B::C::D::foo, we have to look up "A", then "A::B",
593 then "A::B::C", then "A::B::C::D", and finally
594 "A::B::C::D::foo" as single, monolithic symbols, because
595 A, B, C or D may be namespaces.
597 Note that namespaces can nest only inside other
598 namespaces, and not inside classes. So we need only
599 consider *prefixes* of the string; there is no need to look up
600 "B::C" separately as a symbol in the previous example. */
606 struct symbol *sym_class = NULL;
607 struct symbol *sym_var = NULL;
613 /* Check for HP-compiled executable -- in other cases
614 return NULL, and caller must default to standard GDB
617 if (!hp_som_som_object_present)
618 return (struct symbol *) NULL;
622 /* Skip over whitespace and possible global "::" */
623 while (*p && (*p == ' ' || *p == '\t'))
625 if (p[0] == ':' && p[1] == ':')
627 while (*p && (*p == ' ' || *p == '\t'))
632 /* Get to the end of the next namespace or class spec. */
633 /* If we're looking at some non-token, fail immediately */
635 if (!(isalpha (*p) || *p == '$' || *p == '_'))
636 return (struct symbol *) NULL;
638 while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
643 /* If we have the start of a template specification,
644 scan right ahead to its end */
645 q = find_template_name_end (p);
652 /* Skip over "::" and whitespace for next time around */
653 while (*p && (*p == ' ' || *p == '\t'))
655 if (p[0] == ':' && p[1] == ':')
657 while (*p && (*p == ' ' || *p == '\t'))
660 /* Done with tokens? */
661 if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
664 tmp = (char *) alloca (prefix_len + end - start + 3);
667 memcpy (tmp, prefix, prefix_len);
668 memcpy (tmp + prefix_len, coloncolon, 2);
669 memcpy (tmp + prefix_len + 2, start, end - start);
670 tmp[prefix_len + 2 + end - start] = '\000';
674 memcpy (tmp, start, end - start);
675 tmp[end - start] = '\000';
679 prefix_len = strlen (prefix);
681 /* See if the prefix we have now is something we know about */
685 /* More tokens to process, so this must be a class/namespace */
686 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
687 0, (struct symtab **) NULL);
691 /* No more tokens, so try as a variable first */
692 sym_var = lookup_symbol (prefix, 0, VAR_NAMESPACE,
693 0, (struct symtab **) NULL);
694 /* If failed, try as class/namespace */
696 sym_class = lookup_symbol (prefix, 0, STRUCT_NAMESPACE,
697 0, (struct symtab **) NULL);
702 (t = check_typedef (SYMBOL_TYPE (sym_class)),
703 (TYPE_CODE (t) == TYPE_CODE_STRUCT
704 || TYPE_CODE (t) == TYPE_CODE_UNION))))
706 /* We found a valid token */
707 *token = (char *) xmalloc (prefix_len + 1);
708 memcpy (*token, prefix, prefix_len);
709 (*token)[prefix_len] = '\000';
713 /* No variable or class/namespace found, no more tokens */
715 return (struct symbol *) NULL;
718 /* Out of loop, so we must have found a valid token */
725 *argptr = done ? p : end;
727 return sym_var ? sym_var : sym_class; /* found */
731 find_template_name_end (char *p)
734 int just_seen_right = 0;
735 int just_seen_colon = 0;
736 int just_seen_space = 0;
738 if (!p || (*p != '<'))
749 /* In future, may want to allow these?? */
752 depth++; /* start nested template */
753 if (just_seen_colon || just_seen_right || just_seen_space)
754 return 0; /* but not after : or :: or > or space */
757 if (just_seen_colon || just_seen_right)
758 return 0; /* end a (nested?) template */
759 just_seen_right = 1; /* but not after : or :: */
760 if (--depth == 0) /* also disallow >>, insist on > > */
761 return ++p; /* if outermost ended, return */
764 if (just_seen_space || (just_seen_colon > 1))
765 return 0; /* nested class spec coming up */
766 just_seen_colon++; /* we allow :: but not :::: */
771 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
772 (*p >= 'A' && *p <= 'Z') ||
773 (*p >= '0' && *p <= '9') ||
774 (*p == '_') || (*p == ',') || /* commas for template args */
775 (*p == '&') || (*p == '*') || /* pointer and ref types */
776 (*p == '(') || (*p == ')') || /* function types */
777 (*p == '[') || (*p == ']'))) /* array types */
792 /* Return a null-terminated temporary copy of the name
793 of a string token. */
796 copy_name (struct stoken token)
798 memcpy (namecopy, token.ptr, token.length);
799 namecopy[token.length] = 0;
803 /* Reverse an expression from suffix form (in which it is constructed)
804 to prefix form (in which we can conveniently print or execute it). */
807 prefixify_expression (register struct expression *expr)
810 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
811 register struct expression *temp;
812 register int inpos = expr->nelts, outpos = 0;
814 temp = (struct expression *) alloca (len);
816 /* Copy the original expression into temp. */
817 memcpy (temp, expr, len);
819 prefixify_subexp (temp, expr, inpos, outpos);
822 /* Return the number of exp_elements in the subexpression of EXPR
823 whose last exp_element is at index ENDPOS - 1 in EXPR. */
826 length_of_subexp (register struct expression *expr, register int endpos)
828 register int oplen = 1;
829 register int args = 0;
833 error ("?error in length_of_subexp");
835 i = (int) expr->elts[endpos - 1].opcode;
841 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
842 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
865 case OP_F77_UNDETERMINED_ARGLIST:
867 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
870 case OP_MSGCALL: /* Objective C message (method) call */
872 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
900 case STRUCTOP_STRUCT:
906 case OP_NSSTRING: /* Objective C Foundation Class NSString constant */
907 case OP_SELECTOR: /* Objective C "@selector" pseudo-op */
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:
951 args = 1 + (i < (int) BINOP_END);
956 oplen += length_of_subexp (expr, endpos - oplen);
963 /* Copy the subexpression ending just before index INEND in INEXPR
964 into OUTEXPR, starting at index OUTBEG.
965 In the process, convert it from suffix to prefix form. */
968 prefixify_subexp (register struct expression *inexpr,
969 struct expression *outexpr, register int inend, int outbeg)
971 register int oplen = 1;
972 register int args = 0;
975 enum exp_opcode opcode;
977 /* Compute how long the last operation is (in OPLEN),
978 and also how many preceding subexpressions serve as
979 arguments for it (in ARGS). */
981 opcode = inexpr->elts[inend - 1].opcode;
986 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
987 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
1000 case OP_INTERNALVAR:
1010 case OP_F77_UNDETERMINED_ARGLIST:
1012 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1015 case OP_MSGCALL: /* Objective C message (method) call */
1017 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1043 case STRUCTOP_STRUCT:
1050 case OP_NSSTRING: /* Objective C Foundation Class NSString constant */
1051 case OP_SELECTOR: /* Objective C "@selector" pseudo-op */
1054 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1055 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
1059 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
1060 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
1061 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
1066 args = longest_to_int (inexpr->elts[inend - 2].longconst);
1067 args -= longest_to_int (inexpr->elts[inend - 3].longconst);
1073 case TERNOP_SLICE_COUNT:
1077 case BINOP_ASSIGN_MODIFY:
1083 case MULTI_SUBSCRIPT:
1085 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
1095 args = 1 + ((int) opcode < (int) BINOP_END);
1098 /* Copy the final operator itself, from the end of the input
1099 to the beginning of the output. */
1101 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1102 EXP_ELEM_TO_BYTES (oplen));
1105 /* Find the lengths of the arg subexpressions. */
1106 arglens = (int *) alloca (args * sizeof (int));
1107 for (i = args - 1; i >= 0; i--)
1109 oplen = length_of_subexp (inexpr, inend);
1114 /* Now copy each subexpression, preserving the order of
1115 the subexpressions, but prefixifying each one.
1116 In this loop, inend starts at the beginning of
1117 the expression this level is working on
1118 and marches forward over the arguments.
1119 outbeg does similarly in the output. */
1120 for (i = 0; i < args; i++)
1124 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1129 /* This page contains the two entry points to this file. */
1131 /* Read an expression from the string *STRINGPTR points to,
1132 parse it, and return a pointer to a struct expression that we malloc.
1133 Use block BLOCK as the lexical context for variable names;
1134 if BLOCK is zero, use the block of the selected stack frame.
1135 Meanwhile, advance *STRINGPTR to point after the expression,
1136 at the first nonwhite character that is not part of the expression
1137 (possibly a null character).
1139 If COMMA is nonzero, stop if a comma is reached. */
1142 parse_exp_1 (char **stringptr, struct block *block, int comma)
1144 struct cleanup *old_chain;
1146 lexptr = *stringptr;
1150 type_stack_depth = 0;
1152 comma_terminates = comma;
1154 if (lexptr == 0 || *lexptr == 0)
1155 error_no_arg ("expression to compute");
1157 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1162 expression_context_block = block;
1163 expression_context_pc = block->startaddr;
1166 expression_context_block = get_selected_block (&expression_context_pc);
1168 namecopy = (char *) alloca (strlen (lexptr) + 1);
1171 expout = (struct expression *)
1172 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1173 expout->language_defn = current_language;
1174 make_cleanup (free_current_contents, &expout);
1176 if (current_language->la_parser ())
1177 current_language->la_error (NULL);
1179 discard_cleanups (old_chain);
1181 /* Record the actual number of expression elements, and then
1182 reallocate the expression memory so that we free up any
1185 expout->nelts = expout_ptr;
1186 expout = (struct expression *)
1187 xrealloc ((char *) expout,
1188 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1190 /* Convert expression from postfix form as generated by yacc
1191 parser, to a prefix form. */
1193 if (expressiondebug)
1194 dump_prefix_expression (expout, gdb_stdlog,
1195 "before conversion to prefix form");
1197 prefixify_expression (expout);
1199 if (expressiondebug)
1200 dump_postfix_expression (expout, gdb_stdlog,
1201 "after conversion to prefix form");
1203 *stringptr = lexptr;
1207 /* Parse STRING as an expression, and complain if this fails
1208 to use up all of the contents of STRING. */
1211 parse_expression (char *string)
1213 register struct expression *exp;
1214 exp = parse_exp_1 (&string, 0, 0);
1216 error ("Junk after end of expression.");
1220 /* Stuff for maintaining a stack of types. Currently just used by C, but
1221 probably useful for any language which declares its types "backwards". */
1224 check_type_stack_depth (void)
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));
1235 push_type (enum type_pieces tp)
1237 check_type_stack_depth ();
1238 type_stack[type_stack_depth++].piece = tp;
1242 push_type_int (int n)
1244 check_type_stack_depth ();
1245 type_stack[type_stack_depth++].int_val = n;
1249 push_type_address_space (char *string)
1251 push_type_int (address_space_name_to_int (string));
1257 if (type_stack_depth)
1258 return type_stack[--type_stack_depth].piece;
1265 if (type_stack_depth)
1266 return type_stack[--type_stack_depth].int_val;
1267 /* "Can't happen". */
1271 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1272 as modified by all the stuff on the stack. */
1274 follow_types (struct type *follow_type)
1278 int make_volatile = 0;
1279 int make_addr_space = 0;
1281 struct type *range_type;
1284 switch (pop_type ())
1289 follow_type = make_cv_type (make_const,
1290 TYPE_VOLATILE (follow_type),
1293 follow_type = make_cv_type (TYPE_CONST (follow_type),
1296 if (make_addr_space)
1297 follow_type = make_type_with_address_space (follow_type,
1299 make_const = make_volatile = 0;
1300 make_addr_space = 0;
1308 case tp_space_identifier:
1309 make_addr_space = pop_type_int ();
1312 follow_type = lookup_pointer_type (follow_type);
1314 follow_type = make_cv_type (make_const,
1315 TYPE_VOLATILE (follow_type),
1318 follow_type = make_cv_type (TYPE_CONST (follow_type),
1321 if (make_addr_space)
1322 follow_type = make_type_with_address_space (follow_type,
1324 make_const = make_volatile = 0;
1325 make_addr_space = 0;
1328 follow_type = lookup_reference_type (follow_type);
1330 follow_type = make_cv_type (make_const,
1331 TYPE_VOLATILE (follow_type),
1334 follow_type = make_cv_type (TYPE_CONST (follow_type),
1337 if (make_addr_space)
1338 follow_type = make_type_with_address_space (follow_type,
1340 make_const = make_volatile = 0;
1341 make_addr_space = 0;
1344 array_size = pop_type_int ();
1345 /* FIXME-type-allocation: need a way to free this type when we are
1348 create_range_type ((struct type *) NULL,
1349 builtin_type_int, 0,
1350 array_size >= 0 ? array_size - 1 : 0);
1352 create_array_type ((struct type *) NULL,
1353 follow_type, range_type);
1355 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1356 = BOUND_CANNOT_BE_DETERMINED;
1359 /* FIXME-type-allocation: need a way to free this type when we are
1361 follow_type = lookup_function_type (follow_type);
1367 static void build_parse (void);
1373 msym_text_symbol_type =
1374 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1375 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1376 msym_data_symbol_type =
1377 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1378 "<data variable, no debug info>", NULL);
1379 msym_unknown_symbol_type =
1380 init_type (TYPE_CODE_INT, 1, 0,
1381 "<variable (not text or data), no debug info>",
1385 /* This function avoids direct calls to fprintf
1386 in the parser generated debug code. */
1388 parser_fprintf (FILE *x, const char *y, ...)
1393 vfprintf_unfiltered (gdb_stderr, y, args);
1396 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1397 vfprintf_unfiltered (gdb_stderr, y, args);
1403 _initialize_parse (void)
1405 type_stack_size = 80;
1406 type_stack_depth = 0;
1407 type_stack = (union type_stack_elt *)
1408 xmalloc (type_stack_size * sizeof (*type_stack));
1412 /* FIXME - For the moment, handle types by swapping them in and out.
1413 Should be using the per-architecture data-pointer and a large
1415 register_gdbarch_swap (&msym_text_symbol_type, sizeof (msym_text_symbol_type), NULL);
1416 register_gdbarch_swap (&msym_data_symbol_type, sizeof (msym_data_symbol_type), NULL);
1417 register_gdbarch_swap (&msym_unknown_symbol_type, sizeof (msym_unknown_symbol_type), NULL);
1419 register_gdbarch_swap (NULL, 0, build_parse);
1422 add_set_cmd ("expression", class_maintenance, var_zinteger,
1423 (char *) &expressiondebug,
1424 "Set expression debugging.\n\
1425 When non-zero, the internal representation of expressions will be printed.",