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