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