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