2011-01-10 Michael Snyder <msnyder@vmware.com>
[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       /* In this case, assume we have a code symbol instead of
491          a data symbol.  */
492       type = mst_text;
493       section = NULL;
494       addr = pc;
495     }
496
497   if (overlay_debugging)
498     addr = symbol_overlayed_address (addr, section);
499
500   write_exp_elt_opcode (OP_LONG);
501   /* Let's make the type big enough to hold a 64-bit address.  */
502   write_exp_elt_type (objfile_type (objfile)->builtin_core_addr);
503   write_exp_elt_longcst ((LONGEST) addr);
504   write_exp_elt_opcode (OP_LONG);
505
506   if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
507     {
508       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
509       write_exp_elt_objfile (objfile);
510       write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol);
511       write_exp_elt_opcode (UNOP_MEMVAL_TLS);
512       return;
513     }
514
515   write_exp_elt_opcode (UNOP_MEMVAL);
516   switch (type)
517     {
518     case mst_text:
519     case mst_file_text:
520     case mst_solib_trampoline:
521       write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol);
522       break;
523
524     case mst_data:
525     case mst_file_data:
526     case mst_bss:
527     case mst_file_bss:
528       write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol);
529       break;
530
531     default:
532       write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol);
533       break;
534     }
535   write_exp_elt_opcode (UNOP_MEMVAL);
536 }
537
538 /* Mark the current index as the starting location of a structure
539    expression.  This is used when completing on field names.  */
540
541 void
542 mark_struct_expression (void)
543 {
544   expout_last_struct = expout_ptr;
545 }
546
547 \f
548 /* Recognize tokens that start with '$'.  These include:
549
550    $regname     A native register name or a "standard
551    register name".
552
553    $variable    A convenience variable with a name chosen
554    by the user.
555
556    $digits              Value history with index <digits>, starting
557    from the first value which has index 1.
558
559    $$digits     Value history with index <digits> relative
560    to the last value.  I.e. $$0 is the last
561    value, $$1 is the one previous to that, $$2
562    is the one previous to $$1, etc.
563
564    $ | $0 | $$0 The last value in the value history.
565
566    $$           An abbreviation for the second to the last
567    value in the value history, I.e. $$1  */
568
569 void
570 write_dollar_variable (struct stoken str)
571 {
572   struct symbol *sym = NULL;
573   struct minimal_symbol *msym = NULL;
574   struct internalvar *isym = NULL;
575
576   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
577      and $$digits (equivalent to $<-digits> if you could type that).  */
578
579   int negate = 0;
580   int i = 1;
581   /* Double dollar means negate the number and add -1 as well.
582      Thus $$ alone means -1.  */
583   if (str.length >= 2 && str.ptr[1] == '$')
584     {
585       negate = 1;
586       i = 2;
587     }
588   if (i == str.length)
589     {
590       /* Just dollars (one or two).  */
591       i = -negate;
592       goto handle_last;
593     }
594   /* Is the rest of the token digits?  */
595   for (; i < str.length; i++)
596     if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
597       break;
598   if (i == str.length)
599     {
600       i = atoi (str.ptr + 1 + negate);
601       if (negate)
602         i = -i;
603       goto handle_last;
604     }
605
606   /* Handle tokens that refer to machine registers:
607      $ followed by a register name.  */
608   i = user_reg_map_name_to_regnum (parse_gdbarch,
609                                    str.ptr + 1, str.length - 1);
610   if (i >= 0)
611     goto handle_register;
612
613   /* Any names starting with $ are probably debugger internal variables.  */
614
615   isym = lookup_only_internalvar (copy_name (str) + 1);
616   if (isym)
617     {
618       write_exp_elt_opcode (OP_INTERNALVAR);
619       write_exp_elt_intern (isym);
620       write_exp_elt_opcode (OP_INTERNALVAR);
621       return;
622     }
623
624   /* On some systems, such as HP-UX and hppa-linux, certain system routines 
625      have names beginning with $ or $$.  Check for those, first.  */
626
627   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
628                        VAR_DOMAIN, (int *) NULL);
629   if (sym)
630     {
631       write_exp_elt_opcode (OP_VAR_VALUE);
632       write_exp_elt_block (block_found);        /* set by lookup_symbol */
633       write_exp_elt_sym (sym);
634       write_exp_elt_opcode (OP_VAR_VALUE);
635       return;
636     }
637   msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
638   if (msym)
639     {
640       write_exp_msymbol (msym);
641       return;
642     }
643
644   /* Any other names are assumed to be debugger internal variables.  */
645
646   write_exp_elt_opcode (OP_INTERNALVAR);
647   write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
648   write_exp_elt_opcode (OP_INTERNALVAR);
649   return;
650 handle_last:
651   write_exp_elt_opcode (OP_LAST);
652   write_exp_elt_longcst ((LONGEST) i);
653   write_exp_elt_opcode (OP_LAST);
654   return;
655 handle_register:
656   write_exp_elt_opcode (OP_REGISTER);
657   str.length--;
658   str.ptr++;
659   write_exp_string (str);
660   write_exp_elt_opcode (OP_REGISTER);
661   return;
662 }
663
664
665 char *
666 find_template_name_end (char *p)
667 {
668   int depth = 1;
669   int just_seen_right = 0;
670   int just_seen_colon = 0;
671   int just_seen_space = 0;
672
673   if (!p || (*p != '<'))
674     return 0;
675
676   while (*++p)
677     {
678       switch (*p)
679         {
680         case '\'':
681         case '\"':
682         case '{':
683         case '}':
684           /* In future, may want to allow these??  */
685           return 0;
686         case '<':
687           depth++;              /* start nested template */
688           if (just_seen_colon || just_seen_right || just_seen_space)
689             return 0;           /* but not after : or :: or > or space */
690           break;
691         case '>':
692           if (just_seen_colon || just_seen_right)
693             return 0;           /* end a (nested?) template */
694           just_seen_right = 1;  /* but not after : or :: */
695           if (--depth == 0)     /* also disallow >>, insist on > > */
696             return ++p;         /* if outermost ended, return */
697           break;
698         case ':':
699           if (just_seen_space || (just_seen_colon > 1))
700             return 0;           /* nested class spec coming up */
701           just_seen_colon++;    /* we allow :: but not :::: */
702           break;
703         case ' ':
704           break;
705         default:
706           if (!((*p >= 'a' && *p <= 'z') ||     /* allow token chars */
707                 (*p >= 'A' && *p <= 'Z') ||
708                 (*p >= '0' && *p <= '9') ||
709                 (*p == '_') || (*p == ',') ||   /* commas for template args */
710                 (*p == '&') || (*p == '*') ||   /* pointer and ref types */
711                 (*p == '(') || (*p == ')') ||   /* function types */
712                 (*p == '[') || (*p == ']')))    /* array types */
713             return 0;
714         }
715       if (*p != ' ')
716         just_seen_space = 0;
717       if (*p != ':')
718         just_seen_colon = 0;
719       if (*p != '>')
720         just_seen_right = 0;
721     }
722   return 0;
723 }
724 \f
725
726
727 /* Return a null-terminated temporary copy of the name
728    of a string token.  */
729
730 char *
731 copy_name (struct stoken token)
732 {
733   /* Make sure there's enough space for the token.  */
734   if (namecopy_size < token.length + 1)
735     {
736       namecopy_size = token.length + 1;
737       namecopy = xrealloc (namecopy, token.length + 1);
738     }
739       
740   memcpy (namecopy, token.ptr, token.length);
741   namecopy[token.length] = 0;
742
743   return namecopy;
744 }
745 \f
746 /* Reverse an expression from suffix form (in which it is constructed)
747    to prefix form (in which we can conveniently print or execute it).
748    Ordinarily this always returns -1.  However, if EXPOUT_LAST_STRUCT
749    is not -1 (i.e., we are trying to complete a field name), it will
750    return the index of the subexpression which is the left-hand-side
751    of the struct operation at EXPOUT_LAST_STRUCT.  */
752
753 static int
754 prefixify_expression (struct expression *expr)
755 {
756   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
757   struct expression *temp;
758   int inpos = expr->nelts, outpos = 0;
759
760   temp = (struct expression *) alloca (len);
761
762   /* Copy the original expression into temp.  */
763   memcpy (temp, expr, len);
764
765   return prefixify_subexp (temp, expr, inpos, outpos);
766 }
767
768 /* Return the number of exp_elements in the postfix subexpression 
769    of EXPR whose operator is at index ENDPOS - 1 in EXPR.  */
770
771 int
772 length_of_subexp (struct expression *expr, int endpos)
773 {
774   int oplen, args;
775
776   operator_length (expr, endpos, &oplen, &args);
777
778   while (args > 0)
779     {
780       oplen += length_of_subexp (expr, endpos - oplen);
781       args--;
782     }
783
784   return oplen;
785 }
786
787 /* Sets *OPLENP to the length of the operator whose (last) index is 
788    ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
789    operator takes.  */
790
791 void
792 operator_length (const struct expression *expr, int endpos, int *oplenp,
793                  int *argsp)
794 {
795   expr->language_defn->la_exp_desc->operator_length (expr, endpos,
796                                                      oplenp, argsp);
797 }
798
799 /* Default value for operator_length in exp_descriptor vectors.  */
800
801 void
802 operator_length_standard (const struct expression *expr, int endpos,
803                           int *oplenp, int *argsp)
804 {
805   int oplen = 1;
806   int args = 0;
807   enum f90_range_type range_type;
808   int i;
809
810   if (endpos < 1)
811     error (_("?error in operator_length_standard"));
812
813   i = (int) expr->elts[endpos - 1].opcode;
814
815   switch (i)
816     {
817       /* C++  */
818     case OP_SCOPE:
819       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
820       oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
821       break;
822
823     case OP_LONG:
824     case OP_DOUBLE:
825     case OP_DECFLOAT:
826     case OP_VAR_VALUE:
827       oplen = 4;
828       break;
829
830     case OP_TYPE:
831     case OP_BOOL:
832     case OP_LAST:
833     case OP_INTERNALVAR:
834       oplen = 3;
835       break;
836
837     case OP_COMPLEX:
838       oplen = 3;
839       args = 2;
840       break;
841
842     case OP_FUNCALL:
843     case OP_F77_UNDETERMINED_ARGLIST:
844       oplen = 3;
845       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
846       break;
847
848     case TYPE_INSTANCE:
849       oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
850       args = 1;
851       break;
852
853     case OP_OBJC_MSGCALL:       /* Objective C message (method) call.  */
854       oplen = 4;
855       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
856       break;
857
858     case UNOP_MAX:
859     case UNOP_MIN:
860       oplen = 3;
861       break;
862
863     case BINOP_VAL:
864     case UNOP_CAST:
865     case UNOP_DYNAMIC_CAST:
866     case UNOP_REINTERPRET_CAST:
867     case UNOP_MEMVAL:
868       oplen = 3;
869       args = 1;
870       break;
871
872     case UNOP_MEMVAL_TLS:
873       oplen = 4;
874       args = 1;
875       break;
876
877     case UNOP_ABS:
878     case UNOP_CAP:
879     case UNOP_CHR:
880     case UNOP_FLOAT:
881     case UNOP_HIGH:
882     case UNOP_ODD:
883     case UNOP_ORD:
884     case UNOP_TRUNC:
885       oplen = 1;
886       args = 1;
887       break;
888
889     case OP_ADL_FUNC:
890       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
891       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
892       oplen++;
893       oplen++;
894       break;
895
896     case OP_LABELED:
897     case STRUCTOP_STRUCT:
898     case STRUCTOP_PTR:
899       args = 1;
900       /* fall through */
901     case OP_REGISTER:
902     case OP_M2_STRING:
903     case OP_STRING:
904     case OP_OBJC_NSSTRING:      /* Objective C Foundation Class
905                                    NSString constant.  */
906     case OP_OBJC_SELECTOR:      /* Objective C "@selector" pseudo-op.  */
907     case OP_NAME:
908       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
909       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
910       break;
911
912     case OP_BITSTRING:
913       oplen = longest_to_int (expr->elts[endpos - 2].longconst);
914       oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
915       oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
916       break;
917
918     case OP_ARRAY:
919       oplen = 4;
920       args = longest_to_int (expr->elts[endpos - 2].longconst);
921       args -= longest_to_int (expr->elts[endpos - 3].longconst);
922       args += 1;
923       break;
924
925     case TERNOP_COND:
926     case TERNOP_SLICE:
927     case TERNOP_SLICE_COUNT:
928       args = 3;
929       break;
930
931       /* Modula-2 */
932     case MULTI_SUBSCRIPT:
933       oplen = 3;
934       args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
935       break;
936
937     case BINOP_ASSIGN_MODIFY:
938       oplen = 3;
939       args = 2;
940       break;
941
942       /* C++ */
943     case OP_THIS:
944     case OP_OBJC_SELF:
945       oplen = 2;
946       break;
947
948     case OP_F90_RANGE:
949       oplen = 3;
950
951       range_type = longest_to_int (expr->elts[endpos - 2].longconst);
952       switch (range_type)
953         {
954         case LOW_BOUND_DEFAULT:
955         case HIGH_BOUND_DEFAULT:
956           args = 1;
957           break;
958         case BOTH_BOUND_DEFAULT:
959           args = 0;
960           break;
961         case NONE_BOUND_DEFAULT:
962           args = 2;
963           break;
964         }
965
966       break;
967
968     default:
969       args = 1 + (i < (int) BINOP_END);
970     }
971
972   *oplenp = oplen;
973   *argsp = args;
974 }
975
976 /* Copy the subexpression ending just before index INEND in INEXPR
977    into OUTEXPR, starting at index OUTBEG.
978    In the process, convert it from suffix to prefix form.
979    If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
980    Otherwise, it returns the index of the subexpression which is the
981    left-hand-side of the expression at EXPOUT_LAST_STRUCT.  */
982
983 static int
984 prefixify_subexp (struct expression *inexpr,
985                   struct expression *outexpr, int inend, int outbeg)
986 {
987   int oplen;
988   int args;
989   int i;
990   int *arglens;
991   int result = -1;
992
993   operator_length (inexpr, inend, &oplen, &args);
994
995   /* Copy the final operator itself, from the end of the input
996      to the beginning of the output.  */
997   inend -= oplen;
998   memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
999           EXP_ELEM_TO_BYTES (oplen));
1000   outbeg += oplen;
1001
1002   if (expout_last_struct == inend)
1003     result = outbeg - oplen;
1004
1005   /* Find the lengths of the arg subexpressions.  */
1006   arglens = (int *) alloca (args * sizeof (int));
1007   for (i = args - 1; i >= 0; i--)
1008     {
1009       oplen = length_of_subexp (inexpr, inend);
1010       arglens[i] = oplen;
1011       inend -= oplen;
1012     }
1013
1014   /* Now copy each subexpression, preserving the order of
1015      the subexpressions, but prefixifying each one.
1016      In this loop, inend starts at the beginning of
1017      the expression this level is working on
1018      and marches forward over the arguments.
1019      outbeg does similarly in the output.  */
1020   for (i = 0; i < args; i++)
1021     {
1022       int r;
1023
1024       oplen = arglens[i];
1025       inend += oplen;
1026       r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
1027       if (r != -1)
1028         {
1029           /* Return immediately.  We probably have only parsed a
1030              partial expression, so we don't want to try to reverse
1031              the other operands.  */
1032           return r;
1033         }
1034       outbeg += oplen;
1035     }
1036
1037   return result;
1038 }
1039 \f
1040 /* Read an expression from the string *STRINGPTR points to,
1041    parse it, and return a pointer to a  struct expression  that we malloc.
1042    Use block BLOCK as the lexical context for variable names;
1043    if BLOCK is zero, use the block of the selected stack frame.
1044    Meanwhile, advance *STRINGPTR to point after the expression,
1045    at the first nonwhite character that is not part of the expression
1046    (possibly a null character).
1047
1048    If COMMA is nonzero, stop if a comma is reached.  */
1049
1050 struct expression *
1051 parse_exp_1 (char **stringptr, struct block *block, int comma)
1052 {
1053   return parse_exp_in_context (stringptr, block, comma, 0, NULL);
1054 }
1055
1056 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
1057    no value is expected from the expression.
1058    OUT_SUBEXP is set when attempting to complete a field name; in this
1059    case it is set to the index of the subexpression on the
1060    left-hand-side of the struct op.  If not doing such completion, it
1061    is left untouched.  */
1062
1063 static struct expression *
1064 parse_exp_in_context (char **stringptr, struct block *block, int comma, 
1065                       int void_context_p, int *out_subexp)
1066 {
1067   volatile struct gdb_exception except;
1068   struct cleanup *old_chain;
1069   const struct language_defn *lang = NULL;
1070   int subexp;
1071
1072   lexptr = *stringptr;
1073   prev_lexptr = NULL;
1074
1075   paren_depth = 0;
1076   type_stack_depth = 0;
1077   expout_last_struct = -1;
1078
1079   comma_terminates = comma;
1080
1081   if (lexptr == 0 || *lexptr == 0)
1082     error_no_arg (_("expression to compute"));
1083
1084   old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
1085   funcall_chain = 0;
1086
1087   expression_context_block = block;
1088
1089   /* If no context specified, try using the current frame, if any.  */
1090   if (!expression_context_block)
1091     expression_context_block = get_selected_block (&expression_context_pc);
1092   else
1093     expression_context_pc = BLOCK_START (expression_context_block);
1094
1095   /* Fall back to using the current source static context, if any.  */
1096
1097   if (!expression_context_block)
1098     {
1099       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
1100       if (cursal.symtab)
1101         expression_context_block
1102           = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
1103       if (expression_context_block)
1104         expression_context_pc = BLOCK_START (expression_context_block);
1105     }
1106
1107   if (language_mode == language_mode_auto && block != NULL)
1108     {
1109       /* Find the language associated to the given context block.
1110          Default to the current language if it can not be determined.
1111
1112          Note that using the language corresponding to the current frame
1113          can sometimes give unexpected results.  For instance, this
1114          routine is often called several times during the inferior
1115          startup phase to re-parse breakpoint expressions after
1116          a new shared library has been loaded.  The language associated
1117          to the current frame at this moment is not relevant for
1118          the breakpoint.  Using it would therefore be silly, so it seems
1119          better to rely on the current language rather than relying on
1120          the current frame language to parse the expression.  That's why
1121          we do the following language detection only if the context block
1122          has been specifically provided.  */
1123       struct symbol *func = block_linkage_function (block);
1124
1125       if (func != NULL)
1126         lang = language_def (SYMBOL_LANGUAGE (func));
1127       if (lang == NULL || lang->la_language == language_unknown)
1128         lang = current_language;
1129     }
1130   else
1131     lang = current_language;
1132
1133   expout_size = 10;
1134   expout_ptr = 0;
1135   expout = (struct expression *)
1136     xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size));
1137   expout->language_defn = lang;
1138   expout->gdbarch = get_current_arch ();
1139
1140   TRY_CATCH (except, RETURN_MASK_ALL)
1141     {
1142       if (lang->la_parser ())
1143         lang->la_error (NULL);
1144     }
1145   if (except.reason < 0)
1146     {
1147       if (! in_parse_field)
1148         {
1149           xfree (expout);
1150           throw_exception (except);
1151         }
1152     }
1153
1154   discard_cleanups (old_chain);
1155
1156   /* Record the actual number of expression elements, and then
1157      reallocate the expression memory so that we free up any
1158      excess elements.  */
1159
1160   expout->nelts = expout_ptr;
1161   expout = (struct expression *)
1162     xrealloc ((char *) expout,
1163               sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));;
1164
1165   /* Convert expression from postfix form as generated by yacc
1166      parser, to a prefix form.  */
1167
1168   if (expressiondebug)
1169     dump_raw_expression (expout, gdb_stdlog,
1170                          "before conversion to prefix form");
1171
1172   subexp = prefixify_expression (expout);
1173   if (out_subexp)
1174     *out_subexp = subexp;
1175
1176   lang->la_post_parser (&expout, void_context_p);
1177
1178   if (expressiondebug)
1179     dump_prefix_expression (expout, gdb_stdlog);
1180
1181   *stringptr = lexptr;
1182   return expout;
1183 }
1184
1185 /* Parse STRING as an expression, and complain if this fails
1186    to use up all of the contents of STRING.  */
1187
1188 struct expression *
1189 parse_expression (char *string)
1190 {
1191   struct expression *exp;
1192
1193   exp = parse_exp_1 (&string, 0, 0);
1194   if (*string)
1195     error (_("Junk after end of expression."));
1196   return exp;
1197 }
1198
1199 /* Parse STRING as an expression.  If parsing ends in the middle of a
1200    field reference, return the type of the left-hand-side of the
1201    reference; furthermore, if the parsing ends in the field name,
1202    return the field name in *NAME.  If the parsing ends in the middle
1203    of a field reference, but the reference is somehow invalid, throw
1204    an exception.  In all other cases, return NULL.  Returned non-NULL
1205    *NAME must be freed by the caller.  */
1206
1207 struct type *
1208 parse_field_expression (char *string, char **name)
1209 {
1210   struct expression *exp = NULL;
1211   struct value *val;
1212   int subexp;
1213   volatile struct gdb_exception except;
1214
1215   TRY_CATCH (except, RETURN_MASK_ERROR)
1216     {
1217       in_parse_field = 1;
1218       exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
1219     }
1220   in_parse_field = 0;
1221   if (except.reason < 0 || ! exp)
1222     return NULL;
1223   if (expout_last_struct == -1)
1224     {
1225       xfree (exp);
1226       return NULL;
1227     }
1228
1229   *name = extract_field_op (exp, &subexp);
1230   if (!*name)
1231     {
1232       xfree (exp);
1233       return NULL;
1234     }
1235
1236   /* This might throw an exception.  If so, we want to let it
1237      propagate.  */
1238   val = evaluate_subexpression_type (exp, subexp);
1239   /* (*NAME) is a part of the EXP memory block freed below.  */
1240   *name = xstrdup (*name);
1241   xfree (exp);
1242
1243   return value_type (val);
1244 }
1245
1246 /* A post-parser that does nothing.  */
1247
1248 void
1249 null_post_parser (struct expression **exp, int void_context_p)
1250 {
1251 }
1252
1253 /* Parse floating point value P of length LEN.
1254    Return 0 (false) if invalid, 1 (true) if valid.
1255    The successfully parsed number is stored in D.
1256    *SUFFIX points to the suffix of the number in P.
1257
1258    NOTE: This accepts the floating point syntax that sscanf accepts.  */
1259
1260 int
1261 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
1262 {
1263   char *copy;
1264   char *s;
1265   int n, num;
1266
1267   copy = xmalloc (len + 1);
1268   memcpy (copy, p, len);
1269   copy[len] = 0;
1270
1271   num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
1272   xfree (copy);
1273
1274   /* The sscanf man page suggests not making any assumptions on the effect
1275      of %n on the result, so we don't.
1276      That is why we simply test num == 0.  */
1277   if (num == 0)
1278     return 0;
1279
1280   *suffix = p + n;
1281   return 1;
1282 }
1283
1284 /* Parse floating point value P of length LEN, using the C syntax for floats.
1285    Return 0 (false) if invalid, 1 (true) if valid.
1286    The successfully parsed number is stored in *D.
1287    Its type is taken from builtin_type (gdbarch) and is stored in *T.  */
1288
1289 int
1290 parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
1291                DOUBLEST *d, struct type **t)
1292 {
1293   const char *suffix;
1294   int suffix_len;
1295   const struct builtin_type *builtin_types = builtin_type (gdbarch);
1296
1297   if (! parse_float (p, len, d, &suffix))
1298     return 0;
1299
1300   suffix_len = p + len - suffix;
1301
1302   if (suffix_len == 0)
1303     *t = builtin_types->builtin_double;
1304   else if (suffix_len == 1)
1305     {
1306       /* Handle suffixes: 'f' for float, 'l' for long double.  */
1307       if (tolower (*suffix) == 'f')
1308         *t = builtin_types->builtin_float;
1309       else if (tolower (*suffix) == 'l')
1310         *t = builtin_types->builtin_long_double;
1311       else
1312         return 0;
1313     }
1314   else
1315     return 0;
1316
1317   return 1;
1318 }
1319 \f
1320 /* Stuff for maintaining a stack of types.  Currently just used by C, but
1321    probably useful for any language which declares its types "backwards".  */
1322
1323 static void
1324 check_type_stack_depth (void)
1325 {
1326   if (type_stack_depth == type_stack_size)
1327     {
1328       type_stack_size *= 2;
1329       type_stack = (union type_stack_elt *)
1330         xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
1331     }
1332 }
1333
1334 void
1335 push_type (enum type_pieces tp)
1336 {
1337   check_type_stack_depth ();
1338   type_stack[type_stack_depth++].piece = tp;
1339 }
1340
1341 void
1342 push_type_int (int n)
1343 {
1344   check_type_stack_depth ();
1345   type_stack[type_stack_depth++].int_val = n;
1346 }
1347
1348 void
1349 push_type_address_space (char *string)
1350 {
1351   push_type_int (address_space_name_to_int (parse_gdbarch, string));
1352 }
1353
1354 enum type_pieces
1355 pop_type (void)
1356 {
1357   if (type_stack_depth)
1358     return type_stack[--type_stack_depth].piece;
1359   return tp_end;
1360 }
1361
1362 int
1363 pop_type_int (void)
1364 {
1365   if (type_stack_depth)
1366     return type_stack[--type_stack_depth].int_val;
1367   /* "Can't happen".  */
1368   return 0;
1369 }
1370
1371 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
1372    as modified by all the stuff on the stack.  */
1373 struct type *
1374 follow_types (struct type *follow_type)
1375 {
1376   int done = 0;
1377   int make_const = 0;
1378   int make_volatile = 0;
1379   int make_addr_space = 0;
1380   int array_size;
1381
1382   while (!done)
1383     switch (pop_type ())
1384       {
1385       case tp_end:
1386         done = 1;
1387         if (make_const)
1388           follow_type = make_cv_type (make_const, 
1389                                       TYPE_VOLATILE (follow_type), 
1390                                       follow_type, 0);
1391         if (make_volatile)
1392           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1393                                       make_volatile, 
1394                                       follow_type, 0);
1395         if (make_addr_space)
1396           follow_type = make_type_with_address_space (follow_type, 
1397                                                       make_addr_space);
1398         make_const = make_volatile = 0;
1399         make_addr_space = 0;
1400         break;
1401       case tp_const:
1402         make_const = 1;
1403         break;
1404       case tp_volatile:
1405         make_volatile = 1;
1406         break;
1407       case tp_space_identifier:
1408         make_addr_space = pop_type_int ();
1409         break;
1410       case tp_pointer:
1411         follow_type = lookup_pointer_type (follow_type);
1412         if (make_const)
1413           follow_type = make_cv_type (make_const, 
1414                                       TYPE_VOLATILE (follow_type), 
1415                                       follow_type, 0);
1416         if (make_volatile)
1417           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1418                                       make_volatile, 
1419                                       follow_type, 0);
1420         if (make_addr_space)
1421           follow_type = make_type_with_address_space (follow_type, 
1422                                                       make_addr_space);
1423         make_const = make_volatile = 0;
1424         make_addr_space = 0;
1425         break;
1426       case tp_reference:
1427         follow_type = lookup_reference_type (follow_type);
1428         if (make_const)
1429           follow_type = make_cv_type (make_const, 
1430                                       TYPE_VOLATILE (follow_type), 
1431                                       follow_type, 0);
1432         if (make_volatile)
1433           follow_type = make_cv_type (TYPE_CONST (follow_type), 
1434                                       make_volatile, 
1435                                       follow_type, 0);
1436         if (make_addr_space)
1437           follow_type = make_type_with_address_space (follow_type, 
1438                                                       make_addr_space);
1439         make_const = make_volatile = 0;
1440         make_addr_space = 0;
1441         break;
1442       case tp_array:
1443         array_size = pop_type_int ();
1444         /* FIXME-type-allocation: need a way to free this type when we are
1445            done with it.  */
1446         follow_type =
1447           lookup_array_range_type (follow_type,
1448                                    0, array_size >= 0 ? array_size - 1 : 0);
1449         if (array_size < 0)
1450           TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
1451         break;
1452       case tp_function:
1453         /* FIXME-type-allocation: need a way to free this type when we are
1454            done with it.  */
1455         follow_type = lookup_function_type (follow_type);
1456         break;
1457       }
1458   return follow_type;
1459 }
1460 \f
1461 /* This function avoids direct calls to fprintf 
1462    in the parser generated debug code.  */
1463 void
1464 parser_fprintf (FILE *x, const char *y, ...)
1465
1466   va_list args;
1467
1468   va_start (args, y);
1469   if (x == stderr)
1470     vfprintf_unfiltered (gdb_stderr, y, args); 
1471   else
1472     {
1473       fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
1474       vfprintf_unfiltered (gdb_stderr, y, args);
1475     }
1476   va_end (args);
1477 }
1478
1479 /* Implementation of the exp_descriptor method operator_check.  */
1480
1481 int
1482 operator_check_standard (struct expression *exp, int pos,
1483                          int (*objfile_func) (struct objfile *objfile,
1484                                               void *data),
1485                          void *data)
1486 {
1487   const union exp_element *const elts = exp->elts;
1488   struct type *type = NULL;
1489   struct objfile *objfile = NULL;
1490
1491   /* Extended operators should have been already handled by exp_descriptor
1492      iterate method of its specific language.  */
1493   gdb_assert (elts[pos].opcode < OP_EXTENDED0);
1494
1495   /* Track the callers of write_exp_elt_type for this table.  */
1496
1497   switch (elts[pos].opcode)
1498     {
1499     case BINOP_VAL:
1500     case OP_COMPLEX:
1501     case OP_DECFLOAT:
1502     case OP_DOUBLE:
1503     case OP_LONG:
1504     case OP_SCOPE:
1505     case OP_TYPE:
1506     case UNOP_CAST:
1507     case UNOP_DYNAMIC_CAST:
1508     case UNOP_REINTERPRET_CAST:
1509     case UNOP_MAX:
1510     case UNOP_MEMVAL:
1511     case UNOP_MIN:
1512       type = elts[pos + 1].type;
1513       break;
1514
1515     case TYPE_INSTANCE:
1516       {
1517         LONGEST arg, nargs = elts[pos + 1].longconst;
1518
1519         for (arg = 0; arg < nargs; arg++)
1520           {
1521             struct type *type = elts[pos + 2 + arg].type;
1522             struct objfile *objfile = TYPE_OBJFILE (type);
1523
1524             if (objfile && (*objfile_func) (objfile, data))
1525               return 1;
1526           }
1527       }
1528       break;
1529
1530     case UNOP_MEMVAL_TLS:
1531       objfile = elts[pos + 1].objfile;
1532       type = elts[pos + 2].type;
1533       break;
1534
1535     case OP_VAR_VALUE:
1536       {
1537         const struct block *const block = elts[pos + 1].block;
1538         const struct symbol *const symbol = elts[pos + 2].symbol;
1539
1540         /* Check objfile where the variable itself is placed.
1541            SYMBOL_OBJ_SECTION (symbol) may be NULL.  */
1542         if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
1543           return 1;
1544
1545         /* Check objfile where is placed the code touching the variable.  */
1546         objfile = lookup_objfile_from_block (block);
1547
1548         type = SYMBOL_TYPE (symbol);
1549       }
1550       break;
1551     }
1552
1553   /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL.  */
1554
1555   if (type && TYPE_OBJFILE (type)
1556       && (*objfile_func) (TYPE_OBJFILE (type), data))
1557     return 1;
1558   if (objfile && (*objfile_func) (objfile, data))
1559     return 1;
1560
1561   return 0;
1562 }
1563
1564 /* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
1565    The functions are never called with NULL OBJFILE.  Functions get passed an
1566    arbitrary caller supplied DATA pointer.  If any of the functions returns
1567    non-zero value then (any other) non-zero value is immediately returned to
1568    the caller.  Otherwise zero is returned after iterating through whole EXP.
1569    */
1570
1571 static int
1572 exp_iterate (struct expression *exp,
1573              int (*objfile_func) (struct objfile *objfile, void *data),
1574              void *data)
1575 {
1576   int endpos;
1577
1578   for (endpos = exp->nelts; endpos > 0; )
1579     {
1580       int pos, args, oplen = 0;
1581
1582       operator_length (exp, endpos, &oplen, &args);
1583       gdb_assert (oplen > 0);
1584
1585       pos = endpos - oplen;
1586       if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
1587                                                            objfile_func, data))
1588         return 1;
1589
1590       endpos = pos;
1591     }
1592
1593   return 0;
1594 }
1595
1596 /* Helper for exp_uses_objfile.  */
1597
1598 static int
1599 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
1600 {
1601   struct objfile *objfile = objfile_voidp;
1602
1603   if (exp_objfile->separate_debug_objfile_backlink)
1604     exp_objfile = exp_objfile->separate_debug_objfile_backlink;
1605
1606   return exp_objfile == objfile;
1607 }
1608
1609 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
1610    is unloaded), otherwise return 0.  OBJFILE must not be a separate debug info
1611    file.  */
1612
1613 int
1614 exp_uses_objfile (struct expression *exp, struct objfile *objfile)
1615 {
1616   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
1617
1618   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
1619 }
1620
1621 void
1622 _initialize_parse (void)
1623 {
1624   type_stack_size = 80;
1625   type_stack_depth = 0;
1626   type_stack = (union type_stack_elt *)
1627     xmalloc (type_stack_size * sizeof (*type_stack));
1628
1629   add_setshow_zinteger_cmd ("expression", class_maintenance,
1630                             &expressiondebug,
1631                             _("Set expression debugging."),
1632                             _("Show expression debugging."),
1633                             _("When non-zero, the internal representation "
1634                               "of expressions will be printed."),
1635                             NULL,
1636                             show_expressiondebug,
1637                             &setdebuglist, &showdebuglist);
1638   add_setshow_boolean_cmd ("parser", class_maintenance,
1639                             &parser_debug,
1640                            _("Set parser debugging."),
1641                            _("Show parser debugging."),
1642                            _("When non-zero, expression parser "
1643                              "tracing will be enabled."),
1644                             NULL,
1645                             show_parserdebug,
1646                             &setdebuglist, &showdebuglist);
1647 }