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