1 /* Parse expressions for GDB.
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
5 Modified from expread.y by the Department of Computer Science at the
6 State University of New York at Buffalo, 1991.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Parse an expression from text in a string,
24 and return the result as a struct expression pointer.
25 That structure contains arithmetic operations in reverse polish,
26 with constants represented by operations that are followed by special data.
27 See expression.h for the details of the format.
28 What is important here is that it can be built up sequentially
29 during the process of parsing; the lower levels of the tree always
30 come first in the result. */
34 #include "arch-utils.h"
38 #include "expression.h"
42 #include "parser-defs.h"
46 #include "target-float.h"
50 #include "user-regs.h"
55 static unsigned int expressiondebug
= 0;
57 show_expressiondebug (struct ui_file
*file
, int from_tty
,
58 struct cmd_list_element
*c
, const char *value
)
60 gdb_printf (file
, _("Expression debugging is %s.\n"), value
);
64 /* True if an expression parser should set yydebug. */
65 static bool parser_debug
;
68 show_parserdebug (struct ui_file
*file
, int from_tty
,
69 struct cmd_list_element
*c
, const char *value
)
71 gdb_printf (file
, _("Parser debugging is %s.\n"), value
);
75 /* Documented at it's declaration. */
78 innermost_block_tracker::update (const struct block
*b
,
79 innermost_block_tracker_types t
)
81 if ((m_types
& t
) != 0
82 && (m_innermost_block
== NULL
83 || m_innermost_block
->contains (b
)))
84 m_innermost_block
= b
;
90 expr_complete_tag::complete (struct expression
*exp
,
91 completion_tracker
&tracker
)
93 collect_symbol_completion_matches_type (tracker
, m_name
.get (),
94 m_name
.get (), m_code
);
98 /* See parser-defs.h. */
101 parser_state::mark_struct_expression (expr::structop_base_operation
*op
)
103 gdb_assert (parse_completion
&& m_completion_state
== nullptr);
104 m_completion_state
.reset (new expr_complete_structop (op
));
107 /* Indicate that the current parser invocation is completing a tag.
108 TAG is the type code of the tag, and PTR and LENGTH represent the
109 start of the tag name. */
112 parser_state::mark_completion_tag (enum type_code tag
, const char *ptr
,
115 gdb_assert (parse_completion
&& m_completion_state
== nullptr);
116 gdb_assert (tag
== TYPE_CODE_UNION
117 || tag
== TYPE_CODE_STRUCT
118 || tag
== TYPE_CODE_ENUM
);
119 m_completion_state
.reset
120 (new expr_complete_tag (tag
, make_unique_xstrndup (ptr
, length
)));
123 /* See parser-defs.h. */
126 parser_state::push_c_string (int kind
, struct stoken_vector
*vec
)
128 std::vector
<std::string
> data (vec
->len
);
129 for (int i
= 0; i
< vec
->len
; ++i
)
130 data
[i
] = std::string (vec
->tokens
[i
].ptr
, vec
->tokens
[i
].length
);
132 push_new
<expr::c_string_operation
> ((enum c_string_type_values
) kind
,
136 /* See parser-defs.h. */
139 parser_state::push_symbol (const char *name
, block_symbol sym
)
141 if (sym
.symbol
!= nullptr)
143 if (symbol_read_needs_frame (sym
.symbol
))
144 block_tracker
->update (sym
);
145 push_new
<expr::var_value_operation
> (sym
);
149 struct bound_minimal_symbol msymbol
= lookup_bound_minimal_symbol (name
);
150 if (msymbol
.minsym
!= NULL
)
151 push_new
<expr::var_msym_value_operation
> (msymbol
);
152 else if (!have_full_symbols () && !have_partial_symbols ())
153 error (_("No symbol table is loaded. Use the \"file\" command."));
155 error (_("No symbol \"%s\" in current context."), name
);
159 /* See parser-defs.h. */
162 parser_state::push_dollar (struct stoken str
)
164 struct block_symbol sym
;
165 struct bound_minimal_symbol msym
;
166 struct internalvar
*isym
= NULL
;
169 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
170 and $$digits (equivalent to $<-digits> if you could type that). */
174 /* Double dollar means negate the number and add -1 as well.
175 Thus $$ alone means -1. */
176 if (str
.length
>= 2 && str
.ptr
[1] == '$')
183 /* Just dollars (one or two). */
185 push_new
<expr::last_operation
> (i
);
188 /* Is the rest of the token digits? */
189 for (; i
< str
.length
; i
++)
190 if (!(str
.ptr
[i
] >= '0' && str
.ptr
[i
] <= '9'))
194 i
= atoi (str
.ptr
+ 1 + negate
);
197 push_new
<expr::last_operation
> (i
);
201 /* Handle tokens that refer to machine registers:
202 $ followed by a register name. */
203 i
= user_reg_map_name_to_regnum (gdbarch (),
204 str
.ptr
+ 1, str
.length
- 1);
209 push_new
<expr::register_operation
> (copy_name (str
));
210 block_tracker
->update (expression_context_block
,
211 INNERMOST_BLOCK_FOR_REGISTERS
);
215 /* Any names starting with $ are probably debugger internal variables. */
217 copy
= copy_name (str
);
218 isym
= lookup_only_internalvar (copy
.c_str () + 1);
221 push_new
<expr::internalvar_operation
> (isym
);
225 /* On some systems, such as HP-UX and hppa-linux, certain system routines
226 have names beginning with $ or $$. Check for those, first. */
228 sym
= lookup_symbol (copy
.c_str (), NULL
, VAR_DOMAIN
, NULL
);
231 push_new
<expr::var_value_operation
> (sym
);
234 msym
= lookup_bound_minimal_symbol (copy
.c_str ());
237 push_new
<expr::var_msym_value_operation
> (msym
);
241 /* Any other names are assumed to be debugger internal variables. */
243 push_new
<expr::internalvar_operation
>
244 (create_internalvar (copy
.c_str () + 1));
250 find_template_name_end (const char *p
)
253 int just_seen_right
= 0;
254 int just_seen_colon
= 0;
255 int just_seen_space
= 0;
257 if (!p
|| (*p
!= '<'))
268 /* In future, may want to allow these?? */
271 depth
++; /* start nested template */
272 if (just_seen_colon
|| just_seen_right
|| just_seen_space
)
273 return 0; /* but not after : or :: or > or space */
276 if (just_seen_colon
|| just_seen_right
)
277 return 0; /* end a (nested?) template */
278 just_seen_right
= 1; /* but not after : or :: */
279 if (--depth
== 0) /* also disallow >>, insist on > > */
280 return ++p
; /* if outermost ended, return */
283 if (just_seen_space
|| (just_seen_colon
> 1))
284 return 0; /* nested class spec coming up */
285 just_seen_colon
++; /* we allow :: but not :::: */
290 if (!((*p
>= 'a' && *p
<= 'z') || /* allow token chars */
291 (*p
>= 'A' && *p
<= 'Z') ||
292 (*p
>= '0' && *p
<= '9') ||
293 (*p
== '_') || (*p
== ',') || /* commas for template args */
294 (*p
== '&') || (*p
== '*') || /* pointer and ref types */
295 (*p
== '(') || (*p
== ')') || /* function types */
296 (*p
== '[') || (*p
== ']'))) /* array types */
310 /* Return a null-terminated temporary copy of the name of a string token.
312 Tokens that refer to names do so with explicit pointer and length,
313 so they can share the storage that lexptr is parsing.
314 When it is necessary to pass a name to a function that expects
315 a null-terminated string, the substring is copied out
316 into a separate block of storage. */
319 copy_name (struct stoken token
)
321 return std::string (token
.ptr
, token
.length
);
325 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
326 no value is expected from the expression. */
329 parse_exp_in_context (const char **stringptr
, CORE_ADDR pc
,
330 const struct block
*block
,
332 innermost_block_tracker
*tracker
,
333 std::unique_ptr
<expr_completion_base
> *completer
)
335 const struct language_defn
*lang
= NULL
;
337 if (*stringptr
== 0 || **stringptr
== 0)
338 error_no_arg (_("expression to compute"));
340 const struct block
*expression_context_block
= block
;
341 CORE_ADDR expression_context_pc
= 0;
343 innermost_block_tracker local_tracker
;
344 if (tracker
== nullptr)
345 tracker
= &local_tracker
;
347 if ((flags
& PARSER_LEAVE_BLOCK_ALONE
) == 0)
349 /* If no context specified, try using the current frame, if any. */
350 if (!expression_context_block
)
351 expression_context_block
352 = get_selected_block (&expression_context_pc
);
354 expression_context_pc
= expression_context_block
->entry_pc ();
356 expression_context_pc
= pc
;
358 /* Fall back to using the current source static context, if any. */
360 if (!expression_context_block
)
362 struct symtab_and_line cursal
363 = get_current_source_symtab_and_line ();
366 expression_context_block
367 = cursal
.symtab
->compunit ()->blockvector ()->static_block ();
369 if (expression_context_block
)
370 expression_context_pc
= expression_context_block
->entry_pc ();
374 if (language_mode
== language_mode_auto
&& block
!= NULL
)
376 /* Find the language associated to the given context block.
377 Default to the current language if it can not be determined.
379 Note that using the language corresponding to the current frame
380 can sometimes give unexpected results. For instance, this
381 routine is often called several times during the inferior
382 startup phase to re-parse breakpoint expressions after
383 a new shared library has been loaded. The language associated
384 to the current frame at this moment is not relevant for
385 the breakpoint. Using it would therefore be silly, so it seems
386 better to rely on the current language rather than relying on
387 the current frame language to parse the expression. That's why
388 we do the following language detection only if the context block
389 has been specifically provided. */
390 struct symbol
*func
= block
->linkage_function ();
393 lang
= language_def (func
->language ());
394 if (lang
== NULL
|| lang
->la_language
== language_unknown
)
395 lang
= current_language
;
398 lang
= current_language
;
400 /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
401 While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
402 and others called from *.y) ensure CURRENT_LANGUAGE gets restored
403 to the value matching SELECTED_FRAME as set by get_current_arch. */
405 parser_state
ps (lang
, get_current_arch (), expression_context_block
,
406 expression_context_pc
, flags
, *stringptr
,
407 completer
!= nullptr, tracker
);
409 scoped_restore_current_language lang_saver
;
410 set_language (lang
->la_language
);
416 catch (const gdb_exception_error
&except
)
418 /* If parsing for completion, allow this to succeed; but if no
419 expression elements have been written, then there's nothing
421 if (! ps
.parse_completion
|| ps
.expout
->op
== nullptr)
425 expression_up result
= ps
.release ();
426 result
->op
->set_outermost ();
429 result
->dump (gdb_stdlog
);
431 if (completer
!= nullptr)
432 *completer
= std::move (ps
.m_completion_state
);
433 *stringptr
= ps
.lexptr
;
437 /* Read an expression from the string *STRINGPTR points to,
438 parse it, and return a pointer to a struct expression that we malloc.
439 Use block BLOCK as the lexical context for variable names;
440 if BLOCK is zero, use the block of the selected stack frame.
441 Meanwhile, advance *STRINGPTR to point after the expression,
442 at the first nonwhite character that is not part of the expression
443 (possibly a null character). FLAGS are passed to the parser. */
446 parse_exp_1 (const char **stringptr
, CORE_ADDR pc
, const struct block
*block
,
447 parser_flags flags
, innermost_block_tracker
*tracker
)
449 return parse_exp_in_context (stringptr
, pc
, block
, flags
,
453 /* Parse STRING as an expression, and complain if this fails to use up
454 all of the contents of STRING. TRACKER, if non-null, will be
455 updated by the parser. FLAGS are passed to the parser. */
458 parse_expression (const char *string
, innermost_block_tracker
*tracker
,
461 expression_up exp
= parse_exp_in_context (&string
, 0, nullptr, flags
,
464 error (_("Junk after end of expression."));
468 /* Same as parse_expression, but using the given language (LANG)
469 to parse the expression. */
472 parse_expression_with_language (const char *string
, enum language lang
)
474 std::optional
<scoped_restore_current_language
> lang_saver
;
475 if (current_language
->la_language
!= lang
)
477 lang_saver
.emplace ();
481 return parse_expression (string
);
484 /* Parse STRING as an expression. If the parse is marked for
485 completion, set COMPLETER and return the expression. In all other
486 cases, return NULL. */
489 parse_expression_for_completion
491 std::unique_ptr
<expr_completion_base
> *completer
)
497 exp
= parse_exp_in_context (&string
, 0, 0, 0, nullptr, completer
);
499 catch (const gdb_exception_error
&except
)
501 /* Nothing, EXP remains NULL. */
504 /* If we didn't get a completion result, be sure to also not return
505 an expression to our caller. */
506 if (*completer
== nullptr)
512 /* Parse floating point value P of length LEN.
513 Return false if invalid, true if valid.
514 The successfully parsed number is stored in DATA in
515 target format for floating-point type TYPE.
517 NOTE: This accepts the floating point syntax that sscanf accepts. */
520 parse_float (const char *p
, int len
,
521 const struct type
*type
, gdb_byte
*data
)
523 return target_float_from_string (data
, type
, std::string (p
, len
));
526 /* Return true if the number N_SIGN * N fits in a type with TYPE_BITS and
527 TYPE_SIGNED_P. N_SIGNED is either 1 or -1. */
530 fits_in_type (int n_sign
, ULONGEST n
, int type_bits
, bool type_signed_p
)
533 if (n
== 0 && n_sign
== -1)
536 if (n_sign
== -1 && !type_signed_p
)
537 /* Can't fit a negative number in an unsigned type. */
540 if (type_bits
> sizeof (ULONGEST
) * 8)
543 ULONGEST smax
= (ULONGEST
)1 << (type_bits
- 1);
546 /* Negative number, signed type. */
549 else if (n_sign
== 1 && type_signed_p
)
551 /* Positive number, signed type. */
554 else if (n_sign
== 1 && !type_signed_p
)
556 /* Positive number, unsigned type. */
557 return ((n
>> 1) >> (type_bits
- 1)) == 0;
560 gdb_assert_not_reached ("");
563 /* Return true if the number N_SIGN * N fits in a type with TYPE_BITS and
564 TYPE_SIGNED_P. N_SIGNED is either 1 or -1. */
567 fits_in_type (int n_sign
, const gdb_mpz
&n
, int type_bits
, bool type_signed_p
)
569 /* N must be nonnegative. */
570 gdb_assert (n
.sgn () >= 0);
572 /* Zero always fits. */
577 if (n_sign
== -1 && !type_signed_p
)
578 /* Can't fit a negative number in an unsigned type. */
581 gdb_mpz max
= gdb_mpz::pow (2, (type_signed_p
589 /* This function avoids direct calls to fprintf
590 in the parser generated debug code. */
592 parser_fprintf (FILE *x
, const char *y
, ...)
598 gdb_vprintf (gdb_stderr
, y
, args
);
601 gdb_printf (gdb_stderr
, " Unknown FILE used.\n");
602 gdb_vprintf (gdb_stderr
, y
, args
);
607 void _initialize_parse ();
611 add_setshow_zuinteger_cmd ("expression", class_maintenance
,
613 _("Set expression debugging."),
614 _("Show expression debugging."),
615 _("When non-zero, the internal representation "
616 "of expressions will be printed."),
618 show_expressiondebug
,
619 &setdebuglist
, &showdebuglist
);
620 add_setshow_boolean_cmd ("parser", class_maintenance
,
622 _("Set parser debugging."),
623 _("Show parser debugging."),
624 _("When non-zero, expression parser "
625 "tracing will be enabled."),
628 &setdebuglist
, &showdebuglist
);