gdb/parser-defs.h

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