gdb/parser-defs.h

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