1 /* Parser definitions for GDB. 2 3 Copyright (C) 1986-2019 Free Software Foundation, Inc. 4 5 Modified from expread.y by the Department of Computer Science at the 6 State University of New York at Buffalo. 7 8 This file is part of GDB. 9 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. 14 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. 19 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/>. */ 22 23 #if !defined (PARSER_DEFS_H) 24 #define PARSER_DEFS_H 1 25 26 #include "common/vec.h" 27 #include "expression.h" 28 29 struct block; 30 struct language_defn; 31 struct internalvar; 32 33 extern int parser_debug; 34 35 #define parse_gdbarch(ps) ((ps)->expout->gdbarch) 36 #define parse_language(ps) ((ps)->expout->language_defn) 37 38 struct parser_state 39 { 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. */ 43 44 parser_state (size_t initial_size, const struct language_defn *lang, 45 struct gdbarch *gdbarch); 46 47 DISABLE_COPY_AND_ASSIGN (parser_state); 48 49 /* Resize the allocated expression to the correct size, and return 50 it as an expression_up -- passing ownership to the caller. */ 51 expression_up release (); 52 53 /* The size of the expression above. */ 54 55 size_t expout_size; 56 57 /* The expression related to this parser state. */ 58 59 expression_up expout; 60 61 /* The number of elements already in the expression. This is used 62 to know where to put new elements. */ 63 64 size_t expout_ptr; 65 }; 66 67 /* If this is nonzero, this block is used as the lexical context 68 for symbol names. */ 69 70 extern const struct block *expression_context_block; 71 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; 77 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. */ 84 85 enum innermost_block_tracker_type 86 { 87 /* Track the innermost block for symbols within an expression. */ 88 INNERMOST_BLOCK_FOR_SYMBOLS = (1 << 0), 89 90 /* Track the innermost block for registers within an expression. */ 91 INNERMOST_BLOCK_FOR_REGISTERS = (1 << 1) 92 }; 93 DEF_ENUM_FLAGS_TYPE (enum innermost_block_tracker_type, 94 innermost_block_tracker_types); 95 96 /* When parsing expressions we track the innermost block that was 97 referenced. */ 98 99 class innermost_block_tracker 100 { 101 public: 102 innermost_block_tracker () 103 : m_types (INNERMOST_BLOCK_FOR_SYMBOLS), 104 m_innermost_block (NULL) 105 { /* Nothing. */ } 106 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) 112 { 113 m_types = t; 114 m_innermost_block = NULL; 115 } 116 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); 124 125 /* Overload of main UPDATE method which extracts the block from BS. */ 126 void update (const struct block_symbol &bs) 127 { 128 update (bs.block, INNERMOST_BLOCK_FOR_SYMBOLS); 129 } 130 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 135 { 136 return m_innermost_block; 137 } 138 139 private: 140 /* The type of innermost block being looked for. */ 141 innermost_block_tracker_types m_types; 142 143 /* The currently stored innermost block found while parsing an 144 expression. */ 145 const struct block *m_innermost_block; 146 }; 147 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; 152 153 /* Number of arguments seen so far in innermost function call. */ 154 extern int arglist_len; 155 156 /* A string token, either a char-string or bit-string. Char-strings are 157 used, for example, for the names of symbols. */ 158 159 struct stoken 160 { 161 /* Pointer to first byte of char-string or first bit of bit-string. */ 162 const char *ptr; 163 /* Length of string in bytes for char-string or bits for bit-string. */ 164 int length; 165 }; 166 167 struct typed_stoken 168 { 169 /* A language-specific type field. */ 170 int type; 171 /* Pointer to first byte of char-string or first bit of bit-string. */ 172 char *ptr; 173 /* Length of string in bytes for char-string or bits for bit-string. */ 174 int length; 175 }; 176 177 struct stoken_vector 178 { 179 int len; 180 struct typed_stoken *tokens; 181 }; 182 183 struct ttype 184 { 185 struct stoken stoken; 186 struct type *type; 187 }; 188 189 struct symtoken 190 { 191 struct stoken stoken; 192 struct block_symbol sym; 193 int is_a_field_of_this; 194 }; 195 196 struct objc_class_str 197 { 198 struct stoken stoken; 199 struct type *type; 200 int theclass; 201 }; 202 203 /* For parsing of complicated types. 204 An array should be preceded in the list by the size of the array. */ 205 enum type_pieces 206 { 207 tp_end = -1, 208 tp_pointer, 209 tp_reference, 210 tp_rvalue_reference, 211 tp_array, 212 tp_function, 213 tp_function_with_arguments, 214 tp_const, 215 tp_volatile, 216 tp_space_identifier, 217 tp_type_stack 218 }; 219 /* The stack can contain either an enum type_pieces or an int. */ 220 union type_stack_elt 221 { 222 enum type_pieces piece; 223 int int_val; 224 struct type_stack *stack_val; 225 std::vector<struct type *> *typelist_val; 226 }; 227 228 /* The type stack is an instance of this structure. */ 229 230 struct type_stack 231 { 232 /* Elements on the stack. */ 233 std::vector<union type_stack_elt> elements; 234 }; 235 236 /* Reverse an expression from suffix form (in which it is constructed) 237 to prefix form (in which we can conveniently print or execute it). 238 Ordinarily this always returns -1. However, if EXPOUT_LAST_STRUCT 239 is not -1 (i.e., we are trying to complete a field name), it will 240 return the index of the subexpression which is the left-hand-side 241 of the struct operation at EXPOUT_LAST_STRUCT. */ 242 243 extern int prefixify_expression (struct expression *expr); 244 245 extern void write_exp_elt_opcode (struct parser_state *, enum exp_opcode); 246 247 extern void write_exp_elt_sym (struct parser_state *, struct symbol *); 248 249 extern void write_exp_elt_longcst (struct parser_state *, LONGEST); 250 251 extern void write_exp_elt_floatcst (struct parser_state *, const gdb_byte *); 252 253 extern void write_exp_elt_type (struct parser_state *, struct type *); 254 255 extern void write_exp_elt_intern (struct parser_state *, struct internalvar *); 256 257 extern void write_exp_string (struct parser_state *, struct stoken); 258 259 void write_exp_string_vector (struct parser_state *, int type, 260 struct stoken_vector *vec); 261 262 extern void write_exp_bitstring (struct parser_state *, struct stoken); 263 264 extern void write_exp_elt_block (struct parser_state *, const struct block *); 265 266 extern void write_exp_elt_objfile (struct parser_state *, 267 struct objfile *objfile); 268 269 extern void write_exp_msymbol (struct parser_state *, 270 struct bound_minimal_symbol); 271 272 extern void write_dollar_variable (struct parser_state *, struct stoken str); 273 274 extern void mark_struct_expression (struct parser_state *); 275 276 extern const char *find_template_name_end (const char *); 277 278 extern void start_arglist (void); 279 280 extern int end_arglist (void); 281 282 extern char *copy_name (struct stoken); 283 284 extern void insert_type (enum type_pieces); 285 286 extern void push_type (enum type_pieces); 287 288 extern void push_type_int (int); 289 290 extern void insert_type_address_space (struct parser_state *, char *); 291 292 extern enum type_pieces pop_type (void); 293 294 extern int pop_type_int (void); 295 296 extern struct type_stack *get_type_stack (void); 297 298 extern struct type_stack *append_type_stack (struct type_stack *to, 299 struct type_stack *from); 300 301 extern void push_type_stack (struct type_stack *stack); 302 303 extern void push_typelist (std::vector<struct type *> *typelist); 304 305 extern int dump_subexp (struct expression *, struct ui_file *, int); 306 307 extern int dump_subexp_body_standard (struct expression *, 308 struct ui_file *, int); 309 310 extern void operator_length (const struct expression *, int, int *, int *); 311 312 extern void operator_length_standard (const struct expression *, int, int *, 313 int *); 314 315 extern int operator_check_standard (struct expression *exp, int pos, 316 int (*objfile_func) 317 (struct objfile *objfile, void *data), 318 void *data); 319 320 extern const char *op_name_standard (enum exp_opcode); 321 322 extern struct type *follow_types (struct type *); 323 324 extern type_instance_flags follow_type_instance_flags (); 325 326 extern void null_post_parser (expression_up *, int); 327 328 extern bool parse_float (const char *p, int len, 329 const struct type *type, gdb_byte *data); 330 331 /* During parsing of a C expression, the pointer to the next character 332 is in this variable. */ 333 334 extern const char *lexptr; 335 336 /* After a token has been recognized, this variable points to it. 337 Currently used only for error reporting. */ 338 extern const char *prev_lexptr; 339 340 /* Current depth in parentheses within the expression. */ 341 342 extern int paren_depth; 343 344 /* Nonzero means stop parsing on first comma (if not within parentheses). */ 345 346 extern int comma_terminates; 347 348 /* These codes indicate operator precedences for expression printing, 349 least tightly binding first. */ 350 /* Adding 1 to a precedence value is done for binary operators, 351 on the operand which is more tightly bound, so that operators 352 of equal precedence within that operand will get parentheses. */ 353 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator; 354 they are used as the "surrounding precedence" to force 355 various kinds of things to be parenthesized. */ 356 enum precedence 357 { 358 PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR, 359 PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR, 360 PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT, 361 PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION 362 }; 363 364 /* Table mapping opcodes into strings for printing operators 365 and precedences of the operators. */ 366 367 struct op_print 368 { 369 const char *string; 370 enum exp_opcode opcode; 371 /* Precedence of operator. These values are used only by comparisons. */ 372 enum precedence precedence; 373 374 /* For a binary operator: 1 iff right associate. 375 For a unary operator: 1 iff postfix. */ 376 int right_assoc; 377 }; 378 379 /* Information needed to print, prefixify, and evaluate expressions for 380 a given language. */ 381 382 struct exp_descriptor 383 { 384 /* Print subexpression. */ 385 void (*print_subexp) (struct expression *, int *, struct ui_file *, 386 enum precedence); 387 388 /* Returns number of exp_elements needed to represent an operator and 389 the number of subexpressions it takes. */ 390 void (*operator_length) (const struct expression*, int, int*, int *); 391 392 /* Call OBJFILE_FUNC for any objfile found being referenced by the 393 single operator of EXP at position POS. Operator parameters are 394 located at positive (POS + number) offsets in EXP. OBJFILE_FUNC 395 should never be called with NULL OBJFILE. OBJFILE_FUNC should 396 get passed an arbitrary caller supplied DATA pointer. If it 397 returns non-zero value then (any other) non-zero value should be 398 immediately returned to the caller. Otherwise zero should be 399 returned. */ 400 int (*operator_check) (struct expression *exp, int pos, 401 int (*objfile_func) (struct objfile *objfile, 402 void *data), 403 void *data); 404 405 /* Name of this operator for dumping purposes. 406 The returned value should never be NULL, even if EXP_OPCODE is 407 an unknown opcode (a string containing an image of the numeric 408 value of the opcode can be returned, for instance). */ 409 const char *(*op_name) (enum exp_opcode); 410 411 /* Dump the rest of this (prefix) expression after the operator 412 itself has been printed. See dump_subexp_body_standard in 413 (expprint.c). */ 414 int (*dump_subexp_body) (struct expression *, struct ui_file *, int); 415 416 /* Evaluate an expression. */ 417 struct value *(*evaluate_exp) (struct type *, struct expression *, 418 int *, enum noside); 419 }; 420 421 422 /* Default descriptor containing standard definitions of all 423 elements. */ 424 extern const struct exp_descriptor exp_descriptor_standard; 425 426 /* Functions used by language-specific extended operators to (recursively) 427 print/dump subexpressions. */ 428 429 extern void print_subexp (struct expression *, int *, struct ui_file *, 430 enum precedence); 431 432 extern void print_subexp_standard (struct expression *, int *, 433 struct ui_file *, enum precedence); 434 435 /* Function used to avoid direct calls to fprintf 436 in the code generated by the bison parser. */ 437 438 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3); 439 440 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile); 441 442 extern void mark_completion_tag (enum type_code, const char *ptr, 443 int length); 444 445 /* Reallocate the `expout' pointer inside PS so that it can accommodate 446 at least LENELT expression elements. This function does nothing if 447 there is enough room for the elements. */ 448 449 extern void increase_expout_size (struct parser_state *ps, size_t lenelt); 450 451 #endif /* PARSER_DEFS_H */ 452 453