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 #define parse_gdbarch(ps) ((ps)->expout->gdbarch)
36 #define parse_language(ps) ((ps)->expout->language_defn)
40 /* Constructor. INITIAL_SIZE is the initial size of the expout
41 array. LANG is the language used to parse the expression. And
42 GDBARCH is the gdbarch to use during parsing. */
44 parser_state (size_t initial_size, const struct language_defn *lang,
45 struct gdbarch *gdbarch);
47 DISABLE_COPY_AND_ASSIGN (parser_state);
49 /* Resize the allocated expression to the correct size, and return
50 it as an expression_up -- passing ownership to the caller. */
51 ATTRIBUTE_UNUSED_RESULT expression_up release ();
53 /* The size of the expression above. */
57 /* The expression related to this parser state. */
61 /* The number of elements already in the expression. This is used
62 to know where to put new elements. */
67 /* If this is nonzero, this block is used as the lexical context
70 extern const struct block *expression_context_block;
72 /* If expression_context_block is non-zero, then this is the PC within
73 the block that we want to evaluate expressions at. When debugging
74 C or C++ code, we use this to find the exact line we're at, and
75 then look up the macro definitions active at that point. */
76 extern CORE_ADDR expression_context_pc;
78 /* While parsing expressions we need to track the innermost lexical block
79 that we encounter. In some situations we need to track the innermost
80 block just for symbols, and in other situations we want to track the
81 innermost block for symbols and registers. These flags are used by the
82 innermost block tracker to control which blocks we consider for the
83 innermost block. These flags can be combined together as needed. */
85 enum innermost_block_tracker_type
87 /* Track the innermost block for symbols within an expression. */
88 INNERMOST_BLOCK_FOR_SYMBOLS = (1 << 0),
90 /* Track the innermost block for registers within an expression. */
91 INNERMOST_BLOCK_FOR_REGISTERS = (1 << 1)
93 DEF_ENUM_FLAGS_TYPE (enum innermost_block_tracker_type,
94 innermost_block_tracker_types);
96 /* When parsing expressions we track the innermost block that was
99 class innermost_block_tracker
102 innermost_block_tracker ()
103 : m_types (INNERMOST_BLOCK_FOR_SYMBOLS),
104 m_innermost_block (NULL)
107 /* Reset the currently stored innermost block. Usually called before
108 parsing a new expression. As the most common case is that we only
109 want to gather the innermost block for symbols in an expression, this
110 becomes the default block tracker type. */
111 void reset (innermost_block_tracker_types t = INNERMOST_BLOCK_FOR_SYMBOLS)
114 m_innermost_block = NULL;
117 /* Update the stored innermost block if the new block B is more inner
118 than the currently stored block, or if no block is stored yet. The
119 type T tells us whether the block B was for a symbol or for a
120 register. The stored innermost block is only updated if the type T is
121 a type we are interested in, the types we are interested in are held
122 in M_TYPES and set during RESET. */
123 void update (const struct block *b, innermost_block_tracker_types t);
125 /* Overload of main UPDATE method which extracts the block from BS. */
126 void update (const struct block_symbol &bs)
128 update (bs.block, INNERMOST_BLOCK_FOR_SYMBOLS);
131 /* Return the stored innermost block. Can be nullptr if no symbols or
132 registers were found during an expression parse, and so no innermost
133 block was defined. */
134 const struct block *block () const
136 return m_innermost_block;
140 /* The type of innermost block being looked for. */
141 innermost_block_tracker_types m_types;
143 /* The currently stored innermost block found while parsing an
145 const struct block *m_innermost_block;
148 /* The innermost context required by the stack and register variables
149 we've encountered so far. This should be cleared before parsing an
150 expression, and queried once the parse is complete. */
151 extern innermost_block_tracker innermost_block;
153 /* Number of arguments seen so far in innermost function call. */
154 extern int arglist_len;
156 /* A string token, either a char-string or bit-string. Char-strings are
157 used, for example, for the names of symbols. */
161 /* Pointer to first byte of char-string or first bit of bit-string. */
163 /* Length of string in bytes for char-string or bits for bit-string. */
169 /* A language-specific type field. */
171 /* Pointer to first byte of char-string or first bit of bit-string. */
173 /* Length of string in bytes for char-string or bits for bit-string. */
180 struct typed_stoken *tokens;
185 struct stoken stoken;
191 struct stoken stoken;
192 struct block_symbol sym;
193 int is_a_field_of_this;
196 struct objc_class_str
198 struct stoken stoken;
203 /* For parsing of complicated types.
204 An array should be preceded in the list by the size of the array. */
213 tp_function_with_arguments,
220 /* The stack can contain either an enum type_pieces or an int. */
223 enum type_pieces piece;
225 struct type_stack *stack_val;
226 std::vector<struct type *> *typelist_val;
229 /* The type stack is an instance of this structure. */
233 /* Elements on the stack. */
234 std::vector<union type_stack_elt> elements;
237 /* Reverse an expression from suffix form (in which it is constructed)
238 to prefix form (in which we can conveniently print or execute it).
239 Ordinarily this always returns -1. However, if EXPOUT_LAST_STRUCT
240 is not -1 (i.e., we are trying to complete a field name), it will
241 return the index of the subexpression which is the left-hand-side
242 of the struct operation at EXPOUT_LAST_STRUCT. */
244 extern int prefixify_expression (struct expression *expr);
246 extern void write_exp_elt_opcode (struct parser_state *, enum exp_opcode);
248 extern void write_exp_elt_sym (struct parser_state *, struct symbol *);
250 extern void write_exp_elt_longcst (struct parser_state *, LONGEST);
252 extern void write_exp_elt_floatcst (struct parser_state *, const gdb_byte *);
254 extern void write_exp_elt_type (struct parser_state *, struct type *);
256 extern void write_exp_elt_intern (struct parser_state *, struct internalvar *);
258 extern void write_exp_string (struct parser_state *, struct stoken);
260 void write_exp_string_vector (struct parser_state *, int type,
261 struct stoken_vector *vec);
263 extern void write_exp_bitstring (struct parser_state *, struct stoken);
265 extern void write_exp_elt_block (struct parser_state *, const struct block *);
267 extern void write_exp_elt_objfile (struct parser_state *,
268 struct objfile *objfile);
270 extern void write_exp_msymbol (struct parser_state *,
271 struct bound_minimal_symbol);
273 extern void write_dollar_variable (struct parser_state *, struct stoken str);
275 extern void mark_struct_expression (struct parser_state *);
277 extern const char *find_template_name_end (const char *);
279 extern void start_arglist (void);
281 extern int end_arglist (void);
283 extern char *copy_name (struct stoken);
285 extern void insert_type (enum type_pieces);
287 extern void push_type (enum type_pieces);
289 extern void push_type_int (int);
291 extern void insert_type_address_space (struct parser_state *, char *);
293 extern enum type_pieces pop_type (void);
295 extern int pop_type_int (void);
297 extern struct type_stack *get_type_stack (void);
299 extern struct type_stack *append_type_stack (struct type_stack *to,
300 struct type_stack *from);
302 extern void push_type_stack (struct type_stack *stack);
304 extern void push_typelist (std::vector<struct type *> *typelist);
306 extern int dump_subexp (struct expression *, struct ui_file *, int);
308 extern int dump_subexp_body_standard (struct expression *,
309 struct ui_file *, int);
311 extern void operator_length (const struct expression *, int, int *, int *);
313 extern void operator_length_standard (const struct expression *, int, int *,
316 extern int operator_check_standard (struct expression *exp, int pos,
318 (struct objfile *objfile, void *data),
321 extern const char *op_name_standard (enum exp_opcode);
323 extern struct type *follow_types (struct type *);
325 extern type_instance_flags follow_type_instance_flags ();
327 extern void null_post_parser (expression_up *, int);
329 extern bool parse_float (const char *p, int len,
330 const struct type *type, gdb_byte *data);
332 /* During parsing of a C expression, the pointer to the next character
333 is in this variable. */
335 extern const char *lexptr;
337 /* After a token has been recognized, this variable points to it.
338 Currently used only for error reporting. */
339 extern const char *prev_lexptr;
341 /* Current depth in parentheses within the expression. */
343 extern int paren_depth;
345 /* Nonzero means stop parsing on first comma (if not within parentheses). */
347 extern int comma_terminates;
349 /* These codes indicate operator precedences for expression printing,
350 least tightly binding first. */
351 /* Adding 1 to a precedence value is done for binary operators,
352 on the operand which is more tightly bound, so that operators
353 of equal precedence within that operand will get parentheses. */
354 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
355 they are used as the "surrounding precedence" to force
356 various kinds of things to be parenthesized. */
359 PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
360 PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
361 PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
362 PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION
365 /* Table mapping opcodes into strings for printing operators
366 and precedences of the operators. */
371 enum exp_opcode opcode;
372 /* Precedence of operator. These values are used only by comparisons. */
373 enum precedence precedence;
375 /* For a binary operator: 1 iff right associate.
376 For a unary operator: 1 iff postfix. */
380 /* Information needed to print, prefixify, and evaluate expressions for
383 struct exp_descriptor
385 /* Print subexpression. */
386 void (*print_subexp) (struct expression *, int *, struct ui_file *,
389 /* Returns number of exp_elements needed to represent an operator and
390 the number of subexpressions it takes. */
391 void (*operator_length) (const struct expression*, int, int*, int *);
393 /* Call OBJFILE_FUNC for any objfile found being referenced by the
394 single operator of EXP at position POS. Operator parameters are
395 located at positive (POS + number) offsets in EXP. OBJFILE_FUNC
396 should never be called with NULL OBJFILE. OBJFILE_FUNC should
397 get passed an arbitrary caller supplied DATA pointer. If it
398 returns non-zero value then (any other) non-zero value should be
399 immediately returned to the caller. Otherwise zero should be
401 int (*operator_check) (struct expression *exp, int pos,
402 int (*objfile_func) (struct objfile *objfile,
406 /* Name of this operator for dumping purposes.
407 The returned value should never be NULL, even if EXP_OPCODE is
408 an unknown opcode (a string containing an image of the numeric
409 value of the opcode can be returned, for instance). */
410 const char *(*op_name) (enum exp_opcode);
412 /* Dump the rest of this (prefix) expression after the operator
413 itself has been printed. See dump_subexp_body_standard in
415 int (*dump_subexp_body) (struct expression *, struct ui_file *, int);
417 /* Evaluate an expression. */
418 struct value *(*evaluate_exp) (struct type *, struct expression *,
423 /* Default descriptor containing standard definitions of all
425 extern const struct exp_descriptor exp_descriptor_standard;
427 /* Functions used by language-specific extended operators to (recursively)
428 print/dump subexpressions. */
430 extern void print_subexp (struct expression *, int *, struct ui_file *,
433 extern void print_subexp_standard (struct expression *, int *,
434 struct ui_file *, enum precedence);
436 /* Function used to avoid direct calls to fprintf
437 in the code generated by the bison parser. */
439 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
441 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile);
443 extern void mark_completion_tag (enum type_code, const char *ptr,
446 /* Reallocate the `expout' pointer inside PS so that it can accommodate
447 at least LENELT expression elements. This function does nothing if
448 there is enough room for the elements. */
450 extern void increase_expout_size (struct parser_state *ps, size_t lenelt);
452 #endif /* PARSER_DEFS_H */