gdb/parser-defs.h

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