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