gdb/expression.h

   1 /* Definitions for expressions stored in reversed prefix form, for GDB.
   2
   3    Copyright (C) 1986, 1989, 1992, 1994, 2000, 2003, 2005, 2007-2012
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #if !defined (EXPRESSION_H)
  22 #define EXPRESSION_H 1
  23
  24
  25 #include "symtab.h"             /* Needed for "struct block" type.  */
  26 #include "doublest.h"           /* Needed for DOUBLEST.  */
  27
  28
  29 /* Definitions for saved C expressions.  */
  30
  31 /* An expression is represented as a vector of union exp_element's.
  32    Each exp_element is an opcode, except that some opcodes cause
  33    the following exp_element to be treated as a long or double constant
  34    or as a variable.  The opcodes are obeyed, using a stack for temporaries.
  35    The value is left on the temporary stack at the end.  */
  36
  37 /* When it is necessary to include a string,
  38    it can occupy as many exp_elements as it needs.
  39    We find the length of the string using strlen,
  40    divide to find out how many exp_elements are used up,
  41    and skip that many.  Strings, like numbers, are indicated
  42    by the preceding opcode.  */
  43
  44 enum exp_opcode
  45   {
  46 #define OP(name) name ,
  47
  48 #include "std-operator.def"
  49
  50     /* First extension operator.  Individual language modules define extra
  51        operators in *.def include files below with numbers higher than
  52        OP_EXTENDED0.  */
  53     OP (OP_EXTENDED0)
  54
  55 /* Language specific operators.  */
  56 #include "ada-operator.def"
  57
  58 #undef OP
  59
  60     /* Existing only to swallow the last comma (',') from last .inc file.  */
  61     OP_UNUSED_LAST
  62   };
  63
  64 union exp_element
  65   {
  66     enum exp_opcode opcode;
  67     struct symbol *symbol;
  68     LONGEST longconst;
  69     DOUBLEST doubleconst;
  70     gdb_byte decfloatconst[16];
  71     /* Really sizeof (union exp_element) characters (or less for the last
  72        element of a string).  */
  73     char string;
  74     struct type *type;
  75     struct internalvar *internalvar;
  76     const struct block *block;
  77     struct objfile *objfile;
  78   };
  79
  80 struct expression
  81   {
  82     const struct language_defn *language_defn;  /* language it was
  83                                                    entered in.  */
  84     struct gdbarch *gdbarch;  /* architecture it was parsed in.  */
  85     int nelts;
  86     union exp_element elts[1];
  87   };
  88
  89 /* Macros for converting between number of expression elements and bytes
  90    to store that many expression elements.  */
  91
  92 #define EXP_ELEM_TO_BYTES(elements) \
  93     ((elements) * sizeof (union exp_element))
  94 #define BYTES_TO_EXP_ELEM(bytes) \
  95     (((bytes) + sizeof (union exp_element) - 1) / sizeof (union exp_element))
  96
  97 /* From parse.c */
  98
  99 extern struct expression *parse_expression (char *);
 100
 101 extern struct type *parse_field_expression (char *, char **);
 102
 103 extern struct expression *parse_exp_1 (char **, CORE_ADDR pc,
 104                                        const struct block *, int);
 105
 106 /* For use by parsers; set if we want to parse an expression and
 107    attempt to complete a field name.  */
 108 extern int in_parse_field;
 109
 110 /* The innermost context required by the stack and register variables
 111    we've encountered so far.  To use this, set it to NULL, then call
 112    parse_<whatever>, then look at it.  */
 113 extern const struct block *innermost_block;
 114
 115 /* From eval.c */
 116
 117 /* Values of NOSIDE argument to eval_subexp.  */
 118
 119 enum noside
 120   {
 121     EVAL_NORMAL,
 122     EVAL_SKIP,                  /* Only effect is to increment pos.  */
 123     EVAL_AVOID_SIDE_EFFECTS     /* Don't modify any variables or
 124                                    call any functions.  The value
 125                                    returned will have the correct
 126                                    type, and will have an
 127                                    approximately correct lvalue
 128                                    type (inaccuracy: anything that is
 129                                    listed as being in a register in
 130                                    the function in which it was
 131                                    declared will be lval_register).  */
 132   };
 133
 134 extern struct value *evaluate_subexp_standard
 135   (struct type *, struct expression *, int *, enum noside);
 136
 137 /* From expprint.c */
 138
 139 extern void print_expression (struct expression *, struct ui_file *);
 140
 141 extern char *op_name (struct expression *exp, enum exp_opcode opcode);
 142
 143 extern char *op_string (enum exp_opcode);
 144
 145 extern void dump_raw_expression (struct expression *,
 146                                  struct ui_file *, char *);
 147 extern void dump_prefix_expression (struct expression *, struct ui_file *);
 148
 149 #endif /* !defined (EXPRESSION_H) */