[unix-history] / gnu / usr.bin / gdb / expression.h

/* Definitions for expressions stored in reversed prefix form, for GDB.
   Copyright (C) 1986, 1989 Free Software Foundation, Inc.

This file is part of GDB.

GDB is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GDB is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GDB; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* Definitions for saved C expressions.  */

/* An expression is represented as a vector of union exp_element's.
   Each exp_element is an opcode, except that some opcodes cause
   the following exp_element to be treated as a long or double constant
   or as a variable.  The opcodes are obeyed, using a stack for temporaries.
   The value is left on the temporary stack at the end.  */

/* When it is necessary to include a string,
   it can occupy as many exp_elements as it needs.
   We find the length of the string using strlen,
   divide to find out how many exp_elements are used up,
   and skip that many.  Strings, like numbers, are indicated
   by the preceding opcode.  */

enum exp_opcode
{
/* BINOP_... operate on two values computed by following subexpressions,
   replacing them by one result value.  They take no immediate arguments.  */
  BINOP_ADD,		/* + */
  BINOP_SUB,		/* - */
  BINOP_MUL,		/* * */
  BINOP_DIV,		/* / */
  BINOP_REM,		/* % */
  BINOP_LSH,		/* << */
  BINOP_RSH,		/* >> */
  BINOP_AND,		/* && */
  BINOP_OR,		/* || */
  BINOP_LOGAND,		/* & */
  BINOP_LOGIOR,		/* | */
  BINOP_LOGXOR,		/* ^ */
  BINOP_EQUAL,		/* == */
  BINOP_NOTEQUAL,	/* != */
  BINOP_LESS,		/* < */
  BINOP_GTR,		/* > */
  BINOP_LEQ,		/* <= */
  BINOP_GEQ,		/* >= */
  BINOP_REPEAT,		/* @ */
  BINOP_ASSIGN,		/* = */
  BINOP_COMMA,		/* , */
  BINOP_SUBSCRIPT,	/* x[y] */
  BINOP_EXP,		/* Exponentiation */

/* C++.  */
  BINOP_MIN,		/* <? */
  BINOP_MAX,		/* >? */
  BINOP_SCOPE,		/* :: */

  /* STRUCTOP_MEMBER is used for pointer-to-member constructs.
     X . * Y translates into X STRUCTOP_MEMBER Y.  */
  STRUCTOP_MEMBER,
  /* STRUCTOP_MPTR is used for pointer-to-member constructs
     when X is a pointer instead of an aggregate.  */
  STRUCTOP_MPTR,
/* end of C++.  */

  BINOP_END,

  BINOP_ASSIGN_MODIFY,	/* +=, -=, *=, and so on.
			   The following exp_element is another opcode,
			   a BINOP_, saying how to modify.
			   Then comes another BINOP_ASSIGN_MODIFY,
			   making three exp_elements in total.  */

/* Operates on three values computed by following subexpressions.  */
  TERNOP_COND,		/* ?: */

/* The OP_... series take immediate following arguments.
   After the arguments come another OP_... (the same one)
   so that the grouping can be recognized from the end.  */

/* OP_LONG is followed by a type pointer in the next exp_element
   and the long constant value in the following exp_element.
   Then comes another OP_LONG.
   Thus, the operation occupies four exp_elements.  */

