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"
57 /* Standard set of definitions for printing, dumping, prefixifying,
58 * and evaluating expressions. */
60 const struct exp_descriptor exp_descriptor_standard
=
62 print_subexp_standard
,
63 operator_length_standard
,
65 dump_subexp_body_standard
,
66 evaluate_subexp_standard
69 /* Global variables declared in parser-defs.h (and commented there). */
70 struct expression
*expout
;
73 struct block
*expression_context_block
;
74 CORE_ADDR expression_context_pc
;
75 struct block
*innermost_block
;
77 union type_stack_elt
*type_stack
;
78 int type_stack_depth
, type_stack_size
;
84 /* A temporary buffer for identifiers, so we can null-terminate them.
86 We allocate this with xrealloc. parse_exp_1 used to allocate with
87 alloca, using the size of the whole expression as a conservative
88 estimate of the space needed. However, macro expansion can
89 introduce names longer than the original expression; there's no
90 practical way to know beforehand how large that might be. */
94 static int expressiondebug
= 0;
96 show_expressiondebug (struct ui_file
*file
, int from_tty
,
97 struct cmd_list_element
*c
, const char *value
)
99 fprintf_filtered (file
, _("Expression debugging is %s.\n"), value
);
102 static void free_funcalls (void *ignore
);
104 static void prefixify_expression (struct expression
*);
106 static void prefixify_subexp (struct expression
*, struct expression
*, int,
109 static struct expression
*parse_exp_in_context (char **, struct block
*, int,
112 void _initialize_parse (void);
114 /* Data structure for saving values of arglist_len for function calls whose
115 arguments contain other function calls. */
119 struct funcall
*next
;
123 static struct funcall
*funcall_chain
;
125 /* Begin counting arguments for a function call,
126 saving the data about any containing call. */
133 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
134 new->next
= funcall_chain
;
135 new->arglist_len
= arglist_len
;
140 /* Return the number of arguments in a function call just terminated,
141 and restore the data for the containing function call. */
146 int val
= arglist_len
;
147 struct funcall
*call
= funcall_chain
;
148 funcall_chain
= call
->next
;
149 arglist_len
= call
->arglist_len
;
154 /* Free everything in the funcall chain.
155 Used when there is an error inside parsing. */
158 free_funcalls (void *ignore
)
160 struct funcall
*call
, *next
;
162 for (call
= funcall_chain
; call
; call
= next
)
169 /* This page contains the functions for adding data to the struct expression
170 being constructed. */
172 /* Add one element to the end of the expression. */
174 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
175 a register through here */
178 write_exp_elt (union exp_element expelt
)
180 if (expout_ptr
>= expout_size
)
183 expout
= (struct expression
*)
184 xrealloc ((char *) expout
, sizeof (struct expression
)
185 + EXP_ELEM_TO_BYTES (expout_size
));
187 expout
->elts
[expout_ptr
++] = expelt
;
191 write_exp_elt_opcode (enum exp_opcode expelt
)
193 union exp_element tmp
;
194 memset (&tmp
, 0, sizeof (union exp_element
));
202 write_exp_elt_sym (struct symbol
*expelt
)
204 union exp_element tmp
;
205 memset (&tmp
, 0, sizeof (union exp_element
));
213 write_exp_elt_block (struct block
*b
)
215 union exp_element tmp
;
216 memset (&tmp
, 0, sizeof (union exp_element
));
222 write_exp_elt_longcst (LONGEST expelt
)
224 union exp_element tmp
;
225 memset (&tmp
, 0, sizeof (union exp_element
));
227 tmp
.longconst
= expelt
;
233 write_exp_elt_dblcst (DOUBLEST expelt
)
235 union exp_element tmp
;
236 memset (&tmp
, 0, sizeof (union exp_element
));
238 tmp
.doubleconst
= expelt
;
244 write_exp_elt_type (struct type
*expelt
)
246 union exp_element tmp
;
247 memset (&tmp
, 0, sizeof (union exp_element
));
255 write_exp_elt_intern (struct internalvar
*expelt
)
257 union exp_element tmp
;
258 memset (&tmp
, 0, sizeof (union exp_element
));
260 tmp
.internalvar
= expelt
;
265 /* Add a string constant to the end of the expression.
267 String constants are stored by first writing an expression element
268 that contains the length of the string, then stuffing the string
269 constant itself into however many expression elements are needed
270 to hold it, and then writing another expression element that contains
271 the length of the string. I.E. an expression element at each end of
272 the string records the string length, so you can skip over the
273 expression elements containing the actual string bytes from either
274 end of the string. Note that this also allows gdb to handle
275 strings with embedded null bytes, as is required for some languages.
277 Don't be fooled by the fact that the string is null byte terminated,
278 this is strictly for the convenience of debugging gdb itself. Gdb
279 Gdb does not depend up the string being null terminated, since the
280 actual length is recorded in expression elements at each end of the
281 string. The null byte is taken into consideration when computing how
282 many expression elements are required to hold the string constant, of
287 write_exp_string (struct stoken str
)
289 int len
= str
.length
;
293 /* Compute the number of expression elements required to hold the string
294 (including a null byte terminator), along with one expression element
295 at each end to record the actual string length (not including the
296 null byte terminator). */
298 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
300 /* Ensure that we have enough available expression elements to store
303 if ((expout_ptr
+ lenelt
) >= expout_size
)
305 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
306 expout
= (struct expression
*)
307 xrealloc ((char *) expout
, (sizeof (struct expression
)
308 + EXP_ELEM_TO_BYTES (expout_size
)));
311 /* Write the leading length expression element (which advances the current
312 expression element index), then write the string constant followed by a
313 terminating null byte, and then write the trailing length expression
316 write_exp_elt_longcst ((LONGEST
) len
);
317 strdata
= (char *) &expout
->elts
[expout_ptr
];
318 memcpy (strdata
, str
.ptr
, len
);
319 *(strdata
+ len
) = '\0';
320 expout_ptr
+= lenelt
- 2;
321 write_exp_elt_longcst ((LONGEST
) len
);
324 /* Add a bitstring constant to the end of the expression.
326 Bitstring constants are stored by first writing an expression element
327 that contains the length of the bitstring (in bits), then stuffing the
328 bitstring constant itself into however many expression elements are
329 needed to hold it, and then writing another expression element that
330 contains the length of the bitstring. I.E. an expression element at
331 each end of the bitstring records the bitstring length, so you can skip
332 over the expression elements containing the actual bitstring bytes from
333 either end of the bitstring. */
336 write_exp_bitstring (struct stoken str
)
338 int bits
= str
.length
; /* length in bits */
339 int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
343 /* Compute the number of expression elements required to hold the bitstring,
344 along with one expression element at each end to record the actual
345 bitstring length in bits. */
347 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
349 /* Ensure that we have enough available expression elements to store
352 if ((expout_ptr
+ lenelt
) >= expout_size
)
354 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
355 expout
= (struct expression
*)
356 xrealloc ((char *) expout
, (sizeof (struct expression
)
357 + EXP_ELEM_TO_BYTES (expout_size
)));
360 /* Write the leading length expression element (which advances the current
361 expression element index), then write the bitstring constant, and then
362 write the trailing length expression element. */
364 write_exp_elt_longcst ((LONGEST
) bits
);
365 strdata
= (char *) &expout
->elts
[expout_ptr
];
366 memcpy (strdata
, str
.ptr
, len
);
367 expout_ptr
+= lenelt
- 2;
368 write_exp_elt_longcst ((LONGEST
) bits
);
371 /* Add the appropriate elements for a minimal symbol to the end of
372 the expression. The rationale behind passing in text_symbol_type and
373 data_symbol_type was so that Modula-2 could pass in WORD for
374 data_symbol_type. Perhaps it still is useful to have those types vary
375 based on the language, but they no longer have names like "int", so
376 the initial rationale is gone. */
378 static struct type
*msym_text_symbol_type
;
379 static struct type
*msym_data_symbol_type
;
380 static struct type
*msym_unknown_symbol_type
;
383 write_exp_msymbol (struct minimal_symbol
*msymbol
,
384 struct type
*text_symbol_type
,
385 struct type
*data_symbol_type
)
389 write_exp_elt_opcode (OP_LONG
);
390 /* Let's make the type big enough to hold a 64-bit address. */
391 write_exp_elt_type (builtin_type_CORE_ADDR
);
393 addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
394 if (overlay_debugging
)
395 addr
= symbol_overlayed_address (addr
, SYMBOL_BFD_SECTION (msymbol
));
396 write_exp_elt_longcst ((LONGEST
) addr
);
398 write_exp_elt_opcode (OP_LONG
);
400 write_exp_elt_opcode (UNOP_MEMVAL
);
401 switch (msymbol
->type
)
405 case mst_solib_trampoline
:
406 write_exp_elt_type (msym_text_symbol_type
);
413 write_exp_elt_type (msym_data_symbol_type
);
417 write_exp_elt_type (msym_unknown_symbol_type
);
420 write_exp_elt_opcode (UNOP_MEMVAL
);
423 /* Recognize tokens that start with '$'. These include:
425 $regname A native register name or a "standard
428 $variable A convenience variable with a name chosen
431 $digits Value history with index <digits>, starting
432 from the first value which has index 1.
434 $$digits Value history with index <digits> relative
435 to the last value. I.E. $$0 is the last
436 value, $$1 is the one previous to that, $$2
437 is the one previous to $$1, etc.
439 $ | $0 | $$0 The last value in the value history.
441 $$ An abbreviation for the second to the last
442 value in the value history, I.E. $$1
447 write_dollar_variable (struct stoken str
)
449 struct symbol
*sym
= NULL
;
450 struct minimal_symbol
*msym
= NULL
;
452 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
453 and $$digits (equivalent to $<-digits> if you could type that). */
457 /* Double dollar means negate the number and add -1 as well.
458 Thus $$ alone means -1. */
459 if (str
.length
>= 2 && str
.ptr
[1] == '$')
466 /* Just dollars (one or two) */
470 /* Is the rest of the token digits? */
471 for (; i
< str
.length
; i
++)
472 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
476 i
= atoi (str
.ptr
+ 1 + negate
);
482 /* Handle tokens that refer to machine registers:
483 $ followed by a register name. */
484 i
= frame_map_name_to_regnum (deprecated_selected_frame
,
485 str
.ptr
+ 1, str
.length
- 1);
487 goto handle_register
;
489 /* On some systems, such as HP-UX and hppa-linux, certain system routines
490 have names beginning with $ or $$. Check for those, first. */
492 sym
= lookup_symbol (copy_name (str
), (struct block
*) NULL
,
493 VAR_DOMAIN
, (int *) NULL
, (struct symtab
**) NULL
);
496 write_exp_elt_opcode (OP_VAR_VALUE
);
497 write_exp_elt_block (block_found
); /* set by lookup_symbol */
498 write_exp_elt_sym (sym
);
499 write_exp_elt_opcode (OP_VAR_VALUE
);
502 msym
= lookup_minimal_symbol (copy_name (str
), NULL
, NULL
);
505 write_exp_msymbol (msym
,
506 lookup_function_type (builtin_type_int
),
511 /* Any other names starting in $ are debugger internal variables. */
513 write_exp_elt_opcode (OP_INTERNALVAR
);
514 write_exp_elt_intern (lookup_internalvar (copy_name (str
) + 1));
515 write_exp_elt_opcode (OP_INTERNALVAR
);
518 write_exp_elt_opcode (OP_LAST
);
519 write_exp_elt_longcst ((LONGEST
) i
);
520 write_exp_elt_opcode (OP_LAST
);
523 write_exp_elt_opcode (OP_REGISTER
);
524 write_exp_elt_longcst (i
);
525 write_exp_elt_opcode (OP_REGISTER
);
530 /* Parse a string that is possibly a namespace / nested class
531 specification, i.e., something of the form A::B::C::x. Input
532 (NAME) is the entire string; LEN is the current valid length; the
533 output is a string, TOKEN, which points to the largest recognized
534 prefix which is a series of namespaces or classes. CLASS_PREFIX is
535 another output, which records whether a nested class spec was
536 recognized (= 1) or a fully qualified variable name was found (=
537 0). ARGPTR is side-effected (if non-NULL) to point to beyond the
538 string recognized and consumed by this routine.
540 The return value is a pointer to the symbol for the base class or
541 variable if found, or NULL if not found. Callers must check this
542 first -- if NULL, the outputs may not be correct.
544 This function is used c-exp.y. This is used specifically to get
545 around HP aCC (and possibly other compilers), which insists on
546 generating names with embedded colons for namespace or nested class
549 (Argument LEN is currently unused. 1997-08-27)
551 Callers must free memory allocated for the output string TOKEN. */
553 static const char coloncolon
[2] =
557 parse_nested_classes_for_hpacc (char *name
, int len
, char **token
,
558 int *class_prefix
, char **argptr
)
560 /* Comment below comes from decode_line_1 which has very similar
561 code, which is called for "break" command parsing. */
563 /* We have what looks like a class or namespace
564 scope specification (A::B), possibly with many
565 levels of namespaces or classes (A::B::C::D).
567 Some versions of the HP ANSI C++ compiler (as also possibly
568 other compilers) generate class/function/member names with
569 embedded double-colons if they are inside namespaces. To
570 handle this, we loop a few times, considering larger and
571 larger prefixes of the string as though they were single
572 symbols. So, if the initially supplied string is
573 A::B::C::D::foo, we have to look up "A", then "A::B",
574 then "A::B::C", then "A::B::C::D", and finally
575 "A::B::C::D::foo" as single, monolithic symbols, because
576 A, B, C or D may be namespaces.
578 Note that namespaces can nest only inside other
579 namespaces, and not inside classes. So we need only
580 consider *prefixes* of the string; there is no need to look up
581 "B::C" separately as a symbol in the previous example. */
587 struct symbol
*sym_class
= NULL
;
588 struct symbol
*sym_var
= NULL
;
594 /* Check for HP-compiled executable -- in other cases
595 return NULL, and caller must default to standard GDB
598 if (!deprecated_hp_som_som_object_present
)
599 return (struct symbol
*) NULL
;
603 /* Skip over whitespace and possible global "::" */
604 while (*p
&& (*p
== ' ' || *p
== '\t'))
606 if (p
[0] == ':' && p
[1] == ':')
608 while (*p
&& (*p
== ' ' || *p
== '\t'))
613 /* Get to the end of the next namespace or class spec. */
614 /* If we're looking at some non-token, fail immediately */
616 if (!(isalpha (*p
) || *p
== '$' || *p
== '_'))
617 return (struct symbol
*) NULL
;
619 while (*p
&& (isalnum (*p
) || *p
== '$' || *p
== '_'))
624 /* If we have the start of a template specification,
625 scan right ahead to its end */
626 q
= find_template_name_end (p
);
633 /* Skip over "::" and whitespace for next time around */
634 while (*p
&& (*p
== ' ' || *p
== '\t'))
636 if (p
[0] == ':' && p
[1] == ':')
638 while (*p
&& (*p
== ' ' || *p
== '\t'))
641 /* Done with tokens? */
642 if (!*p
|| !(isalpha (*p
) || *p
== '$' || *p
== '_'))
645 tmp
= (char *) alloca (prefix_len
+ end
- start
+ 3);
648 memcpy (tmp
, prefix
, prefix_len
);
649 memcpy (tmp
+ prefix_len
, coloncolon
, 2);
650 memcpy (tmp
+ prefix_len
+ 2, start
, end
- start
);
651 tmp
[prefix_len
+ 2 + end
- start
] = '\000';
655 memcpy (tmp
, start
, end
- start
);
656 tmp
[end
- start
] = '\000';
660 prefix_len
= strlen (prefix
);
662 /* See if the prefix we have now is something we know about */
666 /* More tokens to process, so this must be a class/namespace */
667 sym_class
= lookup_symbol (prefix
, 0, STRUCT_DOMAIN
,
668 0, (struct symtab
**) NULL
);
672 /* No more tokens, so try as a variable first */
673 sym_var
= lookup_symbol (prefix
, 0, VAR_DOMAIN
,
674 0, (struct symtab
**) NULL
);
675 /* If failed, try as class/namespace */
677 sym_class
= lookup_symbol (prefix
, 0, STRUCT_DOMAIN
,
678 0, (struct symtab
**) NULL
);
683 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
684 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
685 || TYPE_CODE (t
) == TYPE_CODE_UNION
))))
687 /* We found a valid token */
688 *token
= (char *) xmalloc (prefix_len
+ 1);
689 memcpy (*token
, prefix
, prefix_len
);
690 (*token
)[prefix_len
] = '\000';
694 /* No variable or class/namespace found, no more tokens */
696 return (struct symbol
*) NULL
;
699 /* Out of loop, so we must have found a valid token */
706 *argptr
= done
? p
: end
;
708 return sym_var
? sym_var
: sym_class
; /* found */
712 find_template_name_end (char *p
)
715 int just_seen_right
= 0;
716 int just_seen_colon
= 0;
717 int just_seen_space
= 0;
719 if (!p
|| (*p
!= '<'))
730 /* In future, may want to allow these?? */
733 depth
++; /* start nested template */
734 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
735 return 0; /* but not after : or :: or > or space */
738 if (just_seen_colon
|| just_seen_right
)
739 return 0; /* end a (nested?) template */
740 just_seen_right
= 1; /* but not after : or :: */
741 if (--depth
== 0) /* also disallow >>, insist on > > */
742 return ++p
; /* if outermost ended, return */
745 if (just_seen_space
|| (just_seen_colon
> 1))
746 return 0; /* nested class spec coming up */
747 just_seen_colon
++; /* we allow :: but not :::: */
752 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
753 (*p
>= 'A' && *p
<= 'Z') ||
754 (*p
>= '0' && *p
<= '9') ||
755 (*p
== '_') || (*p
== ',') || /* commas for template args */
756 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
757 (*p
== '(') || (*p
== ')') || /* function types */
758 (*p
== '[') || (*p
== ']'))) /* array types */
773 /* Return a null-terminated temporary copy of the name
774 of a string token. */
777 copy_name (struct stoken token
)
779 /* Make sure there's enough space for the token. */
780 if (namecopy_size
< token
.length
+ 1)
782 namecopy_size
= token
.length
+ 1;
783 namecopy
= xrealloc (namecopy
, token
.length
+ 1);
786 memcpy (namecopy
, token
.ptr
, token
.length
);
787 namecopy
[token
.length
] = 0;
792 /* Reverse an expression from suffix form (in which it is constructed)
793 to prefix form (in which we can conveniently print or execute it). */
796 prefixify_expression (struct expression
*expr
)
799 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
800 struct expression
*temp
;
801 int inpos
= expr
->nelts
, outpos
= 0;
803 temp
= (struct expression
*) alloca (len
);
805 /* Copy the original expression into temp. */
806 memcpy (temp
, expr
, len
);
808 prefixify_subexp (temp
, expr
, inpos
, outpos
);
811 /* Return the number of exp_elements in the postfix subexpression
812 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
815 length_of_subexp (struct expression
*expr
, int endpos
)
819 operator_length (expr
, endpos
, &oplen
, &args
);
823 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
830 /* Sets *OPLENP to the length of the operator whose (last) index is
831 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
835 operator_length (struct expression
*expr
, int endpos
, int *oplenp
, int *argsp
)
837 expr
->language_defn
->la_exp_desc
->operator_length (expr
, endpos
,
841 /* Default value for operator_length in exp_descriptor vectors. */
844 operator_length_standard (struct expression
*expr
, int endpos
,
845 int *oplenp
, int *argsp
)
849 enum f90_range_type range_type
;
853 error (_("?error in operator_length_standard"));
855 i
= (int) expr
->elts
[endpos
- 1].opcode
;
861 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
862 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
885 case OP_F77_UNDETERMINED_ARGLIST
:
887 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
890 case OP_OBJC_MSGCALL
: /* Objective C message (method) call */
892 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
920 case STRUCTOP_STRUCT
:
926 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant */
927 case OP_OBJC_SELECTOR
: /* Objective C "@selector" pseudo-op */
930 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
931 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
935 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
936 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
937 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
942 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
943 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
949 case TERNOP_SLICE_COUNT
:
954 case MULTI_SUBSCRIPT
:
956 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
959 case BINOP_ASSIGN_MODIFY
:
973 range_type
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
976 case LOW_BOUND_DEFAULT
:
977 case HIGH_BOUND_DEFAULT
:
980 case BOTH_BOUND_DEFAULT
:
983 case NONE_BOUND_DEFAULT
:
991 args
= 1 + (i
< (int) BINOP_END
);
998 /* Copy the subexpression ending just before index INEND in INEXPR
999 into OUTEXPR, starting at index OUTBEG.
1000 In the process, convert it from suffix to prefix form. */
1003 prefixify_subexp (struct expression
*inexpr
,
1004 struct expression
*outexpr
, int inend
, int outbeg
)
1010 enum exp_opcode opcode
;
1012 operator_length (inexpr
, inend
, &oplen
, &args
);
1014 /* Copy the final operator itself, from the end of the input
1015 to the beginning of the output. */
1017 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
1018 EXP_ELEM_TO_BYTES (oplen
));
1021 /* Find the lengths of the arg subexpressions. */
1022 arglens
= (int *) alloca (args
* sizeof (int));
1023 for (i
= args
- 1; i
>= 0; i
--)
1025 oplen
= length_of_subexp (inexpr
, inend
);
1030 /* Now copy each subexpression, preserving the order of
1031 the subexpressions, but prefixifying each one.
1032 In this loop, inend starts at the beginning of
1033 the expression this level is working on
1034 and marches forward over the arguments.
1035 outbeg does similarly in the output. */
1036 for (i
= 0; i
< args
; i
++)
1040 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
1045 /* This page contains the two entry points to this file. */
1047 /* Read an expression from the string *STRINGPTR points to,
1048 parse it, and return a pointer to a struct expression that we malloc.
1049 Use block BLOCK as the lexical context for variable names;
1050 if BLOCK is zero, use the block of the selected stack frame.
1051 Meanwhile, advance *STRINGPTR to point after the expression,
1052 at the first nonwhite character that is not part of the expression
1053 (possibly a null character).
1055 If COMMA is nonzero, stop if a comma is reached. */
1058 parse_exp_1 (char **stringptr
, struct block
*block
, int comma
)
1060 return parse_exp_in_context (stringptr
, block
, comma
, 0);
1063 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1064 no value is expected from the expression. */
1066 static struct expression
*
1067 parse_exp_in_context (char **stringptr
, struct block
*block
, int comma
,
1070 struct cleanup
*old_chain
;
1072 lexptr
= *stringptr
;
1076 type_stack_depth
= 0;
1078 comma_terminates
= comma
;
1080 if (lexptr
== 0 || *lexptr
== 0)
1081 error_no_arg (_("expression to compute"));
1083 old_chain
= make_cleanup (free_funcalls
, 0 /*ignore*/);
1086 /* If no context specified, try using the current frame, if any. */
1089 block
= get_selected_block (&expression_context_pc
);
1091 /* Fall back to using the current source static context, if any. */
1095 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
1097 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal
.symtab
), STATIC_BLOCK
);
1100 /* Save the context, if specified by caller, or found above. */
1104 expression_context_block
= block
;
1105 expression_context_pc
= BLOCK_START (block
);
1110 expout
= (struct expression
*)
1111 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
1112 expout
->language_defn
= current_language
;
1113 make_cleanup (free_current_contents
, &expout
);
1115 if (current_language
->la_parser ())
1116 current_language
->la_error (NULL
);
1118 discard_cleanups (old_chain
);
1120 /* Record the actual number of expression elements, and then
1121 reallocate the expression memory so that we free up any
1124 expout
->nelts
= expout_ptr
;
1125 expout
= (struct expression
*)
1126 xrealloc ((char *) expout
,
1127 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
1129 /* Convert expression from postfix form as generated by yacc
1130 parser, to a prefix form. */
1132 if (expressiondebug
)
1133 dump_raw_expression (expout
, gdb_stdlog
,
1134 "before conversion to prefix form");
1136 prefixify_expression (expout
);
1138 current_language
->la_post_parser (&expout
, void_context_p
);
1140 if (expressiondebug
)
1141 dump_prefix_expression (expout
, gdb_stdlog
);
1143 *stringptr
= lexptr
;
1147 /* Parse STRING as an expression, and complain if this fails
1148 to use up all of the contents of STRING. */
1151 parse_expression (char *string
)
1153 struct expression
*exp
;
1154 exp
= parse_exp_1 (&string
, 0, 0);
1156 error (_("Junk after end of expression."));
1161 /* As for parse_expression, except that if VOID_CONTEXT_P, then
1162 no value is expected from the expression. */
1165 parse_expression_in_context (char *string
, int void_context_p
)
1167 struct expression
*exp
;
1168 exp
= parse_exp_in_context (&string
, 0, 0, void_context_p
);
1169 if (*string
!= '\000')
1170 error (_("Junk after end of expression."));
1174 /* A post-parser that does nothing */
1177 null_post_parser (struct expression
**exp
, int void_context_p
)
1181 /* Stuff for maintaining a stack of types. Currently just used by C, but
1182 probably useful for any language which declares its types "backwards". */
1185 check_type_stack_depth (void)
1187 if (type_stack_depth
== type_stack_size
)
1189 type_stack_size
*= 2;
1190 type_stack
= (union type_stack_elt
*)
1191 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
1196 push_type (enum type_pieces tp
)
1198 check_type_stack_depth ();
1199 type_stack
[type_stack_depth
++].piece
= tp
;
1203 push_type_int (int n
)
1205 check_type_stack_depth ();
1206 type_stack
[type_stack_depth
++].int_val
= n
;
1210 push_type_address_space (char *string
)
1212 push_type_int (address_space_name_to_int (string
));
1218 if (type_stack_depth
)
1219 return type_stack
[--type_stack_depth
].piece
;
1226 if (type_stack_depth
)
1227 return type_stack
[--type_stack_depth
].int_val
;
1228 /* "Can't happen". */
1232 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1233 as modified by all the stuff on the stack. */
1235 follow_types (struct type
*follow_type
)
1239 int make_volatile
= 0;
1240 int make_addr_space
= 0;
1242 struct type
*range_type
;
1245 switch (pop_type ())
1250 follow_type
= make_cv_type (make_const
,
1251 TYPE_VOLATILE (follow_type
),
1254 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1257 if (make_addr_space
)
1258 follow_type
= make_type_with_address_space (follow_type
,
1260 make_const
= make_volatile
= 0;
1261 make_addr_space
= 0;
1269 case tp_space_identifier
:
1270 make_addr_space
= pop_type_int ();
1273 follow_type
= lookup_pointer_type (follow_type
);
1275 follow_type
= make_cv_type (make_const
,
1276 TYPE_VOLATILE (follow_type
),
1279 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1282 if (make_addr_space
)
1283 follow_type
= make_type_with_address_space (follow_type
,
1285 make_const
= make_volatile
= 0;
1286 make_addr_space
= 0;
1289 follow_type
= lookup_reference_type (follow_type
);
1291 follow_type
= make_cv_type (make_const
,
1292 TYPE_VOLATILE (follow_type
),
1295 follow_type
= make_cv_type (TYPE_CONST (follow_type
),
1298 if (make_addr_space
)
1299 follow_type
= make_type_with_address_space (follow_type
,
1301 make_const
= make_volatile
= 0;
1302 make_addr_space
= 0;
1305 array_size
= pop_type_int ();
1306 /* FIXME-type-allocation: need a way to free this type when we are
1309 create_range_type ((struct type
*) NULL
,
1310 builtin_type_int
, 0,
1311 array_size
>= 0 ? array_size
- 1 : 0);
1313 create_array_type ((struct type
*) NULL
,
1314 follow_type
, range_type
);
1316 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type
)
1317 = BOUND_CANNOT_BE_DETERMINED
;
1320 /* FIXME-type-allocation: need a way to free this type when we are
1322 follow_type
= lookup_function_type (follow_type
);
1328 static void build_parse (void);
1334 msym_text_symbol_type
=
1335 init_type (TYPE_CODE_FUNC
, 1, 0, "<text variable, no debug info>", NULL
);
1336 TYPE_TARGET_TYPE (msym_text_symbol_type
) = builtin_type_int
;
1337 msym_data_symbol_type
=
1338 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ HOST_CHAR_BIT
, 0,
1339 "<data variable, no debug info>", NULL
);
1340 msym_unknown_symbol_type
=
1341 init_type (TYPE_CODE_INT
, 1, 0,
1342 "<variable (not text or data), no debug info>",
1346 /* This function avoids direct calls to fprintf
1347 in the parser generated debug code. */
1349 parser_fprintf (FILE *x
, const char *y
, ...)
1354 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1357 fprintf_unfiltered (gdb_stderr
, " Unknown FILE used.\n");
1358 vfprintf_unfiltered (gdb_stderr
, y
, args
);
1364 _initialize_parse (void)
1366 type_stack_size
= 80;
1367 type_stack_depth
= 0;
1368 type_stack
= (union type_stack_elt
*)
1369 xmalloc (type_stack_size
* sizeof (*type_stack
));
1373 /* FIXME - For the moment, handle types by swapping them in and out.
1374 Should be using the per-architecture data-pointer and a large
1376 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_text_symbol_type
);
1377 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_data_symbol_type
);
1378 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_unknown_symbol_type
);
1379 deprecated_register_gdbarch_swap (NULL
, 0, build_parse
);
1381 add_setshow_zinteger_cmd ("expression", class_maintenance
,
1382 &expressiondebug
, _("\
1383 Set expression debugging."), _("\
1384 Show expression debugging."), _("\
1385 When non-zero, the internal representation of expressions will be printed."),
1387 show_expressiondebug
,
1388 &setdebuglist
, &showdebuglist
);