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