* bfd-in.h (bfd_byte, reloc_howto_type): Define here, not...
[deliverable/binutils-gdb.git] / gdb / parse.c
CommitLineData
3d6b6a90 1/* Parse expressions for GDB.
d92f3f08 2 Copyright (C) 1986, 1989, 1990, 1991, 1994 Free Software Foundation, Inc.
3d6b6a90
JG
3 Modified from expread.y by the Department of Computer Science at the
4 State University of New York at Buffalo, 1991.
5
6This file is part of GDB.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21
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. */
30
3d6b6a90 31#include "defs.h"
ba47c66a 32#include <string.h>
3d6b6a90 33#include "symtab.h"
1ab3bf1b 34#include "gdbtypes.h"
3d6b6a90
JG
35#include "frame.h"
36#include "expression.h"
37#include "value.h"
38#include "command.h"
39#include "language.h"
40#include "parser-defs.h"
79448221
JK
41\f
42/* Global variables declared in parser-defs.h (and commented there). */
43struct expression *expout;
44int expout_size;
45int expout_ptr;
46struct block *expression_context_block;
47struct block *innermost_block;
79448221
JK
48int arglist_len;
49union type_stack_elt *type_stack;
50int type_stack_depth, type_stack_size;
51char *lexptr;
52char *namecopy;
53int paren_depth;
54int comma_terminates;
55\f
9da75ad3
FF
56static void
57free_funcalls PARAMS ((void));
58
1ab3bf1b
JG
59static void
60prefixify_expression PARAMS ((struct expression *));
61
62static int
63length_of_subexp PARAMS ((struct expression *, int));
64
65static void
66prefixify_subexp PARAMS ((struct expression *, struct expression *, int, int));
67
9da75ad3
FF
68/* Data structure for saving values of arglist_len for function calls whose
69 arguments contain other function calls. */
70
71struct funcall
72 {
73 struct funcall *next;
74 int arglist_len;
75 };
76
77static struct funcall *funcall_chain;
78
3d6b6a90
JG
79/* Assign machine-independent names to certain registers
80 (unless overridden by the REGISTER_NAMES table) */
81
a332e593
SC
82#ifdef NO_STD_REGS
83unsigned num_std_regs = 0;
84struct std_regs std_regs[1];
85#else
3d6b6a90 86struct std_regs std_regs[] = {
a332e593 87
3d6b6a90
JG
88#ifdef PC_REGNUM
89 { "pc", PC_REGNUM },
90#endif
91#ifdef FP_REGNUM
92 { "fp", FP_REGNUM },
93#endif
94#ifdef SP_REGNUM
95 { "sp", SP_REGNUM },
96#endif
97#ifdef PS_REGNUM
98 { "ps", PS_REGNUM },
99#endif
a332e593 100
3d6b6a90
JG
101};
102
103unsigned num_std_regs = (sizeof std_regs / sizeof std_regs[0]);
104
a332e593
SC
105#endif
106
3d6b6a90
JG
107
108/* Begin counting arguments for a function call,
109 saving the data about any containing call. */
110
111void
112start_arglist ()
113{
9da75ad3 114 register struct funcall *new;
3d6b6a90 115
9da75ad3 116 new = (struct funcall *) xmalloc (sizeof (struct funcall));
3d6b6a90
JG
117 new->next = funcall_chain;
118 new->arglist_len = arglist_len;
119 arglist_len = 0;
120 funcall_chain = new;
121}
122
123/* Return the number of arguments in a function call just terminated,
124 and restore the data for the containing function call. */
125
126int
127end_arglist ()
128{
129 register int val = arglist_len;
130 register struct funcall *call = funcall_chain;
131 funcall_chain = call->next;
132 arglist_len = call->arglist_len;
be772100 133 free ((PTR)call);
3d6b6a90
JG
134 return val;
135}
136
137/* Free everything in the funcall chain.
138 Used when there is an error inside parsing. */
139
9da75ad3 140static void
3d6b6a90
JG
141free_funcalls ()
142{
143 register struct funcall *call, *next;
144
145 for (call = funcall_chain; call; call = next)
146 {
147 next = call->next;
be772100 148 free ((PTR)call);
3d6b6a90
JG
149 }
150}
151\f
152/* This page contains the functions for adding data to the struct expression
153 being constructed. */
154
155/* Add one element to the end of the expression. */
156
157/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
158 a register through here */
159
160void
161write_exp_elt (expelt)
162 union exp_element expelt;
163{
164 if (expout_ptr >= expout_size)
165 {
166 expout_size *= 2;
81028ab0
FF
167 expout = (struct expression *)
168 xrealloc ((char *) expout, sizeof (struct expression)
169 + EXP_ELEM_TO_BYTES (expout_size));
3d6b6a90
JG
170 }
171 expout->elts[expout_ptr++] = expelt;
172}
173
174void
175write_exp_elt_opcode (expelt)
176 enum exp_opcode expelt;
177{
178 union exp_element tmp;
179
180 tmp.opcode = expelt;
181
182 write_exp_elt (tmp);
183}
184
185void
186write_exp_elt_sym (expelt)
187 struct symbol *expelt;
188{
189 union exp_element tmp;
190
191 tmp.symbol = expelt;
192
193 write_exp_elt (tmp);
194}
195
479fdd26
JK
196void
197write_exp_elt_block (b)
198 struct block *b;
199{
200 union exp_element tmp;
201 tmp.block = b;
202 write_exp_elt (tmp);
203}
204
3d6b6a90
JG
205void
206write_exp_elt_longcst (expelt)
207 LONGEST expelt;
208{
209 union exp_element tmp;
210
211 tmp.longconst = expelt;
212
213 write_exp_elt (tmp);
214}
215
216void
217write_exp_elt_dblcst (expelt)
218 double expelt;
219{
220 union exp_element tmp;
221
222 tmp.doubleconst = expelt;
223
224 write_exp_elt (tmp);
225}
226
227void
228write_exp_elt_type (expelt)
229 struct type *expelt;
230{
231 union exp_element tmp;
232
233 tmp.type = expelt;
234
235 write_exp_elt (tmp);
236}
237
238void
239write_exp_elt_intern (expelt)
240 struct internalvar *expelt;
241{
242 union exp_element tmp;
243
244 tmp.internalvar = expelt;
245
246 write_exp_elt (tmp);
247}
248
249/* Add a string constant to the end of the expression.
d1065385
FF
250
251 String constants are stored by first writing an expression element
252 that contains the length of the string, then stuffing the string
253 constant itself into however many expression elements are needed
254 to hold it, and then writing another expression element that contains
255 the length of the string. I.E. an expression element at each end of
256 the string records the string length, so you can skip over the
257 expression elements containing the actual string bytes from either
258 end of the string. Note that this also allows gdb to handle
259 strings with embedded null bytes, as is required for some languages.
260
261 Don't be fooled by the fact that the string is null byte terminated,
262 this is strictly for the convenience of debugging gdb itself. Gdb
263 Gdb does not depend up the string being null terminated, since the
264 actual length is recorded in expression elements at each end of the
265 string. The null byte is taken into consideration when computing how
266 many expression elements are required to hold the string constant, of
267 course. */
268
3d6b6a90
JG
269
270void
271write_exp_string (str)
272 struct stoken str;
273{
274 register int len = str.length;
d1065385
FF
275 register int lenelt;
276 register char *strdata;
3d6b6a90 277
d1065385
FF
278 /* Compute the number of expression elements required to hold the string
279 (including a null byte terminator), along with one expression element
280 at each end to record the actual string length (not including the
281 null byte terminator). */
3d6b6a90 282
81028ab0 283 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
d1065385
FF
284
285 /* Ensure that we have enough available expression elements to store
286 everything. */
287
288 if ((expout_ptr + lenelt) >= expout_size)
3d6b6a90 289 {
d1065385 290 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
3d6b6a90 291 expout = (struct expression *)
1ab3bf1b 292 xrealloc ((char *) expout, (sizeof (struct expression)
81028ab0 293 + EXP_ELEM_TO_BYTES (expout_size)));
3d6b6a90 294 }
d1065385
FF
295
296 /* Write the leading length expression element (which advances the current
297 expression element index), then write the string constant followed by a
298 terminating null byte, and then write the trailing length expression
299 element. */
300
301 write_exp_elt_longcst ((LONGEST) len);
302 strdata = (char *) &expout->elts[expout_ptr];
303 memcpy (strdata, str.ptr, len);
304 *(strdata + len) = '\0';
305 expout_ptr += lenelt - 2;
3d6b6a90
JG
306 write_exp_elt_longcst ((LONGEST) len);
307}
81028ab0
FF
308
309/* Add a bitstring constant to the end of the expression.
310
311 Bitstring constants are stored by first writing an expression element
312 that contains the length of the bitstring (in bits), then stuffing the
313 bitstring constant itself into however many expression elements are
314 needed to hold it, and then writing another expression element that
315 contains the length of the bitstring. I.E. an expression element at
316 each end of the bitstring records the bitstring length, so you can skip
317 over the expression elements containing the actual bitstring bytes from
318 either end of the bitstring. */
319
320void
321write_exp_bitstring (str)
322 struct stoken str;
323{
324 register int bits = str.length; /* length in bits */
325 register int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
326 register int lenelt;
327 register char *strdata;
328
329 /* Compute the number of expression elements required to hold the bitstring,
330 along with one expression element at each end to record the actual
331 bitstring length in bits. */
332
333 lenelt = 2 + BYTES_TO_EXP_ELEM (len);
334
335 /* Ensure that we have enough available expression elements to store
336 everything. */
337
338 if ((expout_ptr + lenelt) >= expout_size)
339 {
340 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
341 expout = (struct expression *)
342 xrealloc ((char *) expout, (sizeof (struct expression)
343 + EXP_ELEM_TO_BYTES (expout_size)));
344 }
345
346 /* Write the leading length expression element (which advances the current
347 expression element index), then write the bitstring constant, and then
348 write the trailing length expression element. */
349
350 write_exp_elt_longcst ((LONGEST) bits);
351 strdata = (char *) &expout->elts[expout_ptr];
352 memcpy (strdata, str.ptr, len);
353 expout_ptr += lenelt - 2;
354 write_exp_elt_longcst ((LONGEST) bits);
355}
abe28b92
JK
356
357/* Add the appropriate elements for a minimal symbol to the end of
3fb93d86
JK
358 the expression. The rationale behind passing in text_symbol_type and
359 data_symbol_type was so that Modula-2 could pass in WORD for
360 data_symbol_type. Perhaps it still is useful to have those types vary
361 based on the language, but they no longer have names like "int", so
362 the initial rationale is gone. */
363
364static struct type *msym_text_symbol_type;
365static struct type *msym_data_symbol_type;
366static struct type *msym_unknown_symbol_type;
abe28b92
JK
367
368void
369write_exp_msymbol (msymbol, text_symbol_type, data_symbol_type)
370 struct minimal_symbol *msymbol;
371 struct type *text_symbol_type;
372 struct type *data_symbol_type;
373{
374 write_exp_elt_opcode (OP_LONG);
4461196e 375 write_exp_elt_type (lookup_pointer_type (builtin_type_void));
abe28b92
JK
376 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
377 write_exp_elt_opcode (OP_LONG);
378
379 write_exp_elt_opcode (UNOP_MEMVAL);
380 switch (msymbol -> type)
381 {
382 case mst_text:
383 case mst_file_text:
ae6d035d 384 case mst_solib_trampoline:
3fb93d86 385 write_exp_elt_type (msym_text_symbol_type);
abe28b92
JK
386 break;
387
388 case mst_data:
389 case mst_file_data:
390 case mst_bss:
391 case mst_file_bss:
3fb93d86 392 write_exp_elt_type (msym_data_symbol_type);
abe28b92
JK
393 break;
394
395 default:
3fb93d86 396 write_exp_elt_type (msym_unknown_symbol_type);
abe28b92
JK
397 break;
398 }
399 write_exp_elt_opcode (UNOP_MEMVAL);
400}
3d6b6a90
JG
401\f
402/* Return a null-terminated temporary copy of the name
403 of a string token. */
404
405char *
406copy_name (token)
407 struct stoken token;
408{
4ed3a9ea 409 memcpy (namecopy, token.ptr, token.length);
3d6b6a90
JG
410 namecopy[token.length] = 0;
411 return namecopy;
412}
413\f
414/* Reverse an expression from suffix form (in which it is constructed)
415 to prefix form (in which we can conveniently print or execute it). */
416
1ab3bf1b 417static void
3d6b6a90
JG
418prefixify_expression (expr)
419 register struct expression *expr;
420{
81028ab0
FF
421 register int len =
422 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
3d6b6a90
JG
423 register struct expression *temp;
424 register int inpos = expr->nelts, outpos = 0;
425
426 temp = (struct expression *) alloca (len);
427
428 /* Copy the original expression into temp. */
4ed3a9ea 429 memcpy (temp, expr, len);
3d6b6a90
JG
430
431 prefixify_subexp (temp, expr, inpos, outpos);
432}
433
434/* Return the number of exp_elements in the subexpression of EXPR
435 whose last exp_element is at index ENDPOS - 1 in EXPR. */
436
1ab3bf1b 437static int
3d6b6a90
JG
438length_of_subexp (expr, endpos)
439 register struct expression *expr;
440 register int endpos;
441{
442 register int oplen = 1;
443 register int args = 0;
444 register int i;
445
d1065385 446 if (endpos < 1)
3d6b6a90
JG
447 error ("?error in length_of_subexp");
448
449 i = (int) expr->elts[endpos - 1].opcode;
450
451 switch (i)
452 {
453 /* C++ */
454 case OP_SCOPE:
81028ab0
FF
455 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
456 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
3d6b6a90
JG
457 break;
458
459 case OP_LONG:
460 case OP_DOUBLE:
479fdd26 461 case OP_VAR_VALUE:
3d6b6a90
JG
462 oplen = 4;
463 break;
464
465 case OP_TYPE:
466 case OP_BOOL:
3d6b6a90
JG
467 case OP_LAST:
468 case OP_REGISTER:
469 case OP_INTERNALVAR:
470 oplen = 3;
471 break;
472
a91a6192
SS
473 case OP_F77_LITERAL_COMPLEX:
474 oplen = 1;
475 args = 2;
476 break;
477
478 case OP_F77_SUBSTR:
479 oplen = 1;
480 args = 2;
481 break;
482
3d6b6a90 483 case OP_FUNCALL:
a91a6192 484 case OP_F77_UNDETERMINED_ARGLIST:
3d6b6a90 485 oplen = 3;
d1065385 486 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
3d6b6a90
JG
487 break;
488
489 case UNOP_MAX:
490 case UNOP_MIN:
491 oplen = 3;
3d6b6a90
JG
492 break;
493
494 case BINOP_VAL:
495 case UNOP_CAST:
496 case UNOP_MEMVAL:
497 oplen = 3;
498 args = 1;
499 break;
500
501 case UNOP_ABS:
502 case UNOP_CAP:
503 case UNOP_CHR:
504 case UNOP_FLOAT:
505 case UNOP_HIGH:
506 case UNOP_ODD:
507 case UNOP_ORD:
508 case UNOP_TRUNC:
509 oplen = 1;
510 args = 1;
511 break;
512
2640f7e1
JG
513 case STRUCTOP_STRUCT:
514 case STRUCTOP_PTR:
515 args = 1;
d1065385 516 /* fall through */
3d6b6a90
JG
517 case OP_M2_STRING:
518 case OP_STRING:
81028ab0
FF
519 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
520 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
521 break;
522
523 case OP_BITSTRING:
524 oplen = longest_to_int (expr->elts[endpos - 2].longconst);
525 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
526 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
3d6b6a90
JG
527 break;
528
c4413e2c
FF
529 case OP_ARRAY:
530 oplen = 4;
531 args = longest_to_int (expr->elts[endpos - 2].longconst);
532 args -= longest_to_int (expr->elts[endpos - 3].longconst);
533 args += 1;
534 break;
535
3d6b6a90
JG
536 case TERNOP_COND:
537 args = 3;
538 break;
539
540 /* Modula-2 */
54bbbfb4 541 case MULTI_SUBSCRIPT:
a91a6192
SS
542 /* Fortran */
543 case MULTI_F77_SUBSCRIPT:
544 oplen = 3;
d1065385 545 args = 1 + longest_to_int (expr->elts[endpos- 2].longconst);
3d6b6a90
JG
546 break;
547
548 case BINOP_ASSIGN_MODIFY:
549 oplen = 3;
550 args = 2;
551 break;
552
553 /* C++ */
554 case OP_THIS:
555 oplen = 2;
556 break;
557
558 default:
559 args = 1 + (i < (int) BINOP_END);
560 }
561
562 while (args > 0)
563 {
564 oplen += length_of_subexp (expr, endpos - oplen);
565 args--;
566 }
567
568 return oplen;
569}
570
571/* Copy the subexpression ending just before index INEND in INEXPR
572 into OUTEXPR, starting at index OUTBEG.
573 In the process, convert it from suffix to prefix form. */
574
575static void
576prefixify_subexp (inexpr, outexpr, inend, outbeg)
577 register struct expression *inexpr;
578 struct expression *outexpr;
579 register int inend;
580 int outbeg;
581{
582 register int oplen = 1;
583 register int args = 0;
584 register int i;
585 int *arglens;
586 enum exp_opcode opcode;
587
588 /* Compute how long the last operation is (in OPLEN),
589 and also how many preceding subexpressions serve as
590 arguments for it (in ARGS). */
591
592 opcode = inexpr->elts[inend - 1].opcode;
593 switch (opcode)
594 {
595 /* C++ */
596 case OP_SCOPE:
81028ab0
FF
597 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
598 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
3d6b6a90
JG
599 break;
600
601 case OP_LONG:
602 case OP_DOUBLE:
479fdd26 603 case OP_VAR_VALUE:
3d6b6a90
JG
604 oplen = 4;
605 break;
606
607 case OP_TYPE:
608 case OP_BOOL:
3d6b6a90
JG
609 case OP_LAST:
610 case OP_REGISTER:
611 case OP_INTERNALVAR:
612 oplen = 3;
613 break;
614
a91a6192
SS
615 case OP_F77_LITERAL_COMPLEX:
616 oplen = 1;
617 args = 2;
618 break;
619
620 case OP_F77_SUBSTR:
621 oplen = 1;
622 args = 2;
623 break;
624
3d6b6a90 625 case OP_FUNCALL:
a91a6192 626 case OP_F77_UNDETERMINED_ARGLIST:
3d6b6a90 627 oplen = 3;
d1065385 628 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
3d6b6a90
JG
629 break;
630
631 case UNOP_MIN:
632 case UNOP_MAX:
633 oplen = 3;
3d6b6a90
JG
634 break;
635
636 case UNOP_CAST:
637 case UNOP_MEMVAL:
638 oplen = 3;
639 args = 1;
640 break;
641
642 case UNOP_ABS:
643 case UNOP_CAP:
644 case UNOP_CHR:
645 case UNOP_FLOAT:
646 case UNOP_HIGH:
647 case UNOP_ODD:
648 case UNOP_ORD:
649 case UNOP_TRUNC:
650 oplen=1;
651 args=1;
652 break;
653
61c1724b 654 case STRUCTOP_STRUCT:
2640f7e1
JG
655 case STRUCTOP_PTR:
656 args = 1;
d1065385 657 /* fall through */
3d6b6a90
JG
658 case OP_M2_STRING:
659 case OP_STRING:
81028ab0
FF
660 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
661 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
662 break;
663
664 case OP_BITSTRING:
665 oplen = longest_to_int (inexpr->elts[inend - 2].longconst);
666 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
667 oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
3d6b6a90
JG
668 break;
669
c4413e2c
FF
670 case OP_ARRAY:
671 oplen = 4;
672 args = longest_to_int (inexpr->elts[inend - 2].longconst);
673 args -= longest_to_int (inexpr->elts[inend - 3].longconst);
674 args += 1;
675 break;
676
3d6b6a90
JG
677 case TERNOP_COND:
678 args = 3;
679 break;
680
681 case BINOP_ASSIGN_MODIFY:
682 oplen = 3;
683 args = 2;
684 break;
685
686 /* Modula-2 */
54bbbfb4 687 case MULTI_SUBSCRIPT:
a91a6192
SS
688 /* Fortran */
689 case MULTI_F77_SUBSCRIPT:
690 oplen = 3;
d1065385 691 args = 1 + longest_to_int (inexpr->elts[inend - 2].longconst);
3d6b6a90
JG
692 break;
693
694 /* C++ */
695 case OP_THIS:
696 oplen = 2;
697 break;
698
699 default:
700 args = 1 + ((int) opcode < (int) BINOP_END);
701 }
702
703 /* Copy the final operator itself, from the end of the input
704 to the beginning of the output. */
705 inend -= oplen;
4ed3a9ea 706 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
81028ab0 707 EXP_ELEM_TO_BYTES (oplen));
3d6b6a90
JG
708 outbeg += oplen;
709
710 /* Find the lengths of the arg subexpressions. */
711 arglens = (int *) alloca (args * sizeof (int));
712 for (i = args - 1; i >= 0; i--)
713 {
714 oplen = length_of_subexp (inexpr, inend);
715 arglens[i] = oplen;
716 inend -= oplen;
717 }
718
719 /* Now copy each subexpression, preserving the order of
720 the subexpressions, but prefixifying each one.
721 In this loop, inend starts at the beginning of
722 the expression this level is working on
723 and marches forward over the arguments.
724 outbeg does similarly in the output. */
725 for (i = 0; i < args; i++)
726 {
727 oplen = arglens[i];
728 inend += oplen;
729 prefixify_subexp (inexpr, outexpr, inend, outbeg);
730 outbeg += oplen;
731 }
732}
733\f
734/* This page contains the two entry points to this file. */
735
736/* Read an expression from the string *STRINGPTR points to,
737 parse it, and return a pointer to a struct expression that we malloc.
738 Use block BLOCK as the lexical context for variable names;
739 if BLOCK is zero, use the block of the selected stack frame.
740 Meanwhile, advance *STRINGPTR to point after the expression,
741 at the first nonwhite character that is not part of the expression
742 (possibly a null character).
743
744 If COMMA is nonzero, stop if a comma is reached. */
745
746struct expression *
747parse_exp_1 (stringptr, block, comma)
748 char **stringptr;
749 struct block *block;
750 int comma;
751{
752 struct cleanup *old_chain;
753
754 lexptr = *stringptr;
755
756 paren_depth = 0;
757 type_stack_depth = 0;
758
759 comma_terminates = comma;
760
761 if (lexptr == 0 || *lexptr == 0)
762 error_no_arg ("expression to compute");
763
764 old_chain = make_cleanup (free_funcalls, 0);
765 funcall_chain = 0;
766
767 expression_context_block = block ? block : get_selected_block ();
768
769 namecopy = (char *) alloca (strlen (lexptr) + 1);
770 expout_size = 10;
771 expout_ptr = 0;
772 expout = (struct expression *)
81028ab0 773 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
3d6b6a90
JG
774 expout->language_defn = current_language;
775 make_cleanup (free_current_contents, &expout);
776
777 if (current_language->la_parser ())
778 current_language->la_error (NULL);
779
780 discard_cleanups (old_chain);
54bbbfb4
FF
781
782 /* Record the actual number of expression elements, and then
783 reallocate the expression memory so that we free up any
784 excess elements. */
785
3d6b6a90
JG
786 expout->nelts = expout_ptr;
787 expout = (struct expression *)
1ab3bf1b 788 xrealloc ((char *) expout,
81028ab0 789 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
54bbbfb4
FF
790
791 /* Convert expression from postfix form as generated by yacc
792 parser, to a prefix form. */
793
199b2450 794 DUMP_EXPRESSION (expout, gdb_stdout, "before conversion to prefix form");
3d6b6a90 795 prefixify_expression (expout);
199b2450 796 DUMP_EXPRESSION (expout, gdb_stdout, "after conversion to prefix form");
54bbbfb4 797
3d6b6a90
JG
798 *stringptr = lexptr;
799 return expout;
800}
801
802/* Parse STRING as an expression, and complain if this fails
803 to use up all of the contents of STRING. */
804
805struct expression *
806parse_expression (string)
807 char *string;
808{
809 register struct expression *exp;
810 exp = parse_exp_1 (&string, 0, 0);
811 if (*string)
812 error ("Junk after end of expression.");
813 return exp;
814}
f843c95f
JK
815\f
816/* Stuff for maintaining a stack of types. Currently just used by C, but
817 probably useful for any language which declares its types "backwards". */
3d6b6a90
JG
818
819void
820push_type (tp)
821 enum type_pieces tp;
822{
823 if (type_stack_depth == type_stack_size)
824 {
825 type_stack_size *= 2;
826 type_stack = (union type_stack_elt *)
1ab3bf1b 827 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
3d6b6a90
JG
828 }
829 type_stack[type_stack_depth++].piece = tp;
830}
831
832void
833push_type_int (n)
834 int n;
835{
836 if (type_stack_depth == type_stack_size)
837 {
838 type_stack_size *= 2;
839 type_stack = (union type_stack_elt *)
1ab3bf1b 840 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
3d6b6a90
JG
841 }
842 type_stack[type_stack_depth++].int_val = n;
843}
844
845enum type_pieces
846pop_type ()
847{
848 if (type_stack_depth)
849 return type_stack[--type_stack_depth].piece;
850 return tp_end;
851}
852
853int
854pop_type_int ()
855{
856 if (type_stack_depth)
857 return type_stack[--type_stack_depth].int_val;
858 /* "Can't happen". */
859 return 0;
860}
861
f843c95f
JK
862/* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
863 as modified by all the stuff on the stack. */
864struct type *
865follow_types (follow_type)
866 struct type *follow_type;
867{
868 int done = 0;
869 int array_size;
870 struct type *range_type;
871
872 while (!done)
873 switch (pop_type ())
874 {
875 case tp_end:
876 done = 1;
877 break;
878 case tp_pointer:
879 follow_type = lookup_pointer_type (follow_type);
880 break;
881 case tp_reference:
882 follow_type = lookup_reference_type (follow_type);
883 break;
884 case tp_array:
885 array_size = pop_type_int ();
886 if (array_size != -1)
887 {
888 range_type =
889 create_range_type ((struct type *) NULL,
890 builtin_type_int, 0,
891 array_size - 1);
892 follow_type =
893 create_array_type ((struct type *) NULL,
894 follow_type, range_type);
895 }
896 else
897 follow_type = lookup_pointer_type (follow_type);
898 break;
899 case tp_function:
900 follow_type = lookup_function_type (follow_type);
901 break;
902 }
903 return follow_type;
904}
905\f
3d6b6a90
JG
906void
907_initialize_parse ()
908{
909 type_stack_size = 80;
910 type_stack_depth = 0;
911 type_stack = (union type_stack_elt *)
912 xmalloc (type_stack_size * sizeof (*type_stack));
3fb93d86
JK
913
914 msym_text_symbol_type =
915 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable without -g>", NULL);
916 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int;
917 msym_data_symbol_type =
918 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
919 "<data variable without -g>", NULL);
920 msym_unknown_symbol_type =
921 init_type (TYPE_CODE_INT, 1, 0, "<unknown segment variable without -g>",
922 NULL);
3d6b6a90 923}
This page took 0.228972 seconds and 4 git commands to generate.