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 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 3 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, see <http://www.gnu.org/licenses/>. */
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"
45 #include "parser-defs.h"
47 #include "symfile.h" /* for overlay functions */
50 #include "gdb_assert.h"
55 /* Standard set of definitions for printing, dumping, prefixifying,
56 * and evaluating expressions. */
58 const struct exp_descriptor exp_descriptor_standard
=
60 print_subexp_standard
,
61 operator_length_standard
,
63 dump_subexp_body_standard
,
64 evaluate_subexp_standard
67 /* Global variables declared in parser-defs.h (and commented there). */
68 struct expression
*expout
;
71 struct block
*expression_context_block
;
72 CORE_ADDR expression_context_pc
;
73 struct block
*innermost_block
;
75 union type_stack_elt
*type_stack
;
76 int type_stack_depth
, type_stack_size
;
82 /* A temporary buffer for identifiers, so we can null-terminate them.
84 We allocate this with xrealloc. parse_exp_1 used to allocate with
85 alloca, using the size of the whole expression as a conservative
86 estimate of the space needed. However, macro expansion can
87 introduce names longer than the original expression; there's no
88 practical way to know beforehand how large that might be. */
92 static int expressiondebug
= 0;
94 show_expressiondebug (struct ui_file
*file
, int from_tty
,
95 struct cmd_list_element
*c
, const char *value
)
97 fprintf_filtered (file
, _("Expression debugging is %s.\n"), value
);
100 static void free_funcalls (void *ignore
);
102 static void prefixify_expression (struct expression
*);
104 static void prefixify_subexp (struct expression
*, struct expression
*, int,
107 static struct expression
*parse_exp_in_context (char **, struct block
*, int,
110 void _initialize_parse (void);
112 /* Data structure for saving values of arglist_len for function calls whose
113 arguments contain other function calls. */
117 struct funcall
*next
;
121 static struct funcall
*funcall_chain
;
123 /* Begin counting arguments for a function call,
124 saving the data about any containing call. */
131 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
132 new->next
= funcall_chain
;
133 new->arglist_len
= arglist_len
;
138 /* Return the number of arguments in a function call just terminated,
139 and restore the data for the containing function call. */
144 int val
= arglist_len
;
145 struct funcall
*call
= funcall_chain
;
146 funcall_chain
= call
->next
;
147 arglist_len
= call
->arglist_len
;
152 /* Free everything in the funcall chain.
153 Used when there is an error inside parsing. */
156 free_funcalls (void *ignore
)
158 struct funcall
*call
, *next
;
160 for (call
= funcall_chain
; call
; call
= next
)
167 /* This page contains the functions for adding data to the struct expression
168 being constructed. */
170 /* Add one element to the end of the expression. */
172 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
173 a register through here */
176 write_exp_elt (union exp_element expelt
)
178 if (expout_ptr
>= expout_size
)
181 expout
= (struct expression
*)
182 xrealloc ((char *) expout
, sizeof (struct expression
)
183 + EXP_ELEM_TO_BYTES (expout_size
));
185 expout
->elts
[expout_ptr
++] = expelt
;
189 write_exp_elt_opcode (enum exp_opcode expelt
)
191 union exp_element tmp
;
192 memset (&tmp
, 0, sizeof (union exp_element
));
200 write_exp_elt_sym (struct symbol
*expelt
)
202 union exp_element tmp
;
203 memset (&tmp
, 0, sizeof (union exp_element
));
211 write_exp_elt_block (struct block
*b
)
213 union exp_element tmp
;
214 memset (&tmp
, 0, sizeof (union exp_element
));
220 write_exp_elt_objfile (struct objfile
*objfile
)
222 union exp_element tmp
;
223 memset (&tmp
, 0, sizeof (union exp_element
));
224 tmp
.objfile
= objfile
;
229 write_exp_elt_longcst (LONGEST expelt
)
231 union exp_element tmp
;
232 memset (&tmp
, 0, sizeof (union exp_element
));
234 tmp
.longconst
= expelt
;
240 write_exp_elt_dblcst (DOUBLEST expelt
)
242 union exp_element tmp
;
243 memset (&tmp
, 0, sizeof (union exp_element
));
245 tmp
.doubleconst
= expelt
;
251 write_exp_elt_type (struct type
*expelt
)
253 union exp_element tmp
;
254 memset (&tmp
, 0, sizeof (union exp_element
));
262 write_exp_elt_intern (struct internalvar
*expelt
)
264 union exp_element tmp
;
265 memset (&tmp
, 0, sizeof (union exp_element
));
267 tmp
.internalvar
= expelt
;
272 /* Add a string constant to the end of the expression.
274 String constants are stored by first writing an expression element
275 that contains the length of the string, then stuffing the string
276 constant itself into however many expression elements are needed
277 to hold it, and then writing another expression element that contains
278 the length of the string. I.E. an expression element at each end of
279 the string records the string length, so you can skip over the
280 expression elements containing the actual string bytes from either
281 end of the string. Note that this also allows gdb to handle
282 strings with embedded null bytes, as is required for some languages.
284 Don't be fooled by the fact that the string is null byte terminated,
285 this is strictly for the convenience of debugging gdb itself. Gdb
286 Gdb does not depend up the string being null terminated, since the
287 actual length is recorded in expression elements at each end of the
288 string. The null byte is taken into consideration when computing how
289 many expression elements are required to hold the string constant, of
294 write_exp_string (struct stoken str
)
296 int len
= str
.length
;
300 /* Compute the number of expression elements required to hold the string
301 (including a null byte terminator), along with one expression element
302 at each end to record the actual string length (not including the
303 null byte terminator). */
305 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
307 /* Ensure that we have enough available expression elements to store
310 if ((expout_ptr
+ lenelt
) >= expout_size
)
312 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
313 expout
= (struct expression
*)
314 xrealloc ((char *) expout
, (sizeof (struct expression
)
315 + EXP_ELEM_TO_BYTES (expout_size
)));
318 /* Write the leading length expression element (which advances the current
319 expression element index), then write the string constant followed by a
320 terminating null byte, and then write the trailing length expression
323 write_exp_elt_longcst ((LONGEST
) len
);
324 strdata
= (char *) &expout
->elts
[expout_ptr
];
325 memcpy (strdata
, str
.ptr
, len
);
326 *(strdata
+ len
) = '\0';
327 expout_ptr
+= lenelt
- 2;
328 write_exp_elt_longcst ((LONGEST
) len
);
331 /* Add a bitstring constant to the end of the expression.
333 Bitstring constants are stored by first writing an expression element
334 that contains the length of the bitstring (in bits), then stuffing the
335 bitstring constant itself into however many expression elements are
336 needed to hold it, and then writing another expression element that
337 contains the length of the bitstring. I.E. an expression element at
338 each end of the bitstring records the bitstring length, so you can skip
339 over the expression elements containing the actual bitstring bytes from
340 either end of the bitstring. */
343 write_exp_bitstring (struct stoken str
)
345 int bits
= str
.length
; /* length in bits */
346 int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
350 /* Compute the number of expression elements required to hold the bitstring,
351 along with one expression element at each end to record the actual
352 bitstring length in bits. */
354 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
356 /* Ensure that we have enough available expression elements to store
359 if ((expout_ptr
+ lenelt
) >= expout_size
)
361 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
362 expout
= (struct expression
*)
363 xrealloc ((char *) expout
, (sizeof (struct expression
)
364 + EXP_ELEM_TO_BYTES (expout_size
)));
367 /* Write the leading length expression element (which advances the current
368 expression element index), then write the bitstring constant, and then
369 write the trailing length expression element. */
371 write_exp_elt_longcst ((LONGEST
) bits
);
372 strdata
= (char *) &expout
->elts
[expout_ptr
];
373 memcpy (strdata
, str
.ptr
, len
);
374 expout_ptr
+= lenelt
- 2;
375 write_exp_elt_longcst ((LONGEST
) bits
);
378 /* Add the appropriate elements for a minimal symbol to the end of
379 the expression. The rationale behind passing in text_symbol_type and
380 data_symbol_type was so that Modula-2 could pass in WORD for
381 data_symbol_type. Perhaps it still is useful to have those types vary
382 based on the language, but they no longer have names like "int", so
383 the initial rationale is gone. */
386 write_exp_msymbol (struct minimal_symbol
*msymbol
,
387 struct type
*text_symbol_type
,
388 struct type
*data_symbol_type
)
390 struct gdbarch
*gdbarch
= current_gdbarch
;
393 write_exp_elt_opcode (OP_LONG
);
394 /* Let's make the type big enough to hold a 64-bit address. */
395 write_exp_elt_type (builtin_type_CORE_ADDR
);
397 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
398 if (overlay_debugging
)
399 addr
= symbol_overlayed_address (addr
, SYMBOL_BFD_SECTION (msymbol
));
400 write_exp_elt_longcst ((LONGEST
) addr
);
402 write_exp_elt_opcode (OP_LONG
);
404 if (SYMBOL_BFD_SECTION (msymbol
)
405 && SYMBOL_BFD_SECTION (msymbol
)->flags
& SEC_THREAD_LOCAL
)
407 bfd
*bfd
= SYMBOL_BFD_SECTION (msymbol
)->owner
;
411 if (ofp
->obfd
== bfd
)
414 write_exp_elt_opcode (UNOP_MEMVAL_TLS
);
415 write_exp_elt_objfile (ofp
);
416 write_exp_elt_type (builtin_type (gdbarch
)->nodebug_tls_symbol
);
417 write_exp_elt_opcode (UNOP_MEMVAL_TLS
);
421 write_exp_elt_opcode (UNOP_MEMVAL
);
422 switch (msymbol
->type
)
426 case mst_solib_trampoline
:
427 write_exp_elt_type (builtin_type (gdbarch
)->nodebug_text_symbol
);
434 write_exp_elt_type (builtin_type (gdbarch
)->nodebug_data_symbol
);
438 write_exp_elt_type (builtin_type (gdbarch
)->nodebug_unknown_symbol
);
441 write_exp_elt_opcode (UNOP_MEMVAL
);
444 /* Recognize tokens that start with '$'. These include:
446 $regname A native register name or a "standard
449 $variable A convenience variable with a name chosen
452 $digits Value history with index <digits>, starting
453 from the first value which has index 1.
455 $$digits Value history with index <digits> relative
456 to the last value. I.E. $$0 is the last
457 value, $$1 is the one previous to that, $$2
458 is the one previous to $$1, etc.
460 $ | $0 | $$0 The last value in the value history.
462 $$ An abbreviation for the second to the last
463 value in the value history, I.E. $$1
468 write_dollar_variable (struct stoken str
)
470 struct symbol
*sym
= NULL
;
471 struct minimal_symbol
*msym
= NULL
;
472 struct internalvar
*isym
= NULL
;
474 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
475 and $$digits (equivalent to $<-digits> if you could type that). */
479 /* Double dollar means negate the number and add -1 as well.
480 Thus $$ alone means -1. */
481 if (str
.length
>= 2 && str
.ptr
[1] == '$')
488 /* Just dollars (one or two) */
492 /* Is the rest of the token digits? */
493 for (; i
< str
.length
; i
++)
494 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
498 i
= atoi (str
.ptr
+ 1 + negate
);
504 /* Handle tokens that refer to machine registers:
505 $ followed by a register name. */
506 i
= frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
507 str
.ptr
+ 1, str
.length
- 1);
509 goto handle_register
;
511 /* Any names starting with $ are probably debugger internal variables. */
513 isym
= lookup_only_internalvar (copy_name (str
) + 1);
516 write_exp_elt_opcode (OP_INTERNALVAR
);
517 write_exp_elt_intern (isym
);
518 write_exp_elt_opcode (OP_INTERNALVAR
);
522 /* On some systems, such as HP-UX and hppa-linux, certain system routines
523 have names beginning with $ or $$. Check for those, first. */
525 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
526 VAR_DOMAIN
, (int *) NULL
, (struct symtab
**) NULL
);
529 write_exp_elt_opcode (OP_VAR_VALUE
);
530 write_exp_elt_block (block_found
); /* set by lookup_symbol */
531 write_exp_elt_sym (sym
);
532 write_exp_elt_opcode (OP_VAR_VALUE
);
535 msym
= lookup_minimal_symbol (copy_name (str
), NULL
, NULL
);
538 write_exp_msymbol (msym
,
539 lookup_function_type (builtin_type_int
),
544 /* Any other names are assumed to be debugger internal variables. */
546 write_exp_elt_opcode (OP_INTERNALVAR
);
547 write_exp_elt_intern (create_internalvar (copy_name (str
) + 1));
548 write_exp_elt_opcode (OP_INTERNALVAR
);
551 write_exp_elt_opcode (OP_LAST
);
552 write_exp_elt_longcst ((LONGEST
) i
);
553 write_exp_elt_opcode (OP_LAST
);
556 write_exp_elt_opcode (OP_REGISTER
);
559 write_exp_string (str
);
560 write_exp_elt_opcode (OP_REGISTER
);
566 find_template_name_end (char *p
)
569 int just_seen_right
= 0;
570 int just_seen_colon
= 0;
571 int just_seen_space
= 0;
573 if (!p
|| (*p
!= '<'))
584 /* In future, may want to allow these?? */
587 depth
++; /* start nested template */
588 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
589 return 0; /* but not after : or :: or > or space */
592 if (just_seen_colon
|| just_seen_right
)
593 return 0; /* end a (nested?) template */
594 just_seen_right
= 1; /* but not after : or :: */
595 if (--depth
== 0) /* also disallow >>, insist on > > */
596 return ++p
; /* if outermost ended, return */
599 if (just_seen_space
|| (just_seen_colon
> 1))
600 return 0; /* nested class spec coming up */
601 just_seen_colon
++; /* we allow :: but not :::: */
606 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
607 (*p
>= 'A' && *p
<= 'Z') ||
608 (*p
>= '0' && *p
<= '9') ||
609 (*p
== '_') || (*p
== ',') || /* commas for template args */
610 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
611 (*p
== '(') || (*p
== ')') || /* function types */
612 (*p
== '[') || (*p
== ']'))) /* array types */
627 /* Return a null-terminated temporary copy of the name
628 of a string token. */
631 copy_name (struct stoken token
)
633 /* Make sure there's enough space for the token. */
634 if (namecopy_size
< token
.length
+ 1)
636 namecopy_size
= token
.length
+ 1;
637 namecopy
= xrealloc (namecopy
, token
.length
+ 1);
640 memcpy (namecopy
, token
.ptr
, token
.length
);
641 namecopy
[token
.length
] = 0;
646 /* Reverse an expression from suffix form (in which it is constructed)
647 to prefix form (in which we can conveniently print or execute it). */
650 prefixify_expression (struct expression
*expr
)
653 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
654 struct expression
*temp
;
655 int inpos
= expr
->nelts
, outpos
= 0;
657 temp
= (struct expression
*) alloca (len
);
659 /* Copy the original expression into temp. */
660 memcpy (temp
, expr
, len
);
662 prefixify_subexp (temp
, expr
, inpos
, outpos
);
665 /* Return the number of exp_elements in the postfix subexpression
666 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
669 length_of_subexp (struct expression
*expr
, int endpos
)
673 operator_length (expr
, endpos
, &oplen
, &args
);
677 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
684 /* Sets *OPLENP to the length of the operator whose (last) index is
685 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
689 operator_length (struct expression
*expr
, int endpos
, int *oplenp
, int *argsp
)
691 expr
->language_defn
->la_exp_desc
->operator_length (expr
, endpos
,
695 /* Default value for operator_length in exp_descriptor vectors. */
698 operator_length_standard (struct expression
*expr
, int endpos
,
699 int *oplenp
, int *argsp
)
703 enum f90_range_type range_type
;
707 error (_("?error in operator_length_standard"));
709 i
= (int) expr
->elts
[endpos
- 1].opcode
;
715 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
716 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
738 case OP_F77_UNDETERMINED_ARGLIST
:
740 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
743 case OP_OBJC_MSGCALL
: /* Objective C message (method) call */
745 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
760 case UNOP_MEMVAL_TLS
:
778 case STRUCTOP_STRUCT
:
785 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant */
786 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op */
788 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
789 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
793 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
794 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
795 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
800 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
801 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
807 case TERNOP_SLICE_COUNT
:
812 case MULTI_SUBSCRIPT
:
814 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
817 case BINOP_ASSIGN_MODIFY
:
831 range_type
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
834 case LOW_BOUND_DEFAULT
:
835 case HIGH_BOUND_DEFAULT
:
838 case BOTH_BOUND_DEFAULT
:
841 case NONE_BOUND_DEFAULT
:
849 args
= 1 + (i
< (int) BINOP_END
);
856 /* Copy the subexpression ending just before index INEND in INEXPR
857 into OUTEXPR, starting at index OUTBEG.
858 In the process, convert it from suffix to prefix form. */
861 prefixify_subexp (struct expression
*inexpr
,
862 struct expression
*outexpr
, int inend
, int outbeg
)
868 enum exp_opcode opcode
;
870 operator_length (inexpr
, inend
, &oplen
, &args
);
872 /* Copy the final operator itself, from the end of the input
873 to the beginning of the output. */
875 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
876 EXP_ELEM_TO_BYTES (oplen
));
879 /* Find the lengths of the arg subexpressions. */
880 arglens
= (int *) alloca (args
* sizeof (int));
881 for (i
= args
- 1; i
>= 0; i
--)
883 oplen
= length_of_subexp (inexpr
, inend
);
888 /* Now copy each subexpression, preserving the order of
889 the subexpressions, but prefixifying each one.
890 In this loop, inend starts at the beginning of
891 the expression this level is working on
892 and marches forward over the arguments.
893 outbeg does similarly in the output. */
894 for (i
= 0; i
< args
; i
++)
898 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
903 /* This page contains the two entry points to this file. */
905 /* Read an expression from the string *STRINGPTR points to,
906 parse it, and return a pointer to a struct expression that we malloc.
907 Use block BLOCK as the lexical context for variable names;
908 if BLOCK is zero, use the block of the selected stack frame.
909 Meanwhile, advance *STRINGPTR to point after the expression,
910 at the first nonwhite character that is not part of the expression
911 (possibly a null character).
913 If COMMA is nonzero, stop if a comma is reached. */
916 parse_exp_1 (char **stringptr
, struct block
*block
, int comma
)
918 return parse_exp_in_context (stringptr
, block
, comma
, 0);
921 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
922 no value is expected from the expression. */
924 static struct expression
*
925 parse_exp_in_context (char **stringptr
, struct block
*block
, int comma
,
928 struct cleanup
*old_chain
;
934 type_stack_depth
= 0;
936 comma_terminates
= comma
;
938 if (lexptr
== 0 || *lexptr
== 0)
939 error_no_arg (_("expression to compute"));
941 old_chain
= make_cleanup (free_funcalls
, 0 /*ignore*/);
944 /* If no context specified, try using the current frame, if any. */
947 block
= get_selected_block (&expression_context_pc
);
949 /* Fall back to using the current source static context, if any. */
953 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
955 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal
.symtab
), STATIC_BLOCK
);
958 /* Save the context, if specified by caller, or found above. */
962 expression_context_block
= block
;
963 expression_context_pc
= BLOCK_START (block
);
968 expout
= (struct expression
*)
969 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
970 expout
->language_defn
= current_language
;
971 make_cleanup (free_current_contents
, &expout
);
973 if (current_language
->la_parser ())
974 current_language
->la_error (NULL
);
976 discard_cleanups (old_chain
);
978 /* Record the actual number of expression elements, and then
979 reallocate the expression memory so that we free up any
982 expout
->nelts
= expout_ptr
;
983 expout
= (struct expression
*)
984 xrealloc ((char *) expout
,
985 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
987 /* Convert expression from postfix form as generated by yacc
988 parser, to a prefix form. */
991 dump_raw_expression (expout
, gdb_stdlog
,
992 "before conversion to prefix form");
994 prefixify_expression (expout
);
996 current_language
->la_post_parser (&expout
, void_context_p
);
999 dump_prefix_expression (expout
, gdb_stdlog
);
1001 *stringptr
= lexptr
;
1005 /* Parse STRING as an expression, and complain if this fails
1006 to use up all of the contents of STRING. */
1009 parse_expression (char *string
)
1011 struct expression
*exp
;
1012 exp
= parse_exp_1 (&string
, 0, 0);
1014 error (_("Junk after end of expression."));
1019 /* As for parse_expression, except that if VOID_CONTEXT_P, then
1020 no value is expected from the expression. */
1023 parse_expression_in_context (char *string
, int void_context_p
)
1025 struct expression
*exp
;
1026 exp
= parse_exp_in_context (&string
, 0, 0, void_context_p
);
1027 if (*string
!= '\000')
1028 error (_("Junk after end of expression."));
1032 /* A post-parser that does nothing */
1035 null_post_parser (struct expression
**exp
, int void_context_p
)
1039 /* Stuff for maintaining a stack of types. Currently just used by C, but
1040 probably useful for any language which declares its types "backwards". */
1043 check_type_stack_depth (void)
1045 if (type_stack_depth
== type_stack_size
)
1047 type_stack_size
*= 2;
1048 type_stack
= (union type_stack_elt
*)
1049 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1054 push_type (enum type_pieces tp
)
1056 check_type_stack_depth ();
1057 type_stack
[type_stack_depth
++].piece
= tp
;
1061 push_type_int (int n
)
1063 check_type_stack_depth ();
1064 type_stack
[type_stack_depth
++].int_val
= n
;
1068 push_type_address_space (char *string
)
1070 push_type_int (address_space_name_to_int (string
));
1076 if (type_stack_depth
)
1077 return type_stack
[--type_stack_depth
].piece
;
1084 if (type_stack_depth
)
1085 return type_stack
[--type_stack_depth
].int_val
;
1086 /* "Can't happen". */
1090 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1091 as modified by all the stuff on the stack. */
1093 follow_types (struct type
*follow_type
)
1097 int make_volatile
= 0;
1098 int make_addr_space
= 0;
1100 struct type
*range_type
;
1103 switch (pop_type ())
1108 follow_type
= make_cv_type (make_const
,
1109 TYPE_VOLATILE (follow_type
),
1112 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1115 if (make_addr_space
)
1116 follow_type
= make_type_with_address_space (follow_type
,
1118 make_const
= make_volatile
= 0;
1119 make_addr_space
= 0;
1127 case tp_space_identifier
:
1128 make_addr_space
= pop_type_int ();
1131 follow_type
= lookup_pointer_type (follow_type
);
1133 follow_type
= make_cv_type (make_const
,
1134 TYPE_VOLATILE (follow_type
),
1137 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1140 if (make_addr_space
)
1141 follow_type
= make_type_with_address_space (follow_type
,
1143 make_const
= make_volatile
= 0;
1144 make_addr_space
= 0;
1147 follow_type
= lookup_reference_type (follow_type
);
1149 follow_type
= make_cv_type (make_const
,
1150 TYPE_VOLATILE (follow_type
),
1153 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1156 if (make_addr_space
)
1157 follow_type
= make_type_with_address_space (follow_type
,
1159 make_const
= make_volatile
= 0;
1160 make_addr_space
= 0;
1163 array_size
= pop_type_int ();
1164 /* FIXME-type-allocation: need a way to free this type when we are
1167 create_range_type ((struct type
*) NULL
,
1168 builtin_type_int
, 0,
1169 array_size
>= 0 ? array_size
- 1 : 0);
1171 create_array_type ((struct type
*) NULL
,
1172 follow_type
, range_type
);
1174 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type
)
1175 = BOUND_CANNOT_BE_DETERMINED
;
1178 /* FIXME-type-allocation: need a way to free this type when we are
1180 follow_type
= lookup_function_type (follow_type
);
1186 /* This function avoids direct calls to fprintf
1187 in the parser generated debug code. */
1189 parser_fprintf (FILE *x
, const char *y
, ...)
1194 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1197 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1198 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1204 _initialize_parse (void)
1206 type_stack_size
= 80;
1207 type_stack_depth
= 0;
1208 type_stack
= (union type_stack_elt
*)
1209 xmalloc (type_stack_size
* sizeof (*type_stack
));
1211 add_setshow_zinteger_cmd ("expression", class_maintenance
,
1212 &expressiondebug
, _("\
1213 Set expression debugging."), _("\
1214 Show expression debugging."), _("\
1215 When non-zero, the internal representation of expressions will be printed."),
1217 show_expressiondebug
,
1218 &setdebuglist
, &showdebuglist
);