gdb/expression.h

   1 /* Definitions for expressions stored in reversed prefix form, for GDB.
   2
   3    Copyright (C) 1986-2013 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #if !defined (EXPRESSION_H)
  21 #define EXPRESSION_H 1
  22
  23
  24 #include "symtab.h"             /* Needed for "struct block" type.  */
  25 #include "doublest.h"           /* Needed for DOUBLEST.  */
  26
  27
  28 /* Definitions for saved C expressions.  */
  29
  30 /* An expression is represented as a vector of union exp_element's.
  31    Each exp_element is an opcode, except that some opcodes cause
  32    the following exp_element to be treated as a long or double constant
  33    or as a variable.  The opcodes are obeyed, using a stack for temporaries.
  34    The value is left on the temporary stack at the end.  */
  35
  36 /* When it is necessary to include a string,
  37    it can occupy as many exp_elements as it needs.
  38    We find the length of the string using strlen,
  39    divide to find out how many exp_elements are used up,
  40    and skip that many.  Strings, like numbers, are indicated
  41    by the preceding opcode.  */
  42
  43 enum exp_opcode
  44   {
  45 #define OP(name) name ,
  46
  47 #include "std-operator.def"
  48
  49     /* First extension operator.  Individual language modules define extra
  50        operators in *.def include files below with numbers higher than
  51        OP_EXTENDED0.  */
  52     OP (OP_EXTENDED0)
  53
  54 /* Language specific operators.  */
  55 #include "ada-operator.def"
  56
  57 #undef OP
  58
  59     /* Existing only to swallow the last comma (',') from last .inc file.  */
  60     OP_UNUSED_LAST
  61   };
  62
  63 union exp_element
  64   {
  65     enum exp_opcode opcode;
  66     struct symbol *symbol;
  67     LONGEST longconst;
  68     DOUBLEST doubleconst;
  69     gdb_byte decfloatconst[16];
  70     /* Really sizeof (union exp_element) characters (or less for the last
  71        element of a string).  */
  72     char string;
  73     struct type *type;
  74     struct internalvar *internalvar;
  75     const struct block *block;
  76     struct objfile *objfile;
  77   };
  78
  79 struct expression
  80   {
  81     const struct language_defn *language_defn;  /* language it was
  82                                                    entered in.  */
  83     struct gdbarch *gdbarch;  /* architecture it was parsed in.  */
  84     int nelts;
  85     union exp_element elts[1];
  86   };
  87
  88 /* Macros for converting between number of expression elements and bytes
  89    to store that many expression elements.  */
  90
  91 #define EXP_ELEM_TO_BYTES(elements) \
  92     ((elements) * sizeof (union exp_element))
  93 #define BYTES_TO_EXP_ELEM(bytes) \
  94     (((bytes) + sizeof (union exp_element) - 1) / sizeof (union exp_element))
  95
  96 /* From parse.c */
  97
  98 extern struct expression *parse_expression (const char *);
  99
 100 extern struct type *parse_expression_for_completion (const char *, char **,
 101                                                      enum type_code *);
 102
 103 extern struct expression *parse_exp_1 (const 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 completion.  */
 108 extern int parse_completion;
 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                                    Ideally this would not even read
 133                                    target memory, but currently it
 134                                    does in many situations.  */
 135   };
 136
 137 extern struct value *evaluate_subexp_standard
 138   (struct type *, struct expression *, int *, enum noside);
 139
 140 /* From expprint.c */
 141
 142 extern void print_expression (struct expression *, struct ui_file *);
 143
 144 extern char *op_name (struct expression *exp, enum exp_opcode opcode);
 145
 146 extern char *op_string (enum exp_opcode);
 147
 148 extern void dump_raw_expression (struct expression *,
 149                                  struct ui_file *, char *);
 150 extern void dump_prefix_expression (struct expression *, struct ui_file *);
 151
 152 #endif /* !defined (EXPRESSION_H) */