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 /* Reverse an expression from suffix form (in which it is constructed)
 303    to prefix form (in which we can conveniently print or execute it).
 304    Ordinarily this always returns -1.  However, if LAST_STRUCT
 305    is not -1 (i.e., we are trying to complete a field name), it will
 306    return the index of the subexpression which is the left-hand-side
 307    of the struct operation at LAST_STRUCT.  */
 308
 309 extern int prefixify_expression (struct expression *expr,
 310                                  int last_struct = -1);
 311
 312 extern void write_exp_elt_opcode (struct expr_builder *, enum exp_opcode);
 313
 314 extern void write_exp_elt_sym (struct expr_builder *, struct symbol *);
 315
 316 extern void write_exp_elt_longcst (struct expr_builder *, LONGEST);
 317
 318 extern void write_exp_elt_floatcst (struct expr_builder *, const gdb_byte *);
 319
 320 extern void write_exp_elt_type (struct expr_builder *, struct type *);
 321
 322 extern void write_exp_elt_intern (struct expr_builder *, struct internalvar *);
 323
 324 extern void write_exp_string (struct expr_builder *, struct stoken);
 325
 326 void write_exp_string_vector (struct expr_builder *, int type,
 327                               struct stoken_vector *vec);
 328
 329 extern void write_exp_bitstring (struct expr_builder *, struct stoken);
 330
 331 extern void write_exp_elt_block (struct expr_builder *, const struct block *);
 332
 333 extern void write_exp_elt_objfile (struct expr_builder *,
 334                                    struct objfile *objfile);
 335
 336 extern void write_exp_msymbol (struct expr_builder *,
 337                                struct bound_minimal_symbol);
 338
 339 extern void write_dollar_variable (struct parser_state *, struct stoken str);
 340
 341 extern const char *find_template_name_end (const char *);
 342
 343 extern char *copy_name (struct stoken);
 344
 345 extern int dump_subexp (struct expression *, struct ui_file *, int);
 346
 347 extern int dump_subexp_body_standard (struct expression *,
 348                                       struct ui_file *, int);
 349
 350 extern void operator_length (const struct expression *, int, int *, int *);
 351
 352 extern void operator_length_standard (const struct expression *, int, int *,
 353                                       int *);
 354
 355 extern int operator_check_standard (struct expression *exp, int pos,
 356                                     int (*objfile_func)
 357                                       (struct objfile *objfile, void *data),
 358                                     void *data);
 359
 360 extern const char *op_name_standard (enum exp_opcode);
 361
 362 extern void null_post_parser (expression_up *, int, int);
 363
 364 extern bool parse_float (const char *p, int len,
 365                          const struct type *type, gdb_byte *data);
 366 \f
 367 /* These codes indicate operator precedences for expression printing,
 368    least tightly binding first.  */
 369 /* Adding 1 to a precedence value is done for binary operators,
 370    on the operand which is more tightly bound, so that operators
 371    of equal precedence within that operand will get parentheses.  */
 372 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
 373    they are used as the "surrounding precedence" to force
 374    various kinds of things to be parenthesized.  */
 375 enum precedence
 376   {
 377     PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
 378     PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
 379     PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
 380     PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION
 381   };
 382
 383 /* Table mapping opcodes into strings for printing operators
 384    and precedences of the operators.  */
 385
 386 struct op_print
 387   {
 388     const char *string;
 389     enum exp_opcode opcode;
 390     /* Precedence of operator.  These values are used only by comparisons.  */
 391     enum precedence precedence;
 392
 393     /* For a binary operator:  1 iff right associate.
 394        For a unary operator:  1 iff postfix.  */
 395     int right_assoc;
 396   };
 397
 398 /* Information needed to print, prefixify, and evaluate expressions for
 399    a given language.  */
 400
 401 struct exp_descriptor
 402   {
 403     /* Print subexpression.  */
 404     void (*print_subexp) (struct expression *, int *, struct ui_file *,
 405                           enum precedence);
 406
 407     /* Returns number of exp_elements needed to represent an operator and
 408        the number of subexpressions it takes.  */
 409     void (*operator_length) (const struct expression*, int, int*, int *);
 410
 411     /* Call OBJFILE_FUNC for any objfile found being referenced by the
 412        single operator of EXP at position POS.  Operator parameters are
 413        located at positive (POS + number) offsets in EXP.  OBJFILE_FUNC
 414        should never be called with NULL OBJFILE.  OBJFILE_FUNC should
 415        get passed an arbitrary caller supplied DATA pointer.  If it
 416        returns non-zero value then (any other) non-zero value should be
 417        immediately returned to the caller.  Otherwise zero should be
 418        returned.  */
 419     int (*operator_check) (struct expression *exp, int pos,
 420                            int (*objfile_func) (struct objfile *objfile,
 421                                                 void *data),
 422                            void *data);
 423
 424     /* Name of this operator for dumping purposes.
 425        The returned value should never be NULL, even if EXP_OPCODE is
 426        an unknown opcode (a string containing an image of the numeric
 427        value of the opcode can be returned, for instance).  */
 428     const char *(*op_name) (enum exp_opcode);
 429
 430     /* Dump the rest of this (prefix) expression after the operator
 431        itself has been printed.  See dump_subexp_body_standard in
 432        (expprint.c).  */
 433     int (*dump_subexp_body) (struct expression *, struct ui_file *, int);
 434
 435     /* Evaluate an expression.  */
 436     struct value *(*evaluate_exp) (struct type *, struct expression *,
 437                                    int *, enum noside);
 438   };
 439
 440
 441 /* Default descriptor containing standard definitions of all
 442    elements.  */
 443 extern const struct exp_descriptor exp_descriptor_standard;
 444
 445 /* Functions used by language-specific extended operators to (recursively)
 446    print/dump subexpressions.  */
 447
 448 extern void print_subexp (struct expression *, int *, struct ui_file *,
 449                           enum precedence);
 450
 451 extern void print_subexp_standard (struct expression *, int *,
 452                                    struct ui_file *, enum precedence);
 453
 454 /* Function used to avoid direct calls to fprintf
 455    in the code generated by the bison parser.  */
 456
 457 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
 458
 459 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile);
 460
 461 #endif /* PARSER_DEFS_H */
 462