1 /* Parser definitions for GDB.
3 Copyright (C) 1986-2019 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.
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 #if !defined (PARSER_DEFS_H)
24 #define PARSER_DEFS_H 1
26 #include "common/vec.h"
27 #include "expression.h"
33 extern int parser_debug;
35 /* A class that can be used to build a "struct expression". */
39 /* Constructor. LANG is the language used to parse the expression.
40 And GDBARCH is the gdbarch to use during parsing. */
42 expr_builder (const struct language_defn *lang,
43 struct gdbarch *gdbarch);
45 DISABLE_COPY_AND_ASSIGN (expr_builder);
47 /* Resize the allocated expression to the correct size, and return
48 it as an expression_up -- passing ownership to the caller. */
49 ATTRIBUTE_UNUSED_RESULT expression_up release ();
51 /* Return the gdbarch that was passed to the constructor. */
53 struct gdbarch *gdbarch ()
55 return expout->gdbarch;
58 /* Return the language that was passed to the constructor. */
60 const struct language_defn *language ()
62 return expout->language_defn;
65 /* The size of the expression above. */
69 /* The expression related to this parser state. */
73 /* The number of elements already in the expression. This is used
74 to know where to put new elements. */
79 /* This is used for expression completion. */
81 struct expr_completion_state
83 /* The index of the last struct expression directly before a '.' or
84 '->'. This is set when parsing and is only used when completing a
85 field name. It is -1 if no dereference operation was found. */
86 int expout_last_struct = -1;
88 /* If we are completing a tagged type name, this will be nonzero. */
89 enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
91 /* The token for tagged type name completion. */
92 gdb::unique_xmalloc_ptr<char> expout_completion_name;
95 /* An instance of this type is instantiated during expression parsing,
96 and passed to the appropriate parser. It holds both inputs to the
97 parser, and result. */
99 struct parser_state : public expr_builder
101 /* Constructor. LANG is the language used to parse the expression.
102 And GDBARCH is the gdbarch to use during parsing. */
104 parser_state (const struct language_defn *lang,
105 struct gdbarch *gdbarch,
106 const struct block *context_block,
107 CORE_ADDR context_pc,
111 : expr_builder (lang, gdbarch),
112 expression_context_block (context_block),
113 expression_context_pc (context_pc),
114 comma_terminates (comma),
116 parse_completion (completion)
120 DISABLE_COPY_AND_ASSIGN (parser_state);
122 /* Begin counting arguments for a function call,
123 saving the data about any containing call. */
125 void start_arglist ()
127 m_funcall_chain.push_back (arglist_len);
131 /* Return the number of arguments in a function call just terminated,
132 and restore the data for the containing function call. */
136 int val = arglist_len;
137 arglist_len = m_funcall_chain.back ();
138 m_funcall_chain.pop_back ();
142 /* Mark the current index as the starting location of a structure
143 expression. This is used when completing on field names. */
145 void mark_struct_expression ();
147 /* Indicate that the current parser invocation is completing a tag.
148 TAG is the type code of the tag, and PTR and LENGTH represent the
149 start of the tag name. */
151 void mark_completion_tag (enum type_code tag, const char *ptr, int length);
154 /* If this is nonzero, this block is used as the lexical context for
157 const struct block * const expression_context_block;
159 /* If expression_context_block is non-zero, then this is the PC
160 within the block that we want to evaluate expressions at. When
161 debugging C or C++ code, we use this to find the exact line we're
162 at, and then look up the macro definitions active at that
164 const CORE_ADDR expression_context_pc;
166 /* Nonzero means stop parsing on first comma (if not within parentheses). */
168 int comma_terminates;
170 /* During parsing of a C expression, the pointer to the next character
171 is in this variable. */
175 /* After a token has been recognized, this variable points to it.
176 Currently used only for error reporting. */
177 const char *prev_lexptr = nullptr;
179 /* Number of arguments seen so far in innermost function call. */
183 /* True if parsing an expression to attempt completion. */
184 int parse_completion;
186 /* Completion state is updated here. */
187 expr_completion_state m_completion_state;
191 /* Data structure for saving values of arglist_len for function calls whose
192 arguments contain other function calls. */
194 std::vector<int> m_funcall_chain;
197 /* When parsing expressions we track the innermost block that was
200 class innermost_block_tracker
203 innermost_block_tracker ()
204 : m_types (INNERMOST_BLOCK_FOR_SYMBOLS),
205 m_innermost_block (NULL)
208 /* Reset the currently stored innermost block. Usually called before
209 parsing a new expression. As the most common case is that we only
210 want to gather the innermost block for symbols in an expression, this
211 becomes the default block tracker type. */
212 void reset (innermost_block_tracker_types t = INNERMOST_BLOCK_FOR_SYMBOLS)
215 m_innermost_block = NULL;
218 /* Update the stored innermost block if the new block B is more inner
219 than the currently stored block, or if no block is stored yet. The
220 type T tells us whether the block B was for a symbol or for a
221 register. The stored innermost block is only updated if the type T is
222 a type we are interested in, the types we are interested in are held
223 in M_TYPES and set during RESET. */
224 void update (const struct block *b, innermost_block_tracker_types t);
226 /* Overload of main UPDATE method which extracts the block from BS. */
227 void update (const struct block_symbol &bs)
229 update (bs.block, INNERMOST_BLOCK_FOR_SYMBOLS);
232 /* Return the stored innermost block. Can be nullptr if no symbols or
233 registers were found during an expression parse, and so no innermost
234 block was defined. */
235 const struct block *block () const
237 return m_innermost_block;
241 /* The type of innermost block being looked for. */
242 innermost_block_tracker_types m_types;
244 /* The currently stored innermost block found while parsing an
246 const struct block *m_innermost_block;
249 /* The innermost context required by the stack and register variables
250 we've encountered so far. This is cleared by the expression
251 parsing functions before parsing an expression, and can queried
252 once the parse is complete. */
253 extern innermost_block_tracker innermost_block;
255 /* A string token, either a char-string or bit-string. Char-strings are
256 used, for example, for the names of symbols. */
260 /* Pointer to first byte of char-string or first bit of bit-string. */
262 /* Length of string in bytes for char-string or bits for bit-string. */
268 /* A language-specific type field. */
270 /* Pointer to first byte of char-string or first bit of bit-string. */
272 /* Length of string in bytes for char-string or bits for bit-string. */
279 struct typed_stoken *tokens;
284 struct stoken stoken;
290 struct stoken stoken;
291 struct block_symbol sym;
292 int is_a_field_of_this;
295 struct objc_class_str
297 struct stoken stoken;
302 /* For parsing of complicated types.
303 An array should be preceded in the list by the size of the array. */
312 tp_function_with_arguments,
319 /* The stack can contain either an enum type_pieces or an int. */
322 enum type_pieces piece;
324 struct type_stack *stack_val;
325 std::vector<struct type *> *typelist_val;
328 /* The type stack is an instance of this structure. */
332 /* Elements on the stack. */
333 std::vector<union type_stack_elt> elements;
336 /* Reverse an expression from suffix form (in which it is constructed)
337 to prefix form (in which we can conveniently print or execute it).
338 Ordinarily this always returns -1. However, if LAST_STRUCT
339 is not -1 (i.e., we are trying to complete a field name), it will
340 return the index of the subexpression which is the left-hand-side
341 of the struct operation at LAST_STRUCT. */
343 extern int prefixify_expression (struct expression *expr,
344 int last_struct = -1);
346 extern void write_exp_elt_opcode (struct expr_builder *, enum exp_opcode);
348 extern void write_exp_elt_sym (struct expr_builder *, struct symbol *);
350 extern void write_exp_elt_longcst (struct expr_builder *, LONGEST);
352 extern void write_exp_elt_floatcst (struct expr_builder *, const gdb_byte *);
354 extern void write_exp_elt_type (struct expr_builder *, struct type *);
356 extern void write_exp_elt_intern (struct expr_builder *, struct internalvar *);
358 extern void write_exp_string (struct expr_builder *, struct stoken);
360 void write_exp_string_vector (struct expr_builder *, int type,
361 struct stoken_vector *vec);
363 extern void write_exp_bitstring (struct expr_builder *, struct stoken);
365 extern void write_exp_elt_block (struct expr_builder *, const struct block *);
367 extern void write_exp_elt_objfile (struct expr_builder *,
368 struct objfile *objfile);
370 extern void write_exp_msymbol (struct expr_builder *,
371 struct bound_minimal_symbol);
373 extern void write_dollar_variable (struct parser_state *, struct stoken str);
375 extern const char *find_template_name_end (const char *);
377 extern char *copy_name (struct stoken);
379 extern void insert_type (enum type_pieces);
381 extern void push_type (enum type_pieces);
383 extern void push_type_int (int);
385 extern void insert_type_address_space (struct expr_builder *, char *);
387 extern enum type_pieces pop_type (void);
389 extern int pop_type_int (void);
391 extern struct type_stack *get_type_stack (void);
393 extern struct type_stack *append_type_stack (struct type_stack *to,
394 struct type_stack *from);
396 extern void push_type_stack (struct type_stack *stack);
398 extern void push_typelist (std::vector<struct type *> *typelist);
400 extern int dump_subexp (struct expression *, struct ui_file *, int);
402 extern int dump_subexp_body_standard (struct expression *,
403 struct ui_file *, int);
405 extern void operator_length (const struct expression *, int, int *, int *);
407 extern void operator_length_standard (const struct expression *, int, int *,
410 extern int operator_check_standard (struct expression *exp, int pos,
412 (struct objfile *objfile, void *data),
415 extern const char *op_name_standard (enum exp_opcode);
417 extern struct type *follow_types (struct type *);
419 extern type_instance_flags follow_type_instance_flags ();
421 extern void null_post_parser (expression_up *, int, int);
423 extern bool parse_float (const char *p, int len,
424 const struct type *type, gdb_byte *data);
426 /* These codes indicate operator precedences for expression printing,
427 least tightly binding first. */
428 /* Adding 1 to a precedence value is done for binary operators,
429 on the operand which is more tightly bound, so that operators
430 of equal precedence within that operand will get parentheses. */
431 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
432 they are used as the "surrounding precedence" to force
433 various kinds of things to be parenthesized. */
436 PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
437 PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
438 PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
439 PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION
442 /* Table mapping opcodes into strings for printing operators
443 and precedences of the operators. */
448 enum exp_opcode opcode;
449 /* Precedence of operator. These values are used only by comparisons. */
450 enum precedence precedence;
452 /* For a binary operator: 1 iff right associate.
453 For a unary operator: 1 iff postfix. */
457 /* Information needed to print, prefixify, and evaluate expressions for
460 struct exp_descriptor
462 /* Print subexpression. */
463 void (*print_subexp) (struct expression *, int *, struct ui_file *,
466 /* Returns number of exp_elements needed to represent an operator and
467 the number of subexpressions it takes. */
468 void (*operator_length) (const struct expression*, int, int*, int *);
470 /* Call OBJFILE_FUNC for any objfile found being referenced by the
471 single operator of EXP at position POS. Operator parameters are
472 located at positive (POS + number) offsets in EXP. OBJFILE_FUNC
473 should never be called with NULL OBJFILE. OBJFILE_FUNC should
474 get passed an arbitrary caller supplied DATA pointer. If it
475 returns non-zero value then (any other) non-zero value should be
476 immediately returned to the caller. Otherwise zero should be
478 int (*operator_check) (struct expression *exp, int pos,
479 int (*objfile_func) (struct objfile *objfile,
483 /* Name of this operator for dumping purposes.
484 The returned value should never be NULL, even if EXP_OPCODE is
485 an unknown opcode (a string containing an image of the numeric
486 value of the opcode can be returned, for instance). */
487 const char *(*op_name) (enum exp_opcode);
489 /* Dump the rest of this (prefix) expression after the operator
490 itself has been printed. See dump_subexp_body_standard in
492 int (*dump_subexp_body) (struct expression *, struct ui_file *, int);
494 /* Evaluate an expression. */
495 struct value *(*evaluate_exp) (struct type *, struct expression *,
500 /* Default descriptor containing standard definitions of all
502 extern const struct exp_descriptor exp_descriptor_standard;
504 /* Functions used by language-specific extended operators to (recursively)
505 print/dump subexpressions. */
507 extern void print_subexp (struct expression *, int *, struct ui_file *,
510 extern void print_subexp_standard (struct expression *, int *,
511 struct ui_file *, enum precedence);
513 /* Function used to avoid direct calls to fprintf
514 in the code generated by the bison parser. */
516 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
518 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile);
520 #endif /* PARSER_DEFS_H */