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     : expr_builder (lang, gdbarch),
  93       expression_context_block (context_block),
  94       expression_context_pc (context_pc)
  95   {
  96   }
  97
  98   DISABLE_COPY_AND_ASSIGN (parser_state);
  99
 100   /* If this is nonzero, this block is used as the lexical context for
 101      symbol names.  */
 102
 103   const struct block * const expression_context_block;
 104
 105   /* If expression_context_block is non-zero, then this is the PC
 106      within the block that we want to evaluate expressions at.  When
 107      debugging C or C++ code, we use this to find the exact line we're
 108      at, and then look up the macro definitions active at that
 109      point.  */
 110   const CORE_ADDR expression_context_pc;
 111 };
 112
 113 /* When parsing expressions we track the innermost block that was
 114    referenced.  */
 115
 116 class innermost_block_tracker
 117 {
 118 public:
 119   innermost_block_tracker ()
 120     : m_types (INNERMOST_BLOCK_FOR_SYMBOLS),
 121       m_innermost_block (NULL)
 122   { /* Nothing.  */ }
 123
 124   /* Reset the currently stored innermost block.  Usually called before
 125      parsing a new expression.  As the most common case is that we only
 126      want to gather the innermost block for symbols in an expression, this
 127      becomes the default block tracker type.  */
 128   void reset (innermost_block_tracker_types t = INNERMOST_BLOCK_FOR_SYMBOLS)
 129   {
 130     m_types = t;
 131     m_innermost_block = NULL;
 132   }
 133
 134   /* Update the stored innermost block if the new block B is more inner
 135      than the currently stored block, or if no block is stored yet.  The
 136      type T tells us whether the block B was for a symbol or for a
 137      register.  The stored innermost block is only updated if the type T is
 138      a type we are interested in, the types we are interested in are held
 139      in M_TYPES and set during RESET.  */
 140   void update (const struct block *b, innermost_block_tracker_types t);
 141
 142   /* Overload of main UPDATE method which extracts the block from BS.  */
 143   void update (const struct block_symbol &bs)
 144   {
 145     update (bs.block, INNERMOST_BLOCK_FOR_SYMBOLS);
 146   }
 147
 148   /* Return the stored innermost block.  Can be nullptr if no symbols or
 149      registers were found during an expression parse, and so no innermost
 150      block was defined.  */
 151   const struct block *block () const
 152   {
 153     return m_innermost_block;
 154   }
 155
 156 private:
 157   /* The type of innermost block being looked for.  */
 158   innermost_block_tracker_types m_types;
 159
 160   /* The currently stored innermost block found while parsing an
 161      expression.  */
 162   const struct block *m_innermost_block;
 163 };
 164
 165 /* The innermost context required by the stack and register variables
 166    we've encountered so far.  This is cleared by the expression
 167    parsing functions before parsing an expression, and can queried
 168    once the parse is complete.  */
 169 extern innermost_block_tracker innermost_block;
 170
 171 /* Number of arguments seen so far in innermost function call.  */
 172 extern int arglist_len;
 173
 174 /* A string token, either a char-string or bit-string.  Char-strings are
 175    used, for example, for the names of symbols.  */
 176
 177 struct stoken
 178   {
 179     /* Pointer to first byte of char-string or first bit of bit-string.  */
 180     const char *ptr;
 181     /* Length of string in bytes for char-string or bits for bit-string.  */
 182     int length;
 183   };
 184
 185 struct typed_stoken
 186   {
 187     /* A language-specific type field.  */
 188     int type;
 189     /* Pointer to first byte of char-string or first bit of bit-string.  */
 190     char *ptr;
 191     /* Length of string in bytes for char-string or bits for bit-string.  */
 192     int length;
 193   };
 194
 195 struct stoken_vector
 196   {
 197     int len;
 198     struct typed_stoken *tokens;
 199   };
 200
 201 struct ttype
 202   {
 203     struct stoken stoken;
 204     struct type *type;
 205   };
 206
 207 struct symtoken
 208   {
 209     struct stoken stoken;
 210     struct block_symbol sym;
 211     int is_a_field_of_this;
 212   };
 213
 214 struct objc_class_str
 215   {
 216     struct stoken stoken;
 217     struct type *type;
 218     int theclass;
 219   };
 220
 221 /* For parsing of complicated types.
 222    An array should be preceded in the list by the size of the array.  */
 223 enum type_pieces
 224   {
 225     tp_end = -1,
 226     tp_pointer,
 227     tp_reference,
 228     tp_rvalue_reference,
 229     tp_array,
 230     tp_function,
 231     tp_function_with_arguments,
 232     tp_const,
 233     tp_volatile,
 234     tp_space_identifier,
 235     tp_type_stack,
 236     tp_kind
 237   };
 238 /* The stack can contain either an enum type_pieces or an int.  */
 239 union type_stack_elt
 240   {
 241     enum type_pieces piece;
 242     int int_val;
 243     struct type_stack *stack_val;
 244     std::vector<struct type *> *typelist_val;
 245   };
 246
 247 /* The type stack is an instance of this structure.  */
 248
 249 struct type_stack
 250 {
 251   /* Elements on the stack.  */
 252   std::vector<union type_stack_elt> elements;
 253 };
 254
 255 /* Reverse an expression from suffix form (in which it is constructed)
 256    to prefix form (in which we can conveniently print or execute it).
 257    Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
 258    is not -1 (i.e., we are trying to complete a field name), it will
 259    return the index of the subexpression which is the left-hand-side
 260    of the struct operation at EXPOUT_LAST_STRUCT.  */
 261
 262 extern int prefixify_expression (struct expression *expr);
 263
 264 extern void write_exp_elt_opcode (struct expr_builder *, enum exp_opcode);
 265
 266 extern void write_exp_elt_sym (struct expr_builder *, struct symbol *);
 267
 268 extern void write_exp_elt_longcst (struct expr_builder *, LONGEST);
 269
 270 extern void write_exp_elt_floatcst (struct expr_builder *, const gdb_byte *);
 271
 272 extern void write_exp_elt_type (struct expr_builder *, struct type *);
 273
 274 extern void write_exp_elt_intern (struct expr_builder *, struct internalvar *);
 275
 276 extern void write_exp_string (struct expr_builder *, struct stoken);
 277
 278 void write_exp_string_vector (struct expr_builder *, int type,
 279                               struct stoken_vector *vec);
 280
 281 extern void write_exp_bitstring (struct expr_builder *, struct stoken);
 282
 283 extern void write_exp_elt_block (struct expr_builder *, const struct block *);
 284
 285 extern void write_exp_elt_objfile (struct expr_builder *,
 286                                    struct objfile *objfile);
 287
 288 extern void write_exp_msymbol (struct expr_builder *,
 289                                struct bound_minimal_symbol);
 290
 291 extern void write_dollar_variable (struct parser_state *, struct stoken str);
 292
 293 extern void mark_struct_expression (struct expr_builder *);
 294
 295 extern const char *find_template_name_end (const char *);
 296
 297 extern void start_arglist (void);
 298
 299 extern int end_arglist (void);
 300
 301 extern char *copy_name (struct stoken);
 302
 303 extern void insert_type (enum type_pieces);
 304
 305 extern void push_type (enum type_pieces);
 306
 307 extern void push_type_int (int);
 308
 309 extern void insert_type_address_space (struct expr_builder *, char *);
 310
 311 extern enum type_pieces pop_type (void);
 312
 313 extern int pop_type_int (void);
 314
 315 extern struct type_stack *get_type_stack (void);
 316
 317 extern struct type_stack *append_type_stack (struct type_stack *to,
 318                                              struct type_stack *from);
 319
 320 extern void push_type_stack (struct type_stack *stack);
 321
 322 extern void push_typelist (std::vector<struct type *> *typelist);
 323
 324 extern int dump_subexp (struct expression *, struct ui_file *, int);
 325
 326 extern int dump_subexp_body_standard (struct expression *,
 327                                       struct ui_file *, int);
 328
 329 extern void operator_length (const struct expression *, int, int *, int *);
 330
 331 extern void operator_length_standard (const struct expression *, int, int *,
 332                                       int *);
 333
 334 extern int operator_check_standard (struct expression *exp, int pos,
 335                                     int (*objfile_func)
 336                                       (struct objfile *objfile, void *data),
 337                                     void *data);
 338
 339 extern const char *op_name_standard (enum exp_opcode);
 340
 341 extern struct type *follow_types (struct type *);
 342
 343 extern type_instance_flags follow_type_instance_flags ();
 344
 345 extern void null_post_parser (expression_up *, int);
 346
 347 extern bool parse_float (const char *p, int len,
 348                          const struct type *type, gdb_byte *data);
 349
 350 /* During parsing of a C expression, the pointer to the next character
 351    is in this variable.  */
 352
 353 extern const char *lexptr;
 354
 355 /* After a token has been recognized, this variable points to it.
 356    Currently used only for error reporting.  */
 357 extern const char *prev_lexptr;
 358
 359 /* Current depth in parentheses within the expression.  */
 360
 361 extern int paren_depth;
 362
 363 /* Nonzero means stop parsing on first comma (if not within parentheses).  */
 364
 365 extern int comma_terminates;
 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