1 /* Parse expressions for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
3 Modified from expread.y by the Department of Computer Science at the
4 State University of New York at Buffalo, 1991.
6 This file is part of GDB.
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 2 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* Parse an expression from text in a string,
23 and return the result as a struct expression pointer.
24 That structure contains arithmetic operations in reverse polish,
25 with constants represented by operations that are followed by special data.
26 See expression.h for the details of the format.
27 What is important here is that it can be built up sequentially
28 during the process of parsing; the lower levels of the tree always
29 come first in the result. */
35 #include "expression.h"
39 #include "parser-defs.h"
42 prefixify_expression PARAMS ((struct expression *));
45 length_of_subexp PARAMS ((struct expression *, int));
48 prefixify_subexp PARAMS ((struct expression *, struct expression *, int, int));
50 /* Assign machine-independent names to certain registers
51 (unless overridden by the REGISTER_NAMES table) */
53 struct std_regs std_regs[] = {
68 unsigned num_std_regs = (sizeof std_regs / sizeof std_regs[0]);
71 /* Begin counting arguments for a function call,
72 saving the data about any containing call. */
77 register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall));
79 new->next = funcall_chain;
80 new->arglist_len = arglist_len;
85 /* Return the number of arguments in a function call just terminated,
86 and restore the data for the containing function call. */
91 register int val = arglist_len;
92 register struct funcall *call = funcall_chain;
93 funcall_chain = call->next;
94 arglist_len = call->arglist_len;
99 /* Free everything in the funcall chain.
100 Used when there is an error inside parsing. */
105 register struct funcall *call, *next;
107 for (call = funcall_chain; call; call = next)
114 /* This page contains the functions for adding data to the struct expression
115 being constructed. */
117 /* Add one element to the end of the expression. */
119 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
120 a register through here */
123 write_exp_elt (expelt)
124 union exp_element expelt;
126 if (expout_ptr >= expout_size)
129 expout = (struct expression *) xrealloc ((char *) expout,
130 sizeof (struct expression)
131 + expout_size * sizeof (union exp_element));
133 expout->elts[expout_ptr++] = expelt;
137 write_exp_elt_opcode (expelt)
138 enum exp_opcode expelt;
140 union exp_element tmp;
148 write_exp_elt_sym (expelt)
149 struct symbol *expelt;
151 union exp_element tmp;
159 write_exp_elt_longcst (expelt)
162 union exp_element tmp;
164 tmp.longconst = expelt;
170 write_exp_elt_dblcst (expelt)
173 union exp_element tmp;
175 tmp.doubleconst = expelt;
181 write_exp_elt_type (expelt)
184 union exp_element tmp;
192 write_exp_elt_intern (expelt)
193 struct internalvar *expelt;
195 union exp_element tmp;
197 tmp.internalvar = expelt;
202 /* Add a string constant to the end of the expression.
203 Follow it by its length in bytes, as a separate exp_element. */
206 write_exp_string (str)
209 register int len = str.length;
211 = (len + sizeof (union exp_element)) / sizeof (union exp_element);
213 expout_ptr += lenelt;
215 if (expout_ptr >= expout_size)
217 expout_size = max (expout_size * 2, expout_ptr + 10);
218 expout = (struct expression *)
219 xrealloc ((char *) expout, (sizeof (struct expression)
220 + (expout_size * sizeof (union exp_element))));
222 memcpy ((char *) &expout->elts[expout_ptr - lenelt], str.ptr, len);
223 ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0;
224 write_exp_elt_longcst ((LONGEST) len);
227 /* Return a null-terminated temporary copy of the name
228 of a string token. */
234 memcpy (namecopy, token.ptr, token.length);
235 namecopy[token.length] = 0;
239 /* Reverse an expression from suffix form (in which it is constructed)
240 to prefix form (in which we can conveniently print or execute it). */
243 prefixify_expression (expr)
244 register struct expression *expr;
246 register int len = sizeof (struct expression) +
247 expr->nelts * sizeof (union exp_element);
248 register struct expression *temp;
249 register int inpos = expr->nelts, outpos = 0;
251 temp = (struct expression *) alloca (len);
253 /* Copy the original expression into temp. */
254 memcpy (temp, expr, len);
256 prefixify_subexp (temp, expr, inpos, outpos);
259 /* Return the number of exp_elements in the subexpression of EXPR
260 whose last exp_element is at index ENDPOS - 1 in EXPR. */
263 length_of_subexp (expr, endpos)
264 register struct expression *expr;
267 register int oplen = 1;
268 register int args = 0;
272 error ("?error in length_of_subexp");
274 i = (int) expr->elts[endpos - 1].opcode;
278 case STRUCTOP_STRUCT:
283 oplen = 4 + ((expr->elts[endpos - 2].longconst
284 + sizeof (union exp_element))
285 / sizeof (union exp_element));
304 args = 1 + expr->elts[endpos - 2].longconst;
334 oplen = 3 + ((expr->elts[endpos - 2].longconst
335 + sizeof (union exp_element))
336 / sizeof (union exp_element));
344 case BINOP_MULTI_SUBSCRIPT:
346 args = 1 + expr->elts[endpos- 2].longconst;
349 case BINOP_ASSIGN_MODIFY:
360 args = 1 + (i < (int) BINOP_END);
365 oplen += length_of_subexp (expr, endpos - oplen);
372 /* Copy the subexpression ending just before index INEND in INEXPR
373 into OUTEXPR, starting at index OUTBEG.
374 In the process, convert it from suffix to prefix form. */
377 prefixify_subexp (inexpr, outexpr, inend, outbeg)
378 register struct expression *inexpr;
379 struct expression *outexpr;
383 register int oplen = 1;
384 register int args = 0;
387 enum exp_opcode opcode;
389 /* Compute how long the last operation is (in OPLEN),
390 and also how many preceding subexpressions serve as
391 arguments for it (in ARGS). */
393 opcode = inexpr->elts[inend - 1].opcode;
396 case STRUCTOP_STRUCT:
401 oplen = 4 + ((inexpr->elts[inend - 2].longconst
402 + sizeof (union exp_element))
403 / sizeof (union exp_element));
422 args = 1 + inexpr->elts[inend - 2].longconst;
451 oplen = 3 + ((inexpr->elts[inend - 2].longconst
452 + sizeof (union exp_element))
453 / sizeof (union exp_element));
461 case BINOP_ASSIGN_MODIFY:
467 case BINOP_MULTI_SUBSCRIPT:
469 args = 1 + inexpr->elts[inend - 2].longconst;
478 args = 1 + ((int) opcode < (int) BINOP_END);
481 /* Copy the final operator itself, from the end of the input
482 to the beginning of the output. */
484 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
485 oplen * sizeof (union exp_element));
488 /* Find the lengths of the arg subexpressions. */
489 arglens = (int *) alloca (args * sizeof (int));
490 for (i = args - 1; i >= 0; i--)
492 oplen = length_of_subexp (inexpr, inend);
497 /* Now copy each subexpression, preserving the order of
498 the subexpressions, but prefixifying each one.
499 In this loop, inend starts at the beginning of
500 the expression this level is working on
501 and marches forward over the arguments.
502 outbeg does similarly in the output. */
503 for (i = 0; i < args; i++)
507 prefixify_subexp (inexpr, outexpr, inend, outbeg);
512 /* This page contains the two entry points to this file. */
514 /* Read an expression from the string *STRINGPTR points to,
515 parse it, and return a pointer to a struct expression that we malloc.
516 Use block BLOCK as the lexical context for variable names;
517 if BLOCK is zero, use the block of the selected stack frame.
518 Meanwhile, advance *STRINGPTR to point after the expression,
519 at the first nonwhite character that is not part of the expression
520 (possibly a null character).
522 If COMMA is nonzero, stop if a comma is reached. */
525 parse_exp_1 (stringptr, block, comma)
530 struct cleanup *old_chain;
535 type_stack_depth = 0;
537 comma_terminates = comma;
539 if (lexptr == 0 || *lexptr == 0)
540 error_no_arg ("expression to compute");
542 old_chain = make_cleanup (free_funcalls, 0);
545 expression_context_block = block ? block : get_selected_block ();
547 namecopy = (char *) alloca (strlen (lexptr) + 1);
550 expout = (struct expression *)
551 xmalloc (sizeof (struct expression)
552 + expout_size * sizeof (union exp_element));
553 expout->language_defn = current_language;
554 make_cleanup (free_current_contents, &expout);
556 if (current_language->la_parser ())
557 current_language->la_error (NULL);
559 discard_cleanups (old_chain);
560 expout->nelts = expout_ptr;
561 expout = (struct expression *)
562 xrealloc ((char *) expout,
563 sizeof (struct expression)
564 + expout_ptr * sizeof (union exp_element));
565 prefixify_expression (expout);
570 /* Parse STRING as an expression, and complain if this fails
571 to use up all of the contents of STRING. */
574 parse_expression (string)
577 register struct expression *exp;
578 exp = parse_exp_1 (&string, 0, 0);
580 error ("Junk after end of expression.");
588 if (type_stack_depth == type_stack_size)
590 type_stack_size *= 2;
591 type_stack = (union type_stack_elt *)
592 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
594 type_stack[type_stack_depth++].piece = tp;
601 if (type_stack_depth == type_stack_size)
603 type_stack_size *= 2;
604 type_stack = (union type_stack_elt *)
605 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
607 type_stack[type_stack_depth++].int_val = n;
613 if (type_stack_depth)
614 return type_stack[--type_stack_depth].piece;
621 if (type_stack_depth)
622 return type_stack[--type_stack_depth].int_val;
623 /* "Can't happen". */
630 type_stack_size = 80;
631 type_stack_depth = 0;
632 type_stack = (union type_stack_elt *)
633 xmalloc (type_stack_size * sizeof (*type_stack));