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_expression_for_completion (char *, char **,
 102                                                      enum type_code *);
 103
 104 extern struct expression *parse_exp_1 (char **, CORE_ADDR pc,
 105                                        const struct block *, int);
 106
 107 /* For use by parsers; set if we want to parse an expression and
 108    attempt completion.  */
 109 extern int parse_completion;
 110
 111 /* The innermost context required by the stack and register variables
 112    we've encountered so far.  To use this, set it to NULL, then call
 113    parse_<whatever>, then look at it.  */
 114 extern const struct block *innermost_block;
 115
 116 /* From eval.c */
 117
 118 /* Values of NOSIDE argument to eval_subexp.  */
 119
 120 enum noside
 121   {
 122     EVAL_NORMAL,
 123     EVAL_SKIP,                  /* Only effect is to increment pos.  */
 124     EVAL_AVOID_SIDE_EFFECTS     /* Don't modify any variables or
 125                                    call any functions.  The value
 126                                    returned will have the correct
 127                                    type, and will have an
 128                                    approximately correct lvalue
 129                                    type (inaccuracy: anything that is
 130                                    listed as being in a register in
 131                                    the function in which it was
 132                                    declared will be lval_register).  */
 133   };
 134
 135 extern struct value *evaluate_subexp_standard
 136   (struct type *, struct expression *, int *, enum noside);
 137
 138 /* From expprint.c */
 139
 140 extern void print_expression (struct expression *, struct ui_file *);
 141
 142 extern char *op_name (struct expression *exp, enum exp_opcode opcode);
 143
 144 extern char *op_string (enum exp_opcode);
 145
 146 extern void dump_raw_expression (struct expression *,
 147                                  struct ui_file *, char *);
 148 extern void dump_prefix_expression (struct expression *, struct ui_file *);
 149
 150 #endif /* !defined (EXPRESSION_H) */