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
403 the expression. The rationale behind passing in text_symbol_type and
404 data_symbol_type was so that Modula-2 could pass in WORD for
405 data_symbol_type. Perhaps it still is useful to have those types vary
406 based on the language, but they no longer have names like "int", so
407 the initial rationale is gone. */
410 write_exp_msymbol (struct minimal_symbol *msymbol,
411 struct type *text_symbol_type,
412 struct type *data_symbol_type)
414 struct objfile *objfile = msymbol_objfile (msymbol);
415 struct gdbarch *gdbarch = get_objfile_arch (objfile);
417 CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
418 asection *bfd_section = SYMBOL_BFD_SECTION (msymbol);
419 enum minimal_symbol_type type = msymbol->type;
422 /* The minimal symbol might point to a function descriptor;
423 resolve it to the actual code address instead. */
424 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target);
427 /* In this case, assume we have a code symbol instead of
434 if (overlay_debugging)
435 addr = symbol_overlayed_address (addr, bfd_section);
437 write_exp_elt_opcode (OP_LONG);
438 /* Let's make the type big enough to hold a 64-bit address. */
439 write_exp_elt_type (builtin_type_CORE_ADDR);
440 write_exp_elt_longcst ((LONGEST) addr);
441 write_exp_elt_opcode (OP_LONG);
443 if (bfd_section && bfd_section->flags & SEC_THREAD_LOCAL)
445 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
446 write_exp_elt_objfile (objfile);
447 write_exp_elt_type (builtin_type (gdbarch)->nodebug_tls_symbol);
448 write_exp_elt_opcode (UNOP_MEMVAL_TLS);
452 write_exp_elt_opcode (UNOP_MEMVAL);
457 case mst_solib_trampoline:
458 write_exp_elt_type (builtin_type (gdbarch)->nodebug_text_symbol);
465 write_exp_elt_type (builtin_type (gdbarch)->nodebug_data_symbol);
469 write_exp_elt_type (builtin_type (gdbarch)->nodebug_unknown_symbol);
472 write_exp_elt_opcode (UNOP_MEMVAL);
475 /* Mark the current index as the starting location of a structure
476 expression. This is used when completing on field names. */
479 mark_struct_expression (void)
481 expout_last_struct = expout_ptr;
485 /* Recognize tokens that start with '$'. These include:
487 $regname A native register name or a "standard
490 $variable A convenience variable with a name chosen
493 $digits Value history with index <digits>, starting
494 from the first value which has index 1.
496 $$digits Value history with index <digits> relative
497 to the last value. I.E. $$0 is the last
498 value, $$1 is the one previous to that, $$2
499 is the one previous to $$1, etc.
501 $ | $0 | $$0 The last value in the value history.
503 $$ An abbreviation for the second to the last
504 value in the value history, I.E. $$1
509 write_dollar_variable (struct stoken str)
511 struct symbol *sym = NULL;
512 struct minimal_symbol *msym = NULL;
513 struct internalvar *isym = NULL;
515 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
516 and $$digits (equivalent to $<-digits> if you could type that). */
520 /* Double dollar means negate the number and add -1 as well.
521 Thus $$ alone means -1. */
522 if (str.length >= 2 && str.ptr[1] == '$')
529 /* Just dollars (one or two) */
533 /* Is the rest of the token digits? */
534 for (; i < str.length; i++)
535 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
539 i = atoi (str.ptr + 1 + negate);
545 /* Handle tokens that refer to machine registers:
546 $ followed by a register name. */
547 i = user_reg_map_name_to_regnum (current_gdbarch,
548 str.ptr + 1, str.length - 1);
550 goto handle_register;
552 /* Any names starting with $ are probably debugger internal variables. */
554 isym = lookup_only_internalvar (copy_name (str) + 1);
557 write_exp_elt_opcode (OP_INTERNALVAR);
558 write_exp_elt_intern (isym);
559 write_exp_elt_opcode (OP_INTERNALVAR);
563 /* On some systems, such as HP-UX and hppa-linux, certain system routines
564 have names beginning with $ or $$. Check for those, first. */
566 sym = lookup_symbol (copy_name (str), (struct block *) NULL,
567 VAR_DOMAIN, (int *) NULL);
570 write_exp_elt_opcode (OP_VAR_VALUE);
571 write_exp_elt_block (block_found); /* set by lookup_symbol */
572 write_exp_elt_sym (sym);
573 write_exp_elt_opcode (OP_VAR_VALUE);
576 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
579 write_exp_msymbol (msym,
580 lookup_function_type (builtin_type_int),
585 /* Any other names are assumed to be debugger internal variables. */
587 write_exp_elt_opcode (OP_INTERNALVAR);
588 write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
589 write_exp_elt_opcode (OP_INTERNALVAR);
592 write_exp_elt_opcode (OP_LAST);
593 write_exp_elt_longcst ((LONGEST) i);
594 write_exp_elt_opcode (OP_LAST);
597 write_exp_elt_opcode (OP_REGISTER);
600 write_exp_string (str);
601 write_exp_elt_opcode (OP_REGISTER);
607 find_template_name_end (char *p)
610 int just_seen_right = 0;
611 int just_seen_colon = 0;
612 int just_seen_space = 0;
614 if (!p || (*p != '<'))
625 /* In future, may want to allow these?? */
628 depth++; /* start nested template */
629 if (just_seen_colon || just_seen_right || just_seen_space)
630 return 0; /* but not after : or :: or > or space */
633 if (just_seen_colon || just_seen_right)
634 return 0; /* end a (nested?) template */
635 just_seen_right = 1; /* but not after : or :: */
636 if (--depth == 0) /* also disallow >>, insist on > > */
637 return ++p; /* if outermost ended, return */
640 if (just_seen_space || (just_seen_colon > 1))
641 return 0; /* nested class spec coming up */
642 just_seen_colon++; /* we allow :: but not :::: */
647 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
648 (*p >= 'A' && *p <= 'Z') ||
649 (*p >= '0' && *p <= '9') ||
650 (*p == '_') || (*p == ',') || /* commas for template args */
651 (*p == '&') || (*p == '*') || /* pointer and ref types */
652 (*p == '(') || (*p == ')') || /* function types */
653 (*p == '[') || (*p == ']'))) /* array types */
668 /* Return a null-terminated temporary copy of the name
669 of a string token. */
672 copy_name (struct stoken token)
674 /* Make sure there's enough space for the token. */
675 if (namecopy_size < token.length + 1)
677 namecopy_size = token.length + 1;
678 namecopy = xrealloc (namecopy, token.length + 1);
681 memcpy (namecopy, token.ptr, token.length);
682 namecopy[token.length] = 0;
687 /* Reverse an expression from suffix form (in which it is constructed)
688 to prefix form (in which we can conveniently print or execute it).
689 Ordinarily this always returns -1. However, if EXPOUT_LAST_STRUCT
690 is not -1 (i.e., we are trying to complete a field name), it will
691 return the index of the subexpression which is the left-hand-side
692 of the struct operation at EXPOUT_LAST_STRUCT. */
695 prefixify_expression (struct expression *expr)
697 int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
698 struct expression *temp;
699 int inpos = expr->nelts, outpos = 0;
701 temp = (struct expression *) alloca (len);
703 /* Copy the original expression into temp. */
704 memcpy (temp, expr, len);
706 return prefixify_subexp (temp, expr, inpos, outpos);
709 /* Return the number of exp_elements in the postfix subexpression
710 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
713 length_of_subexp (struct expression *expr, int endpos)
717 operator_length (expr, endpos, &oplen, &args);
721 oplen += length_of_subexp (expr, endpos - oplen);
728 /* Sets *OPLENP to the length of the operator whose (last) index is
729 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
733 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
735 expr->language_defn->la_exp_desc->operator_length (expr, endpos,
739 /* Default value for operator_length in exp_descriptor vectors. */
742 operator_length_standard (struct expression *expr, int endpos,
743 int *oplenp, int *argsp)
747 enum f90_range_type range_type;
751 error (_("?error in operator_length_standard"));
753 i = (int) expr->elts[endpos - 1].opcode;
759 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
760 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
783 case OP_F77_UNDETERMINED_ARGLIST:
785 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
788 case OP_OBJC_MSGCALL: /* Objective C message (method) call */
790 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
805 case UNOP_MEMVAL_TLS:
823 case STRUCTOP_STRUCT:
830 case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant */
831 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op */
833 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
834 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
838 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
839 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
840 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
845 args = longest_to_int (expr->elts[endpos - 2].longconst);
846 args -= longest_to_int (expr->elts[endpos - 3].longconst);
852 case TERNOP_SLICE_COUNT:
857 case MULTI_SUBSCRIPT:
859 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
862 case BINOP_ASSIGN_MODIFY:
876 range_type = longest_to_int (expr->elts[endpos - 2].longconst);
879 case LOW_BOUND_DEFAULT:
880 case HIGH_BOUND_DEFAULT:
883 case BOTH_BOUND_DEFAULT:
886 case NONE_BOUND_DEFAULT:
894 args = 1 + (i < (int) BINOP_END);
901 /* Copy the subexpression ending just before index INEND in INEXPR
902 into OUTEXPR, starting at index OUTBEG.
903 In the process, convert it from suffix to prefix form.
904 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
905 Otherwise, it returns the index of the subexpression which is the
906 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
909 prefixify_subexp (struct expression *inexpr,
910 struct expression *outexpr, int inend, int outbeg)
916 enum exp_opcode opcode;
919 operator_length (inexpr, inend, &oplen, &args);
921 /* Copy the final operator itself, from the end of the input
922 to the beginning of the output. */
924 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
925 EXP_ELEM_TO_BYTES (oplen));
928 if (expout_last_struct == inend)
929 result = outbeg - oplen;
931 /* Find the lengths of the arg subexpressions. */
932 arglens = (int *) alloca (args * sizeof (int));
933 for (i = args - 1; i >= 0; i--)
935 oplen = length_of_subexp (inexpr, inend);
940 /* Now copy each subexpression, preserving the order of
941 the subexpressions, but prefixifying each one.
942 In this loop, inend starts at the beginning of
943 the expression this level is working on
944 and marches forward over the arguments.
945 outbeg does similarly in the output. */
946 for (i = 0; i < args; i++)
951 r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
954 /* Return immediately. We probably have only parsed a
955 partial expression, so we don't want to try to reverse
956 the other operands. */
965 /* This page contains the two entry points to this file. */
967 /* Read an expression from the string *STRINGPTR points to,
968 parse it, and return a pointer to a struct expression that we malloc.
969 Use block BLOCK as the lexical context for variable names;
970 if BLOCK is zero, use the block of the selected stack frame.
971 Meanwhile, advance *STRINGPTR to point after the expression,
972 at the first nonwhite character that is not part of the expression
973 (possibly a null character).
975 If COMMA is nonzero, stop if a comma is reached. */
978 parse_exp_1 (char **stringptr, struct block *block, int comma)
980 return parse_exp_in_context (stringptr, block, comma, 0, NULL);
983 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
984 no value is expected from the expression.
985 OUT_SUBEXP is set when attempting to complete a field name; in this
986 case it is set to the index of the subexpression on the
987 left-hand-side of the struct op. If not doing such completion, it
988 is left untouched. */
990 static struct expression *
991 parse_exp_in_context (char **stringptr, struct block *block, int comma,
992 int void_context_p, int *out_subexp)
994 volatile struct gdb_exception except;
995 struct cleanup *old_chain;
1002 type_stack_depth = 0;
1003 expout_last_struct = -1;
1005 comma_terminates = comma;
1007 if (lexptr == 0 || *lexptr == 0)
1008 error_no_arg (_("expression to compute"));
1010 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1013 expression_context_block = block;
1015 /* If no context specified, try using the current frame, if any. */
1016 if (!expression_context_block)
1017 expression_context_block = get_selected_block (&expression_context_pc);
1019 expression_context_pc = BLOCK_START (expression_context_block);
1021 /* Fall back to using the current source static context, if any. */
1023 if (!expression_context_block)
1025 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1027 expression_context_block
1028 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1029 if (expression_context_block)
1030 expression_context_pc = BLOCK_START (expression_context_block);
1035 expout = (struct expression *)
1036 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1037 expout->language_defn = current_language;
1039 TRY_CATCH (except, RETURN_MASK_ALL)
1041 if (current_language->la_parser ())
1042 current_language->la_error (NULL);
1044 if (except.reason < 0)
1046 if (! in_parse_field)
1049 throw_exception (except);
1053 discard_cleanups (old_chain);
1055 /* Record the actual number of expression elements, and then
1056 reallocate the expression memory so that we free up any
1059 expout->nelts = expout_ptr;
1060 expout = (struct expression *)
1061 xrealloc ((char *) expout,
1062 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1064 /* Convert expression from postfix form as generated by yacc
1065 parser, to a prefix form. */
1067 if (expressiondebug)
1068 dump_raw_expression (expout, gdb_stdlog,
1069 "before conversion to prefix form");
1071 subexp = prefixify_expression (expout);
1073 *out_subexp = subexp;
1075 current_language->la_post_parser (&expout, void_context_p);
1077 if (expressiondebug)
1078 dump_prefix_expression (expout, gdb_stdlog);
1080 *stringptr = lexptr;
1084 /* Parse STRING as an expression, and complain if this fails
1085 to use up all of the contents of STRING. */
1088 parse_expression (char *string)
1090 struct expression *exp;
1091 exp = parse_exp_1 (&string, 0, 0);
1093 error (_("Junk after end of expression."));
1097 /* Parse STRING as an expression. If parsing ends in the middle of a
1098 field reference, return the type of the left-hand-side of the
1099 reference; furthermore, if the parsing ends in the field name,
1100 return the field name in *NAME. In all other cases, return NULL. */
1103 parse_field_expression (char *string, char **name)
1105 struct expression *exp = NULL;
1108 volatile struct gdb_exception except;
1110 TRY_CATCH (except, RETURN_MASK_ALL)
1113 exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
1116 if (except.reason < 0 || ! exp)
1118 if (expout_last_struct == -1)
1124 *name = extract_field_op (exp, &subexp);
1130 val = evaluate_subexpression_type (exp, subexp);
1133 return value_type (val);
1136 /* A post-parser that does nothing */
1139 null_post_parser (struct expression **exp, int void_context_p)
1143 /* Stuff for maintaining a stack of types. Currently just used by C, but
1144 probably useful for any language which declares its types "backwards". */
1147 check_type_stack_depth (void)
1149 if (type_stack_depth == type_stack_size)
1151 type_stack_size *= 2;
1152 type_stack = (union type_stack_elt *)
1153 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1158 push_type (enum type_pieces tp)
1160 check_type_stack_depth ();
1161 type_stack[type_stack_depth++].piece = tp;
1165 push_type_int (int n)
1167 check_type_stack_depth ();
1168 type_stack[type_stack_depth++].int_val = n;
1172 push_type_address_space (char *string)
1174 push_type_int (address_space_name_to_int (string));
1180 if (type_stack_depth)
1181 return type_stack[--type_stack_depth].piece;
1188 if (type_stack_depth)
1189 return type_stack[--type_stack_depth].int_val;
1190 /* "Can't happen". */
1194 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1195 as modified by all the stuff on the stack. */
1197 follow_types (struct type *follow_type)
1201 int make_volatile = 0;
1202 int make_addr_space = 0;
1204 struct type *range_type;
1207 switch (pop_type ())
1212 follow_type = make_cv_type (make_const,
1213 TYPE_VOLATILE (follow_type),
1216 follow_type = make_cv_type (TYPE_CONST (follow_type),
1219 if (make_addr_space)
1220 follow_type = make_type_with_address_space (follow_type,
1222 make_const = make_volatile = 0;
1223 make_addr_space = 0;
1231 case tp_space_identifier:
1232 make_addr_space = pop_type_int ();
1235 follow_type = lookup_pointer_type (follow_type);
1237 follow_type = make_cv_type (make_const,
1238 TYPE_VOLATILE (follow_type),
1241 follow_type = make_cv_type (TYPE_CONST (follow_type),
1244 if (make_addr_space)
1245 follow_type = make_type_with_address_space (follow_type,
1247 make_const = make_volatile = 0;
1248 make_addr_space = 0;
1251 follow_type = lookup_reference_type (follow_type);
1253 follow_type = make_cv_type (make_const,
1254 TYPE_VOLATILE (follow_type),
1257 follow_type = make_cv_type (TYPE_CONST (follow_type),
1260 if (make_addr_space)
1261 follow_type = make_type_with_address_space (follow_type,
1263 make_const = make_volatile = 0;
1264 make_addr_space = 0;
1267 array_size = pop_type_int ();
1268 /* FIXME-type-allocation: need a way to free this type when we are
1271 create_range_type ((struct type *) NULL,
1272 builtin_type_int, 0,
1273 array_size >= 0 ? array_size - 1 : 0);
1275 create_array_type ((struct type *) NULL,
1276 follow_type, range_type);
1278 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1279 = BOUND_CANNOT_BE_DETERMINED;
1282 /* FIXME-type-allocation: need a way to free this type when we are
1284 follow_type = lookup_function_type (follow_type);
1290 /* This function avoids direct calls to fprintf
1291 in the parser generated debug code. */
1293 parser_fprintf (FILE *x, const char *y, ...)
1298 vfprintf_unfiltered (gdb_stderr, y, args);
1301 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1302 vfprintf_unfiltered (gdb_stderr, y, args);
1308 _initialize_parse (void)
1310 type_stack_size = 80;
1311 type_stack_depth = 0;
1312 type_stack = (union type_stack_elt *)
1313 xmalloc (type_stack_size * sizeof (*type_stack));
1315 add_setshow_zinteger_cmd ("expression", class_maintenance,
1316 &expressiondebug, _("\
1317 Set expression debugging."), _("\
1318 Show expression debugging."), _("\
1319 When non-zero, the internal representation of expressions will be printed."),
1321 show_expressiondebug,
1322 &setdebuglist, &showdebuglist);