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