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 free_funcalls
PARAMS ((void));
45 prefixify_expression
PARAMS ((struct expression
*));
48 length_of_subexp
PARAMS ((struct expression
*, int));
51 prefixify_subexp
PARAMS ((struct expression
*, struct expression
*, int, int));
53 /* Data structure for saving values of arglist_len for function calls whose
54 arguments contain other function calls. */
62 static struct funcall
*funcall_chain
;
64 /* Assign machine-independent names to certain registers
65 (unless overridden by the REGISTER_NAMES table) */
68 unsigned num_std_regs
= 0;
69 struct std_regs std_regs
[1];
71 struct std_regs std_regs
[] = {
88 unsigned num_std_regs
= (sizeof std_regs
/ sizeof std_regs
[0]);
93 /* Begin counting arguments for a function call,
94 saving the data about any containing call. */
99 register struct funcall
*new;
101 new = (struct funcall
*) xmalloc (sizeof (struct funcall
));
102 new->next
= funcall_chain
;
103 new->arglist_len
= arglist_len
;
108 /* Return the number of arguments in a function call just terminated,
109 and restore the data for the containing function call. */
114 register int val
= arglist_len
;
115 register struct funcall
*call
= funcall_chain
;
116 funcall_chain
= call
->next
;
117 arglist_len
= call
->arglist_len
;
122 /* Free everything in the funcall chain.
123 Used when there is an error inside parsing. */
128 register struct funcall
*call
, *next
;
130 for (call
= funcall_chain
; call
; call
= next
)
137 /* This page contains the functions for adding data to the struct expression
138 being constructed. */
140 /* Add one element to the end of the expression. */
142 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
143 a register through here */
146 write_exp_elt (expelt
)
147 union exp_element expelt
;
149 if (expout_ptr
>= expout_size
)
152 expout
= (struct expression
*)
153 xrealloc ((char *) expout
, sizeof (struct expression
)
154 + EXP_ELEM_TO_BYTES (expout_size
));
156 expout
->elts
[expout_ptr
++] = expelt
;
160 write_exp_elt_opcode (expelt
)
161 enum exp_opcode expelt
;
163 union exp_element tmp
;
171 write_exp_elt_sym (expelt
)
172 struct symbol
*expelt
;
174 union exp_element tmp
;
182 write_exp_elt_longcst (expelt
)
185 union exp_element tmp
;
187 tmp
.longconst
= expelt
;
193 write_exp_elt_dblcst (expelt
)
196 union exp_element tmp
;
198 tmp
.doubleconst
= expelt
;
204 write_exp_elt_type (expelt
)
207 union exp_element tmp
;
215 write_exp_elt_intern (expelt
)
216 struct internalvar
*expelt
;
218 union exp_element tmp
;
220 tmp
.internalvar
= expelt
;
225 /* Add a string constant to the end of the expression.
227 String constants are stored by first writing an expression element
228 that contains the length of the string, then stuffing the string
229 constant itself into however many expression elements are needed
230 to hold it, and then writing another expression element that contains
231 the length of the string. I.E. an expression element at each end of
232 the string records the string length, so you can skip over the
233 expression elements containing the actual string bytes from either
234 end of the string. Note that this also allows gdb to handle
235 strings with embedded null bytes, as is required for some languages.
237 Don't be fooled by the fact that the string is null byte terminated,
238 this is strictly for the convenience of debugging gdb itself. Gdb
239 Gdb does not depend up the string being null terminated, since the
240 actual length is recorded in expression elements at each end of the
241 string. The null byte is taken into consideration when computing how
242 many expression elements are required to hold the string constant, of
247 write_exp_string (str
)
250 register int len
= str
.length
;
252 register char *strdata
;
254 /* Compute the number of expression elements required to hold the string
255 (including a null byte terminator), along with one expression element
256 at each end to record the actual string length (not including the
257 null byte terminator). */
259 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
+ 1);
261 /* Ensure that we have enough available expression elements to store
264 if ((expout_ptr
+ lenelt
) >= expout_size
)
266 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
267 expout
= (struct expression
*)
268 xrealloc ((char *) expout
, (sizeof (struct expression
)
269 + EXP_ELEM_TO_BYTES (expout_size
)));
272 /* Write the leading length expression element (which advances the current
273 expression element index), then write the string constant followed by a
274 terminating null byte, and then write the trailing length expression
277 write_exp_elt_longcst ((LONGEST
) len
);
278 strdata
= (char *) &expout
->elts
[expout_ptr
];
279 memcpy (strdata
, str
.ptr
, len
);
280 *(strdata
+ len
) = '\0';
281 expout_ptr
+= lenelt
- 2;
282 write_exp_elt_longcst ((LONGEST
) len
);
285 /* Add a bitstring constant to the end of the expression.
287 Bitstring constants are stored by first writing an expression element
288 that contains the length of the bitstring (in bits), then stuffing the
289 bitstring constant itself into however many expression elements are
290 needed to hold it, and then writing another expression element that
291 contains the length of the bitstring. I.E. an expression element at
292 each end of the bitstring records the bitstring length, so you can skip
293 over the expression elements containing the actual bitstring bytes from
294 either end of the bitstring. */
297 write_exp_bitstring (str
)
300 register int bits
= str
.length
; /* length in bits */
301 register int len
= (bits
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
303 register char *strdata
;
305 /* Compute the number of expression elements required to hold the bitstring,
306 along with one expression element at each end to record the actual
307 bitstring length in bits. */
309 lenelt
= 2 + BYTES_TO_EXP_ELEM (len
);
311 /* Ensure that we have enough available expression elements to store
314 if ((expout_ptr
+ lenelt
) >= expout_size
)
316 expout_size
= max (expout_size
* 2, expout_ptr
+ lenelt
+ 10);
317 expout
= (struct expression
*)
318 xrealloc ((char *) expout
, (sizeof (struct expression
)
319 + EXP_ELEM_TO_BYTES (expout_size
)));
322 /* Write the leading length expression element (which advances the current
323 expression element index), then write the bitstring constant, and then
324 write the trailing length expression element. */
326 write_exp_elt_longcst ((LONGEST
) bits
);
327 strdata
= (char *) &expout
->elts
[expout_ptr
];
328 memcpy (strdata
, str
.ptr
, len
);
329 expout_ptr
+= lenelt
- 2;
330 write_exp_elt_longcst ((LONGEST
) bits
);
333 /* Return a null-terminated temporary copy of the name
334 of a string token. */
340 memcpy (namecopy
, token
.ptr
, token
.length
);
341 namecopy
[token
.length
] = 0;
345 /* Reverse an expression from suffix form (in which it is constructed)
346 to prefix form (in which we can conveniently print or execute it). */
349 prefixify_expression (expr
)
350 register struct expression
*expr
;
353 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expr
->nelts
);
354 register struct expression
*temp
;
355 register int inpos
= expr
->nelts
, outpos
= 0;
357 temp
= (struct expression
*) alloca (len
);
359 /* Copy the original expression into temp. */
360 memcpy (temp
, expr
, len
);
362 prefixify_subexp (temp
, expr
, inpos
, outpos
);
365 /* Return the number of exp_elements in the subexpression of EXPR
366 whose last exp_element is at index ENDPOS - 1 in EXPR. */
369 length_of_subexp (expr
, endpos
)
370 register struct expression
*expr
;
373 register int oplen
= 1;
374 register int args
= 0;
378 error ("?error in length_of_subexp");
380 i
= (int) expr
->elts
[endpos
- 1].opcode
;
386 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
387 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
406 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
433 case STRUCTOP_STRUCT
:
439 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
440 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
444 oplen
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
445 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
446 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
451 args
= longest_to_int (expr
->elts
[endpos
- 2].longconst
);
452 args
-= longest_to_int (expr
->elts
[endpos
- 3].longconst
);
461 case MULTI_SUBSCRIPT
:
463 args
= 1 + longest_to_int (expr
->elts
[endpos
- 2].longconst
);
466 case BINOP_ASSIGN_MODIFY
:
477 args
= 1 + (i
< (int) BINOP_END
);
482 oplen
+= length_of_subexp (expr
, endpos
- oplen
);
489 /* Copy the subexpression ending just before index INEND in INEXPR
490 into OUTEXPR, starting at index OUTBEG.
491 In the process, convert it from suffix to prefix form. */
494 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
)
495 register struct expression
*inexpr
;
496 struct expression
*outexpr
;
500 register int oplen
= 1;
501 register int args
= 0;
504 enum exp_opcode opcode
;
506 /* Compute how long the last operation is (in OPLEN),
507 and also how many preceding subexpressions serve as
508 arguments for it (in ARGS). */
510 opcode
= inexpr
->elts
[inend
- 1].opcode
;
515 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
516 oplen
= 5 + BYTES_TO_EXP_ELEM (oplen
+ 1);
535 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
561 case STRUCTOP_STRUCT
:
567 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
568 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
+ 1);
572 oplen
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
573 oplen
= (oplen
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
;
574 oplen
= 4 + BYTES_TO_EXP_ELEM (oplen
);
579 args
= longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
580 args
-= longest_to_int (inexpr
->elts
[inend
- 3].longconst
);
588 case BINOP_ASSIGN_MODIFY
:
594 case MULTI_SUBSCRIPT
:
596 args
= 1 + longest_to_int (inexpr
->elts
[inend
- 2].longconst
);
605 args
= 1 + ((int) opcode
< (int) BINOP_END
);
608 /* Copy the final operator itself, from the end of the input
609 to the beginning of the output. */
611 memcpy (&outexpr
->elts
[outbeg
], &inexpr
->elts
[inend
],
612 EXP_ELEM_TO_BYTES (oplen
));
615 /* Find the lengths of the arg subexpressions. */
616 arglens
= (int *) alloca (args
* sizeof (int));
617 for (i
= args
- 1; i
>= 0; i
--)
619 oplen
= length_of_subexp (inexpr
, inend
);
624 /* Now copy each subexpression, preserving the order of
625 the subexpressions, but prefixifying each one.
626 In this loop, inend starts at the beginning of
627 the expression this level is working on
628 and marches forward over the arguments.
629 outbeg does similarly in the output. */
630 for (i
= 0; i
< args
; i
++)
634 prefixify_subexp (inexpr
, outexpr
, inend
, outbeg
);
639 /* This page contains the two entry points to this file. */
641 /* Read an expression from the string *STRINGPTR points to,
642 parse it, and return a pointer to a struct expression that we malloc.
643 Use block BLOCK as the lexical context for variable names;
644 if BLOCK is zero, use the block of the selected stack frame.
645 Meanwhile, advance *STRINGPTR to point after the expression,
646 at the first nonwhite character that is not part of the expression
647 (possibly a null character).
649 If COMMA is nonzero, stop if a comma is reached. */
652 parse_exp_1 (stringptr
, block
, comma
)
657 struct cleanup
*old_chain
;
662 type_stack_depth
= 0;
664 comma_terminates
= comma
;
666 if (lexptr
== 0 || *lexptr
== 0)
667 error_no_arg ("expression to compute");
669 old_chain
= make_cleanup (free_funcalls
, 0);
672 expression_context_block
= block
? block
: get_selected_block ();
674 namecopy
= (char *) alloca (strlen (lexptr
) + 1);
677 expout
= (struct expression
*)
678 xmalloc (sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_size
));
679 expout
->language_defn
= current_language
;
680 make_cleanup (free_current_contents
, &expout
);
682 if (current_language
->la_parser ())
683 current_language
->la_error (NULL
);
685 discard_cleanups (old_chain
);
687 /* Record the actual number of expression elements, and then
688 reallocate the expression memory so that we free up any
691 expout
->nelts
= expout_ptr
;
692 expout
= (struct expression
*)
693 xrealloc ((char *) expout
,
694 sizeof (struct expression
) + EXP_ELEM_TO_BYTES (expout_ptr
));;
696 /* Convert expression from postfix form as generated by yacc
697 parser, to a prefix form. */
699 DUMP_EXPRESSION (expout
, stdout
, "before conversion to prefix form");
700 prefixify_expression (expout
);
701 DUMP_EXPRESSION (expout
, stdout
, "after conversion to prefix form");
707 /* Parse STRING as an expression, and complain if this fails
708 to use up all of the contents of STRING. */
711 parse_expression (string
)
714 register struct expression
*exp
;
715 exp
= parse_exp_1 (&string
, 0, 0);
717 error ("Junk after end of expression.");
725 if (type_stack_depth
== type_stack_size
)
727 type_stack_size
*= 2;
728 type_stack
= (union type_stack_elt
*)
729 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
731 type_stack
[type_stack_depth
++].piece
= tp
;
738 if (type_stack_depth
== type_stack_size
)
740 type_stack_size
*= 2;
741 type_stack
= (union type_stack_elt
*)
742 xrealloc ((char *) type_stack
, type_stack_size
* sizeof (*type_stack
));
744 type_stack
[type_stack_depth
++].int_val
= n
;
750 if (type_stack_depth
)
751 return type_stack
[--type_stack_depth
].piece
;
758 if (type_stack_depth
)
759 return type_stack
[--type_stack_depth
].int_val
;
760 /* "Can't happen". */
767 type_stack_size
= 80;
768 type_stack_depth
= 0;
769 type_stack
= (union type_stack_elt
*)
770 xmalloc (type_stack_size
* sizeof (*type_stack
));
This page took 0.044144 seconds and 4 git commands to generate.