Delete TYPE_CODE_CLASS, it's just an alias of TYPE_CODE_STRUCT.
[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_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 symbol *sym = NULL;
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)
676     {
677       write_exp_elt_opcode (ps, OP_VAR_VALUE);
678       write_exp_elt_block (ps, block_found);    /* set by lookup_symbol */
679       write_exp_elt_sym (ps, sym);
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
1009       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
1010       switch (range_type)
1011         {
1012         case LOW_BOUND_DEFAULT:
1013         case HIGH_BOUND_DEFAULT:
1014           args = 1;
1015           break;
1016         case BOTH_BOUND_DEFAULT:
1017           args = 0;
1018           break;
1019         case NONE_BOUND_DEFAULT:
1020           args = 2;
1021           break;
1022         }
1023
1024       break;
1025
1026     default:
1027       args = 1 + (i < (int) BINOP_END);
1028     }
1029
1030   *oplenp = oplen;
1031   *argsp = args;
1032 }
1033
1034 /* Copy the subexpression ending just before index INEND in INEXPR
1035    into OUTEXPR, starting at index OUTBEG.
1036    In the process, convert it from suffix to prefix form.
1037    If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
1038    Otherwise, it returns the index of the subexpression which is the
1039    left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
1040
1041 static int
1042 prefixify_subexp (struct expression *inexpr,
1043                   struct expression *outexpr, int inend, int outbeg)
1044 {
1045   int oplen;
1046   int args;
1047   int i;
1048   int *arglens;
1049   int result = -1;
1050
1051   operator_length (inexpr, inend, &oplen, &args);
1052
1053   /* Copy the final operator itself, from the end of the input
1054      to the beginning of the output.  */
1055   inend -= oplen;
1056   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
1057           EXP_ELEM_TO_BYTES (oplen));
1058   outbeg += oplen;
1059
1060   if (expout_last_struct == inend)
1061     result = outbeg - oplen;
1062
1063   /* Find the lengths of the arg subexpressions.  */
1064   arglens = (int *) alloca (args * sizeof (int));
1065   for (i = args - 1; i >= 0; i--)
1066     {
1067       oplen = length_of_subexp (inexpr, inend);
1068       arglens[i] = oplen;
1069       inend -= oplen;
1070     }
1071
1072   /* Now copy each subexpression, preserving the order of
1073      the subexpressions, but prefixifying each one.
1074      In this loop, inend starts at the beginning of
1075      the expression this level is working on
1076      and marches forward over the arguments.
1077      outbeg does similarly in the output.  */
1078   for (i = 0; i < args; i++)
1079     {
1080       int r;
1081
1082       oplen = arglens[i];
1083       inend += oplen;
1084       r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1085       if (r != -1)
1086         {
1087           /* Return immediately.  We probably have only parsed a
1088              partial expression, so we don't want to try to reverse
1089              the other operands.  */
1090           return r;
1091         }
1092       outbeg += oplen;
1093     }
1094
1095   return result;
1096 }
1097 \f
1098 /* Read an expression from the string *STRINGPTR points to,
1099    parse it, and return a pointer to a struct expression that we malloc.
1100    Use block BLOCK as the lexical context for variable names;
1101    if BLOCK is zero, use the block of the selected stack frame.
1102    Meanwhile, advance *STRINGPTR to point after the expression,
1103    at the first nonwhite character that is not part of the expression
1104    (possibly a null character).
1105
1106    If COMMA is nonzero, stop if a comma is reached.  */
1107
1108 struct expression *
1109 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
1110              int comma)
1111 {
1112   return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
1113 }
1114
1115 static struct expression *
1116 parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
1117                       const struct block *block,
1118                       int comma, int void_context_p, int *out_subexp)
1119 {
1120   return parse_exp_in_context_1 (stringptr, pc, block, comma,
1121                                  void_context_p, out_subexp);
1122 }
1123
1124 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1125    no value is expected from the expression.
1126    OUT_SUBEXP is set when attempting to complete a field name; in this
1127    case it is set to the index of the subexpression on the
1128    left-hand-side of the struct op.  If not doing such completion, it
1129    is left untouched.  */
1130
1131 static struct expression *
1132 parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
1133                         const struct block *block,
1134                         int comma, int void_context_p, int *out_subexp)
1135 {
1136   volatile struct gdb_exception except;
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 (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1178       if (expression_context_block)
1179         expression_context_pc = BLOCK_START (expression_context_block);
1180     }
1181
1182   if (language_mode == language_mode_auto && block != NULL)
1183     {
1184       /* Find the language associated to the given context block.
1185          Default to the current language if it can not be determined.
1186
1187          Note that using the language corresponding to the current frame
1188          can sometimes give unexpected results.  For instance, this
1189          routine is often called several times during the inferior
1190          startup phase to re-parse breakpoint expressions after
1191          a new shared library has been loaded.  The language associated
1192          to the current frame at this moment is not relevant for
1193          the breakpoint.  Using it would therefore be silly, so it seems
1194          better to rely on the current language rather than relying on
1195          the current frame language to parse the expression.  That's why
1196          we do the following language detection only if the context block
1197          has been specifically provided.  */
1198       struct symbol *func = block_linkage_function (block);
1199
1200       if (func != NULL)
1201         lang = language_def (SYMBOL_LANGUAGE (func));
1202       if (lang == NULL || lang->la_language == language_unknown)
1203         lang = current_language;
1204     }
1205   else
1206     lang = current_language;
1207
1208   /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
1209      While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
1210      and others called from *.y) ensure CURRENT_LANGUAGE gets restored
1211      to the value matching SELECTED_FRAME as set by get_current_arch.  */
1212
1213   initialize_expout (&ps, 10, lang, get_current_arch ());
1214   inner_chain = make_cleanup_restore_current_language ();
1215   set_language (lang->la_language);
1216
1217   TRY_CATCH (except, RETURN_MASK_ALL)
1218     {
1219       if (lang->la_parser (&ps))
1220         lang->la_error (NULL);
1221     }
1222   if (except.reason < 0)
1223     {
1224       if (! parse_completion)
1225         {
1226           xfree (ps.expout);
1227           throw_exception (except);
1228         }
1229     }
1230
1231   reallocate_expout (&ps);
1232
1233   /* Convert expression from postfix form as generated by yacc
1234      parser, to a prefix form.  */
1235
1236   if (expressiondebug)
1237     dump_raw_expression (ps.expout, gdb_stdlog,
1238                          "before conversion to prefix form");
1239
1240   subexp = prefixify_expression (ps.expout);
1241   if (out_subexp)
1242     *out_subexp = subexp;
1243
1244   lang->la_post_parser (&ps.expout, void_context_p);
1245
1246   if (expressiondebug)
1247     dump_prefix_expression (ps.expout, gdb_stdlog);
1248
1249   do_cleanups (inner_chain);
1250   discard_cleanups (old_chain);
1251
1252   *stringptr = lexptr;
1253   return ps.expout;
1254 }
1255
1256 /* Parse STRING as an expression, and complain if this fails
1257    to use up all of the contents of STRING.  */
1258
1259 struct expression *
1260 parse_expression (const char *string)
1261 {
1262   struct expression *exp;
1263
1264   exp = parse_exp_1 (&string, 0, 0, 0);
1265   if (*string)
1266     error (_("Junk after end of expression."));
1267   return exp;
1268 }
1269
1270 /* Parse STRING as an expression.  If parsing ends in the middle of a
1271    field reference, return the type of the left-hand-side of the
1272    reference; furthermore, if the parsing ends in the field name,
1273    return the field name in *NAME.  If the parsing ends in the middle
1274    of a field reference, but the reference is somehow invalid, throw
1275    an exception.  In all other cases, return NULL.  Returned non-NULL
1276    *NAME must be freed by the caller.  */
1277
1278 struct type *
1279 parse_expression_for_completion (const char *string, char **name,
1280                                  enum type_code *code)
1281 {
1282   struct expression *exp = NULL;
1283   struct value *val;
1284   int subexp;
1285   volatile struct gdb_exception except;
1286
1287   TRY_CATCH (except, RETURN_MASK_ERROR)
1288     {
1289       parse_completion = 1;
1290       exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
1291     }
1292   parse_completion = 0;
1293   if (except.reason < 0 || ! exp)
1294     return NULL;
1295
1296   if (expout_tag_completion_type != TYPE_CODE_UNDEF)
1297     {
1298       *code = expout_tag_completion_type;
1299       *name = expout_completion_name;
1300       expout_completion_name = NULL;
1301       return NULL;
1302     }
1303
1304   if (expout_last_struct == -1)
1305     {
1306       xfree (exp);
1307       return NULL;
1308     }
1309
1310   *name = extract_field_op (exp, &subexp);
1311   if (!*name)
1312     {
1313       xfree (exp);
1314       return NULL;
1315     }
1316
1317   /* This might throw an exception.  If so, we want to let it
1318      propagate.  */
1319   val = evaluate_subexpression_type (exp, subexp);
1320   /* (*NAME) is a part of the EXP memory block freed below.  */
1321   *name = xstrdup (*name);
1322   xfree (exp);
1323
1324   return value_type (val);
1325 }
1326
1327 /* A post-parser that does nothing.  */
1328
1329 void
1330 null_post_parser (struct expression **exp, int void_context_p)
1331 {
1332 }
1333
1334 /* Parse floating point value P of length LEN.
1335    Return 0 (false) if invalid, 1 (true) if valid.
1336    The successfully parsed number is stored in D.
1337    *SUFFIX points to the suffix of the number in P.
1338
1339    NOTE: This accepts the floating point syntax that sscanf accepts.  */
1340
1341 int
1342 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1343 {
1344   char *copy;
1345   int n, num;
1346
1347   copy = xmalloc (len + 1);
1348   memcpy (copy, p, len);
1349   copy[len] = 0;
1350
1351   num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1352   xfree (copy);
1353
1354   /* The sscanf man page suggests not making any assumptions on the effect
1355      of %n on the result, so we don't.
1356      That is why we simply test num == 0.  */
1357   if (num == 0)
1358     return 0;
1359
1360   *suffix = p + n;
1361   return 1;
1362 }
1363
1364 /* Parse floating point value P of length LEN, using the C syntax for floats.
1365    Return 0 (false) if invalid, 1 (true) if valid.
1366    The successfully parsed number is stored in *D.
1367    Its type is taken from builtin_type (gdbarch) and is stored in *T.  */
1368
1369 int
1370 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1371                DOUBLEST *d, struct type **t)
1372 {
1373   const char *suffix;
1374   int suffix_len;
1375   const struct builtin_type *builtin_types = builtin_type (gdbarch);
1376
1377   if (! parse_float (p, len, d, &suffix))
1378     return 0;
1379
1380   suffix_len = p + len - suffix;
1381
1382   if (suffix_len == 0)
1383     *t = builtin_types->builtin_double;
1384   else if (suffix_len == 1)
1385     {
1386       /* Handle suffixes: 'f' for float, 'l' for long double.  */
1387       if (tolower (*suffix) == 'f')
1388         *t = builtin_types->builtin_float;
1389       else if (tolower (*suffix) == 'l')
1390         *t = builtin_types->builtin_long_double;
1391       else
1392         return 0;
1393     }
1394   else
1395     return 0;
1396
1397   return 1;
1398 }
1399 \f
1400 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1401    probably useful for any language which declares its types "backwards".  */
1402
1403 /* Ensure that there are HOWMUCH open slots on the type stack STACK.  */
1404
1405 static void
1406 type_stack_reserve (struct type_stack *stack, int howmuch)
1407 {
1408   if (stack->depth + howmuch >= stack->size)
1409     {
1410       stack->size *= 2;
1411       if (stack->size < howmuch)
1412         stack->size = howmuch;
1413       stack->elements = xrealloc (stack->elements,
1414                                   stack->size * sizeof (union type_stack_elt));
1415     }
1416 }
1417
1418 /* Ensure that there is a single open slot in the global type stack.  */
1419
1420 static void
1421 check_type_stack_depth (void)
1422 {
1423   type_stack_reserve (&type_stack, 1);
1424 }
1425
1426 /* A helper function for insert_type and insert_type_address_space.
1427    This does work of expanding the type stack and inserting the new
1428    element, ELEMENT, into the stack at location SLOT.  */
1429
1430 static void
1431 insert_into_type_stack (int slot, union type_stack_elt element)
1432 {
1433   check_type_stack_depth ();
1434
1435   if (slot < type_stack.depth)
1436     memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
1437              (type_stack.depth - slot) * sizeof (union type_stack_elt));
1438   type_stack.elements[slot] = element;
1439   ++type_stack.depth;
1440 }
1441
1442 /* Insert a new type, TP, at the bottom of the type stack.  If TP is
1443    tp_pointer or tp_reference, it is inserted at the bottom.  If TP is
1444    a qualifier, it is inserted at slot 1 (just above a previous
1445    tp_pointer) if there is anything on the stack, or simply pushed if
1446    the stack is empty.  Other values for TP are invalid.  */
1447
1448 void
1449 insert_type (enum type_pieces tp)
1450 {
1451   union type_stack_elt element;
1452   int slot;
1453
1454   gdb_assert (tp == tp_pointer || tp == tp_reference
1455               || tp == tp_const || tp == tp_volatile);
1456
1457   /* If there is anything on the stack (we know it will be a
1458      tp_pointer), insert the qualifier above it.  Otherwise, simply
1459      push this on the top of the stack.  */
1460   if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
1461     slot = 1;
1462   else
1463     slot = 0;
1464
1465   element.piece = tp;
1466   insert_into_type_stack (slot, element);
1467 }
1468
1469 void
1470 push_type (enum type_pieces tp)
1471 {
1472   check_type_stack_depth ();
1473   type_stack.elements[type_stack.depth++].piece = tp;
1474 }
1475
1476 void
1477 push_type_int (int n)
1478 {
1479   check_type_stack_depth ();
1480   type_stack.elements[type_stack.depth++].int_val = n;
1481 }
1482
1483 /* Insert a tp_space_identifier and the corresponding address space
1484    value into the stack.  STRING is the name of an address space, as
1485    recognized by address_space_name_to_int.  If the stack is empty,
1486    the new elements are simply pushed.  If the stack is not empty,
1487    this function assumes that the first item on the stack is a
1488    tp_pointer, and the new values are inserted above the first
1489    item.  */
1490
1491 void
1492 insert_type_address_space (struct parser_state *pstate, char *string)
1493 {
1494   union type_stack_elt element;
1495   int slot;
1496
1497   /* If there is anything on the stack (we know it will be a
1498      tp_pointer), insert the address space qualifier above it.
1499      Otherwise, simply push this on the top of the stack.  */
1500   if (type_stack.depth)
1501     slot = 1;
1502   else
1503     slot = 0;
1504
1505   element.piece = tp_space_identifier;
1506   insert_into_type_stack (slot, element);
1507   element.int_val = address_space_name_to_int (parse_gdbarch (pstate),
1508                                                string);
1509   insert_into_type_stack (slot, element);
1510 }
1511
1512 enum type_pieces
1513 pop_type (void)
1514 {
1515   if (type_stack.depth)
1516     return type_stack.elements[--type_stack.depth].piece;
1517   return tp_end;
1518 }
1519
1520 int
1521 pop_type_int (void)
1522 {
1523   if (type_stack.depth)
1524     return type_stack.elements[--type_stack.depth].int_val;
1525   /* "Can't happen".  */
1526   return 0;
1527 }
1528
1529 /* Pop a type list element from the global type stack.  */
1530
1531 static VEC (type_ptr) *
1532 pop_typelist (void)
1533 {
1534   gdb_assert (type_stack.depth);
1535   return type_stack.elements[--type_stack.depth].typelist_val;
1536 }
1537
1538 /* Pop a type_stack element from the global type stack.  */
1539
1540 static struct type_stack *
1541 pop_type_stack (void)
1542 {
1543   gdb_assert (type_stack.depth);
1544   return type_stack.elements[--type_stack.depth].stack_val;
1545 }
1546
1547 /* Append the elements of the type stack FROM to the type stack TO.
1548    Always returns TO.  */
1549
1550 struct type_stack *
1551 append_type_stack (struct type_stack *to, struct type_stack *from)
1552 {
1553   type_stack_reserve (to, from->depth);
1554
1555   memcpy (&to->elements[to->depth], &from->elements[0],
1556           from->depth * sizeof (union type_stack_elt));
1557   to->depth += from->depth;
1558
1559   return to;
1560 }
1561
1562 /* Push the type stack STACK as an element on the global type stack.  */
1563
1564 void
1565 push_type_stack (struct type_stack *stack)
1566 {
1567   check_type_stack_depth ();
1568   type_stack.elements[type_stack.depth++].stack_val = stack;
1569   push_type (tp_type_stack);
1570 }
1571
1572 /* Copy the global type stack into a newly allocated type stack and
1573    return it.  The global stack is cleared.  The returned type stack
1574    must be freed with type_stack_cleanup.  */
1575
1576 struct type_stack *
1577 get_type_stack (void)
1578 {
1579   struct type_stack *result = XNEW (struct type_stack);
1580
1581   *result = type_stack;
1582   type_stack.depth = 0;
1583   type_stack.size = 0;
1584   type_stack.elements = NULL;
1585
1586   return result;
1587 }
1588
1589 /* A cleanup function that destroys a single type stack.  */
1590
1591 void
1592 type_stack_cleanup (void *arg)
1593 {
1594   struct type_stack *stack = arg;
1595
1596   xfree (stack->elements);
1597   xfree (stack);
1598 }
1599
1600 /* Push a function type with arguments onto the global type stack.
1601    LIST holds the argument types.  If the final item in LIST is NULL,
1602    then the function will be varargs.  */
1603
1604 void
1605 push_typelist (VEC (type_ptr) *list)
1606 {
1607   check_type_stack_depth ();
1608   type_stack.elements[type_stack.depth++].typelist_val = list;
1609   push_type (tp_function_with_arguments);
1610 }
1611
1612 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1613    as modified by all the stuff on the stack.  */
1614 struct type *
1615 follow_types (struct type *follow_type)
1616 {
1617   int done = 0;
1618   int make_const = 0;
1619   int make_volatile = 0;
1620   int make_addr_space = 0;
1621   int array_size;
1622
1623   while (!done)
1624     switch (pop_type ())
1625       {
1626       case tp_end:
1627         done = 1;
1628         if (make_const)
1629           follow_type = make_cv_type (make_const, 
1630                                       TYPE_VOLATILE (follow_type), 
1631                                       follow_type, 0);
1632         if (make_volatile)
1633           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1634                                       make_volatile, 
1635                                       follow_type, 0);
1636         if (make_addr_space)
1637           follow_type = make_type_with_address_space (follow_type, 
1638                                                       make_addr_space);
1639         make_const = make_volatile = 0;
1640         make_addr_space = 0;
1641         break;
1642       case tp_const:
1643         make_const = 1;
1644         break;
1645       case tp_volatile:
1646         make_volatile = 1;
1647         break;
1648       case tp_space_identifier:
1649         make_addr_space = pop_type_int ();
1650         break;
1651       case tp_pointer:
1652         follow_type = lookup_pointer_type (follow_type);
1653         if (make_const)
1654           follow_type = make_cv_type (make_const, 
1655                                       TYPE_VOLATILE (follow_type), 
1656                                       follow_type, 0);
1657         if (make_volatile)
1658           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1659                                       make_volatile, 
1660                                       follow_type, 0);
1661         if (make_addr_space)
1662           follow_type = make_type_with_address_space (follow_type, 
1663                                                       make_addr_space);
1664         make_const = make_volatile = 0;
1665         make_addr_space = 0;
1666         break;
1667       case tp_reference:
1668         follow_type = lookup_reference_type (follow_type);
1669         if (make_const)
1670           follow_type = make_cv_type (make_const, 
1671                                       TYPE_VOLATILE (follow_type), 
1672                                       follow_type, 0);
1673         if (make_volatile)
1674           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1675                                       make_volatile, 
1676                                       follow_type, 0);
1677         if (make_addr_space)
1678           follow_type = make_type_with_address_space (follow_type, 
1679                                                       make_addr_space);
1680         make_const = make_volatile = 0;
1681         make_addr_space = 0;
1682         break;
1683       case tp_array:
1684         array_size = pop_type_int ();
1685         /* FIXME-type-allocation: need a way to free this type when we are
1686            done with it.  */
1687         follow_type =
1688           lookup_array_range_type (follow_type,
1689                                    0, array_size >= 0 ? array_size - 1 : 0);
1690         if (array_size < 0)
1691           TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (follow_type))
1692             = PROP_UNDEFINED;
1693         break;
1694       case tp_function:
1695         /* FIXME-type-allocation: need a way to free this type when we are
1696            done with it.  */
1697         follow_type = lookup_function_type (follow_type);
1698         break;
1699
1700       case tp_function_with_arguments:
1701         {
1702           VEC (type_ptr) *args = pop_typelist ();
1703
1704           follow_type
1705             = lookup_function_type_with_arguments (follow_type,
1706                                                    VEC_length (type_ptr, args),
1707                                                    VEC_address (type_ptr,
1708                                                                 args));
1709           VEC_free (type_ptr, args);
1710         }
1711         break;
1712
1713       case tp_type_stack:
1714         {
1715           struct type_stack *stack = pop_type_stack ();
1716           /* Sort of ugly, but not really much worse than the
1717              alternatives.  */
1718           struct type_stack save = type_stack;
1719
1720           type_stack = *stack;
1721           follow_type = follow_types (follow_type);
1722           gdb_assert (type_stack.depth == 0);
1723
1724           type_stack = save;
1725         }
1726         break;
1727       default:
1728         gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
1729       }
1730   return follow_type;
1731 }
1732 \f
1733 /* This function avoids direct calls to fprintf 
1734    in the parser generated debug code.  */
1735 void
1736 parser_fprintf (FILE *x, const char *y, ...)
1737
1738   va_list args;
1739
1740   va_start (args, y);
1741   if (x == stderr)
1742     vfprintf_unfiltered (gdb_stderr, y, args); 
1743   else
1744     {
1745       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1746       vfprintf_unfiltered (gdb_stderr, y, args);
1747     }
1748   va_end (args);
1749 }
1750
1751 /* Implementation of the exp_descriptor method operator_check.  */
1752
1753 int
1754 operator_check_standard (struct expression *exp, int pos,
1755                          int (*objfile_func) (struct objfile *objfile,
1756                                               void *data),
1757                          void *data)
1758 {
1759   const union exp_element *const elts = exp->elts;
1760   struct type *type = NULL;
1761   struct objfile *objfile = NULL;
1762
1763   /* Extended operators should have been already handled by exp_descriptor
1764      iterate method of its specific language.  */
1765   gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1766
1767   /* Track the callers of write_exp_elt_type for this table.  */
1768
1769   switch (elts[pos].opcode)
1770     {
1771     case BINOP_VAL:
1772     case OP_COMPLEX:
1773     case OP_DECFLOAT:
1774     case OP_DOUBLE:
1775     case OP_LONG:
1776     case OP_SCOPE:
1777     case OP_TYPE:
1778     case UNOP_CAST:
1779     case UNOP_MAX:
1780     case UNOP_MEMVAL:
1781     case UNOP_MIN:
1782       type = elts[pos + 1].type;
1783       break;
1784
1785     case TYPE_INSTANCE:
1786       {
1787         LONGEST arg, nargs = elts[pos + 1].longconst;
1788
1789         for (arg = 0; arg < nargs; arg++)
1790           {
1791             struct type *type = elts[pos + 2 + arg].type;
1792             struct objfile *objfile = TYPE_OBJFILE (type);
1793
1794             if (objfile && (*objfile_func) (objfile, data))
1795               return 1;
1796           }
1797       }
1798       break;
1799
1800     case UNOP_MEMVAL_TLS:
1801       objfile = elts[pos + 1].objfile;
1802       type = elts[pos + 2].type;
1803       break;
1804
1805     case OP_VAR_VALUE:
1806       {
1807         const struct block *const block = elts[pos + 1].block;
1808         const struct symbol *const symbol = elts[pos + 2].symbol;
1809
1810         /* Check objfile where the variable itself is placed.
1811            SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1812         if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
1813           return 1;
1814
1815         /* Check objfile where is placed the code touching the variable.  */
1816         objfile = lookup_objfile_from_block (block);
1817
1818         type = SYMBOL_TYPE (symbol);
1819       }
1820       break;
1821     }
1822
1823   /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1824
1825   if (type && TYPE_OBJFILE (type)
1826       && (*objfile_func) (TYPE_OBJFILE (type), data))
1827     return 1;
1828   if (objfile && (*objfile_func) (objfile, data))
1829     return 1;
1830
1831   return 0;
1832 }
1833
1834 /* Call OBJFILE_FUNC for any objfile found being referenced by EXP.
1835    OBJFILE_FUNC is never called with NULL OBJFILE.  OBJFILE_FUNC get
1836    passed an arbitrary caller supplied DATA pointer.  If OBJFILE_FUNC
1837    returns non-zero value then (any other) non-zero value is immediately
1838    returned to the caller.  Otherwise zero is returned after iterating
1839    through whole EXP.  */
1840
1841 static int
1842 exp_iterate (struct expression *exp,
1843              int (*objfile_func) (struct objfile *objfile, void *data),
1844              void *data)
1845 {
1846   int endpos;
1847
1848   for (endpos = exp->nelts; endpos > 0; )
1849     {
1850       int pos, args, oplen = 0;
1851
1852       operator_length (exp, endpos, &oplen, &args);
1853       gdb_assert (oplen > 0);
1854
1855       pos = endpos - oplen;
1856       if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1857                                                            objfile_func, data))
1858         return 1;
1859
1860       endpos = pos;
1861     }
1862
1863   return 0;
1864 }
1865
1866 /* Helper for exp_uses_objfile.  */
1867
1868 static int
1869 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1870 {
1871   struct objfile *objfile = objfile_voidp;
1872
1873   if (exp_objfile->separate_debug_objfile_backlink)
1874     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1875
1876   return exp_objfile == objfile;
1877 }
1878
1879 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1880    is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1881    file.  */
1882
1883 int
1884 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1885 {
1886   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1887
1888   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1889 }
1890
1891 /* See definition in parser-defs.h.  */
1892
1893 void
1894 increase_expout_size (struct parser_state *ps, size_t lenelt)
1895 {
1896   if ((ps->expout_ptr + lenelt) >= ps->expout_size)
1897     {
1898       ps->expout_size = max (ps->expout_size * 2,
1899                              ps->expout_ptr + lenelt + 10);
1900       ps->expout = (struct expression *)
1901         xrealloc (ps->expout, (sizeof (struct expression)
1902                                + EXP_ELEM_TO_BYTES (ps->expout_size)));
1903     }
1904 }
1905
1906 void
1907 _initialize_parse (void)
1908 {
1909   type_stack.size = 0;
1910   type_stack.depth = 0;
1911   type_stack.elements = NULL;
1912
1913   add_setshow_zuinteger_cmd ("expression", class_maintenance,
1914                              &expressiondebug,
1915                              _("Set expression debugging."),
1916                              _("Show expression debugging."),
1917                              _("When non-zero, the internal representation "
1918                                "of expressions will be printed."),
1919                              NULL,
1920                              show_expressiondebug,
1921                              &setdebuglist, &showdebuglist);
1922   add_setshow_boolean_cmd ("parser", class_maintenance,
1923                             &parser_debug,
1924                            _("Set parser debugging."),
1925                            _("Show parser debugging."),
1926                            _("When non-zero, expression parser "
1927                              "tracing will be enabled."),
1928                             NULL,
1929                             show_parserdebug,
1930                             &setdebuglist, &showdebuglist);
1931 }