gdb/expression.h - gdb

Data types defined

Macros defined

Source code

  1. /* Definitions for expressions stored in reversed prefix form, for GDB.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #if !defined (EXPRESSION_H)
  21. ‌#define EXPRESSION_H 1


  24. #include "symtab.h"                /* Needed for "struct block" type.  */
  25. #include "doublest.h"                /* Needed for DOUBLEST.  */


  28. /* Definitions for saved C expressions.  */

  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.  */

  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.  */

  43. ‌enum exp_opcode
  44.   {
  45. ‌#define OP(name) name ,

  47. #include "std-operator.def"

  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)

  54. /* Language specific operators.  */
  55. #include "ada-operator.def"

  57. ‌#undef OP

  59.     /* Existing only to swallow the last comma (',') from last .inc file.  */
  60.     OP_UNUSED_LAST
  61.   };

  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.   };

  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.   };

  88. /* Macros for converting between number of expression elements and bytes
  89.    to store that many expression elements.  */

  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))

  96. /* From parse.c */

  98. extern struct expression *parse_expression (const char *);

  100. extern struct type *parse_expression_for_completion (const char *, char **,
  101.                                                      enum type_code *);

  103. extern struct expression *parse_exp_1 (const char **, CORE_ADDR pc,
  104.                                        const struct block *, int);

  106. /* For use by parsers; set if we want to parse an expression and
  107.    attempt completion.  */
  108. extern int parse_completion;

  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;

  115. /* From eval.c */

  117. /* Values of NOSIDE argument to eval_subexp.  */

  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.   };

  137. extern struct value *evaluate_subexp_standard
  138.   (struct type *, struct expression *, int *, enum noside);

  140. /* From expprint.c */

  142. extern void print_expression (struct expression *, struct ui_file *);

  144. extern char *op_name (struct expression *exp, enum exp_opcode opcode);

  146. extern char *op_string (enum exp_opcode);

  148. extern void dump_raw_expression (struct expression *,
  149.                                  struct ui_file *, char *);
  150. extern void dump_prefix_expression (struct expression *, struct ui_file *);

  152. #endif /* !defined (EXPRESSION_H) */