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