2007-10-25 Wu Zhou <woodzltc@cn.ibm.com>
[platform/upstream/binutils.git] / gdb / parse.c
1 /* Parse expressions for GDB.
2
3    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4    1998, 1999, 2000, 2001, 2004, 2005, 2007 Free Software Foundation, Inc.
5
6    Modified from expread.y by the Department of Computer Science at the
7    State University of New York at Buffalo, 1991.
8
9    This file is part of GDB.
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
24 /* Parse an expression from text in a string,
25    and return the result as a  struct expression  pointer.
26    That structure contains arithmetic operations in reverse polish,
27    with constants represented by operations that are followed by special data.
28    See expression.h for the details of the format.
29    What is important here is that it can be built up sequentially
30    during the process of parsing; the lower levels of the tree always
31    come first in the result.  */
32
33 #include <ctype.h>
34
35 #include "defs.h"
36 #include "gdb_string.h"
37 #include "symtab.h"
38 #include "gdbtypes.h"
39 #include "frame.h"
40 #include "expression.h"
41 #include "value.h"
42 #include "command.h"
43 #include "language.h"
44 #include "f-lang.h"
45 #include "parser-defs.h"
46 #include "gdbcmd.h"
47 #include "symfile.h"            /* for overlay functions */
48 #include "inferior.h"
49 #include "doublest.h"
50 #include "gdb_assert.h"
51 #include "block.h"
52 #include "source.h"
53 #include "objfiles.h"
54
55 /* Standard set of definitions for printing, dumping, prefixifying,
56  * and evaluating expressions.  */
57
58 const struct exp_descriptor exp_descriptor_standard = 
59   {
60     print_subexp_standard,
61     operator_length_standard,
62     op_name_standard,
63     dump_subexp_body_standard,
64     evaluate_subexp_standard
65   };
66 \f
67 /* Global variables declared in parser-defs.h (and commented there).  */
68 struct expression *expout;
69 int expout_size;
70 int expout_ptr;
71 struct block *expression_context_block;
72 CORE_ADDR expression_context_pc;
73 struct block *innermost_block;
74 int arglist_len;
75 union type_stack_elt *type_stack;
76 int type_stack_depth, type_stack_size;
77 char *lexptr;
78 char *prev_lexptr;
79 int paren_depth;
80 int comma_terminates;
81
82 /* A temporary buffer for identifiers, so we can null-terminate them.
83
84    We allocate this with xrealloc.  parse_exp_1 used to allocate with
85    alloca, using the size of the whole expression as a conservative
86    estimate of the space needed.  However, macro expansion can
87    introduce names longer than the original expression; there's no
88    practical way to know beforehand how large that might be.  */
89 char *namecopy;
90 size_t namecopy_size;
91 \f
92 static int expressiondebug = 0;
93 static void
94 show_expressiondebug (struct ui_file *file, int from_tty,
95                       struct cmd_list_element *c, const char *value)
96 {
97   fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
98 }
99
100 static void free_funcalls (void *ignore);
101
102 static void prefixify_expression (struct expression *);
103
104 static void prefixify_subexp (struct expression *, struct expression *, int,
105                               int);
106
107 static struct expression *parse_exp_in_context (char **, struct block *, int, 
108                                                 int);
109
110 void _initialize_parse (void);
111
112 /* Data structure for saving values of arglist_len for function calls whose
113    arguments contain other function calls.  */
114
115 struct funcall
116   {
117     struct funcall *next;
118     int arglist_len;
119   };
120
121 static struct funcall *funcall_chain;
122
123 /* Begin counting arguments for a function call,
124    saving the data about any containing call.  */
125
126 void
127 start_arglist (void)
128 {
129   struct funcall *new;
130
131   new = (struct funcall *) xmalloc (sizeof (struct funcall));
132   new->next = funcall_chain;
133   new->arglist_len = arglist_len;
134   arglist_len = 0;
135   funcall_chain = new;
136 }
137
138 /* Return the number of arguments in a function call just terminated,
139    and restore the data for the containing function call.  */
140
141 int
142 end_arglist (void)
143 {
144   int val = arglist_len;
145   struct funcall *call = funcall_chain;
146   funcall_chain = call->next;
147   arglist_len = call->arglist_len;
148   xfree (call);
149   return val;
150 }
151
152 /* Free everything in the funcall chain.
153    Used when there is an error inside parsing.  */
154
155 static void
156 free_funcalls (void *ignore)
157 {
158   struct funcall *call, *next;
159
160   for (call = funcall_chain; call; call = next)
161     {
162       next = call->next;
163       xfree (call);
164     }
165 }
166 \f
167 /* This page contains the functions for adding data to the  struct expression
168    being constructed.  */
169
170 /* Add one element to the end of the expression.  */
171
172 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
173    a register through here */
174
175 void
176 write_exp_elt (union exp_element expelt)
177 {
178   if (expout_ptr >= expout_size)
179     {
180       expout_size *= 2;
181       expout = (struct expression *)
182         xrealloc ((char *) expout, sizeof (struct expression)
183                   + EXP_ELEM_TO_BYTES (expout_size));
184     }
185   expout->elts[expout_ptr++] = expelt;
186 }
187
188 void
189 write_exp_elt_opcode (enum exp_opcode expelt)
190 {
191   union exp_element tmp;
192   memset (&tmp, 0, sizeof (union exp_element));
193
194   tmp.opcode = expelt;
195
196   write_exp_elt (tmp);
197 }
198
199 void
200 write_exp_elt_sym (struct symbol *expelt)
201 {
202   union exp_element tmp;
203   memset (&tmp, 0, sizeof (union exp_element));
204
205   tmp.symbol = expelt;
206
207   write_exp_elt (tmp);
208 }
209
210 void
211 write_exp_elt_block (struct block *b)
212 {
213   union exp_element tmp;
214   memset (&tmp, 0, sizeof (union exp_element));
215   tmp.block = b;
216   write_exp_elt (tmp);
217 }
218
219 void
220 write_exp_elt_objfile (struct objfile *objfile)
221 {
222   union exp_element tmp;
223   memset (&tmp, 0, sizeof (union exp_element));
224   tmp.objfile = objfile;
225   write_exp_elt (tmp);
226 }
227
228 void
229 write_exp_elt_longcst (LONGEST expelt)
230 {
231   union exp_element tmp;
232   memset (&tmp, 0, sizeof (union exp_element));
233
234   tmp.longconst = expelt;
235
236   write_exp_elt (tmp);
237 }
238
239 void
240 write_exp_elt_dblcst (DOUBLEST expelt)
241 {
242   union exp_element tmp;
243   memset (&tmp, 0, sizeof (union exp_element));
244
245   tmp.doubleconst = expelt;
246
247   write_exp_elt (tmp);
248 }
249
250 void
251 write_exp_elt_decfloatcst (gdb_byte expelt[16])
252 {
253   union exp_element tmp;
254   int index;
255
256   for (index = 0; index < 16; index++)
257     tmp.decfloatconst[index] = expelt[index];
258
259   write_exp_elt (tmp);
260 }
261
262 void
263 write_exp_elt_type (struct type *expelt)
264 {
265   union exp_element tmp;
266   memset (&tmp, 0, sizeof (union exp_element));
267
268   tmp.type = expelt;
269
270   write_exp_elt (tmp);
271 }
272
273 void
274 write_exp_elt_intern (struct internalvar *expelt)
275 {
276   union exp_element tmp;
277   memset (&tmp, 0, sizeof (union exp_element));
278
279   tmp.internalvar = expelt;
280
281   write_exp_elt (tmp);
282 }
283
284 /* Add a string constant to the end of the expression.
285
286    String constants are stored by first writing an expression element
287    that contains the length of the string, then stuffing the string
288    constant itself into however many expression elements are needed
289    to hold it, and then writing another expression element that contains
290    the length of the string.  I.E. an expression element at each end of
291    the string records the string length, so you can skip over the 
292    expression elements containing the actual string bytes from either
293    end of the string.  Note that this also allows gdb to handle
294    strings with embedded null bytes, as is required for some languages.
295
296    Don't be fooled by the fact that the string is null byte terminated,
297    this is strictly for the convenience of debugging gdb itself.  Gdb
298    Gdb does not depend up the string being null terminated, since the
299    actual length is recorded in expression elements at each end of the
300    string.  The null byte is taken into consideration when computing how
301    many expression elements are required to hold the string constant, of
302    course. */
303
304
305 void
306 write_exp_string (struct stoken str)
307 {
308   int len = str.length;
309   int lenelt;
310   char *strdata;
311
312   /* Compute the number of expression elements required to hold the string
313      (including a null byte terminator), along with one expression element
314      at each end to record the actual string length (not including the
315      null byte terminator). */
316
317   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
318
319   /* Ensure that we have enough available expression elements to store
320      everything. */
321
322   if ((expout_ptr + lenelt) >= expout_size)
323     {
324       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
325       expout = (struct expression *)
326         xrealloc ((char *) expout, (sizeof (struct expression)
327                                     + EXP_ELEM_TO_BYTES (expout_size)));
328     }
329
330   /* Write the leading length expression element (which advances the current
331      expression element index), then write the string constant followed by a
332      terminating null byte, and then write the trailing length expression
333      element. */
334
335   write_exp_elt_longcst ((LONGEST) len);
336   strdata = (char *) &expout->elts[expout_ptr];
337   memcpy (strdata, str.ptr, len);
338   *(strdata + len) = '\0';
339   expout_ptr += lenelt - 2;
340   write_exp_elt_longcst ((LONGEST) len);
341 }
342
343 /* Add a bitstring constant to the end of the expression.
344
345    Bitstring constants are stored by first writing an expression element
346    that contains the length of the bitstring (in bits), then stuffing the
347    bitstring constant itself into however many expression elements are
348    needed to hold it, and then writing another expression element that
349    contains the length of the bitstring.  I.E. an expression element at
350    each end of the bitstring records the bitstring length, so you can skip
351    over the expression elements containing the actual bitstring bytes from
352    either end of the bitstring. */
353
354 void
355 write_exp_bitstring (struct stoken str)
356 {
357   int bits = str.length;        /* length in bits */
358   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
359   int lenelt;
360   char *strdata;
361
362   /* Compute the number of expression elements required to hold the bitstring,
363      along with one expression element at each end to record the actual
364      bitstring length in bits. */
365
366   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
367
368   /* Ensure that we have enough available expression elements to store
369      everything. */
370
371   if ((expout_ptr + lenelt) >= expout_size)
372     {
373       expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
374       expout = (struct expression *)
375         xrealloc ((char *) expout, (sizeof (struct expression)
376                                     + EXP_ELEM_TO_BYTES (expout_size)));
377     }
378
379   /* Write the leading length expression element (which advances the current
380      expression element index), then write the bitstring constant, and then
381      write the trailing length expression element. */
382
383   write_exp_elt_longcst ((LONGEST) bits);
384   strdata = (char *) &expout->elts[expout_ptr];
385   memcpy (strdata, str.ptr, len);
386   expout_ptr += lenelt - 2;
387   write_exp_elt_longcst ((LONGEST) bits);
388 }
389
390 /* Add the appropriate elements for a minimal symbol to the end of
391    the expression.  The rationale behind passing in text_symbol_type and
392    data_symbol_type was so that Modula-2 could pass in WORD for
393    data_symbol_type.  Perhaps it still is useful to have those types vary
394    based on the language, but they no longer have names like "int", so
395    the initial rationale is gone.  */
396
397 void
398 write_exp_msymbol (struct minimal_symbol *msymbol, 
399                    struct type *text_symbol_type, 
400                    struct type *data_symbol_type)
401 {
402   struct gdbarch *gdbarch = current_gdbarch;
403   CORE_ADDR addr;
404
405   write_exp_elt_opcode (OP_LONG);
406   /* Let's make the type big enough to hold a 64-bit address.  */
407   write_exp_elt_type (builtin_type_CORE_ADDR);
408
409   addr = SYMBOL_VALUE_ADDRESS (msymbol);
410   if (overlay_debugging)
411     addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol));
412   write_exp_elt_longcst ((LONGEST) addr);
413
414   write_exp_elt_opcode (OP_LONG);
415
416   if (SYMBOL_BFD_SECTION (msymbol)
417       && SYMBOL_BFD_SECTION (msymbol)->flags & SEC_THREAD_LOCAL)
418     {
419       bfd *bfd = SYMBOL_BFD_SECTION (msymbol)->owner;
420       struct objfile *ofp;
421
422       ALL_OBJFILES (ofp)
423         if (ofp->obfd == bfd)
424           break;
425
426       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
427       write_exp_elt_objfile (ofp);
428       write_exp_elt_type (builtin_type (gdbarch)->nodebug_tls_symbol);
429       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
430       return;
431     }
432
433   write_exp_elt_opcode (UNOP_MEMVAL);
434   switch (msymbol->type)
435     {
436     case mst_text:
437     case mst_file_text:
438     case mst_solib_trampoline:
439       write_exp_elt_type (builtin_type (gdbarch)->nodebug_text_symbol);
440       break;
441
442     case mst_data:
443     case mst_file_data:
444     case mst_bss:
445     case mst_file_bss:
446       write_exp_elt_type (builtin_type (gdbarch)->nodebug_data_symbol);
447       break;
448
449     default:
450       write_exp_elt_type (builtin_type (gdbarch)->nodebug_unknown_symbol);
451       break;
452     }
453   write_exp_elt_opcode (UNOP_MEMVAL);
454 }
455 \f
456 /* Recognize tokens that start with '$'.  These include:
457
458    $regname     A native register name or a "standard
459    register name".
460
461    $variable    A convenience variable with a name chosen
462    by the user.
463
464    $digits              Value history with index <digits>, starting
465    from the first value which has index 1.
466
467    $$digits     Value history with index <digits> relative
468    to the last value.  I.E. $$0 is the last
469    value, $$1 is the one previous to that, $$2
470    is the one previous to $$1, etc.
471
472    $ | $0 | $$0 The last value in the value history.
473
474    $$           An abbreviation for the second to the last
475    value in the value history, I.E. $$1
476
477  */
478
479 void
480 write_dollar_variable (struct stoken str)
481 {
482   struct symbol *sym = NULL;
483   struct minimal_symbol *msym = NULL;
484   struct internalvar *isym = NULL;
485
486   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
487      and $$digits (equivalent to $<-digits> if you could type that). */
488
489   int negate = 0;
490   int i = 1;
491   /* Double dollar means negate the number and add -1 as well.
492      Thus $$ alone means -1.  */
493   if (str.length >= 2 && str.ptr[1] == '$')
494     {
495       negate = 1;
496       i = 2;
497     }
498   if (i == str.length)
499     {
500       /* Just dollars (one or two) */
501       i = -negate;
502       goto handle_last;
503     }
504   /* Is the rest of the token digits?  */
505   for (; i < str.length; i++)
506     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
507       break;
508   if (i == str.length)
509     {
510       i = atoi (str.ptr + 1 + negate);
511       if (negate)
512         i = -i;
513       goto handle_last;
514     }
515
516   /* Handle tokens that refer to machine registers:
517      $ followed by a register name.  */
518   i = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
519                                 str.ptr + 1, str.length - 1);
520   if (i >= 0)
521     goto handle_register;
522
523   /* Any names starting with $ are probably debugger internal variables.  */
524
525   isym = lookup_only_internalvar (copy_name (str) + 1);
526   if (isym)
527     {
528       write_exp_elt_opcode (OP_INTERNALVAR);
529       write_exp_elt_intern (isym);
530       write_exp_elt_opcode (OP_INTERNALVAR);
531       return;
532     }
533
534   /* On some systems, such as HP-UX and hppa-linux, certain system routines 
535      have names beginning with $ or $$.  Check for those, first. */
536
537   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
538                        VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
539   if (sym)
540     {
541       write_exp_elt_opcode (OP_VAR_VALUE);
542       write_exp_elt_block (block_found);        /* set by lookup_symbol */
543       write_exp_elt_sym (sym);
544       write_exp_elt_opcode (OP_VAR_VALUE);
545       return;
546     }
547   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
548   if (msym)
549     {
550       write_exp_msymbol (msym,
551                          lookup_function_type (builtin_type_int),
552                          builtin_type_int);
553       return;
554     }
555
556   /* Any other names are assumed to be debugger internal variables.  */
557
558   write_exp_elt_opcode (OP_INTERNALVAR);
559   write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
560   write_exp_elt_opcode (OP_INTERNALVAR);
561   return;
562 handle_last:
563   write_exp_elt_opcode (OP_LAST);
564   write_exp_elt_longcst ((LONGEST) i);
565   write_exp_elt_opcode (OP_LAST);
566   return;
567 handle_register:
568   write_exp_elt_opcode (OP_REGISTER);
569   str.length--;
570   str.ptr++;
571   write_exp_string (str);
572   write_exp_elt_opcode (OP_REGISTER);
573   return;
574 }
575
576
577 char *
578 find_template_name_end (char *p)
579 {
580   int depth = 1;
581   int just_seen_right = 0;
582   int just_seen_colon = 0;
583   int just_seen_space = 0;
584
585   if (!p || (*p != '<'))
586     return 0;
587
588   while (*++p)
589     {
590       switch (*p)
591         {
592         case '\'':
593         case '\"':
594         case '{':
595         case '}':
596           /* In future, may want to allow these?? */
597           return 0;
598         case '<':
599           depth++;              /* start nested template */
600           if (just_seen_colon || just_seen_right || just_seen_space)
601             return 0;           /* but not after : or :: or > or space */
602           break;
603         case '>':
604           if (just_seen_colon || just_seen_right)
605             return 0;           /* end a (nested?) template */
606           just_seen_right = 1;  /* but not after : or :: */
607           if (--depth == 0)     /* also disallow >>, insist on > > */
608             return ++p;         /* if outermost ended, return */
609           break;
610         case ':':
611           if (just_seen_space || (just_seen_colon > 1))
612             return 0;           /* nested class spec coming up */
613           just_seen_colon++;    /* we allow :: but not :::: */
614           break;
615         case ' ':
616           break;
617         default:
618           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
619                 (*p >= 'A' && *p <= 'Z') ||
620                 (*p >= '0' && *p <= '9') ||
621                 (*p == '_') || (*p == ',') ||   /* commas for template args */
622                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
623                 (*p == '(') || (*p == ')') ||   /* function types */
624                 (*p == '[') || (*p == ']')))    /* array types */
625             return 0;
626         }
627       if (*p != ' ')
628         just_seen_space = 0;
629       if (*p != ':')
630         just_seen_colon = 0;
631       if (*p != '>')
632         just_seen_right = 0;
633     }
634   return 0;
635 }
636 \f
637
638
639 /* Return a null-terminated temporary copy of the name
640    of a string token.  */
641
642 char *
643 copy_name (struct stoken token)
644 {
645   /* Make sure there's enough space for the token.  */
646   if (namecopy_size < token.length + 1)
647     {
648       namecopy_size = token.length + 1;
649       namecopy = xrealloc (namecopy, token.length + 1);
650     }
651       
652   memcpy (namecopy, token.ptr, token.length);
653   namecopy[token.length] = 0;
654
655   return namecopy;
656 }
657 \f
658 /* Reverse an expression from suffix form (in which it is constructed)
659    to prefix form (in which we can conveniently print or execute it).  */
660
661 static void
662 prefixify_expression (struct expression *expr)
663 {
664   int len =
665   sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
666   struct expression *temp;
667   int inpos = expr->nelts, outpos = 0;
668
669   temp = (struct expression *) alloca (len);
670
671   /* Copy the original expression into temp.  */
672   memcpy (temp, expr, len);
673
674   prefixify_subexp (temp, expr, inpos, outpos);
675 }
676
677 /* Return the number of exp_elements in the postfix subexpression 
678    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
679
680 int
681 length_of_subexp (struct expression *expr, int endpos)
682 {
683   int oplen, args, i;
684
685   operator_length (expr, endpos, &oplen, &args);
686
687   while (args > 0)
688     {
689       oplen += length_of_subexp (expr, endpos - oplen);
690       args--;
691     }
692
693   return oplen;
694 }
695
696 /* Sets *OPLENP to the length of the operator whose (last) index is 
697    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
698    operator takes.  */
699
700 void
701 operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp)
702 {
703   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
704                                                      oplenp, argsp);
705 }
706
707 /* Default value for operator_length in exp_descriptor vectors.  */
708
709 void
710 operator_length_standard (struct expression *expr, int endpos,
711                           int *oplenp, int *argsp)
712 {
713   int oplen = 1;
714   int args = 0;
715   enum f90_range_type range_type;
716   int i;
717
718   if (endpos < 1)
719     error (_("?error in operator_length_standard"));
720
721   i = (int) expr->elts[endpos - 1].opcode;
722
723   switch (i)
724     {
725       /* C++  */
726     case OP_SCOPE:
727       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
728       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
729       break;
730
731     case OP_LONG:
732     case OP_DOUBLE:
733     case OP_DECFLOAT:
734     case OP_VAR_VALUE:
735       oplen = 4;
736       break;
737
738     case OP_TYPE:
739     case OP_BOOL:
740     case OP_LAST:
741     case OP_INTERNALVAR:
742       oplen = 3;
743       break;
744
745     case OP_COMPLEX:
746       oplen = 1;
747       args = 2;
748       break;
749
750     case OP_FUNCALL:
751     case OP_F77_UNDETERMINED_ARGLIST:
752       oplen = 3;
753       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
754       break;
755
756     case OP_OBJC_MSGCALL:       /* Objective C message (method) call */
757       oplen = 4;
758       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
759       break;
760
761     case UNOP_MAX:
762     case UNOP_MIN:
763       oplen = 3;
764       break;
765
766     case BINOP_VAL:
767     case UNOP_CAST:
768     case UNOP_MEMVAL:
769       oplen = 3;
770       args = 1;
771       break;
772
773     case UNOP_MEMVAL_TLS:
774       oplen = 4;
775       args = 1;
776       break;
777
778     case UNOP_ABS:
779     case UNOP_CAP:
780     case UNOP_CHR:
781     case UNOP_FLOAT:
782     case UNOP_HIGH:
783     case UNOP_ODD:
784     case UNOP_ORD:
785     case UNOP_TRUNC:
786       oplen = 1;
787       args = 1;
788       break;
789
790     case OP_LABELED:
791     case STRUCTOP_STRUCT:
792     case STRUCTOP_PTR:
793       args = 1;
794       /* fall through */
795     case OP_REGISTER:
796     case OP_M2_STRING:
797     case OP_STRING:
798     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class NSString constant */
799     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op */
800     case OP_NAME:
801       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
802       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
803       break;
804
805     case OP_BITSTRING:
806       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
807       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
808       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
809       break;
810
811     case OP_ARRAY:
812       oplen = 4;
813       args = longest_to_int (expr->elts[endpos - 2].longconst);
814       args -= longest_to_int (expr->elts[endpos - 3].longconst);
815       args += 1;
816       break;
817
818     case TERNOP_COND:
819     case TERNOP_SLICE:
820     case TERNOP_SLICE_COUNT:
821       args = 3;
822       break;
823
824       /* Modula-2 */
825     case MULTI_SUBSCRIPT:
826       oplen = 3;
827       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
828       break;
829
830     case BINOP_ASSIGN_MODIFY:
831       oplen = 3;
832       args = 2;
833       break;
834
835       /* C++ */
836     case OP_THIS:
837     case OP_OBJC_SELF:
838       oplen = 2;
839       break;
840
841     case OP_F90_RANGE:
842       oplen = 3;
843
844       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
845       switch (range_type)
846         {
847         case LOW_BOUND_DEFAULT:
848         case HIGH_BOUND_DEFAULT:
849           args = 1;
850           break;
851         case BOTH_BOUND_DEFAULT:
852           args = 0;
853           break;
854         case NONE_BOUND_DEFAULT:
855           args = 2;
856           break;
857         }
858
859       break;
860
861     default:
862       args = 1 + (i < (int) BINOP_END);
863     }
864
865   *oplenp = oplen;
866   *argsp = args;
867 }
868
869 /* Copy the subexpression ending just before index INEND in INEXPR
870    into OUTEXPR, starting at index OUTBEG.
871    In the process, convert it from suffix to prefix form.  */
872
873 static void
874 prefixify_subexp (struct expression *inexpr,
875                   struct expression *outexpr, int inend, int outbeg)
876 {
877   int oplen;
878   int args;
879   int i;
880   int *arglens;
881   enum exp_opcode opcode;
882
883   operator_length (inexpr, inend, &oplen, &args);
884
885   /* Copy the final operator itself, from the end of the input
886      to the beginning of the output.  */
887   inend -= oplen;
888   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
889           EXP_ELEM_TO_BYTES (oplen));
890   outbeg += oplen;
891
892   /* Find the lengths of the arg subexpressions.  */
893   arglens = (int *) alloca (args * sizeof (int));
894   for (i = args - 1; i >= 0; i--)
895     {
896       oplen = length_of_subexp (inexpr, inend);
897       arglens[i] = oplen;
898       inend -= oplen;
899     }
900
901   /* Now copy each subexpression, preserving the order of
902      the subexpressions, but prefixifying each one.
903      In this loop, inend starts at the beginning of
904      the expression this level is working on
905      and marches forward over the arguments.
906      outbeg does similarly in the output.  */
907   for (i = 0; i < args; i++)
908     {
909       oplen = arglens[i];
910       inend += oplen;
911       prefixify_subexp (inexpr, outexpr, inend, outbeg);
912       outbeg += oplen;
913     }
914 }
915 \f
916 /* This page contains the two entry points to this file.  */
917
918 /* Read an expression from the string *STRINGPTR points to,
919    parse it, and return a pointer to a  struct expression  that we malloc.
920    Use block BLOCK as the lexical context for variable names;
921    if BLOCK is zero, use the block of the selected stack frame.
922    Meanwhile, advance *STRINGPTR to point after the expression,
923    at the first nonwhite character that is not part of the expression
924    (possibly a null character).
925
926    If COMMA is nonzero, stop if a comma is reached.  */
927
928 struct expression *
929 parse_exp_1 (char **stringptr, struct block *block, int comma)
930 {
931   return parse_exp_in_context (stringptr, block, comma, 0);
932 }
933
934 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
935    no value is expected from the expression.  */
936
937 static struct expression *
938 parse_exp_in_context (char **stringptr, struct block *block, int comma, 
939                       int void_context_p)
940 {
941   struct cleanup *old_chain;
942
943   lexptr = *stringptr;
944   prev_lexptr = NULL;
945
946   paren_depth = 0;
947   type_stack_depth = 0;
948
949   comma_terminates = comma;
950
951   if (lexptr == 0 || *lexptr == 0)
952     error_no_arg (_("expression to compute"));
953
954   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
955   funcall_chain = 0;
956
957   /* If no context specified, try using the current frame, if any. */
958
959   if (!block)
960     block = get_selected_block (&expression_context_pc);
961
962   /* Fall back to using the current source static context, if any. */
963
964   if (!block)
965     {
966       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
967       if (cursal.symtab)
968         block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
969     }
970
971   /* Save the context, if specified by caller, or found above. */
972
973   if (block)
974     {
975       expression_context_block = block;
976       expression_context_pc = BLOCK_START (block);
977     }
978
979   expout_size = 10;
980   expout_ptr = 0;
981   expout = (struct expression *)
982     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
983   expout->language_defn = current_language;
984   make_cleanup (free_current_contents, &expout);
985
986   if (current_language->la_parser ())
987     current_language->la_error (NULL);
988
989   discard_cleanups (old_chain);
990
991   /* Record the actual number of expression elements, and then
992      reallocate the expression memory so that we free up any
993      excess elements. */
994
995   expout->nelts = expout_ptr;
996   expout = (struct expression *)
997     xrealloc ((char *) expout,
998               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
999
1000   /* Convert expression from postfix form as generated by yacc
1001      parser, to a prefix form. */
1002
1003   if (expressiondebug)
1004     dump_raw_expression (expout, gdb_stdlog,
1005                          "before conversion to prefix form");
1006
1007   prefixify_expression (expout);
1008
1009   current_language->la_post_parser (&expout, void_context_p);
1010
1011   if (expressiondebug)
1012     dump_prefix_expression (expout, gdb_stdlog);
1013
1014   *stringptr = lexptr;
1015   return expout;
1016 }
1017
1018 /* Parse STRING as an expression, and complain if this fails
1019    to use up all of the contents of STRING.  */
1020
1021 struct expression *
1022 parse_expression (char *string)
1023 {
1024   struct expression *exp;
1025   exp = parse_exp_1 (&string, 0, 0);
1026   if (*string)
1027     error (_("Junk after end of expression."));
1028   return exp;
1029 }
1030
1031
1032 /* As for parse_expression, except that if VOID_CONTEXT_P, then
1033    no value is expected from the expression.  */
1034
1035 struct expression *
1036 parse_expression_in_context (char *string, int void_context_p)
1037 {
1038   struct expression *exp;
1039   exp = parse_exp_in_context (&string, 0, 0, void_context_p);
1040   if (*string != '\000')
1041     error (_("Junk after end of expression."));
1042   return exp;
1043 }
1044
1045 /* A post-parser that does nothing */
1046
1047 void
1048 null_post_parser (struct expression **exp, int void_context_p)
1049 {
1050 }
1051 \f
1052 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1053    probably useful for any language which declares its types "backwards".  */
1054
1055 static void
1056 check_type_stack_depth (void)
1057 {
1058   if (type_stack_depth == type_stack_size)
1059     {
1060       type_stack_size *= 2;
1061       type_stack = (union type_stack_elt *)
1062         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1063     }
1064 }
1065
1066 void
1067 push_type (enum type_pieces tp)
1068 {
1069   check_type_stack_depth ();
1070   type_stack[type_stack_depth++].piece = tp;
1071 }
1072
1073 void
1074 push_type_int (int n)
1075 {
1076   check_type_stack_depth ();
1077   type_stack[type_stack_depth++].int_val = n;
1078 }
1079
1080 void
1081 push_type_address_space (char *string)
1082 {
1083   push_type_int (address_space_name_to_int (string));
1084 }
1085
1086 enum type_pieces
1087 pop_type (void)
1088 {
1089   if (type_stack_depth)
1090     return type_stack[--type_stack_depth].piece;
1091   return tp_end;
1092 }
1093
1094 int
1095 pop_type_int (void)
1096 {
1097   if (type_stack_depth)
1098     return type_stack[--type_stack_depth].int_val;
1099   /* "Can't happen".  */
1100   return 0;
1101 }
1102
1103 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1104    as modified by all the stuff on the stack.  */
1105 struct type *
1106 follow_types (struct type *follow_type)
1107 {
1108   int done = 0;
1109   int make_const = 0;
1110   int make_volatile = 0;
1111   int make_addr_space = 0;
1112   int array_size;
1113   struct type *range_type;
1114
1115   while (!done)
1116     switch (pop_type ())
1117       {
1118       case tp_end:
1119         done = 1;
1120         if (make_const)
1121           follow_type = make_cv_type (make_const, 
1122                                       TYPE_VOLATILE (follow_type), 
1123                                       follow_type, 0);
1124         if (make_volatile)
1125           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1126                                       make_volatile, 
1127                                       follow_type, 0);
1128         if (make_addr_space)
1129           follow_type = make_type_with_address_space (follow_type, 
1130                                                       make_addr_space);
1131         make_const = make_volatile = 0;
1132         make_addr_space = 0;
1133         break;
1134       case tp_const:
1135         make_const = 1;
1136         break;
1137       case tp_volatile:
1138         make_volatile = 1;
1139         break;
1140       case tp_space_identifier:
1141         make_addr_space = pop_type_int ();
1142         break;
1143       case tp_pointer:
1144         follow_type = lookup_pointer_type (follow_type);
1145         if (make_const)
1146           follow_type = make_cv_type (make_const, 
1147                                       TYPE_VOLATILE (follow_type), 
1148                                       follow_type, 0);
1149         if (make_volatile)
1150           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1151                                       make_volatile, 
1152                                       follow_type, 0);
1153         if (make_addr_space)
1154           follow_type = make_type_with_address_space (follow_type, 
1155                                                       make_addr_space);
1156         make_const = make_volatile = 0;
1157         make_addr_space = 0;
1158         break;
1159       case tp_reference:
1160         follow_type = lookup_reference_type (follow_type);
1161         if (make_const)
1162           follow_type = make_cv_type (make_const, 
1163                                       TYPE_VOLATILE (follow_type), 
1164                                       follow_type, 0);
1165         if (make_volatile)
1166           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1167                                       make_volatile, 
1168                                       follow_type, 0);
1169         if (make_addr_space)
1170           follow_type = make_type_with_address_space (follow_type, 
1171                                                       make_addr_space);
1172         make_const = make_volatile = 0;
1173         make_addr_space = 0;
1174         break;
1175       case tp_array:
1176         array_size = pop_type_int ();
1177         /* FIXME-type-allocation: need a way to free this type when we are
1178            done with it.  */
1179         range_type =
1180           create_range_type ((struct type *) NULL,
1181                              builtin_type_int, 0,
1182                              array_size >= 0 ? array_size - 1 : 0);
1183         follow_type =
1184           create_array_type ((struct type *) NULL,
1185                              follow_type, range_type);
1186         if (array_size < 0)
1187           TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type)
1188             = BOUND_CANNOT_BE_DETERMINED;
1189         break;
1190       case tp_function:
1191         /* FIXME-type-allocation: need a way to free this type when we are
1192            done with it.  */
1193         follow_type = lookup_function_type (follow_type);
1194         break;
1195       }
1196   return follow_type;
1197 }
1198 \f
1199 /* This function avoids direct calls to fprintf 
1200    in the parser generated debug code.  */
1201 void
1202 parser_fprintf (FILE *x, const char *y, ...)
1203
1204   va_list args;
1205   va_start (args, y);
1206   if (x == stderr)
1207     vfprintf_unfiltered (gdb_stderr, y, args); 
1208   else
1209     {
1210       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1211       vfprintf_unfiltered (gdb_stderr, y, args);
1212     }
1213   va_end (args);
1214 }
1215
1216 void
1217 _initialize_parse (void)
1218 {
1219   type_stack_size = 80;
1220   type_stack_depth = 0;
1221   type_stack = (union type_stack_elt *)
1222     xmalloc (type_stack_size * sizeof (*type_stack));
1223
1224   add_setshow_zinteger_cmd ("expression", class_maintenance,
1225                             &expressiondebug, _("\
1226 Set expression debugging."), _("\
1227 Show expression debugging."), _("\
1228 When non-zero, the internal representation of expressions will be printed."),
1229                             NULL,
1230                             show_expressiondebug,
1231                             &setdebuglist, &showdebuglist);
1232 }