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