gdb/parser-defs.h

   1 /* Parser definitions for GDB.
   2
   3    Copyright (C) 1986-2023 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 "expression.h"
  27 #include "symtab.h"
  28 #include "expop.h"
  29
  30 struct block;
  31 struct language_defn;
  32 struct internalvar;
  33 class innermost_block_tracker;
  34
  35 extern bool parser_debug;
  36
  37 /* A class that can be used to build a "struct expression".  */
  38
  39 struct expr_builder
  40 {
  41   /* Constructor.  LANG is the language used to parse the expression.
  42      And GDBARCH is the gdbarch to use during parsing.  */
  43
  44   expr_builder (const struct language_defn *lang,
  45                 struct gdbarch *gdbarch)
  46     : expout (new expression (lang, gdbarch))
  47   {
  48   }
  49
  50   DISABLE_COPY_AND_ASSIGN (expr_builder);
  51
  52   /* Resize the allocated expression to the correct size, and return
  53      it as an expression_up -- passing ownership to the caller.  */
  54   ATTRIBUTE_UNUSED_RESULT expression_up release ()
  55   {
  56     return std::move (expout);
  57   }
  58
  59   /* Return the gdbarch that was passed to the constructor.  */
  60
  61   struct gdbarch *gdbarch ()
  62   {
  63     return expout->gdbarch;
  64   }
  65
  66   /* Return the language that was passed to the constructor.  */
  67
  68   const struct language_defn *language ()
  69   {
  70     return expout->language_defn;
  71   }
  72
  73   /* Set the root operation of the expression that is currently being
  74      built.  */
  75   void set_operation (expr::operation_up &&op)
  76   {
  77     expout->op = std::move (op);
  78   }
  79
  80   /* The expression related to this parser state.  */
  81
  82   expression_up expout;
  83 };
  84
  85 /* Complete an expression that references a field, like "x->y".  */
  86
  87 struct expr_complete_structop : public expr_completion_base
  88 {
  89   explicit expr_complete_structop (expr::structop_base_operation *op)
  90     : m_op (op)
  91   {
  92   }
  93
  94   bool complete (struct expression *exp,
  95                  completion_tracker &tracker) override
  96   {
  97     return m_op->complete (exp, tracker);
  98   }
  99
 100 private:
 101
 102   /* The last struct expression directly before a '.' or '->'.  This
 103      is set when parsing and is only used when completing a field
 104      name.  It is nullptr if no dereference operation was found.  */
 105   expr::structop_base_operation *m_op = nullptr;
 106 };
 107
 108 /* Complete a tag name in an expression.  This is used for something
 109    like "enum abc<TAB>".  */
 110
 111 struct expr_complete_tag : public expr_completion_base
 112 {
 113   expr_complete_tag (enum type_code code,
 114                      gdb::unique_xmalloc_ptr<char> name)
 115     : m_code (code),
 116       m_name (std::move (name))
 117   {
 118     /* Parsers should enforce this statically.  */
 119     gdb_assert (code == TYPE_CODE_ENUM
 120                 || code == TYPE_CODE_UNION
 121                 || code == TYPE_CODE_STRUCT);
 122   }
 123
 124   bool complete (struct expression *exp,
 125                  completion_tracker &tracker) override;
 126
 127 private:
 128
 129   /* The kind of tag to complete.  */
 130   enum type_code m_code;
 131
 132   /* The token for tagged type name completion.  */
 133   gdb::unique_xmalloc_ptr<char> m_name;
 134 };
 135
 136 /* An instance of this type is instantiated during expression parsing,
 137    and passed to the appropriate parser.  It holds both inputs to the
 138    parser, and result.  */
 139
 140 struct parser_state : public expr_builder
 141 {
 142   /* Constructor.  LANG is the language used to parse the expression.
 143      And GDBARCH is the gdbarch to use during parsing.  */
 144
 145   parser_state (const struct language_defn *lang,
 146                 struct gdbarch *gdbarch,
 147                 const struct block *context_block,
 148                 CORE_ADDR context_pc,
 149                 int comma,
 150                 const char *input,
 151                 bool completion,
 152                 innermost_block_tracker *tracker,
 153                 bool void_p)
 154     : expr_builder (lang, gdbarch),
 155       expression_context_block (context_block),
 156       expression_context_pc (context_pc),
 157       comma_terminates (comma),
 158       lexptr (input),
 159       parse_completion (completion),
 160       block_tracker (tracker),
 161       void_context_p (void_p)
 162   {
 163   }
 164
 165   DISABLE_COPY_AND_ASSIGN (parser_state);
 166
 167   /* Begin counting arguments for a function call,
 168      saving the data about any containing call.  */
 169
 170   void start_arglist ()
 171   {
 172     m_funcall_chain.push_back (arglist_len);
 173     arglist_len = 0;
 174   }
 175
 176   /* Return the number of arguments in a function call just terminated,
 177      and restore the data for the containing function call.  */
 178
 179   int end_arglist ()
 180   {
 181     int val = arglist_len;
 182     arglist_len = m_funcall_chain.back ();
 183     m_funcall_chain.pop_back ();
 184     return val;
 185   }
 186
 187   /* Mark the given operation as the starting location of a structure
 188      expression.  This is used when completing on field names.  */
 189
 190   void mark_struct_expression (expr::structop_base_operation *op);
 191
 192   /* Indicate that the current parser invocation is completing a tag.
 193      TAG is the type code of the tag, and PTR and LENGTH represent the
 194      start of the tag name.  */
 195
 196   void mark_completion_tag (enum type_code tag, const char *ptr, int length);
 197
 198   /* Mark for completion, using an arbitrary completer.  */
 199
 200   void mark_completion (std::unique_ptr<expr_completion_base> completer)
 201   {
 202     gdb_assert (m_completion_state == nullptr);
 203     m_completion_state = std::move (completer);
 204   }
 205
 206   /* Push an operation on the stack.  */
 207   void push (expr::operation_up &&op)
 208   {
 209     m_operations.push_back (std::move (op));
 210   }
 211
 212   /* Create a new operation and push it on the stack.  */
 213   template<typename T, typename... Arg>
 214   void push_new (Arg... args)
 215   {
 216     m_operations.emplace_back (new T (std::forward<Arg> (args)...));
 217   }
 218
 219   /* Push a new C string operation.  */
 220   void push_c_string (int, struct stoken_vector *vec);
 221
 222   /* Push a symbol reference.  If SYM is nullptr, look for a minimal
 223      symbol.  */
 224   void push_symbol (const char *name, block_symbol sym);
 225
 226   /* Push a reference to $mumble.  This may result in a convenience
 227      variable, a history reference, or a register.  */
 228   void push_dollar (struct stoken str);
 229
 230   /* Pop an operation from the stack.  */
 231   expr::operation_up pop ()
 232   {
 233     expr::operation_up result = std::move (m_operations.back ());
 234     m_operations.pop_back ();
 235     return result;
 236   }
 237
 238   /* Pop N elements from the stack and return a vector.  */
 239   std::vector<expr::operation_up> pop_vector (int n)
 240   {
 241     std::vector<expr::operation_up> result (n);
 242     for (int i = 1; i <= n; ++i)
 243       result[n - i] = pop ();
 244     return result;
 245   }
 246
 247   /* A helper that pops an operation, wraps it in some other
 248      operation, and pushes it again.  */
 249   template<typename T>
 250   void wrap ()
 251   {
 252     using namespace expr;
 253     operation_up v = ::expr::make_operation<T> (pop ());
 254     push (std::move (v));
 255   }
 256
 257   /* A helper that pops two operations, wraps them in some other
 258      operation, and pushes the result.  */
 259   template<typename T>
 260   void wrap2 ()
 261   {
 262     expr::operation_up rhs = pop ();
 263     expr::operation_up lhs = pop ();
 264     push (expr::make_operation<T> (std::move (lhs), std::move (rhs)));
 265   }
 266
 267   /* If this is nonzero, this block is used as the lexical context for
 268      symbol names.  */
 269
 270   const struct block * const expression_context_block;
 271
 272   /* If expression_context_block is non-zero, then this is the PC
 273      within the block that we want to evaluate expressions at.  When
 274      debugging C or C++ code, we use this to find the exact line we're
 275      at, and then look up the macro definitions active at that
 276      point.  */
 277   const CORE_ADDR expression_context_pc;
 278
 279   /* Nonzero means stop parsing on first comma (if not within parentheses).  */
 280
 281   int comma_terminates;
 282
 283   /* During parsing of a C expression, the pointer to the next character
 284      is in this variable.  */
 285
 286   const char *lexptr;
 287
 288   /* After a token has been recognized, this variable points to it.
 289      Currently used only for error reporting.  */
 290   const char *prev_lexptr = nullptr;
 291
 292   /* Number of arguments seen so far in innermost function call.  */
 293
 294   int arglist_len = 0;
 295
 296   /* True if parsing an expression to attempt completion.  */
 297   bool parse_completion;
 298
 299   /* Completion state is updated here.  */
 300   std::unique_ptr<expr_completion_base> m_completion_state;
 301
 302   /* The innermost block tracker.  */
 303   innermost_block_tracker *block_tracker;
 304
 305   /* True if no value is expected from the expression.  */
 306   bool void_context_p;
 307
 308 private:
 309
 310   /* Data structure for saving values of arglist_len for function calls whose
 311      arguments contain other function calls.  */
 312
 313   std::vector<int> m_funcall_chain;
 314
 315   /* Stack of operations.  */
 316   std::vector<expr::operation_up> m_operations;
 317 };
 318
 319 /* When parsing expressions we track the innermost block that was
 320    referenced.  */
 321
 322 class innermost_block_tracker
 323 {
 324 public:
 325   innermost_block_tracker (innermost_block_tracker_types types
 326                            = INNERMOST_BLOCK_FOR_SYMBOLS)
 327     : m_types (types),
 328       m_innermost_block (NULL)
 329   { /* Nothing.  */ }
 330
 331   /* Update the stored innermost block if the new block B is more inner
 332      than the currently stored block, or if no block is stored yet.  The
 333      type T tells us whether the block B was for a symbol or for a
 334      register.  The stored innermost block is only updated if the type T is
 335      a type we are interested in, the types we are interested in are held
 336      in M_TYPES and set during RESET.  */
 337   void update (const struct block *b, innermost_block_tracker_types t);
 338
 339   /* Overload of main UPDATE method which extracts the block from BS.  */
 340   void update (const struct block_symbol &bs)
 341   {
 342     update (bs.block, INNERMOST_BLOCK_FOR_SYMBOLS);
 343   }
 344
 345   /* Return the stored innermost block.  Can be nullptr if no symbols or
 346      registers were found during an expression parse, and so no innermost
 347      block was defined.  */
 348   const struct block *block () const
 349   {
 350     return m_innermost_block;
 351   }
 352
 353 private:
 354   /* The type of innermost block being looked for.  */
 355   innermost_block_tracker_types m_types;
 356
 357   /* The currently stored innermost block found while parsing an
 358      expression.  */
 359   const struct block *m_innermost_block;
 360 };
 361
 362 /* A string token, either a char-string or bit-string.  Char-strings are
 363    used, for example, for the names of symbols.  */
 364
 365 struct stoken
 366   {
 367     /* Pointer to first byte of char-string or first bit of bit-string.  */
 368     const char *ptr;
 369     /* Length of string in bytes for char-string or bits for bit-string.  */
 370     int length;
 371   };
 372
 373 struct typed_stoken
 374   {
 375     /* A language-specific type field.  */
 376     int type;
 377     /* Pointer to first byte of char-string or first bit of bit-string.  */
 378     char *ptr;
 379     /* Length of string in bytes for char-string or bits for bit-string.  */
 380     int length;
 381   };
 382
 383 struct stoken_vector
 384   {
 385     int len;
 386     struct typed_stoken *tokens;
 387   };
 388
 389 struct ttype
 390   {
 391     struct stoken stoken;
 392     struct type *type;
 393   };
 394
 395 struct symtoken
 396   {
 397     struct stoken stoken;
 398     struct block_symbol sym;
 399     int is_a_field_of_this;
 400   };
 401
 402 struct objc_class_str
 403   {
 404     struct stoken stoken;
 405     struct type *type;
 406     int theclass;
 407   };
 408
 409 extern const char *find_template_name_end (const char *);
 410
 411 extern std::string copy_name (struct stoken);
 412
 413 extern bool parse_float (const char *p, int len,
 414                          const struct type *type, gdb_byte *data);
 415 extern bool fits_in_type (int n_sign, ULONGEST n, int type_bits,
 416                           bool type_signed_p);
 417 \f
 418
 419 /* Function used to avoid direct calls to fprintf
 420    in the code generated by the bison parser.  */
 421
 422 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
 423
 424 extern bool exp_uses_objfile (struct expression *exp, struct objfile *objfile);
 425
 426 #endif /* PARSER_DEFS_H */
 427