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