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