gdb/parser-defs.h

   1 /* Parser definitions for GDB.
   2
   3    Copyright (C) 1986-2013 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 "doublest.h"
  27 #include "vec.h"
  28 #include "expression.h"
  29
  30 struct block;
  31
  32 extern int parser_debug;
  33
  34 extern struct expression *expout;
  35 extern int expout_size;
  36 extern int expout_ptr;
  37
  38 #define parse_gdbarch (expout->gdbarch)
  39 #define parse_language (expout->language_defn)
  40
  41 /* If this is nonzero, this block is used as the lexical context
  42    for symbol names.  */
  43
  44 extern const struct block *expression_context_block;
  45
  46 /* If expression_context_block is non-zero, then this is the PC within
  47    the block that we want to evaluate expressions at.  When debugging
  48    C or C++ code, we use this to find the exact line we're at, and
  49    then look up the macro definitions active at that point.  */
  50 extern CORE_ADDR expression_context_pc;
  51
  52 /* The innermost context required by the stack and register variables
  53    we've encountered so far.  */
  54 extern const struct block *innermost_block;
  55
  56 /* The block in which the most recently discovered symbol was found.
  57    FIXME: Should be declared along with lookup_symbol in symtab.h; is not
  58    related specifically to parsing.  */
  59 extern const struct block *block_found;
  60
  61 /* Number of arguments seen so far in innermost function call.  */
  62 extern int arglist_len;
  63
  64 /* A string token, either a char-string or bit-string.  Char-strings are
  65    used, for example, for the names of symbols.  */
  66
  67 struct stoken
  68   {
  69     /* Pointer to first byte of char-string or first bit of bit-string.  */
  70     const char *ptr;
  71     /* Length of string in bytes for char-string or bits for bit-string.  */
  72     int length;
  73   };
  74
  75 struct typed_stoken
  76   {
  77     /* A language-specific type field.  */
  78     int type;
  79     /* Pointer to first byte of char-string or first bit of bit-string.  */
  80     char *ptr;
  81     /* Length of string in bytes for char-string or bits for bit-string.  */
  82     int length;
  83   };
  84
  85 struct stoken_vector
  86   {
  87     int len;
  88     struct typed_stoken *tokens;
  89   };
  90
  91 struct ttype
  92   {
  93     struct stoken stoken;
  94     struct type *type;
  95   };
  96
  97 struct symtoken
  98   {
  99     struct stoken stoken;
 100     struct symbol *sym;
 101     int is_a_field_of_this;
 102   };
 103
 104 struct objc_class_str
 105   {
 106     struct stoken stoken;
 107     struct type *type;
 108     int class;
 109   };
 110
 111 typedef struct type *type_ptr;
 112 DEF_VEC_P (type_ptr);
 113
 114 /* For parsing of complicated types.
 115    An array should be preceded in the list by the size of the array.  */
 116 enum type_pieces
 117   {
 118     tp_end = -1,
 119     tp_pointer,
 120     tp_reference,
 121     tp_array,
 122     tp_function,
 123     tp_function_with_arguments,
 124     tp_const,
 125     tp_volatile,
 126     tp_space_identifier,
 127     tp_type_stack
 128   };
 129 /* The stack can contain either an enum type_pieces or an int.  */
 130 union type_stack_elt
 131   {
 132     enum type_pieces piece;
 133     int int_val;
 134     struct type_stack *stack_val;
 135     VEC (type_ptr) *typelist_val;
 136   };
 137
 138 /* The type stack is an instance of this structure.  */
 139
 140 struct type_stack
 141 {
 142   /* Elements on the stack.  */
 143   union type_stack_elt *elements;
 144   /* Current stack depth.  */
 145   int depth;
 146   /* Allocated size of stack.  */
 147   int size;
 148 };
 149
 150 /* Helper function to initialize the expout, expout_size, expout_ptr
 151    trio before it is used to store expression elements created during
 152    the parsing of an expression.  INITIAL_SIZE is the initial size of
 153    the expout array.  LANG is the language used to parse the expression.
 154    And GDBARCH is the gdbarch to use during parsing.  */
 155
 156 extern void initialize_expout (int, const struct language_defn *,
 157                                struct gdbarch *);
 158
 159 /* Helper function that frees any unsed space in the expout array.
 160    It is generally used when the parser has just been parsed and
 161    created.  */
 162
 163 extern void reallocate_expout (void);
 164
 165 /* Reverse an expression from suffix form (in which it is constructed)
 166    to prefix form (in which we can conveniently print or execute it).
 167    Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
 168    is not -1 (i.e., we are trying to complete a field name), it will
 169    return the index of the subexpression which is the left-hand-side
 170    of the struct operation at EXPOUT_LAST_STRUCT.  */
 171
 172 extern int prefixify_expression (struct expression *expr);
 173
 174 extern void write_exp_elt_opcode (enum exp_opcode);
 175
 176 extern void write_exp_elt_sym (struct symbol *);
 177
 178 extern void write_exp_elt_longcst (LONGEST);
 179
 180 extern void write_exp_elt_dblcst (DOUBLEST);
 181
 182 extern void write_exp_elt_decfloatcst (gdb_byte *);
 183
 184 extern void write_exp_elt_type (struct type *);
 185
 186 extern void write_exp_elt_intern (struct internalvar *);
 187
 188 extern void write_exp_string (struct stoken);
 189
 190 void write_exp_string_vector (int type, struct stoken_vector *vec);
 191
 192 extern void write_exp_bitstring (struct stoken);
 193
 194 extern void write_exp_elt_block (const struct block *);
 195
 196 extern void write_exp_elt_objfile (struct objfile *objfile);
 197
 198 extern void write_exp_msymbol (struct bound_minimal_symbol);
 199
 200 extern void write_dollar_variable (struct stoken str);
 201
 202 extern void mark_struct_expression (void);
 203
 204 extern const char *find_template_name_end (const char *);
 205
 206 extern void start_arglist (void);
 207
 208 extern int end_arglist (void);
 209
 210 extern char *copy_name (struct stoken);
 211
 212 extern void insert_type (enum type_pieces);
 213
 214 extern void push_type (enum type_pieces);
 215
 216 extern void push_type_int (int);
 217
 218 extern void insert_type_address_space (char *);
 219
 220 extern enum type_pieces pop_type (void);
 221
 222 extern int pop_type_int (void);
 223
 224 extern struct type_stack *get_type_stack (void);
 225
 226 extern struct type_stack *append_type_stack (struct type_stack *to,
 227                                              struct type_stack *from);
 228
 229 extern void push_type_stack (struct type_stack *stack);
 230
 231 extern void type_stack_cleanup (void *arg);
 232
 233 extern void push_typelist (VEC (type_ptr) *typelist);
 234
 235 extern int length_of_subexp (struct expression *, int);
 236
 237 extern int dump_subexp (struct expression *, struct ui_file *, int);
 238
 239 extern int dump_subexp_body_standard (struct expression *,
 240                                       struct ui_file *, int);
 241
 242 extern void operator_length (const struct expression *, int, int *, int *);
 243
 244 extern void operator_length_standard (const struct expression *, int, int *,
 245                                       int *);
 246
 247 extern int operator_check_standard (struct expression *exp, int pos,
 248                                     int (*objfile_func)
 249                                       (struct objfile *objfile, void *data),
 250                                     void *data);
 251
 252 extern char *op_name_standard (enum exp_opcode);
 253
 254 extern struct type *follow_types (struct type *);
 255
 256 extern void null_post_parser (struct expression **, int);
 257
 258 extern int parse_float (const char *p, int len, DOUBLEST *d,
 259                         const char **suffix);
 260
 261 extern int parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
 262                           DOUBLEST *d, struct type **t);
 263
 264 /* During parsing of a C expression, the pointer to the next character
 265    is in this variable.  */
 266
 267 extern const char *lexptr;
 268
 269 /* After a token has been recognized, this variable points to it.
 270    Currently used only for error reporting.  */
 271 extern const char *prev_lexptr;
 272
 273 /* Current depth in parentheses within the expression.  */
 274
 275 extern int paren_depth;
 276
 277 /* Nonzero means stop parsing on first comma (if not within parentheses).  */
 278
 279 extern int comma_terminates;
 280 \f
 281 /* These codes indicate operator precedences for expression printing,
 282    least tightly binding first.  */
 283 /* Adding 1 to a precedence value is done for binary operators,
 284    on the operand which is more tightly bound, so that operators
 285    of equal precedence within that operand will get parentheses.  */
 286 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
 287    they are used as the "surrounding precedence" to force
 288    various kinds of things to be parenthesized.  */
 289 enum precedence
 290   {
 291     PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
 292     PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
 293     PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
 294     PREC_HYPER, PREC_PREFIX, PREC_SUFFIX, PREC_BUILTIN_FUNCTION
 295   };
 296
 297 /* Table mapping opcodes into strings for printing operators
 298    and precedences of the operators.  */
 299
 300 struct op_print
 301   {
 302     char *string;
 303     enum exp_opcode opcode;
 304     /* Precedence of operator.  These values are used only by comparisons.  */
 305     enum precedence precedence;
 306
 307     /* For a binary operator:  1 iff right associate.
 308        For a unary operator:  1 iff postfix.  */
 309     int right_assoc;
 310   };
 311
 312 /* Information needed to print, prefixify, and evaluate expressions for
 313    a given language.  */
 314
 315 struct exp_descriptor
 316   {
 317     /* Print subexpression.  */
 318     void (*print_subexp) (struct expression *, int *, struct ui_file *,
 319                           enum precedence);
 320
 321     /* Returns number of exp_elements needed to represent an operator and
 322        the number of subexpressions it takes.  */
 323     void (*operator_length) (const struct expression*, int, int*, int *);
 324
 325     /* Call TYPE_FUNC and OBJFILE_FUNC for any TYPE and OBJFILE found being
 326        referenced by the single operator of EXP at position POS.  Operator
 327        parameters are located at positive (POS + number) offsets in EXP.
 328        The functions should never be called with NULL TYPE or NULL OBJFILE.
 329        Functions should get passed an arbitrary caller supplied DATA pointer.
 330        If any of the functions returns non-zero value then (any other) non-zero
 331        value should be immediately returned to the caller.  Otherwise zero
 332        should be returned.  */
 333     int (*operator_check) (struct expression *exp, int pos,
 334                            int (*objfile_func) (struct objfile *objfile,
 335                                                 void *data),
 336                            void *data);
 337
 338     /* Name of this operator for dumping purposes.
 339        The returned value should never be NULL, even if EXP_OPCODE is
 340        an unknown opcode (a string containing an image of the numeric
 341        value of the opcode can be returned, for instance).  */
 342     char *(*op_name) (enum exp_opcode);
 343
 344     /* Dump the rest of this (prefix) expression after the operator
 345        itself has been printed.  See dump_subexp_body_standard in
 346        (expprint.c).  */
 347     int (*dump_subexp_body) (struct expression *, struct ui_file *, int);
 348
 349     /* Evaluate an expression.  */
 350     struct value *(*evaluate_exp) (struct type *, struct expression *,
 351                                    int *, enum noside);
 352   };
 353
 354
 355 /* Default descriptor containing standard definitions of all
 356    elements.  */
 357 extern const struct exp_descriptor exp_descriptor_standard;
 358
 359 /* Functions used by language-specific extended operators to (recursively)
 360    print/dump subexpressions.  */
 361
 362 extern void print_subexp (struct expression *, int *, struct ui_file *,
 363                           enum precedence);
 364
 365 extern void print_subexp_standard (struct expression *, int *,
 366                                    struct ui_file *, enum precedence);
 367
 368 /* Function used to avoid direct calls to fprintf
 369    in the code generated by the bison parser.  */
 370
 371 extern void parser_fprintf (FILE *, const char *, ...) ATTRIBUTE_PRINTF (2, 3);
 372
 373 extern int exp_uses_objfile (struct expression *exp, struct objfile *objfile);
 374
 375 extern void mark_completion_tag (enum type_code, const char *ptr,
 376                                  int length);
 377
 378 #endif /* PARSER_DEFS_H */
 379