  OP_LONG,
/* OP_DOUBLE is similar but takes a double constant instead of a long one.  */
  OP_DOUBLE,
/* OP_VAR_VALUE takes one struct symbol * in the following exp_element,
   followed by another OP_VAR_VALUE, making three exp_elements.  */
  OP_VAR_VALUE,
/* OP_LAST is followed by an integer in the next exp_element.
   The integer is zero for the last value printed,
   or it is the absolute number of a history element.
   With another OP_LAST at the end, this makes three exp_elements.  */
  OP_LAST,
/* OP_REGISTER is followed by an integer in the next exp_element.
   This is the number of a register to fetch (as an int).
   With another OP_REGISTER at the end, this makes three exp_elements.  */
  OP_REGISTER,
/* OP_INTERNALVAR is followed by an internalvar ptr in the next exp_element.
   With another OP_INTERNALVAR at the end, this makes three exp_elements.  */
  OP_INTERNALVAR,
/* OP_FUNCALL is followed by an integer in the next exp_element.
   The integer is the number of args to the function call.
   That many plus one values from following subexpressions
   are used, the first one being the function.
   The integer is followed by a repeat of OP_FUNCALL,
   making three exp_elements.  */
  OP_FUNCALL,
/* OP_STRING represents a string constant.
   Its format is the same as that of a STRUCTOP, but the string
   data is just made into a string constant when the operation
   is executed.  */
  OP_STRING,

/* UNOP_CAST is followed by a type pointer in the next exp_element.
   With another UNOP_CAST at the end, this makes three exp_elements.
   It casts the value of the following subexpression.  */
  UNOP_CAST,
/* UNOP_MEMVAL is followed by a type pointer in the next exp_element
   With another UNOP_MEMVAL at the end, this makes three exp_elements.
   It casts the contents of the word addressed by the value of the
   following subexpression.  */
  UNOP_MEMVAL,
/* UNOP_... operate on one value from a following subexpression
   and replace it with a result.  They take no immediate arguments.  */
  UNOP_NEG,		/* Unary - */
  UNOP_ZEROP,		/* Unary ! */
  UNOP_LOGNOT,		/* Unary ~ */
  UNOP_IND,		/* Unary * */
  UNOP_ADDR,		/* Unary & */
  UNOP_PREINCREMENT,	/* ++ before an expression */
  UNOP_POSTINCREMENT,	/* ++ after an expression */
  UNOP_PREDECREMENT,	/* -- before an expression */
  UNOP_POSTDECREMENT,	/* -- after an expression */
  UNOP_SIZEOF,		/* Unary sizeof (followed by expression) */

/* STRUCTOP_... operate on a value from a following subexpression
   by extracting a structure component specified by a string
   that appears in the following exp_elements (as many as needed).
   STRUCTOP_STRUCT is used for "." and STRUCTOP_PTR for "->".
   They differ only in the error message given in case the value is
   not suitable or the structure component specified is not found.

   The length of the string follows in the next exp_element,
   (after the string), followed by another STRUCTOP_... code.  */
  STRUCTOP_STRUCT,
  STRUCTOP_PTR,

/* C++ */
  /* OP_THIS is just a placeholder for the class instance variable.
     It just comes in a tight (OP_THIS, OP_THIS) pair.  */
  OP_THIS,

  /* OP_SCOPE surrounds a type name and a field name.  The type
     name is encoded as one element, but the field name stays as
     a string, which, of course, is variable length.  */
  OP_SCOPE,

};

union exp_element
{
  enum exp_opcode opcode;
  struct symbol *symbol;
  LONGEST longconst;
  double doubleconst;
  char string;
  struct type *type;
  struct internalvar *internalvar;
};

struct expression
{
  int nelts;
  union exp_element elts[1];
};

