Remove spurious exceptions.h inclusions
[external/binutils.git] / gdb / parse.c
1 /* Parse expressions for GDB.
2
3    Copyright (C) 1986-2014 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 *new;
144
145   new = (struct funcall *) xmalloc (sizeof (struct funcall));
146   new->next = funcall_chain;
147   new->arglist_len = arglist_len;
148   arglist_len = 0;
149   funcall_chain = new;
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_CLASS
587               || tag == TYPE_CODE_ENUM);
588   expout_tag_completion_type = tag;
589   expout_completion_name = xmalloc (length + 1);
590   memcpy (expout_completion_name, ptr, length);
591   expout_completion_name[length] = '\0';
592 }
593
594 \f
595 /* Recognize tokens that start with '$'.  These include:
596
597    $regname     A native register name or a "standard
598    register name".
599
600    $variable    A convenience variable with a name chosen
601    by the user.
602
603    $digits              Value history with index <digits>, starting
604    from the first value which has index 1.
605
606    $$digits     Value history with index <digits> relative
607    to the last value.  I.e. $$0 is the last
608    value, $$1 is the one previous to that, $$2
609    is the one previous to $$1, etc.
610
611    $ | $0 | $$0 The last value in the value history.
612
613    $$           An abbreviation for the second to the last
614    value in the value history, I.e. $$1  */
615
616 void
617 write_dollar_variable (struct parser_state *ps, struct stoken str)
618 {
619   struct symbol *sym = NULL;
620   struct bound_minimal_symbol msym;
621   struct internalvar *isym = NULL;
622
623   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
624      and $$digits (equivalent to $<-digits> if you could type that).  */
625
626   int negate = 0;
627   int i = 1;
628   /* Double dollar means negate the number and add -1 as well.
629      Thus $$ alone means -1.  */
630   if (str.length >= 2 && str.ptr[1] == '$')
631     {
632       negate = 1;
633       i = 2;
634     }
635   if (i == str.length)
636     {
637       /* Just dollars (one or two).  */
638       i = -negate;
639       goto handle_last;
640     }
641   /* Is the rest of the token digits?  */
642   for (; i < str.length; i++)
643     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
644       break;
645   if (i == str.length)
646     {
647       i = atoi (str.ptr + 1 + negate);
648       if (negate)
649         i = -i;
650       goto handle_last;
651     }
652
653   /* Handle tokens that refer to machine registers:
654      $ followed by a register name.  */
655   i = user_reg_map_name_to_regnum (parse_gdbarch (ps),
656                                    str.ptr + 1, str.length - 1);
657   if (i >= 0)
658     goto handle_register;
659
660   /* Any names starting with $ are probably debugger internal variables.  */
661
662   isym = lookup_only_internalvar (copy_name (str) + 1);
663   if (isym)
664     {
665       write_exp_elt_opcode (ps, OP_INTERNALVAR);
666       write_exp_elt_intern (ps, isym);
667       write_exp_elt_opcode (ps, OP_INTERNALVAR);
668       return;
669     }
670
671   /* On some systems, such as HP-UX and hppa-linux, certain system routines 
672      have names beginning with $ or $$.  Check for those, first.  */
673
674   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
675                        VAR_DOMAIN, NULL);
676   if (sym)
677     {
678       write_exp_elt_opcode (ps, OP_VAR_VALUE);
679       write_exp_elt_block (ps, block_found);    /* set by lookup_symbol */
680       write_exp_elt_sym (ps, sym);
681       write_exp_elt_opcode (ps, OP_VAR_VALUE);
682       return;
683     }
684   msym = lookup_bound_minimal_symbol (copy_name (str));
685   if (msym.minsym)
686     {
687       write_exp_msymbol (ps, msym);
688       return;
689     }
690
691   /* Any other names are assumed to be debugger internal variables.  */
692
693   write_exp_elt_opcode (ps, OP_INTERNALVAR);
694   write_exp_elt_intern (ps, create_internalvar (copy_name (str) + 1));
695   write_exp_elt_opcode (ps, OP_INTERNALVAR);
696   return;
697 handle_last:
698   write_exp_elt_opcode (ps, OP_LAST);
699   write_exp_elt_longcst (ps, (LONGEST) i);
700   write_exp_elt_opcode (ps, OP_LAST);
701   return;
702 handle_register:
703   write_exp_elt_opcode (ps, OP_REGISTER);
704   str.length--;
705   str.ptr++;
706   write_exp_string (ps, str);
707   write_exp_elt_opcode (ps, OP_REGISTER);
708   return;
709 }
710
711
712 const char *
713 find_template_name_end (const char *p)
714 {
715   int depth = 1;
716   int just_seen_right = 0;
717   int just_seen_colon = 0;
718   int just_seen_space = 0;
719
720   if (!p || (*p != '<'))
721     return 0;
722
723   while (*++p)
724     {
725       switch (*p)
726         {
727         case '\'':
728         case '\"':
729         case '{':
730         case '}':
731           /* In future, may want to allow these??  */
732           return 0;
733         case '<':
734           depth++;              /* start nested template */
735           if (just_seen_colon || just_seen_right || just_seen_space)
736             return 0;           /* but not after : or :: or > or space */
737           break;
738         case '>':
739           if (just_seen_colon || just_seen_right)
740             return 0;           /* end a (nested?) template */
741           just_seen_right = 1;  /* but not after : or :: */
742           if (--depth == 0)     /* also disallow >>, insist on > > */
743             return ++p;         /* if outermost ended, return */
744           break;
745         case ':':
746           if (just_seen_space || (just_seen_colon > 1))
747             return 0;           /* nested class spec coming up */
748           just_seen_colon++;    /* we allow :: but not :::: */
749           break;
750         case ' ':
751           break;
752         default:
753           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
754                 (*p >= 'A' && *p <= 'Z') ||
755                 (*p >= '0' && *p <= '9') ||
756                 (*p == '_') || (*p == ',') ||   /* commas for template args */
757                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
758                 (*p == '(') || (*p == ')') ||   /* function types */
759                 (*p == '[') || (*p == ']')))    /* array types */
760             return 0;
761         }
762       if (*p != ' ')
763         just_seen_space = 0;
764       if (*p != ':')
765         just_seen_colon = 0;
766       if (*p != '>')
767         just_seen_right = 0;
768     }
769   return 0;
770 }
771 \f
772
773 /* Return a null-terminated temporary copy of the name of a string token.
774
775    Tokens that refer to names do so with explicit pointer and length,
776    so they can share the storage that lexptr is parsing.
777    When it is necessary to pass a name to a function that expects
778    a null-terminated string, the substring is copied out
779    into a separate block of storage.
780
781    N.B. A single buffer is reused on each call.  */
782
783 char *
784 copy_name (struct stoken token)
785 {
786   /* A temporary buffer for identifiers, so we can null-terminate them.
787      We allocate this with xrealloc.  parse_exp_1 used to allocate with
788      alloca, using the size of the whole expression as a conservative
789      estimate of the space needed.  However, macro expansion can
790      introduce names longer than the original expression; there's no
791      practical way to know beforehand how large that might be.  */
792   static char *namecopy;
793   static size_t namecopy_size;
794
795   /* Make sure there's enough space for the token.  */
796   if (namecopy_size < token.length + 1)
797     {
798       namecopy_size = token.length + 1;
799       namecopy = xrealloc (namecopy, token.length + 1);
800     }
801       
802   memcpy (namecopy, token.ptr, token.length);
803   namecopy[token.length] = 0;
804
805   return namecopy;
806 }
807 \f
808
809 /* See comments on parser-defs.h.  */
810
811 int
812 prefixify_expression (struct expression *expr)
813 {
814   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
815   struct expression *temp;
816   int inpos = expr->nelts, outpos = 0;
817
818   temp = (struct expression *) alloca (len);
819
820   /* Copy the original expression into temp.  */
821   memcpy (temp, expr, len);
822
823   return prefixify_subexp (temp, expr, inpos, outpos);
824 }
825
826 /* Return the number of exp_elements in the postfix subexpression 
827    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
828
829 int
830 length_of_subexp (struct expression *expr, int endpos)
831 {
832   int oplen, args;
833
834   operator_length (expr, endpos, &oplen, &args);
835
836   while (args > 0)
837     {
838       oplen += length_of_subexp (expr, endpos - oplen);
839       args--;
840     }
841
842   return oplen;
843 }
844
845 /* Sets *OPLENP to the length of the operator whose (last) index is 
846    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
847    operator takes.  */
848
849 void
850 operator_length (const struct expression *expr, int endpos, int *oplenp,
851                  int *argsp)
852 {
853   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
854                                                      oplenp, argsp);
855 }
856
857 /* Default value for operator_length in exp_descriptor vectors.  */
858
859 void
860 operator_length_standard (const struct expression *expr, int endpos,
861                           int *oplenp, int *argsp)
862 {
863   int oplen = 1;
864   int args = 0;
865   enum f90_range_type range_type;
866   int i;
867
868   if (endpos < 1)
869     error (_("?error in operator_length_standard"));
870
871   i = (int) expr->elts[endpos - 1].opcode;
872
873   switch (i)
874     {
875       /* C++  */
876     case OP_SCOPE:
877       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
878       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
879       break;
880
881     case OP_LONG:
882     case OP_DOUBLE:
883     case OP_DECFLOAT:
884     case OP_VAR_VALUE:
885       oplen = 4;
886       break;
887
888     case OP_TYPE:
889     case OP_BOOL:
890     case OP_LAST:
891     case OP_INTERNALVAR:
892     case OP_VAR_ENTRY_VALUE:
893       oplen = 3;
894       break;
895
896     case OP_COMPLEX:
897       oplen = 3;
898       args = 2;
899       break;
900
901     case OP_FUNCALL:
902     case OP_F77_UNDETERMINED_ARGLIST:
903       oplen = 3;
904       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
905       break;
906
907     case TYPE_INSTANCE:
908       oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
909       args = 1;
910       break;
911
912     case OP_OBJC_MSGCALL:       /* Objective C message (method) call.  */
913       oplen = 4;
914       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
915       break;
916
917     case UNOP_MAX:
918     case UNOP_MIN:
919       oplen = 3;
920       break;
921
922     case UNOP_CAST_TYPE:
923     case UNOP_DYNAMIC_CAST:
924     case UNOP_REINTERPRET_CAST:
925     case UNOP_MEMVAL_TYPE:
926       oplen = 1;
927       args = 2;
928       break;
929
930     case BINOP_VAL:
931     case UNOP_CAST:
932     case UNOP_MEMVAL:
933       oplen = 3;
934       args = 1;
935       break;
936
937     case UNOP_MEMVAL_TLS:
938       oplen = 4;
939       args = 1;
940       break;
941
942     case UNOP_ABS:
943     case UNOP_CAP:
944     case UNOP_CHR:
945     case UNOP_FLOAT:
946     case UNOP_HIGH:
947     case UNOP_ODD:
948     case UNOP_ORD:
949     case UNOP_TRUNC:
950     case OP_TYPEOF:
951     case OP_DECLTYPE:
952     case OP_TYPEID:
953       oplen = 1;
954       args = 1;
955       break;
956
957     case OP_ADL_FUNC:
958       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
959       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
960       oplen++;
961       oplen++;
962       break;
963
964     case STRUCTOP_STRUCT:
965     case STRUCTOP_PTR:
966       args = 1;
967       /* fall through */
968     case OP_REGISTER:
969     case OP_M2_STRING:
970     case OP_STRING:
971     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class
972                                    NSString constant.  */
973     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op.  */
974     case OP_NAME:
975       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
976       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
977       break;
978
979     case OP_ARRAY:
980       oplen = 4;
981       args = longest_to_int (expr->elts[endpos - 2].longconst);
982       args -= longest_to_int (expr->elts[endpos - 3].longconst);
983       args += 1;
984       break;
985
986     case TERNOP_COND:
987     case TERNOP_SLICE:
988       args = 3;
989       break;
990
991       /* Modula-2 */
992     case MULTI_SUBSCRIPT:
993       oplen = 3;
994       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
995       break;
996
997     case BINOP_ASSIGN_MODIFY:
998       oplen = 3;
999       args = 2;
1000       break;
1001
1002       /* C++ */
1003     case OP_THIS:
1004       oplen = 2;
1005       break;
1006
1007     case OP_F90_RANGE:
1008       oplen = 3;
1009
1010       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
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   volatile struct gdb_exception except;
1138   struct cleanup *old_chain, *inner_chain;
1139   const struct language_defn *lang = NULL;
1140   struct parser_state ps;
1141   int subexp;
1142
1143   lexptr = *stringptr;
1144   prev_lexptr = NULL;
1145
1146   paren_depth = 0;
1147   type_stack.depth = 0;
1148   expout_last_struct = -1;
1149   expout_tag_completion_type = TYPE_CODE_UNDEF;
1150   xfree (expout_completion_name);
1151   expout_completion_name = NULL;
1152
1153   comma_terminates = comma;
1154
1155   if (lexptr == 0 || *lexptr == 0)
1156     error_no_arg (_("expression to compute"));
1157
1158   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1159   funcall_chain = 0;
1160
1161   expression_context_block = block;
1162
1163   /* If no context specified, try using the current frame, if any.  */
1164   if (!expression_context_block)
1165     expression_context_block = get_selected_block (&expression_context_pc);
1166   else if (pc == 0)
1167     expression_context_pc = BLOCK_START (expression_context_block);
1168   else
1169     expression_context_pc = pc;
1170
1171   /* Fall back to using the current source static context, if any.  */
1172
1173   if (!expression_context_block)
1174     {
1175       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1176       if (cursal.symtab)
1177         expression_context_block
1178           = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), 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_CATCH (except, RETURN_MASK_ALL)
1219     {
1220       if (lang->la_parser (&ps))
1221         lang->la_error (NULL);
1222     }
1223   if (except.reason < 0)
1224     {
1225       if (! parse_completion)
1226         {
1227           xfree (ps.expout);
1228           throw_exception (except);
1229         }
1230     }
1231
1232   reallocate_expout (&ps);
1233
1234   /* Convert expression from postfix form as generated by yacc
1235      parser, to a prefix form.  */
1236
1237   if (expressiondebug)
1238     dump_raw_expression (ps.expout, gdb_stdlog,
1239                          "before conversion to prefix form");
1240
1241   subexp = prefixify_expression (ps.expout);
1242   if (out_subexp)
1243     *out_subexp = subexp;
1244
1245   lang->la_post_parser (&ps.expout, void_context_p);
1246
1247   if (expressiondebug)
1248     dump_prefix_expression (ps.expout, gdb_stdlog);
1249
1250   do_cleanups (inner_chain);
1251   discard_cleanups (old_chain);
1252
1253   *stringptr = lexptr;
1254   return ps.expout;
1255 }
1256
1257 /* Parse STRING as an expression, and complain if this fails
1258    to use up all of the contents of STRING.  */
1259
1260 struct expression *
1261 parse_expression (const char *string)
1262 {
1263   struct expression *exp;
1264
1265   exp = parse_exp_1 (&string, 0, 0, 0);
1266   if (*string)
1267     error (_("Junk after end of expression."));
1268   return exp;
1269 }
1270
1271 /* Parse STRING as an expression.  If parsing ends in the middle of a
1272    field reference, return the type of the left-hand-side of the
1273    reference; furthermore, if the parsing ends in the field name,
1274    return the field name in *NAME.  If the parsing ends in the middle
1275    of a field reference, but the reference is somehow invalid, throw
1276    an exception.  In all other cases, return NULL.  Returned non-NULL
1277    *NAME must be freed by the caller.  */
1278
1279 struct type *
1280 parse_expression_for_completion (const char *string, char **name,
1281                                  enum type_code *code)
1282 {
1283   struct expression *exp = NULL;
1284   struct value *val;
1285   int subexp;
1286   volatile struct gdb_exception except;
1287
1288   TRY_CATCH (except, RETURN_MASK_ERROR)
1289     {
1290       parse_completion = 1;
1291       exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
1292     }
1293   parse_completion = 0;
1294   if (except.reason < 0 || ! exp)
1295     return NULL;
1296
1297   if (expout_tag_completion_type != TYPE_CODE_UNDEF)
1298     {
1299       *code = expout_tag_completion_type;
1300       *name = expout_completion_name;
1301       expout_completion_name = NULL;
1302       return NULL;
1303     }
1304
1305   if (expout_last_struct == -1)
1306     {
1307       xfree (exp);
1308       return NULL;
1309     }
1310
1311   *name = extract_field_op (exp, &subexp);
1312   if (!*name)
1313     {
1314       xfree (exp);
1315       return NULL;
1316     }
1317
1318   /* This might throw an exception.  If so, we want to let it
1319      propagate.  */
1320   val = evaluate_subexpression_type (exp, subexp);
1321   /* (*NAME) is a part of the EXP memory block freed below.  */
1322   *name = xstrdup (*name);
1323   xfree (exp);
1324
1325   return value_type (val);
1326 }
1327
1328 /* A post-parser that does nothing.  */
1329
1330 void
1331 null_post_parser (struct expression **exp, int void_context_p)
1332 {
1333 }
1334
1335 /* Parse floating point value P of length LEN.
1336    Return 0 (false) if invalid, 1 (true) if valid.
1337    The successfully parsed number is stored in D.
1338    *SUFFIX points to the suffix of the number in P.
1339
1340    NOTE: This accepts the floating point syntax that sscanf accepts.  */
1341
1342 int
1343 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1344 {
1345   char *copy;
1346   int n, num;
1347
1348   copy = xmalloc (len + 1);
1349   memcpy (copy, p, len);
1350   copy[len] = 0;
1351
1352   num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1353   xfree (copy);
1354
1355   /* The sscanf man page suggests not making any assumptions on the effect
1356      of %n on the result, so we don't.
1357      That is why we simply test num == 0.  */
1358   if (num == 0)
1359     return 0;
1360
1361   *suffix = p + n;
1362   return 1;
1363 }
1364
1365 /* Parse floating point value P of length LEN, using the C syntax for floats.
1366    Return 0 (false) if invalid, 1 (true) if valid.
1367    The successfully parsed number is stored in *D.
1368    Its type is taken from builtin_type (gdbarch) and is stored in *T.  */
1369
1370 int
1371 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1372                DOUBLEST *d, struct type **t)
1373 {
1374   const char *suffix;
1375   int suffix_len;
1376   const struct builtin_type *builtin_types = builtin_type (gdbarch);
1377
1378   if (! parse_float (p, len, d, &suffix))
1379     return 0;
1380
1381   suffix_len = p + len - suffix;
1382
1383   if (suffix_len == 0)
1384     *t = builtin_types->builtin_double;
1385   else if (suffix_len == 1)
1386     {
1387       /* Handle suffixes: 'f' for float, 'l' for long double.  */
1388       if (tolower (*suffix) == 'f')
1389         *t = builtin_types->builtin_float;
1390       else if (tolower (*suffix) == 'l')
1391         *t = builtin_types->builtin_long_double;
1392       else
1393         return 0;
1394     }
1395   else
1396     return 0;
1397
1398   return 1;
1399 }
1400 \f
1401 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1402    probably useful for any language which declares its types "backwards".  */
1403
1404 /* Ensure that there are HOWMUCH open slots on the type stack STACK.  */
1405
1406 static void
1407 type_stack_reserve (struct type_stack *stack, int howmuch)
1408 {
1409   if (stack->depth + howmuch >= stack->size)
1410     {
1411       stack->size *= 2;
1412       if (stack->size < howmuch)
1413         stack->size = howmuch;
1414       stack->elements = xrealloc (stack->elements,
1415                                   stack->size * sizeof (union type_stack_elt));
1416     }
1417 }
1418
1419 /* Ensure that there is a single open slot in the global type stack.  */
1420
1421 static void
1422 check_type_stack_depth (void)
1423 {
1424   type_stack_reserve (&type_stack, 1);
1425 }
1426
1427 /* A helper function for insert_type and insert_type_address_space.
1428    This does work of expanding the type stack and inserting the new
1429    element, ELEMENT, into the stack at location SLOT.  */
1430
1431 static void
1432 insert_into_type_stack (int slot, union type_stack_elt element)
1433 {
1434   check_type_stack_depth ();
1435
1436   if (slot < type_stack.depth)
1437     memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
1438              (type_stack.depth - slot) * sizeof (union type_stack_elt));
1439   type_stack.elements[slot] = element;
1440   ++type_stack.depth;
1441 }
1442
1443 /* Insert a new type, TP, at the bottom of the type stack.  If TP is
1444    tp_pointer or tp_reference, it is inserted at the bottom.  If TP is
1445    a qualifier, it is inserted at slot 1 (just above a previous
1446    tp_pointer) if there is anything on the stack, or simply pushed if
1447    the stack is empty.  Other values for TP are invalid.  */
1448
1449 void
1450 insert_type (enum type_pieces tp)
1451 {
1452   union type_stack_elt element;
1453   int slot;
1454
1455   gdb_assert (tp == tp_pointer || tp == tp_reference
1456               || tp == tp_const || tp == tp_volatile);
1457
1458   /* If there is anything on the stack (we know it will be a
1459      tp_pointer), insert the qualifier above it.  Otherwise, simply
1460      push this on the top of the stack.  */
1461   if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
1462     slot = 1;
1463   else
1464     slot = 0;
1465
1466   element.piece = tp;
1467   insert_into_type_stack (slot, element);
1468 }
1469
1470 void
1471 push_type (enum type_pieces tp)
1472 {
1473   check_type_stack_depth ();
1474   type_stack.elements[type_stack.depth++].piece = tp;
1475 }
1476
1477 void
1478 push_type_int (int n)
1479 {
1480   check_type_stack_depth ();
1481   type_stack.elements[type_stack.depth++].int_val = n;
1482 }
1483
1484 /* Insert a tp_space_identifier and the corresponding address space
1485    value into the stack.  STRING is the name of an address space, as
1486    recognized by address_space_name_to_int.  If the stack is empty,
1487    the new elements are simply pushed.  If the stack is not empty,
1488    this function assumes that the first item on the stack is a
1489    tp_pointer, and the new values are inserted above the first
1490    item.  */
1491
1492 void
1493 insert_type_address_space (struct parser_state *pstate, char *string)
1494 {
1495   union type_stack_elt element;
1496   int slot;
1497
1498   /* If there is anything on the stack (we know it will be a
1499      tp_pointer), insert the address space qualifier above it.
1500      Otherwise, simply push this on the top of the stack.  */
1501   if (type_stack.depth)
1502     slot = 1;
1503   else
1504     slot = 0;
1505
1506   element.piece = tp_space_identifier;
1507   insert_into_type_stack (slot, element);
1508   element.int_val = address_space_name_to_int (parse_gdbarch (pstate),
1509                                                string);
1510   insert_into_type_stack (slot, element);
1511 }
1512
1513 enum type_pieces
1514 pop_type (void)
1515 {
1516   if (type_stack.depth)
1517     return type_stack.elements[--type_stack.depth].piece;
1518   return tp_end;
1519 }
1520
1521 int
1522 pop_type_int (void)
1523 {
1524   if (type_stack.depth)
1525     return type_stack.elements[--type_stack.depth].int_val;
1526   /* "Can't happen".  */
1527   return 0;
1528 }
1529
1530 /* Pop a type list element from the global type stack.  */
1531
1532 static VEC (type_ptr) *
1533 pop_typelist (void)
1534 {
1535   gdb_assert (type_stack.depth);
1536   return type_stack.elements[--type_stack.depth].typelist_val;
1537 }
1538
1539 /* Pop a type_stack element from the global type stack.  */
1540
1541 static struct type_stack *
1542 pop_type_stack (void)
1543 {
1544   gdb_assert (type_stack.depth);
1545   return type_stack.elements[--type_stack.depth].stack_val;
1546 }
1547
1548 /* Append the elements of the type stack FROM to the type stack TO.
1549    Always returns TO.  */
1550
1551 struct type_stack *
1552 append_type_stack (struct type_stack *to, struct type_stack *from)
1553 {
1554   type_stack_reserve (to, from->depth);
1555
1556   memcpy (&to->elements[to->depth], &from->elements[0],
1557           from->depth * sizeof (union type_stack_elt));
1558   to->depth += from->depth;
1559
1560   return to;
1561 }
1562
1563 /* Push the type stack STACK as an element on the global type stack.  */
1564
1565 void
1566 push_type_stack (struct type_stack *stack)
1567 {
1568   check_type_stack_depth ();
1569   type_stack.elements[type_stack.depth++].stack_val = stack;
1570   push_type (tp_type_stack);
1571 }
1572
1573 /* Copy the global type stack into a newly allocated type stack and
1574    return it.  The global stack is cleared.  The returned type stack
1575    must be freed with type_stack_cleanup.  */
1576
1577 struct type_stack *
1578 get_type_stack (void)
1579 {
1580   struct type_stack *result = XNEW (struct type_stack);
1581
1582   *result = type_stack;
1583   type_stack.depth = 0;
1584   type_stack.size = 0;
1585   type_stack.elements = NULL;
1586
1587   return result;
1588 }
1589
1590 /* A cleanup function that destroys a single type stack.  */
1591
1592 void
1593 type_stack_cleanup (void *arg)
1594 {
1595   struct type_stack *stack = arg;
1596
1597   xfree (stack->elements);
1598   xfree (stack);
1599 }
1600
1601 /* Push a function type with arguments onto the global type stack.
1602    LIST holds the argument types.  If the final item in LIST is NULL,
1603    then the function will be varargs.  */
1604
1605 void
1606 push_typelist (VEC (type_ptr) *list)
1607 {
1608   check_type_stack_depth ();
1609   type_stack.elements[type_stack.depth++].typelist_val = list;
1610   push_type (tp_function_with_arguments);
1611 }
1612
1613 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1614    as modified by all the stuff on the stack.  */
1615 struct type *
1616 follow_types (struct type *follow_type)
1617 {
1618   int done = 0;
1619   int make_const = 0;
1620   int make_volatile = 0;
1621   int make_addr_space = 0;
1622   int array_size;
1623
1624   while (!done)
1625     switch (pop_type ())
1626       {
1627       case tp_end:
1628         done = 1;
1629         if (make_const)
1630           follow_type = make_cv_type (make_const, 
1631                                       TYPE_VOLATILE (follow_type), 
1632                                       follow_type, 0);
1633         if (make_volatile)
1634           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1635                                       make_volatile, 
1636                                       follow_type, 0);
1637         if (make_addr_space)
1638           follow_type = make_type_with_address_space (follow_type, 
1639                                                       make_addr_space);
1640         make_const = make_volatile = 0;
1641         make_addr_space = 0;
1642         break;
1643       case tp_const:
1644         make_const = 1;
1645         break;
1646       case tp_volatile:
1647         make_volatile = 1;
1648         break;
1649       case tp_space_identifier:
1650         make_addr_space = pop_type_int ();
1651         break;
1652       case tp_pointer:
1653         follow_type = lookup_pointer_type (follow_type);
1654         if (make_const)
1655           follow_type = make_cv_type (make_const, 
1656                                       TYPE_VOLATILE (follow_type), 
1657                                       follow_type, 0);
1658         if (make_volatile)
1659           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1660                                       make_volatile, 
1661                                       follow_type, 0);
1662         if (make_addr_space)
1663           follow_type = make_type_with_address_space (follow_type, 
1664                                                       make_addr_space);
1665         make_const = make_volatile = 0;
1666         make_addr_space = 0;
1667         break;
1668       case tp_reference:
1669         follow_type = lookup_reference_type (follow_type);
1670         if (make_const)
1671           follow_type = make_cv_type (make_const, 
1672                                       TYPE_VOLATILE (follow_type), 
1673                                       follow_type, 0);
1674         if (make_volatile)
1675           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1676                                       make_volatile, 
1677                                       follow_type, 0);
1678         if (make_addr_space)
1679           follow_type = make_type_with_address_space (follow_type, 
1680                                                       make_addr_space);
1681         make_const = make_volatile = 0;
1682         make_addr_space = 0;
1683         break;
1684       case tp_array:
1685         array_size = pop_type_int ();
1686         /* FIXME-type-allocation: need a way to free this type when we are
1687            done with it.  */
1688         follow_type =
1689           lookup_array_range_type (follow_type,
1690                                    0, array_size >= 0 ? array_size - 1 : 0);
1691         if (array_size < 0)
1692           TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type))
1693             = PROP_UNDEFINED;
1694         break;
1695       case tp_function:
1696         /* FIXME-type-allocation: need a way to free this type when we are
1697            done with it.  */
1698         follow_type = lookup_function_type (follow_type);
1699         break;
1700
1701       case tp_function_with_arguments:
1702         {
1703           VEC (type_ptr) *args = pop_typelist ();
1704
1705           follow_type
1706             = lookup_function_type_with_arguments (follow_type,
1707                                                    VEC_length (type_ptr, args),
1708                                                    VEC_address (type_ptr,
1709                                                                 args));
1710           VEC_free (type_ptr, args);
1711         }
1712         break;
1713
1714       case tp_type_stack:
1715         {
1716           struct type_stack *stack = pop_type_stack ();
1717           /* Sort of ugly, but not really much worse than the
1718              alternatives.  */
1719           struct type_stack save = type_stack;
1720
1721           type_stack = *stack;
1722           follow_type = follow_types (follow_type);
1723           gdb_assert (type_stack.depth == 0);
1724
1725           type_stack = save;
1726         }
1727         break;
1728       default:
1729         gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1730       }
1731   return follow_type;
1732 }
1733 \f
1734 /* This function avoids direct calls to fprintf 
1735    in the parser generated debug code.  */
1736 void
1737 parser_fprintf (FILE *x, const char *y, ...)
1738
1739   va_list args;
1740
1741   va_start (args, y);
1742   if (x == stderr)
1743     vfprintf_unfiltered (gdb_stderr, y, args); 
1744   else
1745     {
1746       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1747       vfprintf_unfiltered (gdb_stderr, y, args);
1748     }
1749   va_end (args);
1750 }
1751
1752 /* Implementation of the exp_descriptor method operator_check.  */
1753
1754 int
1755 operator_check_standard (struct expression *exp, int pos,
1756                          int (*objfile_func) (struct objfile *objfile,
1757                                               void *data),
1758                          void *data)
1759 {
1760   const union exp_element *const elts = exp->elts;
1761   struct type *type = NULL;
1762   struct objfile *objfile = NULL;
1763
1764   /* Extended operators should have been already handled by exp_descriptor
1765      iterate method of its specific language.  */
1766   gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1767
1768   /* Track the callers of write_exp_elt_type for this table.  */
1769
1770   switch (elts[pos].opcode)
1771     {
1772     case BINOP_VAL:
1773     case OP_COMPLEX:
1774     case OP_DECFLOAT:
1775     case OP_DOUBLE:
1776     case OP_LONG:
1777     case OP_SCOPE:
1778     case OP_TYPE:
1779     case UNOP_CAST:
1780     case UNOP_MAX:
1781     case UNOP_MEMVAL:
1782     case UNOP_MIN:
1783       type = elts[pos + 1].type;
1784       break;
1785
1786     case TYPE_INSTANCE:
1787       {
1788         LONGEST arg, nargs = elts[pos + 1].longconst;
1789
1790         for (arg = 0; arg < nargs; arg++)
1791           {
1792             struct type *type = elts[pos + 2 + arg].type;
1793             struct objfile *objfile = TYPE_OBJFILE (type);
1794
1795             if (objfile && (*objfile_func) (objfile, data))
1796               return 1;
1797           }
1798       }
1799       break;
1800
1801     case UNOP_MEMVAL_TLS:
1802       objfile = elts[pos + 1].objfile;
1803       type = elts[pos + 2].type;
1804       break;
1805
1806     case OP_VAR_VALUE:
1807       {
1808         const struct block *const block = elts[pos + 1].block;
1809         const struct symbol *const symbol = elts[pos + 2].symbol;
1810
1811         /* Check objfile where the variable itself is placed.
1812            SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1813         if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
1814           return 1;
1815
1816         /* Check objfile where is placed the code touching the variable.  */
1817         objfile = lookup_objfile_from_block (block);
1818
1819         type = SYMBOL_TYPE (symbol);
1820       }
1821       break;
1822     }
1823
1824   /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1825
1826   if (type && TYPE_OBJFILE (type)
1827       && (*objfile_func) (TYPE_OBJFILE (type), data))
1828     return 1;
1829   if (objfile && (*objfile_func) (objfile, data))
1830     return 1;
1831
1832   return 0;
1833 }
1834
1835 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1836    OBJFILE_FUNC is never called with NULL OBJFILE.  OBJFILE_FUNC get
1837    passed an arbitrary caller supplied DATA pointer.  If OBJFILE_FUNC
1838    returns non-zero value then (any other) non-zero value is immediately
1839    returned to the caller.  Otherwise zero is returned after iterating
1840    through whole EXP.  */
1841
1842 static int
1843 exp_iterate (struct expression *exp,
1844              int (*objfile_func) (struct objfile *objfile, void *data),
1845              void *data)
1846 {
1847   int endpos;
1848
1849   for (endpos = exp->nelts; endpos > 0; )
1850     {
1851       int pos, args, oplen = 0;
1852
1853       operator_length (exp, endpos, &oplen, &args);
1854       gdb_assert (oplen > 0);
1855
1856       pos = endpos - oplen;
1857       if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1858                                                            objfile_func, data))
1859         return 1;
1860
1861       endpos = pos;
1862     }
1863
1864   return 0;
1865 }
1866
1867 /* Helper for exp_uses_objfile.  */
1868
1869 static int
1870 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1871 {
1872   struct objfile *objfile = objfile_voidp;
1873
1874   if (exp_objfile->separate_debug_objfile_backlink)
1875     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1876
1877   return exp_objfile == objfile;
1878 }
1879
1880 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1881    is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1882    file.  */
1883
1884 int
1885 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1886 {
1887   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1888
1889   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1890 }
1891
1892 /* See definition in parser-defs.h.  */
1893
1894 void
1895 increase_expout_size (struct parser_state *ps, size_t lenelt)
1896 {
1897   if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1898     {
1899       ps->expout_size = max (ps->expout_size * 2,
1900                              ps->expout_ptr + lenelt + 10);
1901       ps->expout = (struct expression *)
1902         xrealloc (ps->expout, (sizeof (struct expression)
1903                                + EXP_ELEM_TO_BYTES (ps->expout_size)));
1904     }
1905 }
1906
1907 void
1908 _initialize_parse (void)
1909 {
1910   type_stack.size = 0;
1911   type_stack.depth = 0;
1912   type_stack.elements = NULL;
1913
1914   add_setshow_zuinteger_cmd ("expression", class_maintenance,
1915                              &expressiondebug,
1916                              _("Set expression debugging."),
1917                              _("Show expression debugging."),
1918                              _("When non-zero, the internal representation "
1919                                "of expressions will be printed."),
1920                              NULL,
1921                              show_expressiondebug,
1922                              &setdebuglist, &showdebuglist);
1923   add_setshow_boolean_cmd ("parser", class_maintenance,
1924                             &parser_debug,
1925                            _("Set parser debugging."),
1926                            _("Show parser debugging."),
1927                            _("When non-zero, expression parser "
1928                              "tracing will be enabled."),
1929                             NULL,
1930                             show_parserdebug,
1931                             &setdebuglist, &showdebuglist);
1932 }