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 const char *op_name_standard (enum exp_opcode);
 359
 360 extern bool parse_float (const char *p, int len,
 361                          const struct type *type, gdb_byte *data);
 362 \f
 363 /* These codes indicate operator precedences for expression printing,
 364    least tightly binding first.  */
 365 /* Adding 1 to a precedence value is done for binary operators,
 366    on the operand which is more tightly bound, so that operators
 367    of equal precedence within that operand will get parentheses.  */
 368 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
 369    they are used as the "surrounding precedence" to force
 370    various kinds of things to be parenthesized.  */
 371 enum precedence
 372   {
 373     PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
 374     PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
 375     PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
 376     PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION
 377   };
 378
 379 /* Table mapping opcodes into strings for printing operators
 380    and precedences of the operators.  */
 381
 382 struct op_print
 383   {
 384     const char *string;
 385     enum exp_opcode opcode;
 386     /* Precedence of operator.  These values are used only by comparisons.  */
 387     enum precedence precedence;
 388
 389     /* For a binary operator:  1 iff right associate.
 390        For a unary operator:  1 iff postfix.  */
 391     int right_assoc;
 392   };
 393
 394 /* Information needed to print, prefixify, and evaluate expressions for
 395    a given language.  */
 396
 397 struct exp_descriptor
 398   {
 399     /* Print subexpression.  */
 400     void (*print_subexp) (struct expression *, int *, struct ui_file *,
 401                           enum precedence);
 402
 403     /* Returns number of exp_elements needed to represent an operator and
 404        the number of subexpressions it takes.  */
 405     void (*operator_length) (const struct expression*, int, int*, int *);
 406
 407     /* Call OBJFILE_FUNC for any objfile found being referenced by the
 408        single operator of EXP at position POS.  Operator parameters are
 409        located at positive (POS + number) offsets in EXP.  OBJFILE_FUNC
 410        should never be called with NULL OBJFILE.  OBJFILE_FUNC should
 411        get passed an arbitrary caller supplied DATA pointer.  If it
 412        returns non-zero value then (any other) non-zero value should be
 413        immediately returned to the caller.  Otherwise zero should be
 414        returned.  */
 415     int (*operator_check) (struct expression *exp, int pos,
 416                            int (*objfile_func) (struct objfile *objfile,
 417                                                 void *data),
 418                            void *data);
 419
 420     /* Name of this operator for dumping purposes.
 421        The returned value should never be NULL, even if EXP_OPCODE is
 422        an unknown opcode (a string containing an image of the numeric
 423        value of the opcode can be returned, for instance).  */
 424     const char *(*op_name) (enum exp_opcode);
 425
 426     /* Dump the rest of this (prefix) expression after the operator
 427        itself has been printed.  See dump_subexp_body_standard in
 428        (expprint.c).  */
 429     int (*dump_subexp_body) (struct expression *, struct ui_file *, int);
 430
 431     /* Evaluate an expression.  */
 432     struct value *(*evaluate_exp) (struct type *, struct expression *,
 433                                    int *, enum noside);
 434   };
 435
 436
 437 /* Default descriptor containing standard definitions of all
 438    elements.  */
 439 extern const struct exp_descriptor exp_descriptor_standard;
 440
 441 /* Functions used by language-specific extended operators to (recursively)
 442    print/dump subexpressions.  */
 443
 444 extern void print_subexp (struct expression *, int *, struct ui_file *,
 445                           enum precedence);
 446
 447 extern void print_subexp_standard (struct expression *, int *,
 448                                    struct ui_file *, enum precedence);
 449
 450 /* Print a function call like expression to STREAM.  This is called as a
 451    helper function by which point the expression node identifying this as a
 452    function call has already been stripped off and POS should point to the
 453    number of function call arguments.  EXP is the object containing the
 454    list of expression elements.  */
 455
 456 extern void print_subexp_funcall (struct expression *exp, int *pos,
 457                                   struct ui_file *stream);
 458
 459 /* Function used to avoid direct calls to fprintf
 460    in the code generated by the bison parser.  */
 461
 462 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
 463
 464 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile);
 465
 466 #endif /* PARSER_DEFS_H */
 467