struct expression *parse_c_expression ();
struct expression *parse_c_1 ();
Commit	Line	Data
78ed81a3	1	/* Definitions for expressions stored in reversed prefix form, for GDB.
	2	Copyright (C) 1986, 1989 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	GDB is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 1, or (at your option)
	9	any later version.
	10
	11	GDB is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GDB; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	/* Definitions for saved C expressions. */
	21
	22	/* An expression is represented as a vector of union exp_element's.
	23	Each exp_element is an opcode, except that some opcodes cause
	24	the following exp_element to be treated as a long or double constant
	25	or as a variable. The opcodes are obeyed, using a stack for temporaries.
	26	The value is left on the temporary stack at the end. */
	27
	28	/* When it is necessary to include a string,
	29	it can occupy as many exp_elements as it needs.
	30	We find the length of the string using strlen,
	31	divide to find out how many exp_elements are used up,
	32	and skip that many. Strings, like numbers, are indicated
	33	by the preceding opcode. */
	34
	35	enum exp_opcode
	36	{
	37	/* BINOP_... operate on two values computed by following subexpressions,
	38	replacing them by one result value. They take no immediate arguments. */
	39	BINOP_ADD, /* + */
	40	BINOP_SUB, /* - */
	41	BINOP_MUL, /* * */
	42	BINOP_DIV, /* / */
	43	BINOP_REM, /* % */
	44	BINOP_LSH, /* << */
	45	BINOP_RSH, /* >> */
	46	BINOP_AND, /* && */
	47	BINOP_OR, /* \|\| */
	48	BINOP_LOGAND, /* & */
	49	BINOP_LOGIOR, /* \| */
	50	BINOP_LOGXOR, /* ^ */
	51	BINOP_EQUAL, /* == */
	52	BINOP_NOTEQUAL, /* != */
	53	BINOP_LESS, /* < */
	54	BINOP_GTR, /* > */
	55	BINOP_LEQ, /* <= */
	56	BINOP_GEQ, /* >= */
	57	BINOP_REPEAT, /* @ */
	58	BINOP_ASSIGN, /* = */
	59	BINOP_COMMA, /* , */
	60	BINOP_SUBSCRIPT, /* x[y] */
	61	BINOP_EXP, /* Exponentiation */
	62
	63	/* C++. */
	64	BINOP_MIN, /* <? */
65	BINOP_MAX, /* >? */
66	BINOP_SCOPE, /* :: */
67
68	/* STRUCTOP_MEMBER is used for pointer-to-member constructs.
69	X . * Y translates into X STRUCTOP_MEMBER Y. */
70	STRUCTOP_MEMBER,
71	/* STRUCTOP_MPTR is used for pointer-to-member constructs
72	when X is a pointer instead of an aggregate. */
73	STRUCTOP_MPTR,
74	/* end of C++. */
75
76	BINOP_END,
77
78	BINOP_ASSIGN_MODIFY, /* +=, -=, *=, and so on.
79	The following exp_element is another opcode,
80	a BINOP_, saying how to modify.
81	Then comes another BINOP_ASSIGN_MODIFY,
82	making three exp_elements in total. */
83
84	/* Operates on three values computed by following subexpressions. */
85	TERNOP_COND, /* ?: */
86
87	/* The OP_... series take immediate following arguments.
88	After the arguments come another OP_... (the same one)
89	so that the grouping can be recognized from the end. */
90
91	/* OP_LONG is followed by a type pointer in the next exp_element
92	and the long constant value in the following exp_element.
93	Then comes another OP_LONG.
94	Thus, the operation occupies four exp_elements. */
95
96	OP_LONG,
97	/* OP_DOUBLE is similar but takes a double constant instead of a long one. */
98	OP_DOUBLE,
99	/* OP_VAR_VALUE takes one struct symbol * in the following exp_element,
100	followed by another OP_VAR_VALUE, making three exp_elements. */
101	OP_VAR_VALUE,
102	/* OP_LAST is followed by an integer in the next exp_element.
103	The integer is zero for the last value printed,
104	or it is the absolute number of a history element.
105	With another OP_LAST at the end, this makes three exp_elements. */
106	OP_LAST,
107	/* OP_REGISTER is followed by an integer in the next exp_element.
108	This is the number of a register to fetch (as an int).
109	With another OP_REGISTER at the end, this makes three exp_elements. */
110	OP_REGISTER,
111	/* OP_INTERNALVAR is followed by an internalvar ptr in the next exp_element.
112	With another OP_INTERNALVAR at the end, this makes three exp_elements. */
113	OP_INTERNALVAR,
114	/* OP_FUNCALL is followed by an integer in the next exp_element.
115	The integer is the number of args to the function call.
116	That many plus one values from following subexpressions
117	are used, the first one being the function.
118	The integer is followed by a repeat of OP_FUNCALL,
119	making three exp_elements. */
120	OP_FUNCALL,
121	/* OP_STRING represents a string constant.
122	Its format is the same as that of a STRUCTOP, but the string
123	data is just made into a string constant when the operation
124	is executed. */
125	OP_STRING,
126
127	/* UNOP_CAST is followed by a type pointer in the next exp_element.
128	With another UNOP_CAST at the end, this makes three exp_elements.
129	It casts the value of the following subexpression. */
130	UNOP_CAST,
131	/* UNOP_MEMVAL is followed by a type pointer in the next exp_element
132	With another UNOP_MEMVAL at the end, this makes three exp_elements.
133	It casts the contents of the word addressed by the value of the
134	following subexpression. */
135	UNOP_MEMVAL,
136	/* UNOP_... operate on one value from a following subexpression
137	and replace it with a result. They take no immediate arguments. */
138	UNOP_NEG, /* Unary - */
139	UNOP_ZEROP, /* Unary ! */
140	UNOP_LOGNOT, /* Unary ~ */
141	UNOP_IND, /* Unary * */
142	UNOP_ADDR, /* Unary & */
143	UNOP_PREINCREMENT, /* ++ before an expression */
144	UNOP_POSTINCREMENT, /* ++ after an expression */
145	UNOP_PREDECREMENT, /* -- before an expression */
146	UNOP_POSTDECREMENT, /* -- after an expression */
147	UNOP_SIZEOF, /* Unary sizeof (followed by expression) */
148
149	/* STRUCTOP_... operate on a value from a following subexpression
150	by extracting a structure component specified by a string
151	that appears in the following exp_elements (as many as needed).
152	STRUCTOP_STRUCT is used for "." and STRUCTOP_PTR for "->".
153	They differ only in the error message given in case the value is
154	not suitable or the structure component specified is not found.
155
156	The length of the string follows in the next exp_element,
157	(after the string), followed by another STRUCTOP_... code. */
158	STRUCTOP_STRUCT,
159	STRUCTOP_PTR,
160
161	/* C++ */
162	/* OP_THIS is just a placeholder for the class instance variable.
163	It just comes in a tight (OP_THIS, OP_THIS) pair. */
164	OP_THIS,
165
166	/* OP_SCOPE surrounds a type name and a field name. The type
167	name is encoded as one element, but the field name stays as
168	a string, which, of course, is variable length. */
169	OP_SCOPE,
170
171	};
172
173	union exp_element
174	{
175	enum exp_opcode opcode;
176	struct symbol *symbol;
177	LONGEST longconst;
178	double doubleconst;
179	char string;
180	struct type *type;
181	struct internalvar *internalvar;
182	};
183
184	struct expression
185	{
186	int nelts;
187	union exp_element elts[1];
188	};
189
190	struct expression *parse_c_expression ();
191	struct expression *parse_c_1 ();