1 /* Parse expressions for GDB.
3 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 1998, 1999, 2000, 2001, 2004, 2005, 2007, 2008
5 Free Software Foundation, Inc.
7 Modified from expread.y by the Department of Computer Science at the
8 State University of New York at Buffalo, 1991.
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 /* Parse an expression from text in a string,
26 and return the result as a struct expression pointer.
27 That structure contains arithmetic operations in reverse polish,
28 with constants represented by operations that are followed by special data.
29 See expression.h for the details of the format.
30 What is important here is that it can be built up sequentially
31 during the process of parsing; the lower levels of the tree always
32 come first in the result. */
37 #include "gdb_string.h"
41 #include "expression.h"
46 #include "parser-defs.h"
48 #include "symfile.h" /* for overlay functions */
51 #include "gdb_assert.h"
55 #include "exceptions.h"
56 #include "user-regs.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 /* True if parsing an expression to find a field reference. This is
86 only used by completion. */
89 /* The index of the last struct expression directly before a '.' or
90 '->'. This is set when parsing and is only used when completing a
91 field name. It is -1 if no dereference operation was found. */
92 static int expout_last_struct = -1;
94 /* A temporary buffer for identifiers, so we can null-terminate them.
96 We allocate this with xrealloc. parse_exp_1 used to allocate with
97 alloca, using the size of the whole expression as a conservative
98 estimate of the space needed. However, macro expansion can
99 introduce names longer than the original expression; there's no
100 practical way to know beforehand how large that might be. */
102 size_t namecopy_size;
104 static int expressiondebug = 0;
106 show_expressiondebug (struct ui_file *file, int from_tty,
107 struct cmd_list_element *c, const char *value)
109 fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
112 static void free_funcalls (void *ignore);
114 static int prefixify_expression (struct expression *);
116 static int prefixify_subexp (struct expression *, struct expression *, int,
119 static struct expression *parse_exp_in_context (char **, struct block *, int,
122 void _initialize_parse (void);
124 /* Data structure for saving values of arglist_len for function calls whose
125 arguments contain other function calls. */
129 struct funcall *next;
133 static struct funcall *funcall_chain;
135 /* Begin counting arguments for a function call,
136 saving the data about any containing call. */
143 new = (struct funcall *) xmalloc (sizeof (struct funcall));
144 new->next = funcall_chain;
145 new->arglist_len = arglist_len;
150 /* Return the number of arguments in a function call just terminated,
151 and restore the data for the containing function call. */
156 int val = arglist_len;
157 struct funcall *call = funcall_chain;
158 funcall_chain = call->next;
159 arglist_len = call->arglist_len;
164 /* Free everything in the funcall chain.
165 Used when there is an error inside parsing. */
168 free_funcalls (void *ignore)
170 struct funcall *call, *next;
172 for (call = funcall_chain; call; call = next)
179 /* This page contains the functions for adding data to the struct expression
180 being constructed. */
182 /* Add one element to the end of the expression. */
184 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
185 a register through here */
188 write_exp_elt (union exp_element expelt)
190 if (expout_ptr >= expout_size)
193 expout = (struct expression *)
194 xrealloc ((char *) expout, sizeof (struct expression)
195 + EXP_ELEM_TO_BYTES (expout_size));
197 expout->elts[expout_ptr++] = expelt;
201 write_exp_elt_opcode (enum exp_opcode expelt)
203 union exp_element tmp;
204 memset (&tmp, 0, sizeof (union exp_element));
212 write_exp_elt_sym (struct symbol *expelt)
214 union exp_element tmp;
215 memset (&tmp, 0, sizeof (union exp_element));
223 write_exp_elt_block (struct block *b)
225 union exp_element tmp;
226 memset (&tmp, 0, sizeof (union exp_element));
232 write_exp_elt_objfile (struct objfile *objfile)
234 union exp_element tmp;
235 memset (&tmp, 0, sizeof (union exp_element));
236 tmp.objfile = objfile;
241 write_exp_elt_longcst (LONGEST expelt)
243 union exp_element tmp;
244 memset (&tmp, 0, sizeof (union exp_element));
246 tmp.longconst = expelt;
252 write_exp_elt_dblcst (DOUBLEST expelt)
254 union exp_element tmp;
255 memset (&tmp, 0, sizeof (union exp_element));
257 tmp.doubleconst = expelt;
263 write_exp_elt_decfloatcst (gdb_byte expelt[16])
265 union exp_element tmp;
268 for (index = 0; index < 16; index++)
269 tmp.decfloatconst[index] = expelt[index];
275 write_exp_elt_type (struct type *expelt)
277 union exp_element tmp;
278 memset (&tmp, 0, sizeof (union exp_element));
286 write_exp_elt_intern (struct internalvar *expelt)
288 union exp_element tmp;
289 memset (&tmp, 0, sizeof (union exp_element));
291 tmp.internalvar = expelt;
296 /* Add a string constant to the end of the expression.
298 String constants are stored by first writing an expression element
299 that contains the length of the string, then stuffing the string
300 constant itself into however many expression elements are needed
301 to hold it, and then writing another expression element that contains
302 the length of the string. I.E. an expression element at each end of
303 the string records the string length, so you can skip over the
304 expression elements containing the actual string bytes from either
305 end of the string. Note that this also allows gdb to handle
306 strings with embedded null bytes, as is required for some languages.
308 Don't be fooled by the fact that the string is null byte terminated,
309 this is strictly for the convenience of debugging gdb itself. Gdb
310 Gdb does not depend up the string being null terminated, since the
311 actual length is recorded in expression elements at each end of the
312 string. The null byte is taken into consideration when computing how
313 many expression elements are required to hold the string constant, of
318 write_exp_string (struct stoken str)
320 int len = str.length;
324 /* Compute the number of expression elements required to hold the string
325 (including a null byte terminator), along with one expression element
326 at each end to record the actual string length (not including the
327 null byte terminator). */
329 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
331 /* Ensure that we have enough available expression elements to store
334 if ((expout_ptr + lenelt) >= expout_size)
336 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
337 expout = (struct expression *)
338 xrealloc ((char *) expout, (sizeof (struct expression)
339 + EXP_ELEM_TO_BYTES (expout_size)));
342 /* Write the leading length expression element (which advances the current
343 expression element index), then write the string constant followed by a
344 terminating null byte, and then write the trailing length expression
347 write_exp_elt_longcst ((LONGEST) len);
348 strdata = (char *) &expout->elts[expout_ptr];
349 memcpy (strdata, str.ptr, len);
350 *(strdata + len) = '\0';
351 expout_ptr += lenelt - 2;
352 write_exp_elt_longcst ((LONGEST) len);
355 /* Add a bitstring constant to the end of the expression.
357 Bitstring constants are stored by first writing an expression element
358 that contains the length of the bitstring (in bits), then stuffing the
359 bitstring constant itself into however many expression elements are
360 needed to hold it, and then writing another expression element that
361 contains the length of the bitstring. I.E. an expression element at
362 each end of the bitstring records the bitstring length, so you can skip
363 over the expression elements containing the actual bitstring bytes from
364 either end of the bitstring. */
367 write_exp_bitstring (struct stoken str)
369 int bits = str.length; /* length in bits */
370 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
374 /* Compute the number of expression elements required to hold the bitstring,
375 along with one expression element at each end to record the actual
376 bitstring length in bits. */
378 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
380 /* Ensure that we have enough available expression elements to store
383 if ((expout_ptr + lenelt) >= expout_size)
385 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
386 expout = (struct expression *)
387 xrealloc ((char *) expout, (sizeof (struct expression)
388 + EXP_ELEM_TO_BYTES (expout_size)));
391 /* Write the leading length expression element (which advances the current
392 expression element index), then write the bitstring constant, and then
393 write the trailing length expression element. */
395 write_exp_elt_longcst ((LONGEST) bits);
396 strdata = (char *) &expout->elts[expout_ptr];
397 memcpy (strdata, str.ptr, len);
398 expout_ptr += lenelt - 2;
399 write_exp_elt_longcst ((LONGEST) bits);
402 /* Add the appropriate elements for a minimal symbol to the end of
406 write_exp_msymbol (struct minimal_symbol *msymbol)
408 struct objfile *objfile = msymbol_objfile (msymbol);
409 struct gdbarch *gdbarch = get_objfile_arch (objfile);
411 CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
412 struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
413 enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
416 /* The minimal symbol might point to a function descriptor;
417 resolve it to the actual code address instead. */
418 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target);
421 /* In this case, assume we have a code symbol instead of
428 if (overlay_debugging)
429 addr = symbol_overlayed_address (addr, section);
431 write_exp_elt_opcode (OP_LONG);
432 /* Let's make the type big enough to hold a 64-bit address. */
433 write_exp_elt_type (builtin_type (gdbarch)->builtin_core_addr);
434 write_exp_elt_longcst ((LONGEST) addr);
435 write_exp_elt_opcode (OP_LONG);
437 if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
439 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
440 write_exp_elt_objfile (objfile);
441 write_exp_elt_type (builtin_type (gdbarch)->nodebug_tls_symbol);
442 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
446 write_exp_elt_opcode (UNOP_MEMVAL);
451 case mst_solib_trampoline:
452 write_exp_elt_type (builtin_type (gdbarch)->nodebug_text_symbol);
459 write_exp_elt_type (builtin_type (gdbarch)->nodebug_data_symbol);
463 write_exp_elt_type (builtin_type (gdbarch)->nodebug_unknown_symbol);
466 write_exp_elt_opcode (UNOP_MEMVAL);
469 /* Mark the current index as the starting location of a structure
470 expression. This is used when completing on field names. */
473 mark_struct_expression (void)
475 expout_last_struct = expout_ptr;
479 /* Recognize tokens that start with '$'. These include:
481 $regname A native register name or a "standard
484 $variable A convenience variable with a name chosen
487 $digits Value history with index <digits>, starting
488 from the first value which has index 1.
490 $$digits Value history with index <digits> relative
491 to the last value. I.E. $$0 is the last
492 value, $$1 is the one previous to that, $$2
493 is the one previous to $$1, etc.
495 $ | $0 | $$0 The last value in the value history.
497 $$ An abbreviation for the second to the last
498 value in the value history, I.E. $$1
503 write_dollar_variable (struct stoken str)
505 struct symbol *sym = NULL;
506 struct minimal_symbol *msym = NULL;
507 struct internalvar *isym = NULL;
509 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
510 and $$digits (equivalent to $<-digits> if you could type that). */
514 /* Double dollar means negate the number and add -1 as well.
515 Thus $$ alone means -1. */
516 if (str.length >= 2 && str.ptr[1] == '$')
523 /* Just dollars (one or two) */
527 /* Is the rest of the token digits? */
528 for (; i < str.length; i++)
529 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
533 i = atoi (str.ptr + 1 + negate);
539 /* Handle tokens that refer to machine registers:
540 $ followed by a register name. */
541 i = user_reg_map_name_to_regnum (current_gdbarch,
542 str.ptr + 1, str.length - 1);
544 goto handle_register;
546 /* Any names starting with $ are probably debugger internal variables. */
548 isym = lookup_only_internalvar (copy_name (str) + 1);
551 write_exp_elt_opcode (OP_INTERNALVAR);
552 write_exp_elt_intern (isym);
553 write_exp_elt_opcode (OP_INTERNALVAR);
557 /* On some systems, such as HP-UX and hppa-linux, certain system routines
558 have names beginning with $ or $$. Check for those, first. */
560 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
561 VAR_DOMAIN, (int *) NULL);
564 write_exp_elt_opcode (OP_VAR_VALUE);
565 write_exp_elt_block (block_found); /* set by lookup_symbol */
566 write_exp_elt_sym (sym);
567 write_exp_elt_opcode (OP_VAR_VALUE);
570 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
573 write_exp_msymbol (msym);
577 /* Any other names are assumed to be debugger internal variables. */
579 write_exp_elt_opcode (OP_INTERNALVAR);
580 write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
581 write_exp_elt_opcode (OP_INTERNALVAR);
584 write_exp_elt_opcode (OP_LAST);
585 write_exp_elt_longcst ((LONGEST) i);
586 write_exp_elt_opcode (OP_LAST);
589 write_exp_elt_opcode (OP_REGISTER);
592 write_exp_string (str);
593 write_exp_elt_opcode (OP_REGISTER);
599 find_template_name_end (char *p)
602 int just_seen_right = 0;
603 int just_seen_colon = 0;
604 int just_seen_space = 0;
606 if (!p || (*p != '<'))
617 /* In future, may want to allow these?? */
620 depth++; /* start nested template */
621 if (just_seen_colon || just_seen_right || just_seen_space)
622 return 0; /* but not after : or :: or > or space */
625 if (just_seen_colon || just_seen_right)
626 return 0; /* end a (nested?) template */
627 just_seen_right = 1; /* but not after : or :: */
628 if (--depth == 0) /* also disallow >>, insist on > > */
629 return ++p; /* if outermost ended, return */
632 if (just_seen_space || (just_seen_colon > 1))
633 return 0; /* nested class spec coming up */
634 just_seen_colon++; /* we allow :: but not :::: */
639 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
640 (*p >= 'A' && *p <= 'Z') ||
641 (*p >= '0' && *p <= '9') ||
642 (*p == '_') || (*p == ',') || /* commas for template args */
643 (*p == '&') || (*p == '*') || /* pointer and ref types */
644 (*p == '(') || (*p == ')') || /* function types */
645 (*p == '[') || (*p == ']'))) /* array types */
660 /* Return a null-terminated temporary copy of the name
661 of a string token. */
664 copy_name (struct stoken token)
666 /* Make sure there's enough space for the token. */
667 if (namecopy_size < token.length + 1)
669 namecopy_size = token.length + 1;
670 namecopy = xrealloc (namecopy, token.length + 1);
673 memcpy (namecopy, token.ptr, token.length);
674 namecopy[token.length] = 0;
679 /* Reverse an expression from suffix form (in which it is constructed)
680 to prefix form (in which we can conveniently print or execute it).
681 Ordinarily this always returns -1. However, if EXPOUT_LAST_STRUCT
682 is not -1 (i.e., we are trying to complete a field name), it will
683 return the index of the subexpression which is the left-hand-side
684 of the struct operation at EXPOUT_LAST_STRUCT. */
687 prefixify_expression (struct expression *expr)
689 int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
690 struct expression *temp;
691 int inpos = expr->nelts, outpos = 0;
693 temp = (struct expression *) alloca (len);
695 /* Copy the original expression into temp. */
696 memcpy (temp, expr, len);
698 return prefixify_subexp (temp, expr, inpos, outpos);
701 /* Return the number of exp_elements in the postfix subexpression
702 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
705 length_of_subexp (struct expression *expr, int endpos)
709 operator_length (expr, endpos, &oplen, &args);
713 oplen += length_of_subexp (expr, endpos - oplen);
720 /* Sets *OPLENP to the length of the operator whose (last) index is
721 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
725 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
727 expr->language_defn->la_exp_desc->operator_length (expr, endpos,
731 /* Default value for operator_length in exp_descriptor vectors. */
734 operator_length_standard (struct expression *expr, int endpos,
735 int *oplenp, int *argsp)
739 enum f90_range_type range_type;
743 error (_("?error in operator_length_standard"));
745 i = (int) expr->elts[endpos - 1].opcode;
751 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
752 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
775 case OP_F77_UNDETERMINED_ARGLIST:
777 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
780 case OP_OBJC_MSGCALL: /* Objective C message (method) call */
782 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
797 case UNOP_MEMVAL_TLS:
815 case STRUCTOP_STRUCT:
822 case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant */
823 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op */
825 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
826 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
830 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
831 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
832 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
837 args = longest_to_int (expr->elts[endpos - 2].longconst);
838 args -= longest_to_int (expr->elts[endpos - 3].longconst);
844 case TERNOP_SLICE_COUNT:
849 case MULTI_SUBSCRIPT:
851 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
854 case BINOP_ASSIGN_MODIFY:
868 range_type = longest_to_int (expr->elts[endpos - 2].longconst);
871 case LOW_BOUND_DEFAULT:
872 case HIGH_BOUND_DEFAULT:
875 case BOTH_BOUND_DEFAULT:
878 case NONE_BOUND_DEFAULT:
886 args = 1 + (i < (int) BINOP_END);
893 /* Copy the subexpression ending just before index INEND in INEXPR
894 into OUTEXPR, starting at index OUTBEG.
895 In the process, convert it from suffix to prefix form.
896 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
897 Otherwise, it returns the index of the subexpression which is the
898 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
901 prefixify_subexp (struct expression *inexpr,
902 struct expression *outexpr, int inend, int outbeg)
908 enum exp_opcode opcode;
911 operator_length (inexpr, inend, &oplen, &args);
913 /* Copy the final operator itself, from the end of the input
914 to the beginning of the output. */
916 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
917 EXP_ELEM_TO_BYTES (oplen));
920 if (expout_last_struct == inend)
921 result = outbeg - oplen;
923 /* Find the lengths of the arg subexpressions. */
924 arglens = (int *) alloca (args * sizeof (int));
925 for (i = args - 1; i >= 0; i--)
927 oplen = length_of_subexp (inexpr, inend);
932 /* Now copy each subexpression, preserving the order of
933 the subexpressions, but prefixifying each one.
934 In this loop, inend starts at the beginning of
935 the expression this level is working on
936 and marches forward over the arguments.
937 outbeg does similarly in the output. */
938 for (i = 0; i < args; i++)
943 r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
946 /* Return immediately. We probably have only parsed a
947 partial expression, so we don't want to try to reverse
948 the other operands. */
957 /* This page contains the two entry points to this file. */
959 /* Read an expression from the string *STRINGPTR points to,
960 parse it, and return a pointer to a struct expression that we malloc.
961 Use block BLOCK as the lexical context for variable names;
962 if BLOCK is zero, use the block of the selected stack frame.
963 Meanwhile, advance *STRINGPTR to point after the expression,
964 at the first nonwhite character that is not part of the expression
965 (possibly a null character).
967 If COMMA is nonzero, stop if a comma is reached. */
970 parse_exp_1 (char **stringptr, struct block *block, int comma)
972 return parse_exp_in_context (stringptr, block, comma, 0, NULL);
975 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
976 no value is expected from the expression.
977 OUT_SUBEXP is set when attempting to complete a field name; in this
978 case it is set to the index of the subexpression on the
979 left-hand-side of the struct op. If not doing such completion, it
980 is left untouched. */
982 static struct expression *
983 parse_exp_in_context (char **stringptr, struct block *block, int comma,
984 int void_context_p, int *out_subexp)
986 volatile struct gdb_exception except;
987 struct cleanup *old_chain;
994 type_stack_depth = 0;
995 expout_last_struct = -1;
997 comma_terminates = comma;
999 if (lexptr == 0 || *lexptr == 0)
1000 error_no_arg (_("expression to compute"));
1002 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1005 expression_context_block = block;
1007 /* If no context specified, try using the current frame, if any. */
1008 if (!expression_context_block)
1009 expression_context_block = get_selected_block (&expression_context_pc);
1011 expression_context_pc = BLOCK_START (expression_context_block);
1013 /* Fall back to using the current source static context, if any. */
1015 if (!expression_context_block)
1017 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1019 expression_context_block
1020 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1021 if (expression_context_block)
1022 expression_context_pc = BLOCK_START (expression_context_block);
1027 expout = (struct expression *)
1028 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1029 expout->language_defn = current_language;
1030 expout->gdbarch = current_gdbarch;
1032 TRY_CATCH (except, RETURN_MASK_ALL)
1034 if (current_language->la_parser ())
1035 current_language->la_error (NULL);
1037 if (except.reason < 0)
1039 if (! in_parse_field)
1042 throw_exception (except);
1046 discard_cleanups (old_chain);
1048 /* Record the actual number of expression elements, and then
1049 reallocate the expression memory so that we free up any
1052 expout->nelts = expout_ptr;
1053 expout = (struct expression *)
1054 xrealloc ((char *) expout,
1055 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1057 /* Convert expression from postfix form as generated by yacc
1058 parser, to a prefix form. */
1060 if (expressiondebug)
1061 dump_raw_expression (expout, gdb_stdlog,
1062 "before conversion to prefix form");
1064 subexp = prefixify_expression (expout);
1066 *out_subexp = subexp;
1068 current_language->la_post_parser (&expout, void_context_p);
1070 if (expressiondebug)
1071 dump_prefix_expression (expout, gdb_stdlog);
1073 *stringptr = lexptr;
1077 /* Parse STRING as an expression, and complain if this fails
1078 to use up all of the contents of STRING. */
1081 parse_expression (char *string)
1083 struct expression *exp;
1084 exp = parse_exp_1 (&string, 0, 0);
1086 error (_("Junk after end of expression."));
1090 /* Parse STRING as an expression. If parsing ends in the middle of a
1091 field reference, return the type of the left-hand-side of the
1092 reference; furthermore, if the parsing ends in the field name,
1093 return the field name in *NAME. In all other cases, return NULL. */
1096 parse_field_expression (char *string, char **name)
1098 struct expression *exp = NULL;
1101 volatile struct gdb_exception except;
1103 TRY_CATCH (except, RETURN_MASK_ALL)
1106 exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
1109 if (except.reason < 0 || ! exp)
1111 if (expout_last_struct == -1)
1117 *name = extract_field_op (exp, &subexp);
1123 val = evaluate_subexpression_type (exp, subexp);
1126 return value_type (val);
1129 /* A post-parser that does nothing */
1132 null_post_parser (struct expression **exp, int void_context_p)
1136 /* Stuff for maintaining a stack of types. Currently just used by C, but
1137 probably useful for any language which declares its types "backwards". */
1140 check_type_stack_depth (void)
1142 if (type_stack_depth == type_stack_size)
1144 type_stack_size *= 2;
1145 type_stack = (union type_stack_elt *)
1146 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1151 push_type (enum type_pieces tp)
1153 check_type_stack_depth ();
1154 type_stack[type_stack_depth++].piece = tp;
1158 push_type_int (int n)
1160 check_type_stack_depth ();
1161 type_stack[type_stack_depth++].int_val = n;
1165 push_type_address_space (char *string)
1167 push_type_int (address_space_name_to_int (string));
1173 if (type_stack_depth)
1174 return type_stack[--type_stack_depth].piece;
1181 if (type_stack_depth)
1182 return type_stack[--type_stack_depth].int_val;
1183 /* "Can't happen". */
1187 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1188 as modified by all the stuff on the stack. */
1190 follow_types (struct type *follow_type)
1194 int make_volatile = 0;
1195 int make_addr_space = 0;
1197 struct type *range_type;
1200 switch (pop_type ())
1205 follow_type = make_cv_type (make_const,
1206 TYPE_VOLATILE (follow_type),
1209 follow_type = make_cv_type (TYPE_CONST (follow_type),
1212 if (make_addr_space)
1213 follow_type = make_type_with_address_space (follow_type,
1215 make_const = make_volatile = 0;
1216 make_addr_space = 0;
1224 case tp_space_identifier:
1225 make_addr_space = pop_type_int ();
1228 follow_type = lookup_pointer_type (follow_type);
1230 follow_type = make_cv_type (make_const,
1231 TYPE_VOLATILE (follow_type),
1234 follow_type = make_cv_type (TYPE_CONST (follow_type),
1237 if (make_addr_space)
1238 follow_type = make_type_with_address_space (follow_type,
1240 make_const = make_volatile = 0;
1241 make_addr_space = 0;
1244 follow_type = lookup_reference_type (follow_type);
1246 follow_type = make_cv_type (make_const,
1247 TYPE_VOLATILE (follow_type),
1250 follow_type = make_cv_type (TYPE_CONST (follow_type),
1253 if (make_addr_space)
1254 follow_type = make_type_with_address_space (follow_type,
1256 make_const = make_volatile = 0;
1257 make_addr_space = 0;
1260 array_size = pop_type_int ();
1261 /* FIXME-type-allocation: need a way to free this type when we are
1264 create_range_type ((struct type *) NULL,
1265 builtin_type_int32, 0,
1266 array_size >= 0 ? array_size - 1 : 0);
1268 create_array_type ((struct type *) NULL,
1269 follow_type, range_type);
1271 TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1274 /* FIXME-type-allocation: need a way to free this type when we are
1276 follow_type = lookup_function_type (follow_type);
1282 /* This function avoids direct calls to fprintf
1283 in the parser generated debug code. */
1285 parser_fprintf (FILE *x, const char *y, ...)
1290 vfprintf_unfiltered (gdb_stderr, y, args);
1293 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1294 vfprintf_unfiltered (gdb_stderr, y, args);
1300 _initialize_parse (void)
1302 type_stack_size = 80;
1303 type_stack_depth = 0;
1304 type_stack = (union type_stack_elt *)
1305 xmalloc (type_stack_size * sizeof (*type_stack));
1307 add_setshow_zinteger_cmd ("expression", class_maintenance,
1308 &expressiondebug, _("\
1309 Set expression debugging."), _("\
1310 Show expression debugging."), _("\
1311 When non-zero, the internal representation of expressions will be printed."),
1313 show_expressiondebug,
1314 &setdebuglist, &showdebuglist);