1 /* Parse expressions for GDB.
3 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2004, 2005 Free Software Foundation, Inc.
6 Modified from expread.y by the Department of Computer Science at the
7 State University of New York at Buffalo, 1991.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
26 /* Parse an expression from text in a string,
27 and return the result as a struct expression pointer.
28 That structure contains arithmetic operations in reverse polish,
29 with constants represented by operations that are followed by special data.
30 See expression.h for the details of the format.
31 What is important here is that it can be built up sequentially
32 during the process of parsing; the lower levels of the tree always
33 come first in the result. */
38 #include "gdb_string.h"
42 #include "expression.h"
47 #include "parser-defs.h"
49 #include "symfile.h" /* for overlay functions */
50 #include "inferior.h" /* for NUM_PSEUDO_REGS. NOTE: replace
51 with "gdbarch.h" when appropriate. */
53 #include "gdb_assert.h"
58 /* Standard set of definitions for printing, dumping, prefixifying,
59 * and evaluating expressions. */
61 const struct exp_descriptor exp_descriptor_standard =
63 print_subexp_standard,
64 operator_length_standard,
66 dump_subexp_body_standard,
67 evaluate_subexp_standard
70 /* Global variables declared in parser-defs.h (and commented there). */
71 struct expression *expout;
74 struct block *expression_context_block;
75 CORE_ADDR expression_context_pc;
76 struct block *innermost_block;
78 union type_stack_elt *type_stack;
79 int type_stack_depth, type_stack_size;
85 /* A temporary buffer for identifiers, so we can null-terminate them.
87 We allocate this with xrealloc. parse_exp_1 used to allocate with
88 alloca, using the size of the whole expression as a conservative
89 estimate of the space needed. However, macro expansion can
90 introduce names longer than the original expression; there's no
91 practical way to know beforehand how large that might be. */
95 static int expressiondebug = 0;
97 show_expressiondebug (struct ui_file *file, int from_tty,
98 struct cmd_list_element *c, const char *value)
100 fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
103 static void free_funcalls (void *ignore);
105 static void prefixify_expression (struct expression *);
107 static void prefixify_subexp (struct expression *, struct expression *, int,
110 static struct expression *parse_exp_in_context (char **, struct block *, int,
113 void _initialize_parse (void);
115 /* Data structure for saving values of arglist_len for function calls whose
116 arguments contain other function calls. */
120 struct funcall *next;
124 static struct funcall *funcall_chain;
126 /* Begin counting arguments for a function call,
127 saving the data about any containing call. */
134 new = (struct funcall *) xmalloc (sizeof (struct funcall));
135 new->next = funcall_chain;
136 new->arglist_len = arglist_len;
141 /* Return the number of arguments in a function call just terminated,
142 and restore the data for the containing function call. */
147 int val = arglist_len;
148 struct funcall *call = funcall_chain;
149 funcall_chain = call->next;
150 arglist_len = call->arglist_len;
155 /* Free everything in the funcall chain.
156 Used when there is an error inside parsing. */
159 free_funcalls (void *ignore)
161 struct funcall *call, *next;
163 for (call = funcall_chain; call; call = next)
170 /* This page contains the functions for adding data to the struct expression
171 being constructed. */
173 /* Add one element to the end of the expression. */
175 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
176 a register through here */
179 write_exp_elt (union exp_element expelt)
181 if (expout_ptr >= expout_size)
184 expout = (struct expression *)
185 xrealloc ((char *) expout, sizeof (struct expression)
186 + EXP_ELEM_TO_BYTES (expout_size));
188 expout->elts[expout_ptr++] = expelt;
192 write_exp_elt_opcode (enum exp_opcode expelt)
194 union exp_element tmp;
195 memset (&tmp, 0, sizeof (union exp_element));
203 write_exp_elt_sym (struct symbol *expelt)
205 union exp_element tmp;
206 memset (&tmp, 0, sizeof (union exp_element));
214 write_exp_elt_block (struct block *b)
216 union exp_element tmp;
217 memset (&tmp, 0, sizeof (union exp_element));
223 write_exp_elt_objfile (struct objfile *objfile)
225 union exp_element tmp;
226 memset (&tmp, 0, sizeof (union exp_element));
227 tmp.objfile = objfile;
232 write_exp_elt_longcst (LONGEST expelt)
234 union exp_element tmp;
235 memset (&tmp, 0, sizeof (union exp_element));
237 tmp.longconst = expelt;
243 write_exp_elt_dblcst (DOUBLEST expelt)
245 union exp_element tmp;
246 memset (&tmp, 0, sizeof (union exp_element));
248 tmp.doubleconst = expelt;
254 write_exp_elt_type (struct type *expelt)
256 union exp_element tmp;
257 memset (&tmp, 0, sizeof (union exp_element));
265 write_exp_elt_intern (struct internalvar *expelt)
267 union exp_element tmp;
268 memset (&tmp, 0, sizeof (union exp_element));
270 tmp.internalvar = expelt;
275 /* Add a string constant to the end of the expression.
277 String constants are stored by first writing an expression element
278 that contains the length of the string, then stuffing the string
279 constant itself into however many expression elements are needed
280 to hold it, and then writing another expression element that contains
281 the length of the string. I.E. an expression element at each end of
282 the string records the string length, so you can skip over the
283 expression elements containing the actual string bytes from either
284 end of the string. Note that this also allows gdb to handle
285 strings with embedded null bytes, as is required for some languages.
287 Don't be fooled by the fact that the string is null byte terminated,
288 this is strictly for the convenience of debugging gdb itself. Gdb
289 Gdb does not depend up the string being null terminated, since the
290 actual length is recorded in expression elements at each end of the
291 string. The null byte is taken into consideration when computing how
292 many expression elements are required to hold the string constant, of
297 write_exp_string (struct stoken str)
299 int len = str.length;
303 /* Compute the number of expression elements required to hold the string
304 (including a null byte terminator), along with one expression element
305 at each end to record the actual string length (not including the
306 null byte terminator). */
308 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
310 /* Ensure that we have enough available expression elements to store
313 if ((expout_ptr + lenelt) >= expout_size)
315 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
316 expout = (struct expression *)
317 xrealloc ((char *) expout, (sizeof (struct expression)
318 + EXP_ELEM_TO_BYTES (expout_size)));
321 /* Write the leading length expression element (which advances the current
322 expression element index), then write the string constant followed by a
323 terminating null byte, and then write the trailing length expression
326 write_exp_elt_longcst ((LONGEST) len);
327 strdata = (char *) &expout->elts[expout_ptr];
328 memcpy (strdata, str.ptr, len);
329 *(strdata + len) = '\0';
330 expout_ptr += lenelt - 2;
331 write_exp_elt_longcst ((LONGEST) len);
334 /* Add a bitstring constant to the end of the expression.
336 Bitstring constants are stored by first writing an expression element
337 that contains the length of the bitstring (in bits), then stuffing the
338 bitstring constant itself into however many expression elements are
339 needed to hold it, and then writing another expression element that
340 contains the length of the bitstring. I.E. an expression element at
341 each end of the bitstring records the bitstring length, so you can skip
342 over the expression elements containing the actual bitstring bytes from
343 either end of the bitstring. */
346 write_exp_bitstring (struct stoken str)
348 int bits = str.length; /* length in bits */
349 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
353 /* Compute the number of expression elements required to hold the bitstring,
354 along with one expression element at each end to record the actual
355 bitstring length in bits. */
357 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
359 /* Ensure that we have enough available expression elements to store
362 if ((expout_ptr + lenelt) >= expout_size)
364 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
365 expout = (struct expression *)
366 xrealloc ((char *) expout, (sizeof (struct expression)
367 + EXP_ELEM_TO_BYTES (expout_size)));
370 /* Write the leading length expression element (which advances the current
371 expression element index), then write the bitstring constant, and then
372 write the trailing length expression element. */
374 write_exp_elt_longcst ((LONGEST) bits);
375 strdata = (char *) &expout->elts[expout_ptr];
376 memcpy (strdata, str.ptr, len);
377 expout_ptr += lenelt - 2;
378 write_exp_elt_longcst ((LONGEST) bits);
381 /* Add the appropriate elements for a minimal symbol to the end of
382 the expression. The rationale behind passing in text_symbol_type and
383 data_symbol_type was so that Modula-2 could pass in WORD for
384 data_symbol_type. Perhaps it still is useful to have those types vary
385 based on the language, but they no longer have names like "int", so
386 the initial rationale is gone. */
388 static struct type *msym_text_symbol_type;
389 static struct type *msym_data_symbol_type;
390 static struct type *msym_unknown_symbol_type;
391 static struct type *msym_tls_symbol_type;
394 write_exp_msymbol (struct minimal_symbol *msymbol,
395 struct type *text_symbol_type,
396 struct type *data_symbol_type)
400 write_exp_elt_opcode (OP_LONG);
401 /* Let's make the type big enough to hold a 64-bit address. */
402 write_exp_elt_type (builtin_type_CORE_ADDR);
404 addr = SYMBOL_VALUE_ADDRESS (msymbol);
405 if (overlay_debugging)
406 addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
407 write_exp_elt_longcst ((LONGEST) addr);
409 write_exp_elt_opcode (OP_LONG);
411 if (SYMBOL_BFD_SECTION (msymbol)
412 && SYMBOL_BFD_SECTION (msymbol)->flags & SEC_THREAD_LOCAL)
414 bfd *bfd = SYMBOL_BFD_SECTION (msymbol)->owner;
418 if (ofp->obfd == bfd)
421 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
422 write_exp_elt_objfile (ofp);
423 write_exp_elt_type (msym_tls_symbol_type);
424 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
428 write_exp_elt_opcode (UNOP_MEMVAL);
429 switch (msymbol->type)
433 case mst_solib_trampoline:
434 write_exp_elt_type (msym_text_symbol_type);
441 write_exp_elt_type (msym_data_symbol_type);
445 write_exp_elt_type (msym_unknown_symbol_type);
448 write_exp_elt_opcode (UNOP_MEMVAL);
451 /* Recognize tokens that start with '$'. These include:
453 $regname A native register name or a "standard
456 $variable A convenience variable with a name chosen
459 $digits Value history with index <digits>, starting
460 from the first value which has index 1.
462 $$digits Value history with index <digits> relative
463 to the last value. I.E. $$0 is the last
464 value, $$1 is the one previous to that, $$2
465 is the one previous to $$1, etc.
467 $ | $0 | $$0 The last value in the value history.
469 $$ An abbreviation for the second to the last
470 value in the value history, I.E. $$1
475 write_dollar_variable (struct stoken str)
477 struct symbol *sym = NULL;
478 struct minimal_symbol *msym = NULL;
480 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
481 and $$digits (equivalent to $<-digits> if you could type that). */
485 /* Double dollar means negate the number and add -1 as well.
486 Thus $$ alone means -1. */
487 if (str.length >= 2 && str.ptr[1] == '$')
494 /* Just dollars (one or two) */
498 /* Is the rest of the token digits? */
499 for (; i < str.length; i++)
500 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
504 i = atoi (str.ptr + 1 + negate);
510 /* Handle tokens that refer to machine registers:
511 $ followed by a register name. */
512 i = frame_map_name_to_regnum (deprecated_selected_frame,
513 str.ptr + 1, str.length - 1);
515 goto handle_register;
517 /* On some systems, such as HP-UX and hppa-linux, certain system routines
518 have names beginning with $ or $$. Check for those, first. */
520 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
521 VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
524 write_exp_elt_opcode (OP_VAR_VALUE);
525 write_exp_elt_block (block_found); /* set by lookup_symbol */
526 write_exp_elt_sym (sym);
527 write_exp_elt_opcode (OP_VAR_VALUE);
530 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
533 write_exp_msymbol (msym,
534 lookup_function_type (builtin_type_int),
539 /* Any other names starting in $ are debugger internal variables. */
541 write_exp_elt_opcode (OP_INTERNALVAR);
542 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1));
543 write_exp_elt_opcode (OP_INTERNALVAR);
546 write_exp_elt_opcode (OP_LAST);
547 write_exp_elt_longcst ((LONGEST) i);
548 write_exp_elt_opcode (OP_LAST);
551 write_exp_elt_opcode (OP_REGISTER);
552 write_exp_elt_longcst (i);
553 write_exp_elt_opcode (OP_REGISTER);
558 /* Parse a string that is possibly a namespace / nested class
559 specification, i.e., something of the form A::B::C::x. Input
560 (NAME) is the entire string; LEN is the current valid length; the
561 output is a string, TOKEN, which points to the largest recognized
562 prefix which is a series of namespaces or classes. CLASS_PREFIX is
563 another output, which records whether a nested class spec was
564 recognized (= 1) or a fully qualified variable name was found (=
565 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
566 string recognized and consumed by this routine.
568 The return value is a pointer to the symbol for the base class or
569 variable if found, or NULL if not found. Callers must check this
570 first -- if NULL, the outputs may not be correct.
572 This function is used c-exp.y. This is used specifically to get
573 around HP aCC (and possibly other compilers), which insists on
574 generating names with embedded colons for namespace or nested class
577 (Argument LEN is currently unused. 1997-08-27)
579 Callers must free memory allocated for the output string TOKEN. */
581 static const char coloncolon[2] =
585 parse_nested_classes_for_hpacc (char *name, int len, char **token,
586 int *class_prefix, char **argptr)
588 /* Comment below comes from decode_line_1 which has very similar
589 code, which is called for "break" command parsing. */
591 /* We have what looks like a class or namespace
592 scope specification (A::B), possibly with many
593 levels of namespaces or classes (A::B::C::D).
595 Some versions of the HP ANSI C++ compiler (as also possibly
596 other compilers) generate class/function/member names with
597 embedded double-colons if they are inside namespaces. To
598 handle this, we loop a few times, considering larger and
599 larger prefixes of the string as though they were single
600 symbols. So, if the initially supplied string is
601 A::B::C::D::foo, we have to look up "A", then "A::B",
602 then "A::B::C", then "A::B::C::D", and finally
603 "A::B::C::D::foo" as single, monolithic symbols, because
604 A, B, C or D may be namespaces.
606 Note that namespaces can nest only inside other
607 namespaces, and not inside classes. So we need only
608 consider *prefixes* of the string; there is no need to look up
609 "B::C" separately as a symbol in the previous example. */
615 struct symbol *sym_class = NULL;
616 struct symbol *sym_var = NULL;
622 /* Check for HP-compiled executable -- in other cases
623 return NULL, and caller must default to standard GDB
626 if (!deprecated_hp_som_som_object_present)
627 return (struct symbol *) NULL;
631 /* Skip over whitespace and possible global "::" */
632 while (*p && (*p == ' ' || *p == '\t'))
634 if (p[0] == ':' && p[1] == ':')
636 while (*p && (*p == ' ' || *p == '\t'))
641 /* Get to the end of the next namespace or class spec. */
642 /* If we're looking at some non-token, fail immediately */
644 if (!(isalpha (*p) || *p == '$' || *p == '_'))
645 return (struct symbol *) NULL;
647 while (*p && (isalnum (*p) || *p == '$' || *p == '_'))
652 /* If we have the start of a template specification,
653 scan right ahead to its end */
654 q = find_template_name_end (p);
661 /* Skip over "::" and whitespace for next time around */
662 while (*p && (*p == ' ' || *p == '\t'))
664 if (p[0] == ':' && p[1] == ':')
666 while (*p && (*p == ' ' || *p == '\t'))
669 /* Done with tokens? */
670 if (!*p || !(isalpha (*p) || *p == '$' || *p == '_'))
673 tmp = (char *) alloca (prefix_len + end - start + 3);
676 memcpy (tmp, prefix, prefix_len);
677 memcpy (tmp + prefix_len, coloncolon, 2);
678 memcpy (tmp + prefix_len + 2, start, end - start);
679 tmp[prefix_len + 2 + end - start] = '\000';
683 memcpy (tmp, start, end - start);
684 tmp[end - start] = '\000';
688 prefix_len = strlen (prefix);
690 /* See if the prefix we have now is something we know about */
694 /* More tokens to process, so this must be a class/namespace */
695 sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
696 0, (struct symtab **) NULL);
700 /* No more tokens, so try as a variable first */
701 sym_var = lookup_symbol (prefix, 0, VAR_DOMAIN,
702 0, (struct symtab **) NULL);
703 /* If failed, try as class/namespace */
705 sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN,
706 0, (struct symtab **) NULL);
711 (t = check_typedef (SYMBOL_TYPE (sym_class)),
712 (TYPE_CODE (t) == TYPE_CODE_STRUCT
713 || TYPE_CODE (t) == TYPE_CODE_UNION))))
715 /* We found a valid token */
716 *token = (char *) xmalloc (prefix_len + 1);
717 memcpy (*token, prefix, prefix_len);
718 (*token)[prefix_len] = '\000';
722 /* No variable or class/namespace found, no more tokens */
724 return (struct symbol *) NULL;
727 /* Out of loop, so we must have found a valid token */
734 *argptr = done ? p : end;
736 return sym_var ? sym_var : sym_class; /* found */
740 find_template_name_end (char *p)
743 int just_seen_right = 0;
744 int just_seen_colon = 0;
745 int just_seen_space = 0;
747 if (!p || (*p != '<'))
758 /* In future, may want to allow these?? */
761 depth++; /* start nested template */
762 if (just_seen_colon || just_seen_right || just_seen_space)
763 return 0; /* but not after : or :: or > or space */
766 if (just_seen_colon || just_seen_right)
767 return 0; /* end a (nested?) template */
768 just_seen_right = 1; /* but not after : or :: */
769 if (--depth == 0) /* also disallow >>, insist on > > */
770 return ++p; /* if outermost ended, return */
773 if (just_seen_space || (just_seen_colon > 1))
774 return 0; /* nested class spec coming up */
775 just_seen_colon++; /* we allow :: but not :::: */
780 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
781 (*p >= 'A' && *p <= 'Z') ||
782 (*p >= '0' && *p <= '9') ||
783 (*p == '_') || (*p == ',') || /* commas for template args */
784 (*p == '&') || (*p == '*') || /* pointer and ref types */
785 (*p == '(') || (*p == ')') || /* function types */
786 (*p == '[') || (*p == ']'))) /* array types */
801 /* Return a null-terminated temporary copy of the name
802 of a string token. */
805 copy_name (struct stoken token)
807 /* Make sure there's enough space for the token. */
808 if (namecopy_size < token.length + 1)
810 namecopy_size = token.length + 1;
811 namecopy = xrealloc (namecopy, token.length + 1);
814 memcpy (namecopy, token.ptr, token.length);
815 namecopy[token.length] = 0;
820 /* Reverse an expression from suffix form (in which it is constructed)
821 to prefix form (in which we can conveniently print or execute it). */
824 prefixify_expression (struct expression *expr)
827 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
828 struct expression *temp;
829 int inpos = expr->nelts, outpos = 0;
831 temp = (struct expression *) alloca (len);
833 /* Copy the original expression into temp. */
834 memcpy (temp, expr, len);
836 prefixify_subexp (temp, expr, inpos, outpos);
839 /* Return the number of exp_elements in the postfix subexpression
840 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
843 length_of_subexp (struct expression *expr, int endpos)
847 operator_length (expr, endpos, &oplen, &args);
851 oplen += length_of_subexp (expr, endpos - oplen);
858 /* Sets *OPLENP to the length of the operator whose (last) index is
859 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
863 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
865 expr->language_defn->la_exp_desc->operator_length (expr, endpos,
869 /* Default value for operator_length in exp_descriptor vectors. */
872 operator_length_standard (struct expression *expr, int endpos,
873 int *oplenp, int *argsp)
877 enum f90_range_type range_type;
881 error (_("?error in operator_length_standard"));
883 i = (int) expr->elts[endpos - 1].opcode;
889 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
890 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
913 case OP_F77_UNDETERMINED_ARGLIST:
915 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
918 case OP_OBJC_MSGCALL: /* Objective C message (method) call */
920 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
935 case UNOP_MEMVAL_TLS:
953 case STRUCTOP_STRUCT:
959 case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant */
960 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op */
963 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
964 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
968 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
969 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
970 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
975 args = longest_to_int (expr->elts[endpos - 2].longconst);
976 args -= longest_to_int (expr->elts[endpos - 3].longconst);
982 case TERNOP_SLICE_COUNT:
987 case MULTI_SUBSCRIPT:
989 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
992 case BINOP_ASSIGN_MODIFY:
1006 range_type = longest_to_int (expr->elts[endpos - 2].longconst);
1009 case LOW_BOUND_DEFAULT:
1010 case HIGH_BOUND_DEFAULT:
1013 case BOTH_BOUND_DEFAULT:
1016 case NONE_BOUND_DEFAULT:
1024 args = 1 + (i < (int) BINOP_END);
1031 /* Copy the subexpression ending just before index INEND in INEXPR
1032 into OUTEXPR, starting at index OUTBEG.
1033 In the process, convert it from suffix to prefix form. */
1036 prefixify_subexp (struct expression *inexpr,
1037 struct expression *outexpr, int inend, int outbeg)
1043 enum exp_opcode opcode;
1045 operator_length (inexpr, inend, &oplen, &args);
1047 /* Copy the final operator itself, from the end of the input
1048 to the beginning of the output. */
1050 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1051 EXP_ELEM_TO_BYTES (oplen));
1054 /* Find the lengths of the arg subexpressions. */
1055 arglens = (int *) alloca (args * sizeof (int));
1056 for (i = args - 1; i >= 0; i--)
1058 oplen = length_of_subexp (inexpr, inend);
1063 /* Now copy each subexpression, preserving the order of
1064 the subexpressions, but prefixifying each one.
1065 In this loop, inend starts at the beginning of
1066 the expression this level is working on
1067 and marches forward over the arguments.
1068 outbeg does similarly in the output. */
1069 for (i = 0; i < args; i++)
1073 prefixify_subexp (inexpr, outexpr, inend, outbeg);
1078 /* This page contains the two entry points to this file. */
1080 /* Read an expression from the string *STRINGPTR points to,
1081 parse it, and return a pointer to a struct expression that we malloc.
1082 Use block BLOCK as the lexical context for variable names;
1083 if BLOCK is zero, use the block of the selected stack frame.
1084 Meanwhile, advance *STRINGPTR to point after the expression,
1085 at the first nonwhite character that is not part of the expression
1086 (possibly a null character).
1088 If COMMA is nonzero, stop if a comma is reached. */
1091 parse_exp_1 (char **stringptr, struct block *block, int comma)
1093 return parse_exp_in_context (stringptr, block, comma, 0);
1096 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1097 no value is expected from the expression. */
1099 static struct expression *
1100 parse_exp_in_context (char **stringptr, struct block *block, int comma,
1103 struct cleanup *old_chain;
1105 lexptr = *stringptr;
1109 type_stack_depth = 0;
1111 comma_terminates = comma;
1113 if (lexptr == 0 || *lexptr == 0)
1114 error_no_arg (_("expression to compute"));
1116 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1119 /* If no context specified, try using the current frame, if any. */
1122 block = get_selected_block (&expression_context_pc);
1124 /* Fall back to using the current source static context, if any. */
1128 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1130 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1133 /* Save the context, if specified by caller, or found above. */
1137 expression_context_block = block;
1138 expression_context_pc = BLOCK_START (block);
1143 expout = (struct expression *)
1144 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1145 expout->language_defn = current_language;
1146 make_cleanup (free_current_contents, &expout);
1148 if (current_language->la_parser ())
1149 current_language->la_error (NULL);
1151 discard_cleanups (old_chain);
1153 /* Record the actual number of expression elements, and then
1154 reallocate the expression memory so that we free up any
1157 expout->nelts = expout_ptr;
1158 expout = (struct expression *)
1159 xrealloc ((char *) expout,
1160 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1162 /* Convert expression from postfix form as generated by yacc
1163 parser, to a prefix form. */
1165 if (expressiondebug)
1166 dump_raw_expression (expout, gdb_stdlog,
1167 "before conversion to prefix form");
1169 prefixify_expression (expout);
1171 current_language->la_post_parser (&expout, void_context_p);
1173 if (expressiondebug)
1174 dump_prefix_expression (expout, gdb_stdlog);
1176 *stringptr = lexptr;
1180 /* Parse STRING as an expression, and complain if this fails
1181 to use up all of the contents of STRING. */
1184 parse_expression (char *string)
1186 struct expression *exp;
1187 exp = parse_exp_1 (&string, 0, 0);
1189 error (_("Junk after end of expression."));
1194 /* As for parse_expression, except that if VOID_CONTEXT_P, then
1195 no value is expected from the expression. */
1198 parse_expression_in_context (char *string, int void_context_p)
1200 struct expression *exp;
1201 exp = parse_exp_in_context (&string, 0, 0, void_context_p);
1202 if (*string != '\000')
1203 error (_("Junk after end of expression."));
1207 /* A post-parser that does nothing */
1210 null_post_parser (struct expression **exp, int void_context_p)
1214 /* Stuff for maintaining a stack of types. Currently just used by C, but
1215 probably useful for any language which declares its types "backwards". */
1218 check_type_stack_depth (void)
1220 if (type_stack_depth == type_stack_size)
1222 type_stack_size *= 2;
1223 type_stack = (union type_stack_elt *)
1224 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1229 push_type (enum type_pieces tp)
1231 check_type_stack_depth ();
1232 type_stack[type_stack_depth++].piece = tp;
1236 push_type_int (int n)
1238 check_type_stack_depth ();
1239 type_stack[type_stack_depth++].int_val = n;
1243 push_type_address_space (char *string)
1245 push_type_int (address_space_name_to_int (string));
1251 if (type_stack_depth)
1252 return type_stack[--type_stack_depth].piece;
1259 if (type_stack_depth)
1260 return type_stack[--type_stack_depth].int_val;
1261 /* "Can't happen". */
1265 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1266 as modified by all the stuff on the stack. */
1268 follow_types (struct type *follow_type)
1272 int make_volatile = 0;
1273 int make_addr_space = 0;
1275 struct type *range_type;
1278 switch (pop_type ())
1283 follow_type = make_cv_type (make_const,
1284 TYPE_VOLATILE (follow_type),
1287 follow_type = make_cv_type (TYPE_CONST (follow_type),
1290 if (make_addr_space)
1291 follow_type = make_type_with_address_space (follow_type,
1293 make_const = make_volatile = 0;
1294 make_addr_space = 0;
1302 case tp_space_identifier:
1303 make_addr_space = pop_type_int ();
1306 follow_type = lookup_pointer_type (follow_type);
1308 follow_type = make_cv_type (make_const,
1309 TYPE_VOLATILE (follow_type),
1312 follow_type = make_cv_type (TYPE_CONST (follow_type),
1315 if (make_addr_space)
1316 follow_type = make_type_with_address_space (follow_type,
1318 make_const = make_volatile = 0;
1319 make_addr_space = 0;
1322 follow_type = lookup_reference_type (follow_type);
1324 follow_type = make_cv_type (make_const,
1325 TYPE_VOLATILE (follow_type),
1328 follow_type = make_cv_type (TYPE_CONST (follow_type),
1331 if (make_addr_space)
1332 follow_type = make_type_with_address_space (follow_type,
1334 make_const = make_volatile = 0;
1335 make_addr_space = 0;
1338 array_size = pop_type_int ();
1339 /* FIXME-type-allocation: need a way to free this type when we are
1342 create_range_type ((struct type *) NULL,
1343 builtin_type_int, 0,
1344 array_size >= 0 ? array_size - 1 : 0);
1346 create_array_type ((struct type *) NULL,
1347 follow_type, range_type);
1349 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1350 = BOUND_CANNOT_BE_DETERMINED;
1353 /* FIXME-type-allocation: need a way to free this type when we are
1355 follow_type = lookup_function_type (follow_type);
1361 static void build_parse (void);
1367 msym_text_symbol_type =
1368 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
1369 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
1370 msym_data_symbol_type =
1371 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1372 "<data variable, no debug info>", NULL);
1373 msym_unknown_symbol_type =
1374 init_type (TYPE_CODE_INT, 1, 0,
1375 "<variable (not text or data), no debug info>",
1378 msym_tls_symbol_type =
1379 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
1380 "<thread local variable, no debug info>", NULL);
1383 /* This function avoids direct calls to fprintf
1384 in the parser generated debug code. */
1386 parser_fprintf (FILE *x, const char *y, ...)
1391 vfprintf_unfiltered (gdb_stderr, y, args);
1394 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1395 vfprintf_unfiltered (gdb_stderr, y, args);
1401 _initialize_parse (void)
1403 type_stack_size = 80;
1404 type_stack_depth = 0;
1405 type_stack = (union type_stack_elt *)
1406 xmalloc (type_stack_size * sizeof (*type_stack));
1410 /* FIXME - For the moment, handle types by swapping them in and out.
1411 Should be using the per-architecture data-pointer and a large
1413 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_text_symbol_type);
1414 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_data_symbol_type);
1415 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_unknown_symbol_type);
1416 deprecated_register_gdbarch_swap (NULL, 0, build_parse);
1418 add_setshow_zinteger_cmd ("expression", class_maintenance,
1419 &expressiondebug, _("\
1420 Set expression debugging."), _("\
1421 Show expression debugging."), _("\
1422 When non-zero, the internal representation of expressions will be printed."),
1424 show_expressiondebug,
1425 &setdebuglist, &showdebuglist);