gdb/parser-defs.h

   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 /* A class that can be used to build a "struct expression".  */
  36
  37 struct expr_builder
  38 {
  39   /* Constructor.  LANG is the language used to parse the expression.
  40      And GDBARCH is the gdbarch to use during parsing.  */
  41
  42   expr_builder (const struct language_defn *lang,
  43                 struct gdbarch *gdbarch);
  44
  45   DISABLE_COPY_AND_ASSIGN (expr_builder);
  46
  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 ();
  50
  51   /* Return the gdbarch that was passed to the constructor.  */
  52
  53   struct gdbarch *gdbarch ()
  54   {
  55     return expout->gdbarch;
  56   }
  57
  58   /* Return the language that was passed to the constructor.  */
  59
  60   const struct language_defn *language ()
  61   {
  62     return expout->language_defn;
  63   }
  64
  65   /* The size of the expression above.  */
  66
  67   size_t expout_size;
  68
  69   /* The expression related to this parser state.  */
  70
  71   expression_up expout;
  72
  73   /* The number of elements already in the expression.  This is used
  74      to know where to put new elements.  */
  75
  76   size_t expout_ptr;
  77 };
  78
  79 /* An instance of this type is instantiated during expression parsing,
  80    and passed to the appropriate parser.  It holds both inputs to the
  81    parser, and result.  */
  82
  83 struct parser_state : public expr_builder
  84 {
  85   /* Constructor.  LANG is the language used to parse the expression.
  86      And GDBARCH is the gdbarch to use during parsing.  */
  87
  88   parser_state (const struct language_defn *lang,
  89                 struct gdbarch *gdbarch,
  90                 const struct block *context_block,
  91                 CORE_ADDR context_pc,
  92                 int comma,
  93                 const char *input)
  94     : expr_builder (lang, gdbarch),
  95       expression_context_block (context_block),
  96       expression_context_pc (context_pc),
  97       comma_terminates (comma),
  98       lexptr (input)
  99   {
 100   }
 101
 102   DISABLE_COPY_AND_ASSIGN (parser_state);
 103
 104   /* Begin counting arguments for a function call,
 105      saving the data about any containing call.  */
 106
 107   void start_arglist ()
 108   {
 109     m_funcall_chain.push_back (arglist_len);
 110     arglist_len = 0;
 111   }
 112
 113   /* Return the number of arguments in a function call just terminated,
 114      and restore the data for the containing function call.  */
 115
 116   int end_arglist ()
 117   {
 118     int val = arglist_len;
 119     arglist_len = m_funcall_chain.back ();
 120     m_funcall_chain.pop_back ();
 121     return val;
 122   }
 123
 124
 125   /* If this is nonzero, this block is used as the lexical context for
 126      symbol names.  */
 127
 128   const struct block * const expression_context_block;
 129
 130   /* If expression_context_block is non-zero, then this is the PC
 131      within the block that we want to evaluate expressions at.  When
 132      debugging C or C++ code, we use this to find the exact line we're
 133      at, and then look up the macro definitions active at that
 134      point.  */
 135   const CORE_ADDR expression_context_pc;
 136
 137   /* Nonzero means stop parsing on first comma (if not within parentheses).  */
 138
 139   int comma_terminates;
 140
 141   /* During parsing of a C expression, the pointer to the next character
 142      is in this variable.  */
 143
 144   const char *lexptr;
 145
 146   /* After a token has been recognized, this variable points to it.
 147      Currently used only for error reporting.  */
 148   const char *prev_lexptr = nullptr;
 149
 150   /* Number of arguments seen so far in innermost function call.  */
 151
 152   int arglist_len = 0;
 153
 154 private:
 155
 156   /* Data structure for saving values of arglist_len for function calls whose
 157      arguments contain other function calls.  */
 158
 159   std::vector<int> m_funcall_chain;
 160 };
 161
 162 /* When parsing expressions we track the innermost block that was
 163    referenced.  */
 164
 165 class innermost_block_tracker
 166 {
 167 public:
 168   innermost_block_tracker ()
 169     : m_types (INNERMOST_BLOCK_FOR_SYMBOLS),
 170       m_innermost_block (NULL)
 171   { /* Nothing.  */ }
 172
 173   /* Reset the currently stored innermost block.  Usually called before
 174      parsing a new expression.  As the most common case is that we only
 175      want to gather the innermost block for symbols in an expression, this
 176      becomes the default block tracker type.  */
 177   void reset (innermost_block_tracker_types t = INNERMOST_BLOCK_FOR_SYMBOLS)
 178   {
 179     m_types = t;
 180     m_innermost_block = NULL;
 181   }
 182
 183   /* Update the stored innermost block if the new block B is more inner
 184      than the currently stored block, or if no block is stored yet.  The
 185      type T tells us whether the block B was for a symbol or for a
 186      register.  The stored innermost block is only updated if the type T is
 187      a type we are interested in, the types we are interested in are held
 188      in M_TYPES and set during RESET.  */
 189   void update (const struct block *b, innermost_block_tracker_types t);
 190
 191   /* Overload of main UPDATE method which extracts the block from BS.  */
 192   void update (const struct block_symbol &bs)
 193   {
 194     update (bs.block, INNERMOST_BLOCK_FOR_SYMBOLS);
 195   }
 196
 197   /* Return the stored innermost block.  Can be nullptr if no symbols or
 198      registers were found during an expression parse, and so no innermost
 199      block was defined.  */
 200   const struct block *block () const
 201   {
 202     return m_innermost_block;
 203   }
 204
 205 private:
 206   /* The type of innermost block being looked for.  */
 207   innermost_block_tracker_types m_types;
 208
 209   /* The currently stored innermost block found while parsing an
 210      expression.  */
 211   const struct block *m_innermost_block;
 212 };
 213
 214 /* The innermost context required by the stack and register variables
 215    we've encountered so far.  This is cleared by the expression
 216    parsing functions before parsing an expression, and can queried
 217    once the parse is complete.  */
 218 extern innermost_block_tracker innermost_block;
 219
 220 /* A string token, either a char-string or bit-string.  Char-strings are
 221    used, for example, for the names of symbols.  */
 222
 223 struct stoken
 224   {
 225     /* Pointer to first byte of char-string or first bit of bit-string.  */
 226     const char *ptr;
 227     /* Length of string in bytes for char-string or bits for bit-string.  */
 228     int length;
 229   };
 230
 231 struct typed_stoken
 232   {
 233     /* A language-specific type field.  */
 234     int type;
 235     /* Pointer to first byte of char-string or first bit of bit-string.  */
 236     char *ptr;
 237     /* Length of string in bytes for char-string or bits for bit-string.  */
 238     int length;
 239   };
 240
 241 struct stoken_vector
 242   {
 243     int len;
 244     struct typed_stoken *tokens;
 245   };
 246
 247 struct ttype
 248   {
 249     struct stoken stoken;
 250     struct type *type;
 251   };
 252
 253 struct symtoken
 254   {
 255     struct stoken stoken;
 256     struct block_symbol sym;
 257     int is_a_field_of_this;
 258   };
 259
 260 struct objc_class_str
 261   {
 262     struct stoken stoken;
 263     struct type *type;
 264     int theclass;
 265   };
 266
 267 /* For parsing of complicated types.
 268    An array should be preceded in the list by the size of the array.  */
 269 enum type_pieces
 270   {
 271     tp_end = -1,
 272     tp_pointer,
 273     tp_reference,
 274     tp_rvalue_reference,
 275     tp_array,
 276     tp_function,
 277     tp_function_with_arguments,
 278     tp_const,
 279     tp_volatile,
 280     tp_space_identifier,
 281     tp_type_stack,
 282     tp_kind
 283   };
 284 /* The stack can contain either an enum type_pieces or an int.  */
 285 union type_stack_elt
 286   {
 287     enum type_pieces piece;
 288     int int_val;
 289     struct type_stack *stack_val;
 290     std::vector<struct type *> *typelist_val;
 291   };
 292
 293 /* The type stack is an instance of this structure.  */
 294
 295 struct type_stack
 296 {
 297   /* Elements on the stack.  */
 298   std::vector<union type_stack_elt> elements;
 299 };
 300
 301 /* Reverse an expression from suffix form (in which it is constructed)
 302    to prefix form (in which we can conveniently print or execute it).
 303    Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
 304    is not -1 (i.e., we are trying to complete a field name), it will
 305    return the index of the subexpression which is the left-hand-side
 306    of the struct operation at EXPOUT_LAST_STRUCT.  */
 307
 308 extern int prefixify_expression (struct expression *expr);
 309
 310 extern void write_exp_elt_opcode (struct expr_builder *, enum exp_opcode);
 311
 312 extern void write_exp_elt_sym (struct expr_builder *, struct symbol *);
 313
 314 extern void write_exp_elt_longcst (struct expr_builder *, LONGEST);
 315
 316 extern void write_exp_elt_floatcst (struct expr_builder *, const gdb_byte *);
 317
 318 extern void write_exp_elt_type (struct expr_builder *, struct type *);
 319
 320 extern void write_exp_elt_intern (struct expr_builder *, struct internalvar *);
 321
 322 extern void write_exp_string (struct expr_builder *, struct stoken);
 323
 324 void write_exp_string_vector (struct expr_builder *, int type,
 325                               struct stoken_vector *vec);
 326
 327 extern void write_exp_bitstring (struct expr_builder *, struct stoken);
 328
 329 extern void write_exp_elt_block (struct expr_builder *, const struct block *);
 330
 331 extern void write_exp_elt_objfile (struct expr_builder *,
 332                                    struct objfile *objfile);
 333
 334 extern void write_exp_msymbol (struct expr_builder *,
 335                                struct bound_minimal_symbol);
 336
 337 extern void write_dollar_variable (struct parser_state *, struct stoken str);
 338
 339 extern void mark_struct_expression (struct expr_builder *);
 340
 341 extern const char *find_template_name_end (const char *);
 342
 343 extern char *copy_name (struct stoken);
 344
 345 extern void insert_type (enum type_pieces);
 346
 347 extern void push_type (enum type_pieces);
 348
 349 extern void push_type_int (int);
 350
 351 extern void insert_type_address_space (struct expr_builder *, char *);
 352
 353 extern enum type_pieces pop_type (void);
 354
 355 extern int pop_type_int (void);
 356
 357 extern struct type_stack *get_type_stack (void);
 358
 359 extern struct type_stack *append_type_stack (struct type_stack *to,
 360                                              struct type_stack *from);
 361
 362 extern void push_type_stack (struct type_stack *stack);
 363
 364 extern void push_typelist (std::vector<struct type *> *typelist);
 365
 366 extern int dump_subexp (struct expression *, struct ui_file *, int);
 367
 368 extern int dump_subexp_body_standard (struct expression *,
 369                                       struct ui_file *, int);
 370
 371 extern void operator_length (const struct expression *, int, int *, int *);
 372
 373 extern void operator_length_standard (const struct expression *, int, int *,
 374                                       int *);
 375
 376 extern int operator_check_standard (struct expression *exp, int pos,
 377                                     int (*objfile_func)
 378                                       (struct objfile *objfile, void *data),
 379                                     void *data);
 380
 381 extern const char *op_name_standard (enum exp_opcode);
 382
 383 extern struct type *follow_types (struct type *);
 384
 385 extern type_instance_flags follow_type_instance_flags ();
 386
 387 extern void null_post_parser (expression_up *, int);
 388
 389 extern bool parse_float (const char *p, int len,
 390                          const struct type *type, gdb_byte *data);
 391 \f
 392 /* These codes indicate operator precedences for expression printing,
 393    least tightly binding first.  */
 394 /* Adding 1 to a precedence value is done for binary operators,
 395    on the operand which is more tightly bound, so that operators
 396    of equal precedence within that operand will get parentheses.  */
 397 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
 398    they are used as the "surrounding precedence" to force
 399    various kinds of things to be parenthesized.  */
 400 enum precedence
 401   {
 402     PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
 403     PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
 404     PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
 405     PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION
 406   };
 407
 408 /* Table mapping opcodes into strings for printing operators
 409    and precedences of the operators.  */
 410
 411 struct op_print
 412   {
 413     const char *string;
 414     enum exp_opcode opcode;
 415     /* Precedence of operator.  These values are used only by comparisons.  */
 416     enum precedence precedence;
 417
 418     /* For a binary operator:  1 iff right associate.
 419        For a unary operator:  1 iff postfix.  */
 420     int right_assoc;
 421   };
 422
 423 /* Information needed to print, prefixify, and evaluate expressions for
 424    a given language.  */
 425
 426 struct exp_descriptor
 427   {
 428     /* Print subexpression.  */
 429     void (*print_subexp) (struct expression *, int *, struct ui_file *,
 430                           enum precedence);
 431
 432     /* Returns number of exp_elements needed to represent an operator and
 433        the number of subexpressions it takes.  */
 434     void (*operator_length) (const struct expression*, int, int*, int *);
 435
 436     /* Call OBJFILE_FUNC for any objfile found being referenced by the
 437        single operator of EXP at position POS.  Operator parameters are
 438        located at positive (POS + number) offsets in EXP.  OBJFILE_FUNC
 439        should never be called with NULL OBJFILE.  OBJFILE_FUNC should
 440        get passed an arbitrary caller supplied DATA pointer.  If it
 441        returns non-zero value then (any other) non-zero value should be
 442        immediately returned to the caller.  Otherwise zero should be
 443        returned.  */
 444     int (*operator_check) (struct expression *exp, int pos,
 445                            int (*objfile_func) (struct objfile *objfile,
 446                                                 void *data),
 447                            void *data);
 448
 449     /* Name of this operator for dumping purposes.
 450        The returned value should never be NULL, even if EXP_OPCODE is
 451        an unknown opcode (a string containing an image of the numeric
 452        value of the opcode can be returned, for instance).  */
 453     const char *(*op_name) (enum exp_opcode);
 454
 455     /* Dump the rest of this (prefix) expression after the operator
 456        itself has been printed.  See dump_subexp_body_standard in
 457        (expprint.c).  */
 458     int (*dump_subexp_body) (struct expression *, struct ui_file *, int);
 459
 460     /* Evaluate an expression.  */
 461     struct value *(*evaluate_exp) (struct type *, struct expression *,
 462                                    int *, enum noside);
 463   };
 464
 465
 466 /* Default descriptor containing standard definitions of all
 467    elements.  */
 468 extern const struct exp_descriptor exp_descriptor_standard;
 469
 470 /* Functions used by language-specific extended operators to (recursively)
 471    print/dump subexpressions.  */
 472
 473 extern void print_subexp (struct expression *, int *, struct ui_file *,
 474                           enum precedence);
 475
 476 extern void print_subexp_standard (struct expression *, int *,
 477                                    struct ui_file *, enum precedence);
 478
 479 /* Function used to avoid direct calls to fprintf
 480    in the code generated by the bison parser.  */
 481
 482 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
 483
 484 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile);
 485
 486 extern void mark_completion_tag (enum type_code, const char *ptr,
 487                                  int length);
 488
 489 #endif /* PARSER_DEFS_H */
 490