Add casts for legitimate integer to enum conversions
[external/binutils.git] / gdb / parse.c
1 /* Parse expressions for GDB.
2
3    Copyright (C) 1986-2015 Free Software Foundation, Inc.
4
5    Modified from expread.y by the Department of Computer Science at the
6    State University of New York at Buffalo, 1991.
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 /* Parse an expression from text in a string,
24    and return the result as a struct expression pointer.
25    That structure contains arithmetic operations in reverse polish,
26    with constants represented by operations that are followed by special data.
27    See expression.h for the details of the format.
28    What is important here is that it can be built up sequentially
29    during the process of parsing; the lower levels of the tree always
30    come first in the result.  */
31
32 #include "defs.h"
33 #include <ctype.h>
34 #include "arch-utils.h"
35 #include "symtab.h"
36 #include "gdbtypes.h"
37 #include "frame.h"
38 #include "expression.h"
39 #include "value.h"
40 #include "command.h"
41 #include "language.h"
42 #include "f-lang.h"
43 #include "parser-defs.h"
44 #include "gdbcmd.h"
45 #include "symfile.h"            /* for overlay functions */
46 #include "inferior.h"
47 #include "doublest.h"
48 #include "block.h"
49 #include "source.h"
50 #include "objfiles.h"
51 #include "user-regs.h"
52
53 /* Standard set of definitions for printing, dumping, prefixifying,
54  * and evaluating expressions.  */
55
56 const struct exp_descriptor exp_descriptor_standard = 
57   {
58     print_subexp_standard,
59     operator_length_standard,
60     operator_check_standard,
61     op_name_standard,
62     dump_subexp_body_standard,
63     evaluate_subexp_standard
64   };
65 \f
66 /* Global variables declared in parser-defs.h (and commented there).  */
67 const struct block *expression_context_block;
68 CORE_ADDR expression_context_pc;
69 const struct block *innermost_block;
70 int arglist_len;
71 static struct type_stack type_stack;
72 const char *lexptr;
73 const char *prev_lexptr;
74 int paren_depth;
75 int comma_terminates;
76
77 /* True if parsing an expression to attempt completion.  */
78 int parse_completion;
79
80 /* The index of the last struct expression directly before a '.' or
81    '->'.  This is set when parsing and is only used when completing a
82    field name.  It is -1 if no dereference operation was found.  */
83 static int expout_last_struct = -1;
84
85 /* If we are completing a tagged type name, this will be nonzero.  */
86 static enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
87
88 /* The token for tagged type name completion.  */
89 static char *expout_completion_name;
90
91 \f
92 static unsigned 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
101 /* Non-zero if an expression parser should set yydebug.  */
102 int parser_debug;
103
104 static void
105 show_parserdebug (struct ui_file *file, int from_tty,
106                   struct cmd_list_element *c, const char *value)
107 {
108   fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
109 }
110
111
112 static void free_funcalls (void *ignore);
113
114 static int prefixify_subexp (struct expression *, struct expression *, int,
115                              int);
116
117 static struct expression *parse_exp_in_context (const char **, CORE_ADDR,
118                                                 const struct block *, int, 
119                                                 int, int *);
120 static struct expression *parse_exp_in_context_1 (const char **, CORE_ADDR,
121                                                   const struct block *, int,
122                                                   int, int *);
123
124 void _initialize_parse (void);
125
126 /* Data structure for saving values of arglist_len for function calls whose
127    arguments contain other function calls.  */
128
129 struct funcall
130   {
131     struct funcall *next;
132     int arglist_len;
133   };
134
135 static struct funcall *funcall_chain;
136
137 /* Begin counting arguments for a function call,
138    saving the data about any containing call.  */
139
140 void
141 start_arglist (void)
142 {
143   struct funcall *newobj;
144
145   newobj = (struct funcall *) xmalloc (sizeof (struct funcall));
146   newobj->next = funcall_chain;
147   newobj->arglist_len = arglist_len;
148   arglist_len = 0;
149   funcall_chain = newobj;
150 }
151
152 /* Return the number of arguments in a function call just terminated,
153    and restore the data for the containing function call.  */
154
155 int
156 end_arglist (void)
157 {
158   int val = arglist_len;
159   struct funcall *call = funcall_chain;
160
161   funcall_chain = call->next;
162   arglist_len = call->arglist_len;
163   xfree (call);
164   return val;
165 }
166
167 /* Free everything in the funcall chain.
168    Used when there is an error inside parsing.  */
169
170 static void
171 free_funcalls (void *ignore)
172 {
173   struct funcall *call, *next;
174
175   for (call = funcall_chain; call; call = next)
176     {
177       next = call->next;
178       xfree (call);
179     }
180 }
181 \f
182
183 /* See definition in parser-defs.h.  */
184
185 void
186 initialize_expout (struct parser_state *ps, size_t initial_size,
187                    const struct language_defn *lang,
188                    struct gdbarch *gdbarch)
189 {
190   ps->expout_size = initial_size;
191   ps->expout_ptr = 0;
192   ps->expout = xmalloc (sizeof (struct expression)
193                         + EXP_ELEM_TO_BYTES (ps->expout_size));
194   ps->expout->language_defn = lang;
195   ps->expout->gdbarch = gdbarch;
196 }
197
198 /* See definition in parser-defs.h.  */
199
200 void
201 reallocate_expout (struct parser_state *ps)
202 {
203   /* Record the actual number of expression elements, and then
204      reallocate the expression memory so that we free up any
205      excess elements.  */
206
207   ps->expout->nelts = ps->expout_ptr;
208   ps->expout = (struct expression *)
209      xrealloc (ps->expout,
210                sizeof (struct expression)
211                + EXP_ELEM_TO_BYTES (ps->expout_ptr));
212 }
213
214 /* This page contains the functions for adding data to the struct expression
215    being constructed.  */
216
217 /* Add one element to the end of the expression.  */
218
219 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
220    a register through here.  */
221
222 static void
223 write_exp_elt (struct parser_state *ps, const union exp_element *expelt)
224 {
225   if (ps->expout_ptr >= ps->expout_size)
226     {
227       ps->expout_size *= 2;
228       ps->expout = (struct expression *)
229         xrealloc (ps->expout, sizeof (struct expression)
230                   + EXP_ELEM_TO_BYTES (ps->expout_size));
231     }
232   ps->expout->elts[ps->expout_ptr++] = *expelt;
233 }
234
235 void
236 write_exp_elt_opcode (struct parser_state *ps, enum exp_opcode expelt)
237 {
238   union exp_element tmp;
239
240   memset (&tmp, 0, sizeof (union exp_element));
241   tmp.opcode = expelt;
242   write_exp_elt (ps, &tmp);
243 }
244
245 void
246 write_exp_elt_sym (struct parser_state *ps, struct symbol *expelt)
247 {
248   union exp_element tmp;
249
250   memset (&tmp, 0, sizeof (union exp_element));
251   tmp.symbol = expelt;
252   write_exp_elt (ps, &tmp);
253 }
254
255 void
256 write_exp_elt_block (struct parser_state *ps, const struct block *b)
257 {
258   union exp_element tmp;
259
260   memset (&tmp, 0, sizeof (union exp_element));
261   tmp.block = b;
262   write_exp_elt (ps, &tmp);
263 }
264
265 void
266 write_exp_elt_objfile (struct parser_state *ps, struct objfile *objfile)
267 {
268   union exp_element tmp;
269
270   memset (&tmp, 0, sizeof (union exp_element));
271   tmp.objfile = objfile;
272   write_exp_elt (ps, &tmp);
273 }
274
275 void
276 write_exp_elt_longcst (struct parser_state *ps, LONGEST expelt)
277 {
278   union exp_element tmp;
279
280   memset (&tmp, 0, sizeof (union exp_element));
281   tmp.longconst = expelt;
282   write_exp_elt (ps, &tmp);
283 }
284
285 void
286 write_exp_elt_dblcst (struct parser_state *ps, DOUBLEST expelt)
287 {
288   union exp_element tmp;
289
290   memset (&tmp, 0, sizeof (union exp_element));
291   tmp.doubleconst = expelt;
292   write_exp_elt (ps, &tmp);
293 }
294
295 void
296 write_exp_elt_decfloatcst (struct parser_state *ps, gdb_byte expelt[16])
297 {
298   union exp_element tmp;
299   int index;
300
301   for (index = 0; index < 16; index++)
302     tmp.decfloatconst[index] = expelt[index];
303
304   write_exp_elt (ps, &tmp);
305 }
306
307 void
308 write_exp_elt_type (struct parser_state *ps, struct type *expelt)
309 {
310   union exp_element tmp;
311
312   memset (&tmp, 0, sizeof (union exp_element));
313   tmp.type = expelt;
314   write_exp_elt (ps, &tmp);
315 }
316
317 void
318 write_exp_elt_intern (struct parser_state *ps, struct internalvar *expelt)
319 {
320   union exp_element tmp;
321
322   memset (&tmp, 0, sizeof (union exp_element));
323   tmp.internalvar = expelt;
324   write_exp_elt (ps, &tmp);
325 }
326
327 /* Add a string constant to the end of the expression.
328
329    String constants are stored by first writing an expression element
330    that contains the length of the string, then stuffing the string
331    constant itself into however many expression elements are needed
332    to hold it, and then writing another expression element that contains
333    the length of the string.  I.e. an expression element at each end of
334    the string records the string length, so you can skip over the 
335    expression elements containing the actual string bytes from either
336    end of the string.  Note that this also allows gdb to handle
337    strings with embedded null bytes, as is required for some languages.
338
339    Don't be fooled by the fact that the string is null byte terminated,
340    this is strictly for the convenience of debugging gdb itself.
341    Gdb does not depend up the string being null terminated, since the
342    actual length is recorded in expression elements at each end of the
343    string.  The null byte is taken into consideration when computing how
344    many expression elements are required to hold the string constant, of
345    course.  */
346
347
348 void
349 write_exp_string (struct parser_state *ps, struct stoken str)
350 {
351   int len = str.length;
352   size_t lenelt;
353   char *strdata;
354
355   /* Compute the number of expression elements required to hold the string
356      (including a null byte terminator), along with one expression element
357      at each end to record the actual string length (not including the
358      null byte terminator).  */
359
360   lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
361
362   increase_expout_size (ps, lenelt);
363
364   /* Write the leading length expression element (which advances the current
365      expression element index), then write the string constant followed by a
366      terminating null byte, and then write the trailing length expression
367      element.  */
368
369   write_exp_elt_longcst (ps, (LONGEST) len);
370   strdata = (char *) &ps->expout->elts[ps->expout_ptr];
371   memcpy (strdata, str.ptr, len);
372   *(strdata + len) = '\0';
373   ps->expout_ptr += lenelt - 2;
374   write_exp_elt_longcst (ps, (LONGEST) len);
375 }
376
377 /* Add a vector of string constants to the end of the expression.
378
379    This adds an OP_STRING operation, but encodes the contents
380    differently from write_exp_string.  The language is expected to
381    handle evaluation of this expression itself.
382    
383    After the usual OP_STRING header, TYPE is written into the
384    expression as a long constant.  The interpretation of this field is
385    up to the language evaluator.
386    
387    Next, each string in VEC is written.  The length is written as a
388    long constant, followed by the contents of the string.  */
389
390 void
391 write_exp_string_vector (struct parser_state *ps, int type,
392                          struct stoken_vector *vec)
393 {
394   int i, len;
395   size_t n_slots;
396
397   /* Compute the size.  We compute the size in number of slots to
398      avoid issues with string padding.  */
399   n_slots = 0;
400   for (i = 0; i < vec->len; ++i)
401     {
402       /* One slot for the length of this element, plus the number of
403          slots needed for this string.  */
404       n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
405     }
406
407   /* One more slot for the type of the string.  */
408   ++n_slots;
409
410   /* Now compute a phony string length.  */
411   len = EXP_ELEM_TO_BYTES (n_slots) - 1;
412
413   n_slots += 4;
414   increase_expout_size (ps, n_slots);
415
416   write_exp_elt_opcode (ps, OP_STRING);
417   write_exp_elt_longcst (ps, len);
418   write_exp_elt_longcst (ps, type);
419
420   for (i = 0; i < vec->len; ++i)
421     {
422       write_exp_elt_longcst (ps, vec->tokens[i].length);
423       memcpy (&ps->expout->elts[ps->expout_ptr], vec->tokens[i].ptr,
424               vec->tokens[i].length);
425       ps->expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
426     }
427
428   write_exp_elt_longcst (ps, len);
429   write_exp_elt_opcode (ps, OP_STRING);
430 }
431
432 /* Add a bitstring constant to the end of the expression.
433
434    Bitstring constants are stored by first writing an expression element
435    that contains the length of the bitstring (in bits), then stuffing the
436    bitstring constant itself into however many expression elements are
437    needed to hold it, and then writing another expression element that
438    contains the length of the bitstring.  I.e. an expression element at
439    each end of the bitstring records the bitstring length, so you can skip
440    over the expression elements containing the actual bitstring bytes from
441    either end of the bitstring.  */
442
443 void
444 write_exp_bitstring (struct parser_state *ps, struct stoken str)
445 {
446   int bits = str.length;        /* length in bits */
447   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
448   size_t lenelt;
449   char *strdata;
450
451   /* Compute the number of expression elements required to hold the bitstring,
452      along with one expression element at each end to record the actual
453      bitstring length in bits.  */
454
455   lenelt = 2 + BYTES_TO_EXP_ELEM (len);
456
457   increase_expout_size (ps, lenelt);
458
459   /* Write the leading length expression element (which advances the current
460      expression element index), then write the bitstring constant, and then
461      write the trailing length expression element.  */
462
463   write_exp_elt_longcst (ps, (LONGEST) bits);
464   strdata = (char *) &ps->expout->elts[ps->expout_ptr];
465   memcpy (strdata, str.ptr, len);
466   ps->expout_ptr += lenelt - 2;
467   write_exp_elt_longcst (ps, (LONGEST) bits);
468 }
469
470 /* Add the appropriate elements for a minimal symbol to the end of
471    the expression.  */
472
473 void
474 write_exp_msymbol (struct parser_state *ps,
475                    struct bound_minimal_symbol bound_msym)
476 {
477   struct minimal_symbol *msymbol = bound_msym.minsym;
478   struct objfile *objfile = bound_msym.objfile;
479   struct gdbarch *gdbarch = get_objfile_arch (objfile);
480
481   CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
482   struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
483   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
484   CORE_ADDR pc;
485
486   /* The minimal symbol might point to a function descriptor;
487      resolve it to the actual code address instead.  */
488   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
489   if (pc != addr)
490     {
491       struct bound_minimal_symbol ifunc_msym = lookup_minimal_symbol_by_pc (pc);
492
493       /* In this case, assume we have a code symbol instead of
494          a data symbol.  */
495
496       if (ifunc_msym.minsym != NULL
497           && MSYMBOL_TYPE (ifunc_msym.minsym) == mst_text_gnu_ifunc
498           && BMSYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
499         {
500           /* A function descriptor has been resolved but PC is still in the
501              STT_GNU_IFUNC resolver body (such as because inferior does not
502              run to be able to call it).  */
503
504           type = mst_text_gnu_ifunc;
505         }
506       else
507         type = mst_text;
508       section = NULL;
509       addr = pc;
510     }
511
512   if (overlay_debugging)
513     addr = symbol_overlayed_address (addr, section);
514
515   write_exp_elt_opcode (ps, OP_LONG);
516   /* Let's make the type big enough to hold a 64-bit address.  */
517   write_exp_elt_type (ps, objfile_type (objfile)->builtin_core_addr);
518   write_exp_elt_longcst (ps, (LONGEST) addr);
519   write_exp_elt_opcode (ps, OP_LONG);
520
521   if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
522     {
523       write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS);
524       write_exp_elt_objfile (ps, objfile);
525       write_exp_elt_type (ps, objfile_type (objfile)->nodebug_tls_symbol);
526       write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS);
527       return;
528     }
529
530   write_exp_elt_opcode (ps, UNOP_MEMVAL);
531   switch (type)
532     {
533     case mst_text:
534     case mst_file_text:
535     case mst_solib_trampoline:
536       write_exp_elt_type (ps, objfile_type (objfile)->nodebug_text_symbol);
537       break;
538
539     case mst_text_gnu_ifunc:
540       write_exp_elt_type (ps, objfile_type (objfile)
541                           ->nodebug_text_gnu_ifunc_symbol);
542       break;
543
544     case mst_data:
545     case mst_file_data:
546     case mst_bss:
547     case mst_file_bss:
548       write_exp_elt_type (ps, objfile_type (objfile)->nodebug_data_symbol);
549       break;
550
551     case mst_slot_got_plt:
552       write_exp_elt_type (ps, objfile_type (objfile)->nodebug_got_plt_symbol);
553       break;
554
555     default:
556       write_exp_elt_type (ps, objfile_type (objfile)->nodebug_unknown_symbol);
557       break;
558     }
559   write_exp_elt_opcode (ps, UNOP_MEMVAL);
560 }
561
562 /* Mark the current index as the starting location of a structure
563    expression.  This is used when completing on field names.  */
564
565 void
566 mark_struct_expression (struct parser_state *ps)
567 {
568   gdb_assert (parse_completion
569               && expout_tag_completion_type == TYPE_CODE_UNDEF);
570   expout_last_struct = ps->expout_ptr;
571 }
572
573 /* Indicate that the current parser invocation is completing a tag.
574    TAG is the type code of the tag, and PTR and LENGTH represent the
575    start of the tag name.  */
576
577 void
578 mark_completion_tag (enum type_code tag, const char *ptr, int length)
579 {
580   gdb_assert (parse_completion
581               && expout_tag_completion_type == TYPE_CODE_UNDEF
582               && expout_completion_name == NULL
583               && expout_last_struct == -1);
584   gdb_assert (tag == TYPE_CODE_UNION
585               || tag == TYPE_CODE_STRUCT
586               || tag == TYPE_CODE_ENUM);
587   expout_tag_completion_type = tag;
588   expout_completion_name = xmalloc (length + 1);
589   memcpy (expout_completion_name, ptr, length);
590   expout_completion_name[length] = '\0';
591 }
592
593 \f
594 /* Recognize tokens that start with '$'.  These include:
595
596    $regname     A native register name or a "standard
597    register name".
598
599    $variable    A convenience variable with a name chosen
600    by the user.
601
602    $digits              Value history with index <digits>, starting
603    from the first value which has index 1.
604
605    $$digits     Value history with index <digits> relative
606    to the last value.  I.e. $$0 is the last
607    value, $$1 is the one previous to that, $$2
608    is the one previous to $$1, etc.
609
610    $ | $0 | $$0 The last value in the value history.
611
612    $$           An abbreviation for the second to the last
613    value in the value history, I.e. $$1  */
614
615 void
616 write_dollar_variable (struct parser_state *ps, struct stoken str)
617 {
618   struct block_symbol sym;
619   struct bound_minimal_symbol msym;
620   struct internalvar *isym = NULL;
621
622   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
623      and $$digits (equivalent to $<-digits> if you could type that).  */
624
625   int negate = 0;
626   int i = 1;
627   /* Double dollar means negate the number and add -1 as well.
628      Thus $$ alone means -1.  */
629   if (str.length >= 2 && str.ptr[1] == '$')
630     {
631       negate = 1;
632       i = 2;
633     }
634   if (i == str.length)
635     {
636       /* Just dollars (one or two).  */
637       i = -negate;
638       goto handle_last;
639     }
640   /* Is the rest of the token digits?  */
641   for (; i < str.length; i++)
642     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
643       break;
644   if (i == str.length)
645     {
646       i = atoi (str.ptr + 1 + negate);
647       if (negate)
648         i = -i;
649       goto handle_last;
650     }
651
652   /* Handle tokens that refer to machine registers:
653      $ followed by a register name.  */
654   i = user_reg_map_name_to_regnum (parse_gdbarch (ps),
655                                    str.ptr + 1, str.length - 1);
656   if (i >= 0)
657     goto handle_register;
658
659   /* Any names starting with $ are probably debugger internal variables.  */
660
661   isym = lookup_only_internalvar (copy_name (str) + 1);
662   if (isym)
663     {
664       write_exp_elt_opcode (ps, OP_INTERNALVAR);
665       write_exp_elt_intern (ps, isym);
666       write_exp_elt_opcode (ps, OP_INTERNALVAR);
667       return;
668     }
669
670   /* On some systems, such as HP-UX and hppa-linux, certain system routines 
671      have names beginning with $ or $$.  Check for those, first.  */
672
673   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
674                        VAR_DOMAIN, NULL);
675   if (sym.symbol)
676     {
677       write_exp_elt_opcode (ps, OP_VAR_VALUE);
678       write_exp_elt_block (ps, sym.block);
679       write_exp_elt_sym (ps, sym.symbol);
680       write_exp_elt_opcode (ps, OP_VAR_VALUE);
681       return;
682     }
683   msym = lookup_bound_minimal_symbol (copy_name (str));
684   if (msym.minsym)
685     {
686       write_exp_msymbol (ps, msym);
687       return;
688     }
689
690   /* Any other names are assumed to be debugger internal variables.  */
691
692   write_exp_elt_opcode (ps, OP_INTERNALVAR);
693   write_exp_elt_intern (ps, create_internalvar (copy_name (str) + 1));
694   write_exp_elt_opcode (ps, OP_INTERNALVAR);
695   return;
696 handle_last:
697   write_exp_elt_opcode (ps, OP_LAST);
698   write_exp_elt_longcst (ps, (LONGEST) i);
699   write_exp_elt_opcode (ps, OP_LAST);
700   return;
701 handle_register:
702   write_exp_elt_opcode (ps, OP_REGISTER);
703   str.length--;
704   str.ptr++;
705   write_exp_string (ps, str);
706   write_exp_elt_opcode (ps, OP_REGISTER);
707   return;
708 }
709
710
711 const char *
712 find_template_name_end (const char *p)
713 {
714   int depth = 1;
715   int just_seen_right = 0;
716   int just_seen_colon = 0;
717   int just_seen_space = 0;
718
719   if (!p || (*p != '<'))
720     return 0;
721
722   while (*++p)
723     {
724       switch (*p)
725         {
726         case '\'':
727         case '\"':
728         case '{':
729         case '}':
730           /* In future, may want to allow these??  */
731           return 0;
732         case '<':
733           depth++;              /* start nested template */
734           if (just_seen_colon || just_seen_right || just_seen_space)
735             return 0;           /* but not after : or :: or > or space */
736           break;
737         case '>':
738           if (just_seen_colon || just_seen_right)
739             return 0;           /* end a (nested?) template */
740           just_seen_right = 1;  /* but not after : or :: */
741           if (--depth == 0)     /* also disallow >>, insist on > > */
742             return ++p;         /* if outermost ended, return */
743           break;
744         case ':':
745           if (just_seen_space || (just_seen_colon > 1))
746             return 0;           /* nested class spec coming up */
747           just_seen_colon++;    /* we allow :: but not :::: */
748           break;
749         case ' ':
750           break;
751         default:
752           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
753                 (*p >= 'A' && *p <= 'Z') ||
754                 (*p >= '0' && *p <= '9') ||
755                 (*p == '_') || (*p == ',') ||   /* commas for template args */
756                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
757                 (*p == '(') || (*p == ')') ||   /* function types */
758                 (*p == '[') || (*p == ']')))    /* array types */
759             return 0;
760         }
761       if (*p != ' ')
762         just_seen_space = 0;
763       if (*p != ':')
764         just_seen_colon = 0;
765       if (*p != '>')
766         just_seen_right = 0;
767     }
768   return 0;
769 }
770 \f
771
772 /* Return a null-terminated temporary copy of the name of a string token.
773
774    Tokens that refer to names do so with explicit pointer and length,
775    so they can share the storage that lexptr is parsing.
776    When it is necessary to pass a name to a function that expects
777    a null-terminated string, the substring is copied out
778    into a separate block of storage.
779
780    N.B. A single buffer is reused on each call.  */
781
782 char *
783 copy_name (struct stoken token)
784 {
785   /* A temporary buffer for identifiers, so we can null-terminate them.
786      We allocate this with xrealloc.  parse_exp_1 used to allocate with
787      alloca, using the size of the whole expression as a conservative
788      estimate of the space needed.  However, macro expansion can
789      introduce names longer than the original expression; there's no
790      practical way to know beforehand how large that might be.  */
791   static char *namecopy;
792   static size_t namecopy_size;
793
794   /* Make sure there's enough space for the token.  */
795   if (namecopy_size < token.length + 1)
796     {
797       namecopy_size = token.length + 1;
798       namecopy = xrealloc (namecopy, token.length + 1);
799     }
800       
801   memcpy (namecopy, token.ptr, token.length);
802   namecopy[token.length] = 0;
803
804   return namecopy;
805 }
806 \f
807
808 /* See comments on parser-defs.h.  */
809
810 int
811 prefixify_expression (struct expression *expr)
812 {
813   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
814   struct expression *temp;
815   int inpos = expr->nelts, outpos = 0;
816
817   temp = (struct expression *) alloca (len);
818
819   /* Copy the original expression into temp.  */
820   memcpy (temp, expr, len);
821
822   return prefixify_subexp (temp, expr, inpos, outpos);
823 }
824
825 /* Return the number of exp_elements in the postfix subexpression 
826    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
827
828 int
829 length_of_subexp (struct expression *expr, int endpos)
830 {
831   int oplen, args;
832
833   operator_length (expr, endpos, &oplen, &args);
834
835   while (args > 0)
836     {
837       oplen += length_of_subexp (expr, endpos - oplen);
838       args--;
839     }
840
841   return oplen;
842 }
843
844 /* Sets *OPLENP to the length of the operator whose (last) index is 
845    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
846    operator takes.  */
847
848 void
849 operator_length (const struct expression *expr, int endpos, int *oplenp,
850                  int *argsp)
851 {
852   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
853                                                      oplenp, argsp);
854 }
855
856 /* Default value for operator_length in exp_descriptor vectors.  */
857
858 void
859 operator_length_standard (const struct expression *expr, int endpos,
860                           int *oplenp, int *argsp)
861 {
862   int oplen = 1;
863   int args = 0;
864   enum f90_range_type range_type;
865   int i;
866
867   if (endpos < 1)
868     error (_("?error in operator_length_standard"));
869
870   i = (int) expr->elts[endpos - 1].opcode;
871
872   switch (i)
873     {
874       /* C++  */
875     case OP_SCOPE:
876       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
877       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
878       break;
879
880     case OP_LONG:
881     case OP_DOUBLE:
882     case OP_DECFLOAT:
883     case OP_VAR_VALUE:
884       oplen = 4;
885       break;
886
887     case OP_TYPE:
888     case OP_BOOL:
889     case OP_LAST:
890     case OP_INTERNALVAR:
891     case OP_VAR_ENTRY_VALUE:
892       oplen = 3;
893       break;
894
895     case OP_COMPLEX:
896       oplen = 3;
897       args = 2;
898       break;
899
900     case OP_FUNCALL:
901     case OP_F77_UNDETERMINED_ARGLIST:
902       oplen = 3;
903       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
904       break;
905
906     case TYPE_INSTANCE:
907       oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
908       args = 1;
909       break;
910
911     case OP_OBJC_MSGCALL:       /* Objective C message (method) call.  */
912       oplen = 4;
913       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
914       break;
915
916     case UNOP_MAX:
917     case UNOP_MIN:
918       oplen = 3;
919       break;
920
921     case UNOP_CAST_TYPE:
922     case UNOP_DYNAMIC_CAST:
923     case UNOP_REINTERPRET_CAST:
924     case UNOP_MEMVAL_TYPE:
925       oplen = 1;
926       args = 2;
927       break;
928
929     case BINOP_VAL:
930     case UNOP_CAST:
931     case UNOP_MEMVAL:
932       oplen = 3;
933       args = 1;
934       break;
935
936     case UNOP_MEMVAL_TLS:
937       oplen = 4;
938       args = 1;
939       break;
940
941     case UNOP_ABS:
942     case UNOP_CAP:
943     case UNOP_CHR:
944     case UNOP_FLOAT:
945     case UNOP_HIGH:
946     case UNOP_ODD:
947     case UNOP_ORD:
948     case UNOP_TRUNC:
949     case OP_TYPEOF:
950     case OP_DECLTYPE:
951     case OP_TYPEID:
952       oplen = 1;
953       args = 1;
954       break;
955
956     case OP_ADL_FUNC:
957       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
958       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
959       oplen++;
960       oplen++;
961       break;
962
963     case STRUCTOP_STRUCT:
964     case STRUCTOP_PTR:
965       args = 1;
966       /* fall through */
967     case OP_REGISTER:
968     case OP_M2_STRING:
969     case OP_STRING:
970     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class
971                                    NSString constant.  */
972     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op.  */
973     case OP_NAME:
974       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
975       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
976       break;
977
978     case OP_ARRAY:
979       oplen = 4;
980       args = longest_to_int (expr->elts[endpos - 2].longconst);
981       args -= longest_to_int (expr->elts[endpos - 3].longconst);
982       args += 1;
983       break;
984
985     case TERNOP_COND:
986     case TERNOP_SLICE:
987       args = 3;
988       break;
989
990       /* Modula-2 */
991     case MULTI_SUBSCRIPT:
992       oplen = 3;
993       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
994       break;
995
996     case BINOP_ASSIGN_MODIFY:
997       oplen = 3;
998       args = 2;
999       break;
1000
1001       /* C++ */
1002     case OP_THIS:
1003       oplen = 2;
1004       break;
1005
1006     case OP_F90_RANGE:
1007       oplen = 3;
1008       range_type = (enum f90_range_type)
1009         longest_to_int (expr->elts[endpos - 2].longconst);
1010
1011       switch (range_type)
1012         {
1013         case LOW_BOUND_DEFAULT:
1014         case HIGH_BOUND_DEFAULT:
1015           args = 1;
1016           break;
1017         case BOTH_BOUND_DEFAULT:
1018           args = 0;
1019           break;
1020         case NONE_BOUND_DEFAULT:
1021           args = 2;
1022           break;
1023         }
1024
1025       break;
1026
1027     default:
1028       args = 1 + (i < (int) BINOP_END);
1029     }
1030
1031   *oplenp = oplen;
1032   *argsp = args;
1033 }
1034
1035 /* Copy the subexpression ending just before index INEND in INEXPR
1036    into OUTEXPR, starting at index OUTBEG.
1037    In the process, convert it from suffix to prefix form.
1038    If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1039    Otherwise, it returns the index of the subexpression which is the
1040    left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
1041
1042 static int
1043 prefixify_subexp (struct expression *inexpr,
1044                   struct expression *outexpr, int inend, int outbeg)
1045 {
1046   int oplen;
1047   int args;
1048   int i;
1049   int *arglens;
1050   int result = -1;
1051
1052   operator_length (inexpr, inend, &oplen, &args);
1053
1054   /* Copy the final operator itself, from the end of the input
1055      to the beginning of the output.  */
1056   inend -= oplen;
1057   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1058           EXP_ELEM_TO_BYTES (oplen));
1059   outbeg += oplen;
1060
1061   if (expout_last_struct == inend)
1062     result = outbeg - oplen;
1063
1064   /* Find the lengths of the arg subexpressions.  */
1065   arglens = (int *) alloca (args * sizeof (int));
1066   for (i = args - 1; i >= 0; i--)
1067     {
1068       oplen = length_of_subexp (inexpr, inend);
1069       arglens[i] = oplen;
1070       inend -= oplen;
1071     }
1072
1073   /* Now copy each subexpression, preserving the order of
1074      the subexpressions, but prefixifying each one.
1075      In this loop, inend starts at the beginning of
1076      the expression this level is working on
1077      and marches forward over the arguments.
1078      outbeg does similarly in the output.  */
1079   for (i = 0; i < args; i++)
1080     {
1081       int r;
1082
1083       oplen = arglens[i];
1084       inend += oplen;
1085       r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1086       if (r != -1)
1087         {
1088           /* Return immediately.  We probably have only parsed a
1089              partial expression, so we don't want to try to reverse
1090              the other operands.  */
1091           return r;
1092         }
1093       outbeg += oplen;
1094     }
1095
1096   return result;
1097 }
1098 \f
1099 /* Read an expression from the string *STRINGPTR points to,
1100    parse it, and return a pointer to a struct expression that we malloc.
1101    Use block BLOCK as the lexical context for variable names;
1102    if BLOCK is zero, use the block of the selected stack frame.
1103    Meanwhile, advance *STRINGPTR to point after the expression,
1104    at the first nonwhite character that is not part of the expression
1105    (possibly a null character).
1106
1107    If COMMA is nonzero, stop if a comma is reached.  */
1108
1109 struct expression *
1110 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
1111              int comma)
1112 {
1113   return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
1114 }
1115
1116 static struct expression *
1117 parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
1118                       const struct block *block,
1119                       int comma, int void_context_p, int *out_subexp)
1120 {
1121   return parse_exp_in_context_1 (stringptr, pc, block, comma,
1122                                  void_context_p, out_subexp);
1123 }
1124
1125 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1126    no value is expected from the expression.
1127    OUT_SUBEXP is set when attempting to complete a field name; in this
1128    case it is set to the index of the subexpression on the
1129    left-hand-side of the struct op.  If not doing such completion, it
1130    is left untouched.  */
1131
1132 static struct expression *
1133 parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
1134                         const struct block *block,
1135                         int comma, int void_context_p, int *out_subexp)
1136 {
1137   struct cleanup *old_chain, *inner_chain;
1138   const struct language_defn *lang = NULL;
1139   struct parser_state ps;
1140   int subexp;
1141
1142   lexptr = *stringptr;
1143   prev_lexptr = NULL;
1144
1145   paren_depth = 0;
1146   type_stack.depth = 0;
1147   expout_last_struct = -1;
1148   expout_tag_completion_type = TYPE_CODE_UNDEF;
1149   xfree (expout_completion_name);
1150   expout_completion_name = NULL;
1151
1152   comma_terminates = comma;
1153
1154   if (lexptr == 0 || *lexptr == 0)
1155     error_no_arg (_("expression to compute"));
1156
1157   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1158   funcall_chain = 0;
1159
1160   expression_context_block = block;
1161
1162   /* If no context specified, try using the current frame, if any.  */
1163   if (!expression_context_block)
1164     expression_context_block = get_selected_block (&expression_context_pc);
1165   else if (pc == 0)
1166     expression_context_pc = BLOCK_START (expression_context_block);
1167   else
1168     expression_context_pc = pc;
1169
1170   /* Fall back to using the current source static context, if any.  */
1171
1172   if (!expression_context_block)
1173     {
1174       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1175       if (cursal.symtab)
1176         expression_context_block
1177           = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
1178                                STATIC_BLOCK);
1179       if (expression_context_block)
1180         expression_context_pc = BLOCK_START (expression_context_block);
1181     }
1182
1183   if (language_mode == language_mode_auto && block != NULL)
1184     {
1185       /* Find the language associated to the given context block.
1186          Default to the current language if it can not be determined.
1187
1188          Note that using the language corresponding to the current frame
1189          can sometimes give unexpected results.  For instance, this
1190          routine is often called several times during the inferior
1191          startup phase to re-parse breakpoint expressions after
1192          a new shared library has been loaded.  The language associated
1193          to the current frame at this moment is not relevant for
1194          the breakpoint.  Using it would therefore be silly, so it seems
1195          better to rely on the current language rather than relying on
1196          the current frame language to parse the expression.  That's why
1197          we do the following language detection only if the context block
1198          has been specifically provided.  */
1199       struct symbol *func = block_linkage_function (block);
1200
1201       if (func != NULL)
1202         lang = language_def (SYMBOL_LANGUAGE (func));
1203       if (lang == NULL || lang->la_language == language_unknown)
1204         lang = current_language;
1205     }
1206   else
1207     lang = current_language;
1208
1209   /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1210      While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1211      and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1212      to the value matching SELECTED_FRAME as set by get_current_arch.  */
1213
1214   initialize_expout (&ps, 10, lang, get_current_arch ());
1215   inner_chain = make_cleanup_restore_current_language ();
1216   set_language (lang->la_language);
1217
1218   TRY
1219     {
1220       if (lang->la_parser (&ps))
1221         lang->la_error (NULL);
1222     }
1223   CATCH (except, RETURN_MASK_ALL)
1224     {
1225       if (! parse_completion)
1226         {
1227           xfree (ps.expout);
1228           throw_exception (except);
1229         }
1230     }
1231   END_CATCH
1232
1233   reallocate_expout (&ps);
1234
1235   /* Convert expression from postfix form as generated by yacc
1236      parser, to a prefix form.  */
1237
1238   if (expressiondebug)
1239     dump_raw_expression (ps.expout, gdb_stdlog,
1240                          "before conversion to prefix form");
1241
1242   subexp = prefixify_expression (ps.expout);
1243   if (out_subexp)
1244     *out_subexp = subexp;
1245
1246   lang->la_post_parser (&ps.expout, void_context_p);
1247
1248   if (expressiondebug)
1249     dump_prefix_expression (ps.expout, gdb_stdlog);
1250
1251   do_cleanups (inner_chain);
1252   discard_cleanups (old_chain);
1253
1254   *stringptr = lexptr;
1255   return ps.expout;
1256 }
1257
1258 /* Parse STRING as an expression, and complain if this fails
1259    to use up all of the contents of STRING.  */
1260
1261 struct expression *
1262 parse_expression (const char *string)
1263 {
1264   struct expression *exp;
1265
1266   exp = parse_exp_1 (&string, 0, 0, 0);
1267   if (*string)
1268     error (_("Junk after end of expression."));
1269   return exp;
1270 }
1271
1272 /* Same as parse_expression, but using the given language (LANG)
1273    to parse the expression.  */
1274
1275 struct expression *
1276 parse_expression_with_language (const char *string, enum language lang)
1277 {
1278   struct cleanup *old_chain = NULL;
1279   struct expression *expr;
1280
1281   if (current_language->la_language != lang)
1282     {
1283       old_chain = make_cleanup_restore_current_language ();
1284       set_language (lang);
1285     }
1286
1287   expr = parse_expression (string);
1288
1289   if (old_chain != NULL)
1290     do_cleanups (old_chain);
1291   return expr;
1292 }
1293
1294 /* Parse STRING as an expression.  If parsing ends in the middle of a
1295    field reference, return the type of the left-hand-side of the
1296    reference; furthermore, if the parsing ends in the field name,
1297    return the field name in *NAME.  If the parsing ends in the middle
1298    of a field reference, but the reference is somehow invalid, throw
1299    an exception.  In all other cases, return NULL.  Returned non-NULL
1300    *NAME must be freed by the caller.  */
1301
1302 struct type *
1303 parse_expression_for_completion (const char *string, char **name,
1304                                  enum type_code *code)
1305 {
1306   struct expression *exp = NULL;
1307   struct value *val;
1308   int subexp;
1309
1310   TRY
1311     {
1312       parse_completion = 1;
1313       exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
1314     }
1315   CATCH (except, RETURN_MASK_ERROR)
1316     {
1317       /* Nothing, EXP remains NULL.  */
1318     }
1319   END_CATCH
1320
1321   parse_completion = 0;
1322   if (exp == NULL)
1323     return NULL;
1324
1325   if (expout_tag_completion_type != TYPE_CODE_UNDEF)
1326     {
1327       *code = expout_tag_completion_type;
1328       *name = expout_completion_name;
1329       expout_completion_name = NULL;
1330       return NULL;
1331     }
1332
1333   if (expout_last_struct == -1)
1334     {
1335       xfree (exp);
1336       return NULL;
1337     }
1338
1339   *name = extract_field_op (exp, &subexp);
1340   if (!*name)
1341     {
1342       xfree (exp);
1343       return NULL;
1344     }
1345
1346   /* This might throw an exception.  If so, we want to let it
1347      propagate.  */
1348   val = evaluate_subexpression_type (exp, subexp);
1349   /* (*NAME) is a part of the EXP memory block freed below.  */
1350   *name = xstrdup (*name);
1351   xfree (exp);
1352
1353   return value_type (val);
1354 }
1355
1356 /* A post-parser that does nothing.  */
1357
1358 void
1359 null_post_parser (struct expression **exp, int void_context_p)
1360 {
1361 }
1362
1363 /* Parse floating point value P of length LEN.
1364    Return 0 (false) if invalid, 1 (true) if valid.
1365    The successfully parsed number is stored in D.
1366    *SUFFIX points to the suffix of the number in P.
1367
1368    NOTE: This accepts the floating point syntax that sscanf accepts.  */
1369
1370 int
1371 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1372 {
1373   char *copy;
1374   int n, num;
1375
1376   copy = xmalloc (len + 1);
1377   memcpy (copy, p, len);
1378   copy[len] = 0;
1379
1380   num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1381   xfree (copy);
1382
1383   /* The sscanf man page suggests not making any assumptions on the effect
1384      of %n on the result, so we don't.
1385      That is why we simply test num == 0.  */
1386   if (num == 0)
1387     return 0;
1388
1389   *suffix = p + n;
1390   return 1;
1391 }
1392
1393 /* Parse floating point value P of length LEN, using the C syntax for floats.
1394    Return 0 (false) if invalid, 1 (true) if valid.
1395    The successfully parsed number is stored in *D.
1396    Its type is taken from builtin_type (gdbarch) and is stored in *T.  */
1397
1398 int
1399 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1400                DOUBLEST *d, struct type **t)
1401 {
1402   const char *suffix;
1403   int suffix_len;
1404   const struct builtin_type *builtin_types = builtin_type (gdbarch);
1405
1406   if (! parse_float (p, len, d, &suffix))
1407     return 0;
1408
1409   suffix_len = p + len - suffix;
1410
1411   if (suffix_len == 0)
1412     *t = builtin_types->builtin_double;
1413   else if (suffix_len == 1)
1414     {
1415       /* Handle suffixes: 'f' for float, 'l' for long double.  */
1416       if (tolower (*suffix) == 'f')
1417         *t = builtin_types->builtin_float;
1418       else if (tolower (*suffix) == 'l')
1419         *t = builtin_types->builtin_long_double;
1420       else
1421         return 0;
1422     }
1423   else
1424     return 0;
1425
1426   return 1;
1427 }
1428 \f
1429 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1430    probably useful for any language which declares its types "backwards".  */
1431
1432 /* Ensure that there are HOWMUCH open slots on the type stack STACK.  */
1433
1434 static void
1435 type_stack_reserve (struct type_stack *stack, int howmuch)
1436 {
1437   if (stack->depth + howmuch >= stack->size)
1438     {
1439       stack->size *= 2;
1440       if (stack->size < howmuch)
1441         stack->size = howmuch;
1442       stack->elements = xrealloc (stack->elements,
1443                                   stack->size * sizeof (union type_stack_elt));
1444     }
1445 }
1446
1447 /* Ensure that there is a single open slot in the global type stack.  */
1448
1449 static void
1450 check_type_stack_depth (void)
1451 {
1452   type_stack_reserve (&type_stack, 1);
1453 }
1454
1455 /* A helper function for insert_type and insert_type_address_space.
1456    This does work of expanding the type stack and inserting the new
1457    element, ELEMENT, into the stack at location SLOT.  */
1458
1459 static void
1460 insert_into_type_stack (int slot, union type_stack_elt element)
1461 {
1462   check_type_stack_depth ();
1463
1464   if (slot < type_stack.depth)
1465     memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
1466              (type_stack.depth - slot) * sizeof (union type_stack_elt));
1467   type_stack.elements[slot] = element;
1468   ++type_stack.depth;
1469 }
1470
1471 /* Insert a new type, TP, at the bottom of the type stack.  If TP is
1472    tp_pointer or tp_reference, it is inserted at the bottom.  If TP is
1473    a qualifier, it is inserted at slot 1 (just above a previous
1474    tp_pointer) if there is anything on the stack, or simply pushed if
1475    the stack is empty.  Other values for TP are invalid.  */
1476
1477 void
1478 insert_type (enum type_pieces tp)
1479 {
1480   union type_stack_elt element;
1481   int slot;
1482
1483   gdb_assert (tp == tp_pointer || tp == tp_reference
1484               || tp == tp_const || tp == tp_volatile);
1485
1486   /* If there is anything on the stack (we know it will be a
1487      tp_pointer), insert the qualifier above it.  Otherwise, simply
1488      push this on the top of the stack.  */
1489   if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
1490     slot = 1;
1491   else
1492     slot = 0;
1493
1494   element.piece = tp;
1495   insert_into_type_stack (slot, element);
1496 }
1497
1498 void
1499 push_type (enum type_pieces tp)
1500 {
1501   check_type_stack_depth ();
1502   type_stack.elements[type_stack.depth++].piece = tp;
1503 }
1504
1505 void
1506 push_type_int (int n)
1507 {
1508   check_type_stack_depth ();
1509   type_stack.elements[type_stack.depth++].int_val = n;
1510 }
1511
1512 /* Insert a tp_space_identifier and the corresponding address space
1513    value into the stack.  STRING is the name of an address space, as
1514    recognized by address_space_name_to_int.  If the stack is empty,
1515    the new elements are simply pushed.  If the stack is not empty,
1516    this function assumes that the first item on the stack is a
1517    tp_pointer, and the new values are inserted above the first
1518    item.  */
1519
1520 void
1521 insert_type_address_space (struct parser_state *pstate, char *string)
1522 {
1523   union type_stack_elt element;
1524   int slot;
1525
1526   /* If there is anything on the stack (we know it will be a
1527      tp_pointer), insert the address space qualifier above it.
1528      Otherwise, simply push this on the top of the stack.  */
1529   if (type_stack.depth)
1530     slot = 1;
1531   else
1532     slot = 0;
1533
1534   element.piece = tp_space_identifier;
1535   insert_into_type_stack (slot, element);
1536   element.int_val = address_space_name_to_int (parse_gdbarch (pstate),
1537                                                string);
1538   insert_into_type_stack (slot, element);
1539 }
1540
1541 enum type_pieces
1542 pop_type (void)
1543 {
1544   if (type_stack.depth)
1545     return type_stack.elements[--type_stack.depth].piece;
1546   return tp_end;
1547 }
1548
1549 int
1550 pop_type_int (void)
1551 {
1552   if (type_stack.depth)
1553     return type_stack.elements[--type_stack.depth].int_val;
1554   /* "Can't happen".  */
1555   return 0;
1556 }
1557
1558 /* Pop a type list element from the global type stack.  */
1559
1560 static VEC (type_ptr) *
1561 pop_typelist (void)
1562 {
1563   gdb_assert (type_stack.depth);
1564   return type_stack.elements[--type_stack.depth].typelist_val;
1565 }
1566
1567 /* Pop a type_stack element from the global type stack.  */
1568
1569 static struct type_stack *
1570 pop_type_stack (void)
1571 {
1572   gdb_assert (type_stack.depth);
1573   return type_stack.elements[--type_stack.depth].stack_val;
1574 }
1575
1576 /* Append the elements of the type stack FROM to the type stack TO.
1577    Always returns TO.  */
1578
1579 struct type_stack *
1580 append_type_stack (struct type_stack *to, struct type_stack *from)
1581 {
1582   type_stack_reserve (to, from->depth);
1583
1584   memcpy (&to->elements[to->depth], &from->elements[0],
1585           from->depth * sizeof (union type_stack_elt));
1586   to->depth += from->depth;
1587
1588   return to;
1589 }
1590
1591 /* Push the type stack STACK as an element on the global type stack.  */
1592
1593 void
1594 push_type_stack (struct type_stack *stack)
1595 {
1596   check_type_stack_depth ();
1597   type_stack.elements[type_stack.depth++].stack_val = stack;
1598   push_type (tp_type_stack);
1599 }
1600
1601 /* Copy the global type stack into a newly allocated type stack and
1602    return it.  The global stack is cleared.  The returned type stack
1603    must be freed with type_stack_cleanup.  */
1604
1605 struct type_stack *
1606 get_type_stack (void)
1607 {
1608   struct type_stack *result = XNEW (struct type_stack);
1609
1610   *result = type_stack;
1611   type_stack.depth = 0;
1612   type_stack.size = 0;
1613   type_stack.elements = NULL;
1614
1615   return result;
1616 }
1617
1618 /* A cleanup function that destroys a single type stack.  */
1619
1620 void
1621 type_stack_cleanup (void *arg)
1622 {
1623   struct type_stack *stack = arg;
1624
1625   xfree (stack->elements);
1626   xfree (stack);
1627 }
1628
1629 /* Push a function type with arguments onto the global type stack.
1630    LIST holds the argument types.  If the final item in LIST is NULL,
1631    then the function will be varargs.  */
1632
1633 void
1634 push_typelist (VEC (type_ptr) *list)
1635 {
1636   check_type_stack_depth ();
1637   type_stack.elements[type_stack.depth++].typelist_val = list;
1638   push_type (tp_function_with_arguments);
1639 }
1640
1641 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1642    as modified by all the stuff on the stack.  */
1643 struct type *
1644 follow_types (struct type *follow_type)
1645 {
1646   int done = 0;
1647   int make_const = 0;
1648   int make_volatile = 0;
1649   int make_addr_space = 0;
1650   int array_size;
1651
1652   while (!done)
1653     switch (pop_type ())
1654       {
1655       case tp_end:
1656         done = 1;
1657         if (make_const)
1658           follow_type = make_cv_type (make_const, 
1659                                       TYPE_VOLATILE (follow_type), 
1660                                       follow_type, 0);
1661         if (make_volatile)
1662           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1663                                       make_volatile, 
1664                                       follow_type, 0);
1665         if (make_addr_space)
1666           follow_type = make_type_with_address_space (follow_type, 
1667                                                       make_addr_space);
1668         make_const = make_volatile = 0;
1669         make_addr_space = 0;
1670         break;
1671       case tp_const:
1672         make_const = 1;
1673         break;
1674       case tp_volatile:
1675         make_volatile = 1;
1676         break;
1677       case tp_space_identifier:
1678         make_addr_space = pop_type_int ();
1679         break;
1680       case tp_pointer:
1681         follow_type = lookup_pointer_type (follow_type);
1682         if (make_const)
1683           follow_type = make_cv_type (make_const, 
1684                                       TYPE_VOLATILE (follow_type), 
1685                                       follow_type, 0);
1686         if (make_volatile)
1687           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1688                                       make_volatile, 
1689                                       follow_type, 0);
1690         if (make_addr_space)
1691           follow_type = make_type_with_address_space (follow_type, 
1692                                                       make_addr_space);
1693         make_const = make_volatile = 0;
1694         make_addr_space = 0;
1695         break;
1696       case tp_reference:
1697         follow_type = lookup_reference_type (follow_type);
1698         if (make_const)
1699           follow_type = make_cv_type (make_const, 
1700                                       TYPE_VOLATILE (follow_type), 
1701                                       follow_type, 0);
1702         if (make_volatile)
1703           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1704                                       make_volatile, 
1705                                       follow_type, 0);
1706         if (make_addr_space)
1707           follow_type = make_type_with_address_space (follow_type, 
1708                                                       make_addr_space);
1709         make_const = make_volatile = 0;
1710         make_addr_space = 0;
1711         break;
1712       case tp_array:
1713         array_size = pop_type_int ();
1714         /* FIXME-type-allocation: need a way to free this type when we are
1715            done with it.  */
1716         follow_type =
1717           lookup_array_range_type (follow_type,
1718                                    0, array_size >= 0 ? array_size - 1 : 0);
1719         if (array_size < 0)
1720           TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type))
1721             = PROP_UNDEFINED;
1722         break;
1723       case tp_function:
1724         /* FIXME-type-allocation: need a way to free this type when we are
1725            done with it.  */
1726         follow_type = lookup_function_type (follow_type);
1727         break;
1728
1729       case tp_function_with_arguments:
1730         {
1731           VEC (type_ptr) *args = pop_typelist ();
1732
1733           follow_type
1734             = lookup_function_type_with_arguments (follow_type,
1735                                                    VEC_length (type_ptr, args),
1736                                                    VEC_address (type_ptr,
1737                                                                 args));
1738           VEC_free (type_ptr, args);
1739         }
1740         break;
1741
1742       case tp_type_stack:
1743         {
1744           struct type_stack *stack = pop_type_stack ();
1745           /* Sort of ugly, but not really much worse than the
1746              alternatives.  */
1747           struct type_stack save = type_stack;
1748
1749           type_stack = *stack;
1750           follow_type = follow_types (follow_type);
1751           gdb_assert (type_stack.depth == 0);
1752
1753           type_stack = save;
1754         }
1755         break;
1756       default:
1757         gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1758       }
1759   return follow_type;
1760 }
1761 \f
1762 /* This function avoids direct calls to fprintf 
1763    in the parser generated debug code.  */
1764 void
1765 parser_fprintf (FILE *x, const char *y, ...)
1766
1767   va_list args;
1768
1769   va_start (args, y);
1770   if (x == stderr)
1771     vfprintf_unfiltered (gdb_stderr, y, args); 
1772   else
1773     {
1774       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1775       vfprintf_unfiltered (gdb_stderr, y, args);
1776     }
1777   va_end (args);
1778 }
1779
1780 /* Implementation of the exp_descriptor method operator_check.  */
1781
1782 int
1783 operator_check_standard (struct expression *exp, int pos,
1784                          int (*objfile_func) (struct objfile *objfile,
1785                                               void *data),
1786                          void *data)
1787 {
1788   const union exp_element *const elts = exp->elts;
1789   struct type *type = NULL;
1790   struct objfile *objfile = NULL;
1791
1792   /* Extended operators should have been already handled by exp_descriptor
1793      iterate method of its specific language.  */
1794   gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1795
1796   /* Track the callers of write_exp_elt_type for this table.  */
1797
1798   switch (elts[pos].opcode)
1799     {
1800     case BINOP_VAL:
1801     case OP_COMPLEX:
1802     case OP_DECFLOAT:
1803     case OP_DOUBLE:
1804     case OP_LONG:
1805     case OP_SCOPE:
1806     case OP_TYPE:
1807     case UNOP_CAST:
1808     case UNOP_MAX:
1809     case UNOP_MEMVAL:
1810     case UNOP_MIN:
1811       type = elts[pos + 1].type;
1812       break;
1813
1814     case TYPE_INSTANCE:
1815       {
1816         LONGEST arg, nargs = elts[pos + 1].longconst;
1817
1818         for (arg = 0; arg < nargs; arg++)
1819           {
1820             struct type *type = elts[pos + 2 + arg].type;
1821             struct objfile *objfile = TYPE_OBJFILE (type);
1822
1823             if (objfile && (*objfile_func) (objfile, data))
1824               return 1;
1825           }
1826       }
1827       break;
1828
1829     case UNOP_MEMVAL_TLS:
1830       objfile = elts[pos + 1].objfile;
1831       type = elts[pos + 2].type;
1832       break;
1833
1834     case OP_VAR_VALUE:
1835       {
1836         const struct block *const block = elts[pos + 1].block;
1837         const struct symbol *const symbol = elts[pos + 2].symbol;
1838
1839         /* Check objfile where the variable itself is placed.
1840            SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1841         if ((*objfile_func) (symbol_objfile (symbol), data))
1842           return 1;
1843
1844         /* Check objfile where is placed the code touching the variable.  */
1845         objfile = lookup_objfile_from_block (block);
1846
1847         type = SYMBOL_TYPE (symbol);
1848       }
1849       break;
1850     }
1851
1852   /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1853
1854   if (type && TYPE_OBJFILE (type)
1855       && (*objfile_func) (TYPE_OBJFILE (type), data))
1856     return 1;
1857   if (objfile && (*objfile_func) (objfile, data))
1858     return 1;
1859
1860   return 0;
1861 }
1862
1863 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1864    OBJFILE_FUNC is never called with NULL OBJFILE.  OBJFILE_FUNC get
1865    passed an arbitrary caller supplied DATA pointer.  If OBJFILE_FUNC
1866    returns non-zero value then (any other) non-zero value is immediately
1867    returned to the caller.  Otherwise zero is returned after iterating
1868    through whole EXP.  */
1869
1870 static int
1871 exp_iterate (struct expression *exp,
1872              int (*objfile_func) (struct objfile *objfile, void *data),
1873              void *data)
1874 {
1875   int endpos;
1876
1877   for (endpos = exp->nelts; endpos > 0; )
1878     {
1879       int pos, args, oplen = 0;
1880
1881       operator_length (exp, endpos, &oplen, &args);
1882       gdb_assert (oplen > 0);
1883
1884       pos = endpos - oplen;
1885       if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1886                                                            objfile_func, data))
1887         return 1;
1888
1889       endpos = pos;
1890     }
1891
1892   return 0;
1893 }
1894
1895 /* Helper for exp_uses_objfile.  */
1896
1897 static int
1898 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1899 {
1900   struct objfile *objfile = objfile_voidp;
1901
1902   if (exp_objfile->separate_debug_objfile_backlink)
1903     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1904
1905   return exp_objfile == objfile;
1906 }
1907
1908 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1909    is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1910    file.  */
1911
1912 int
1913 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1914 {
1915   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1916
1917   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1918 }
1919
1920 /* See definition in parser-defs.h.  */
1921
1922 void
1923 increase_expout_size (struct parser_state *ps, size_t lenelt)
1924 {
1925   if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1926     {
1927       ps->expout_size = max (ps->expout_size * 2,
1928                              ps->expout_ptr + lenelt + 10);
1929       ps->expout = (struct expression *)
1930         xrealloc (ps->expout, (sizeof (struct expression)
1931                                + EXP_ELEM_TO_BYTES (ps->expout_size)));
1932     }
1933 }
1934
1935 void
1936 _initialize_parse (void)
1937 {
1938   type_stack.size = 0;
1939   type_stack.depth = 0;
1940   type_stack.elements = NULL;
1941
1942   add_setshow_zuinteger_cmd ("expression", class_maintenance,
1943                              &expressiondebug,
1944                              _("Set expression debugging."),
1945                              _("Show expression debugging."),
1946                              _("When non-zero, the internal representation "
1947                                "of expressions will be printed."),
1948                              NULL,
1949                              show_expressiondebug,
1950                              &setdebuglist, &showdebuglist);
1951   add_setshow_boolean_cmd ("parser", class_maintenance,
1952                             &parser_debug,
1953                            _("Set parser debugging."),
1954                            _("Show parser debugging."),
1955                            _("When non-zero, expression parser "
1956                              "tracing will be enabled."),
1957                             NULL,
1958                             show_parserdebug,
1959                             &setdebuglist, &showdebuglist);
1960 }