Copyright updates for 2007.
[external/binutils.git] / gdb / expprint.c
1 /* Print in infix form a struct expression.
2
3    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4    1998, 1999, 2000, 2003, 2007 Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
21    Boston, MA 02110-1301, USA.  */
22
23 #include "defs.h"
24 #include "symtab.h"
25 #include "gdbtypes.h"
26 #include "expression.h"
27 #include "value.h"
28 #include "language.h"
29 #include "parser-defs.h"
30 #include "user-regs.h"          /* For user_reg_map_regnum_to_name.  */
31 #include "target.h"
32 #include "gdb_string.h"
33 #include "block.h"
34 #include "objfiles.h"
35
36 #ifdef HAVE_CTYPE_H
37 #include <ctype.h>
38 #endif
39
40 void
41 print_expression (struct expression *exp, struct ui_file *stream)
42 {
43   int pc = 0;
44   print_subexp (exp, &pc, stream, PREC_NULL);
45 }
46
47 /* Print the subexpression of EXP that starts in position POS, on STREAM.
48    PREC is the precedence of the surrounding operator;
49    if the precedence of the main operator of this subexpression is less,
50    parentheses are needed here.  */
51
52 void
53 print_subexp (struct expression *exp, int *pos,
54               struct ui_file *stream, enum precedence prec)
55 {
56   exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec);
57 }
58
59 /* Standard implementation of print_subexp for use in language_defn
60    vectors.  */
61 void
62 print_subexp_standard (struct expression *exp, int *pos,
63                        struct ui_file *stream, enum precedence prec)
64 {
65   unsigned tem;
66   const struct op_print *op_print_tab;
67   int pc;
68   unsigned nargs;
69   char *op_str;
70   int assign_modify = 0;
71   enum exp_opcode opcode;
72   enum precedence myprec = PREC_NULL;
73   /* Set to 1 for a right-associative operator.  */
74   int assoc = 0;
75   struct value *val;
76   char *tempstr = NULL;
77
78   op_print_tab = exp->language_defn->la_op_print_tab;
79   pc = (*pos)++;
80   opcode = exp->elts[pc].opcode;
81   switch (opcode)
82     {
83       /* Common ops */
84
85     case OP_SCOPE:
86       myprec = PREC_PREFIX;
87       assoc = 0;
88       fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
89       fputs_filtered ("::", stream);
90       nargs = longest_to_int (exp->elts[pc + 2].longconst);
91       (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
92       fputs_filtered (&exp->elts[pc + 3].string, stream);
93       return;
94
95     case OP_LONG:
96       (*pos) += 3;
97       value_print (value_from_longest (exp->elts[pc + 1].type,
98                                        exp->elts[pc + 2].longconst),
99                    stream, 0, Val_no_prettyprint);
100       return;
101
102     case OP_DOUBLE:
103       (*pos) += 3;
104       value_print (value_from_double (exp->elts[pc + 1].type,
105                                       exp->elts[pc + 2].doubleconst),
106                    stream, 0, Val_no_prettyprint);
107       return;
108
109     case OP_VAR_VALUE:
110       {
111         struct block *b;
112         (*pos) += 3;
113         b = exp->elts[pc + 1].block;
114         if (b != NULL
115             && BLOCK_FUNCTION (b) != NULL
116             && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
117           {
118             fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
119             fputs_filtered ("::", stream);
120           }
121         fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
122       }
123       return;
124
125     case OP_LAST:
126       (*pos) += 2;
127       fprintf_filtered (stream, "$%d",
128                         longest_to_int (exp->elts[pc + 1].longconst));
129       return;
130
131     case OP_REGISTER:
132       {
133         int regnum = longest_to_int (exp->elts[pc + 1].longconst);
134         const char *name = user_reg_map_regnum_to_name (current_gdbarch,
135                                                         regnum);
136         (*pos) += 2;
137         fprintf_filtered (stream, "$%s", name);
138         return;
139       }
140
141     case OP_BOOL:
142       (*pos) += 2;
143       fprintf_filtered (stream, "%s",
144                         longest_to_int (exp->elts[pc + 1].longconst)
145                         ? "TRUE" : "FALSE");
146       return;
147
148     case OP_INTERNALVAR:
149       (*pos) += 2;
150       fprintf_filtered (stream, "$%s",
151                         internalvar_name (exp->elts[pc + 1].internalvar));
152       return;
153
154     case OP_FUNCALL:
155       (*pos) += 2;
156       nargs = longest_to_int (exp->elts[pc + 1].longconst);
157       print_subexp (exp, pos, stream, PREC_SUFFIX);
158       fputs_filtered (" (", stream);
159       for (tem = 0; tem < nargs; tem++)
160         {
161           if (tem != 0)
162             fputs_filtered (", ", stream);
163           print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
164         }
165       fputs_filtered (")", stream);
166       return;
167
168     case OP_NAME:
169     case OP_EXPRSTRING:
170       nargs = longest_to_int (exp->elts[pc + 1].longconst);
171       (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
172       fputs_filtered (&exp->elts[pc + 2].string, stream);
173       return;
174
175     case OP_STRING:
176       nargs = longest_to_int (exp->elts[pc + 1].longconst);
177       (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
178       /* LA_PRINT_STRING will print using the current repeat count threshold.
179          If necessary, we can temporarily set it to zero, or pass it as an
180          additional parameter to LA_PRINT_STRING.  -fnf */
181       LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
182       return;
183
184     case OP_BITSTRING:
185       nargs = longest_to_int (exp->elts[pc + 1].longconst);
186       (*pos)
187         += 3 + BYTES_TO_EXP_ELEM ((nargs + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
188       fprintf_unfiltered (stream, "B'<unimplemented>'");
189       return;
190
191     case OP_OBJC_NSSTRING:      /* Objective-C Foundation Class NSString constant.  */
192       nargs = longest_to_int (exp->elts[pc + 1].longconst);
193       (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
194       fputs_filtered ("@\"", stream);
195       LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
196       fputs_filtered ("\"", stream);
197       return;
198
199     case OP_OBJC_MSGCALL:
200       {                 /* Objective C message (method) call.  */
201         char *selector;
202         (*pos) += 3;
203         nargs = longest_to_int (exp->elts[pc + 2].longconst);
204         fprintf_unfiltered (stream, "[");
205         print_subexp (exp, pos, stream, PREC_SUFFIX);
206         if (0 == target_read_string (exp->elts[pc + 1].longconst,
207                                      &selector, 1024, NULL))
208           {
209             error (_("bad selector"));
210             return;
211           }
212         if (nargs)
213           {
214             char *s, *nextS;
215             s = alloca (strlen (selector) + 1);
216             strcpy (s, selector);
217             for (tem = 0; tem < nargs; tem++)
218               {
219                 nextS = strchr (s, ':');
220                 *nextS = '\0';
221                 fprintf_unfiltered (stream, " %s: ", s);
222                 s = nextS + 1;
223                 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
224               }
225           }
226         else
227           {
228             fprintf_unfiltered (stream, " %s", selector);
229           }
230         fprintf_unfiltered (stream, "]");
231         /* "selector" was malloc'd by target_read_string. Free it.  */
232         xfree (selector);
233         return;
234       }
235
236     case OP_ARRAY:
237       (*pos) += 3;
238       nargs = longest_to_int (exp->elts[pc + 2].longconst);
239       nargs -= longest_to_int (exp->elts[pc + 1].longconst);
240       nargs++;
241       tem = 0;
242       if (exp->elts[pc + 4].opcode == OP_LONG
243           && exp->elts[pc + 5].type == builtin_type_char
244           && exp->language_defn->la_language == language_c)
245         {
246           /* Attempt to print C character arrays using string syntax.
247              Walk through the args, picking up one character from each
248              of the OP_LONG expression elements.  If any array element
249              does not match our expection of what we should find for
250              a simple string, revert back to array printing.  Note that
251              the last expression element is an explicit null terminator
252              byte, which doesn't get printed. */
253           tempstr = alloca (nargs);
254           pc += 4;
255           while (tem < nargs)
256             {
257               if (exp->elts[pc].opcode != OP_LONG
258                   || exp->elts[pc + 1].type != builtin_type_char)
259                 {
260                   /* Not a simple array of char, use regular array printing. */
261                   tem = 0;
262                   break;
263                 }
264               else
265                 {
266                   tempstr[tem++] =
267                     longest_to_int (exp->elts[pc + 2].longconst);
268                   pc += 4;
269                 }
270             }
271         }
272       if (tem > 0)
273         {
274           LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0);
275           (*pos) = pc;
276         }
277       else
278         {
279           fputs_filtered (" {", stream);
280           for (tem = 0; tem < nargs; tem++)
281             {
282               if (tem != 0)
283                 {
284                   fputs_filtered (", ", stream);
285                 }
286               print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
287             }
288           fputs_filtered ("}", stream);
289         }
290       return;
291
292     case OP_LABELED:
293       tem = longest_to_int (exp->elts[pc + 1].longconst);
294       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
295       /* Gcc support both these syntaxes.  Unsure which is preferred.  */
296 #if 1
297       fputs_filtered (&exp->elts[pc + 2].string, stream);
298       fputs_filtered (": ", stream);
299 #else
300       fputs_filtered (".", stream);
301       fputs_filtered (&exp->elts[pc + 2].string, stream);
302       fputs_filtered ("=", stream);
303 #endif
304       print_subexp (exp, pos, stream, PREC_SUFFIX);
305       return;
306
307     case TERNOP_COND:
308       if ((int) prec > (int) PREC_COMMA)
309         fputs_filtered ("(", stream);
310       /* Print the subexpressions, forcing parentheses
311          around any binary operations within them.
312          This is more parentheses than are strictly necessary,
313          but it looks clearer.  */
314       print_subexp (exp, pos, stream, PREC_HYPER);
315       fputs_filtered (" ? ", stream);
316       print_subexp (exp, pos, stream, PREC_HYPER);
317       fputs_filtered (" : ", stream);
318       print_subexp (exp, pos, stream, PREC_HYPER);
319       if ((int) prec > (int) PREC_COMMA)
320         fputs_filtered (")", stream);
321       return;
322
323     case TERNOP_SLICE:
324     case TERNOP_SLICE_COUNT:
325       print_subexp (exp, pos, stream, PREC_SUFFIX);
326       fputs_filtered ("(", stream);
327       print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
328       fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
329       print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
330       fputs_filtered (")", stream);
331       return;
332
333     case STRUCTOP_STRUCT:
334       tem = longest_to_int (exp->elts[pc + 1].longconst);
335       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
336       print_subexp (exp, pos, stream, PREC_SUFFIX);
337       fputs_filtered (".", stream);
338       fputs_filtered (&exp->elts[pc + 2].string, stream);
339       return;
340
341       /* Will not occur for Modula-2 */
342     case STRUCTOP_PTR:
343       tem = longest_to_int (exp->elts[pc + 1].longconst);
344       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
345       print_subexp (exp, pos, stream, PREC_SUFFIX);
346       fputs_filtered ("->", stream);
347       fputs_filtered (&exp->elts[pc + 2].string, stream);
348       return;
349
350     case STRUCTOP_MEMBER:
351       print_subexp (exp, pos, stream, PREC_SUFFIX);
352       fputs_filtered (".*", stream);
353       print_subexp (exp, pos, stream, PREC_SUFFIX);
354       return;
355
356     case STRUCTOP_MPTR:
357       print_subexp (exp, pos, stream, PREC_SUFFIX);
358       fputs_filtered ("->*", stream);
359       print_subexp (exp, pos, stream, PREC_SUFFIX);
360       return;
361
362     case BINOP_SUBSCRIPT:
363       print_subexp (exp, pos, stream, PREC_SUFFIX);
364       fputs_filtered ("[", stream);
365       print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
366       fputs_filtered ("]", stream);
367       return;
368
369     case UNOP_POSTINCREMENT:
370       print_subexp (exp, pos, stream, PREC_SUFFIX);
371       fputs_filtered ("++", stream);
372       return;
373
374     case UNOP_POSTDECREMENT:
375       print_subexp (exp, pos, stream, PREC_SUFFIX);
376       fputs_filtered ("--", stream);
377       return;
378
379     case UNOP_CAST:
380       (*pos) += 2;
381       if ((int) prec > (int) PREC_PREFIX)
382         fputs_filtered ("(", stream);
383       fputs_filtered ("(", stream);
384       type_print (exp->elts[pc + 1].type, "", stream, 0);
385       fputs_filtered (") ", stream);
386       print_subexp (exp, pos, stream, PREC_PREFIX);
387       if ((int) prec > (int) PREC_PREFIX)
388         fputs_filtered (")", stream);
389       return;
390
391     case UNOP_MEMVAL:
392       (*pos) += 2;
393       if ((int) prec > (int) PREC_PREFIX)
394         fputs_filtered ("(", stream);
395       if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC &&
396           exp->elts[pc + 3].opcode == OP_LONG)
397         {
398           /* We have a minimal symbol fn, probably.  It's encoded
399              as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
400              Swallow the OP_LONG (including both its opcodes); ignore
401              its type; print the value in the type of the MEMVAL.  */
402           (*pos) += 4;
403           val = value_at_lazy (exp->elts[pc + 1].type,
404                                (CORE_ADDR) exp->elts[pc + 5].longconst);
405           value_print (val, stream, 0, Val_no_prettyprint);
406         }
407       else
408         {
409           fputs_filtered ("{", stream);
410           type_print (exp->elts[pc + 1].type, "", stream, 0);
411           fputs_filtered ("} ", stream);
412           print_subexp (exp, pos, stream, PREC_PREFIX);
413         }
414       if ((int) prec > (int) PREC_PREFIX)
415         fputs_filtered (")", stream);
416       return;
417
418     case UNOP_MEMVAL_TLS:
419       (*pos) += 3;
420       if ((int) prec > (int) PREC_PREFIX)
421         fputs_filtered ("(", stream);
422       fputs_filtered ("{", stream);
423       type_print (exp->elts[pc + 2].type, "", stream, 0);
424       fputs_filtered ("} ", stream);
425       print_subexp (exp, pos, stream, PREC_PREFIX);
426       if ((int) prec > (int) PREC_PREFIX)
427         fputs_filtered (")", stream);
428       return;
429
430     case BINOP_ASSIGN_MODIFY:
431       opcode = exp->elts[pc + 1].opcode;
432       (*pos) += 2;
433       myprec = PREC_ASSIGN;
434       assoc = 1;
435       assign_modify = 1;
436       op_str = "???";
437       for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
438         if (op_print_tab[tem].opcode == opcode)
439           {
440             op_str = op_print_tab[tem].string;
441             break;
442           }
443       if (op_print_tab[tem].opcode != opcode)
444         /* Not found; don't try to keep going because we don't know how
445            to interpret further elements.  */
446         error (_("Invalid expression"));
447       break;
448
449       /* C++ ops */
450
451     case OP_THIS:
452       ++(*pos);
453       fputs_filtered ("this", stream);
454       return;
455
456       /* Objective-C ops */
457
458     case OP_OBJC_SELF:
459       ++(*pos);
460       fputs_filtered ("self", stream);  /* The ObjC equivalent of "this".  */
461       return;
462
463       /* Modula-2 ops */
464
465     case MULTI_SUBSCRIPT:
466       (*pos) += 2;
467       nargs = longest_to_int (exp->elts[pc + 1].longconst);
468       print_subexp (exp, pos, stream, PREC_SUFFIX);
469       fprintf_unfiltered (stream, " [");
470       for (tem = 0; tem < nargs; tem++)
471         {
472           if (tem != 0)
473             fprintf_unfiltered (stream, ", ");
474           print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
475         }
476       fprintf_unfiltered (stream, "]");
477       return;
478
479     case BINOP_VAL:
480       (*pos) += 2;
481       fprintf_unfiltered (stream, "VAL(");
482       type_print (exp->elts[pc + 1].type, "", stream, 0);
483       fprintf_unfiltered (stream, ",");
484       print_subexp (exp, pos, stream, PREC_PREFIX);
485       fprintf_unfiltered (stream, ")");
486       return;
487
488     case BINOP_INCL:
489     case BINOP_EXCL:
490       error (_("print_subexp:  Not implemented."));
491
492       /* Default ops */
493
494     default:
495       op_str = "???";
496       for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
497         if (op_print_tab[tem].opcode == opcode)
498           {
499             op_str = op_print_tab[tem].string;
500             myprec = op_print_tab[tem].precedence;
501             assoc = op_print_tab[tem].right_assoc;
502             break;
503           }
504       if (op_print_tab[tem].opcode != opcode)
505         /* Not found; don't try to keep going because we don't know how
506            to interpret further elements.  For example, this happens
507            if opcode is OP_TYPE.  */
508         error (_("Invalid expression"));
509     }
510
511   /* Note that PREC_BUILTIN will always emit parentheses. */
512   if ((int) myprec < (int) prec)
513     fputs_filtered ("(", stream);
514   if ((int) opcode > (int) BINOP_END)
515     {
516       if (assoc)
517         {
518           /* Unary postfix operator.  */
519           print_subexp (exp, pos, stream, PREC_SUFFIX);
520           fputs_filtered (op_str, stream);
521         }
522       else
523         {
524           /* Unary prefix operator.  */
525           fputs_filtered (op_str, stream);
526           if (myprec == PREC_BUILTIN_FUNCTION)
527             fputs_filtered ("(", stream);
528           print_subexp (exp, pos, stream, PREC_PREFIX);
529           if (myprec == PREC_BUILTIN_FUNCTION)
530             fputs_filtered (")", stream);
531         }
532     }
533   else
534     {
535       /* Binary operator.  */
536       /* Print left operand.
537          If operator is right-associative,
538          increment precedence for this operand.  */
539       print_subexp (exp, pos, stream,
540                     (enum precedence) ((int) myprec + assoc));
541       /* Print the operator itself.  */
542       if (assign_modify)
543         fprintf_filtered (stream, " %s= ", op_str);
544       else if (op_str[0] == ',')
545         fprintf_filtered (stream, "%s ", op_str);
546       else
547         fprintf_filtered (stream, " %s ", op_str);
548       /* Print right operand.
549          If operator is left-associative,
550          increment precedence for this operand.  */
551       print_subexp (exp, pos, stream,
552                     (enum precedence) ((int) myprec + !assoc));
553     }
554
555   if ((int) myprec < (int) prec)
556     fputs_filtered (")", stream);
557 }
558
559 /* Return the operator corresponding to opcode OP as
560    a string.   NULL indicates that the opcode was not found in the
561    current language table.  */
562 char *
563 op_string (enum exp_opcode op)
564 {
565   int tem;
566   const struct op_print *op_print_tab;
567
568   op_print_tab = current_language->la_op_print_tab;
569   for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
570     if (op_print_tab[tem].opcode == op)
571       return op_print_tab[tem].string;
572   return NULL;
573 }
574
575 /* Support for dumping the raw data from expressions in a human readable
576    form.  */
577
578 static char *op_name (struct expression *, enum exp_opcode);
579 static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
580
581 /* Name for OPCODE, when it appears in expression EXP. */
582
583 static char *
584 op_name (struct expression *exp, enum exp_opcode opcode)
585 {
586   return exp->language_defn->la_exp_desc->op_name (opcode);
587 }
588
589 /* Default name for the standard operator OPCODE (i.e., one defined in
590    the definition of enum exp_opcode).  */
591
592 char *
593 op_name_standard (enum exp_opcode opcode)
594 {
595   switch (opcode)
596     {
597     default:
598       {
599         static char buf[30];
600
601         sprintf (buf, "<unknown %d>", opcode);
602         return buf;
603       }
604     case OP_NULL:
605       return "OP_NULL";
606     case BINOP_ADD:
607       return "BINOP_ADD";
608     case BINOP_SUB:
609       return "BINOP_SUB";
610     case BINOP_MUL:
611       return "BINOP_MUL";
612     case BINOP_DIV:
613       return "BINOP_DIV";
614     case BINOP_REM:
615       return "BINOP_REM";
616     case BINOP_MOD:
617       return "BINOP_MOD";
618     case BINOP_LSH:
619       return "BINOP_LSH";
620     case BINOP_RSH:
621       return "BINOP_RSH";
622     case BINOP_LOGICAL_AND:
623       return "BINOP_LOGICAL_AND";
624     case BINOP_LOGICAL_OR:
625       return "BINOP_LOGICAL_OR";
626     case BINOP_BITWISE_AND:
627       return "BINOP_BITWISE_AND";
628     case BINOP_BITWISE_IOR:
629       return "BINOP_BITWISE_IOR";
630     case BINOP_BITWISE_XOR:
631       return "BINOP_BITWISE_XOR";
632     case BINOP_EQUAL:
633       return "BINOP_EQUAL";
634     case BINOP_NOTEQUAL:
635       return "BINOP_NOTEQUAL";
636     case BINOP_LESS:
637       return "BINOP_LESS";
638     case BINOP_GTR:
639       return "BINOP_GTR";
640     case BINOP_LEQ:
641       return "BINOP_LEQ";
642     case BINOP_GEQ:
643       return "BINOP_GEQ";
644     case BINOP_REPEAT:
645       return "BINOP_REPEAT";
646     case BINOP_ASSIGN:
647       return "BINOP_ASSIGN";
648     case BINOP_COMMA:
649       return "BINOP_COMMA";
650     case BINOP_SUBSCRIPT:
651       return "BINOP_SUBSCRIPT";
652     case MULTI_SUBSCRIPT:
653       return "MULTI_SUBSCRIPT";
654     case BINOP_EXP:
655       return "BINOP_EXP";
656     case BINOP_MIN:
657       return "BINOP_MIN";
658     case BINOP_MAX:
659       return "BINOP_MAX";
660     case STRUCTOP_MEMBER:
661       return "STRUCTOP_MEMBER";
662     case STRUCTOP_MPTR:
663       return "STRUCTOP_MPTR";
664     case BINOP_INTDIV:
665       return "BINOP_INTDIV";
666     case BINOP_ASSIGN_MODIFY:
667       return "BINOP_ASSIGN_MODIFY";
668     case BINOP_VAL:
669       return "BINOP_VAL";
670     case BINOP_INCL:
671       return "BINOP_INCL";
672     case BINOP_EXCL:
673       return "BINOP_EXCL";
674     case BINOP_CONCAT:
675       return "BINOP_CONCAT";
676     case BINOP_RANGE:
677       return "BINOP_RANGE";
678     case BINOP_END:
679       return "BINOP_END";
680     case TERNOP_COND:
681       return "TERNOP_COND";
682     case TERNOP_SLICE:
683       return "TERNOP_SLICE";
684     case TERNOP_SLICE_COUNT:
685       return "TERNOP_SLICE_COUNT";
686     case OP_LONG:
687       return "OP_LONG";
688     case OP_DOUBLE:
689       return "OP_DOUBLE";
690     case OP_VAR_VALUE:
691       return "OP_VAR_VALUE";
692     case OP_LAST:
693       return "OP_LAST";
694     case OP_REGISTER:
695       return "OP_REGISTER";
696     case OP_INTERNALVAR:
697       return "OP_INTERNALVAR";
698     case OP_FUNCALL:
699       return "OP_FUNCALL";
700     case OP_STRING:
701       return "OP_STRING";
702     case OP_BITSTRING:
703       return "OP_BITSTRING";
704     case OP_ARRAY:
705       return "OP_ARRAY";
706     case UNOP_CAST:
707       return "UNOP_CAST";
708     case UNOP_MEMVAL:
709       return "UNOP_MEMVAL";
710     case UNOP_MEMVAL_TLS:
711       return "UNOP_MEMVAL_TLS";
712     case UNOP_NEG:
713       return "UNOP_NEG";
714     case UNOP_LOGICAL_NOT:
715       return "UNOP_LOGICAL_NOT";
716     case UNOP_COMPLEMENT:
717       return "UNOP_COMPLEMENT";
718     case UNOP_IND:
719       return "UNOP_IND";
720     case UNOP_ADDR:
721       return "UNOP_ADDR";
722     case UNOP_PREINCREMENT:
723       return "UNOP_PREINCREMENT";
724     case UNOP_POSTINCREMENT:
725       return "UNOP_POSTINCREMENT";
726     case UNOP_PREDECREMENT:
727       return "UNOP_PREDECREMENT";
728     case UNOP_POSTDECREMENT:
729       return "UNOP_POSTDECREMENT";
730     case UNOP_SIZEOF:
731       return "UNOP_SIZEOF";
732     case UNOP_LOWER:
733       return "UNOP_LOWER";
734     case UNOP_UPPER:
735       return "UNOP_UPPER";
736     case UNOP_LENGTH:
737       return "UNOP_LENGTH";
738     case UNOP_PLUS:
739       return "UNOP_PLUS";
740     case UNOP_CAP:
741       return "UNOP_CAP";
742     case UNOP_CHR:
743       return "UNOP_CHR";
744     case UNOP_ORD:
745       return "UNOP_ORD";
746     case UNOP_ABS:
747       return "UNOP_ABS";
748     case UNOP_FLOAT:
749       return "UNOP_FLOAT";
750     case UNOP_HIGH:
751       return "UNOP_HIGH";
752     case UNOP_MAX:
753       return "UNOP_MAX";
754     case UNOP_MIN:
755       return "UNOP_MIN";
756     case UNOP_ODD:
757       return "UNOP_ODD";
758     case UNOP_TRUNC:
759       return "UNOP_TRUNC";
760     case OP_BOOL:
761       return "OP_BOOL";
762     case OP_M2_STRING:
763       return "OP_M2_STRING";
764     case STRUCTOP_STRUCT:
765       return "STRUCTOP_STRUCT";
766     case STRUCTOP_PTR:
767       return "STRUCTOP_PTR";
768     case OP_THIS:
769       return "OP_THIS";
770     case OP_OBJC_SELF:
771       return "OP_OBJC_SELF";
772     case OP_SCOPE:
773       return "OP_SCOPE";
774     case OP_TYPE:
775       return "OP_TYPE";
776     case OP_LABELED:
777       return "OP_LABELED";
778     }
779 }
780
781 void
782 dump_raw_expression (struct expression *exp, struct ui_file *stream,
783                      char *note)
784 {
785   int elt;
786   char *opcode_name;
787   char *eltscan;
788   int eltsize;
789
790   fprintf_filtered (stream, "Dump of expression @ ");
791   gdb_print_host_address (exp, stream);
792   fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
793                     exp->language_defn->la_name, exp->nelts,
794                     (long) sizeof (union exp_element));
795   fprintf_filtered (stream, "\t%5s  %20s  %16s  %s\n", "Index", "Opcode",
796                     "Hex Value", "String Value");
797   for (elt = 0; elt < exp->nelts; elt++)
798     {
799       fprintf_filtered (stream, "\t%5d  ", elt);
800       opcode_name = op_name (exp, exp->elts[elt].opcode);
801
802       fprintf_filtered (stream, "%20s  ", opcode_name);
803       print_longest (stream, 'd', 0, exp->elts[elt].longconst);
804       fprintf_filtered (stream, "  ");
805
806       for (eltscan = (char *) &exp->elts[elt],
807            eltsize = sizeof (union exp_element);
808            eltsize-- > 0;
809            eltscan++)
810         {
811           fprintf_filtered (stream, "%c",
812                             isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
813         }
814       fprintf_filtered (stream, "\n");
815     }
816 }
817
818 /* Dump the subexpression of prefix expression EXP whose operator is at
819    position ELT onto STREAM.  Returns the position of the next 
820    subexpression in EXP.  */
821
822 int
823 dump_subexp (struct expression *exp, struct ui_file *stream, int elt)
824 {
825   static int indent = 0;
826   int i;
827
828   fprintf_filtered (stream, "\n");
829   fprintf_filtered (stream, "\t%5d  ", elt);
830
831   for (i = 1; i <= indent; i++)
832     fprintf_filtered (stream, " ");
833   indent += 2;
834
835   fprintf_filtered (stream, "%-20s  ", op_name (exp, exp->elts[elt].opcode));
836
837   elt = dump_subexp_body (exp, stream, elt);
838
839   indent -= 2;
840
841   return elt;
842 }
843
844 /* Dump the operands of prefix expression EXP whose opcode is at
845    position ELT onto STREAM.  Returns the position of the next 
846    subexpression in EXP.  */
847
848 static int
849 dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
850 {
851   return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt);
852 }
853
854 /* Default value for subexp_body in exp_descriptor vector.  */
855
856 int
857 dump_subexp_body_standard (struct expression *exp, 
858                            struct ui_file *stream, int elt)
859 {
860   int opcode = exp->elts[elt++].opcode;
861
862   switch (opcode)
863     {
864     case TERNOP_COND:
865     case TERNOP_SLICE:
866     case TERNOP_SLICE_COUNT:
867       elt = dump_subexp (exp, stream, elt);
868     case BINOP_ADD:
869     case BINOP_SUB:
870     case BINOP_MUL:
871     case BINOP_DIV:
872     case BINOP_REM:
873     case BINOP_MOD:
874     case BINOP_LSH:
875     case BINOP_RSH:
876     case BINOP_LOGICAL_AND:
877     case BINOP_LOGICAL_OR:
878     case BINOP_BITWISE_AND:
879     case BINOP_BITWISE_IOR:
880     case BINOP_BITWISE_XOR:
881     case BINOP_EQUAL:
882     case BINOP_NOTEQUAL:
883     case BINOP_LESS:
884     case BINOP_GTR:
885     case BINOP_LEQ:
886     case BINOP_GEQ:
887     case BINOP_REPEAT:
888     case BINOP_ASSIGN:
889     case BINOP_COMMA:
890     case BINOP_SUBSCRIPT:
891     case BINOP_EXP:
892     case BINOP_MIN:
893     case BINOP_MAX:
894     case BINOP_INTDIV:
895     case BINOP_ASSIGN_MODIFY:
896     case BINOP_VAL:
897     case BINOP_INCL:
898     case BINOP_EXCL:
899     case BINOP_CONCAT:
900     case BINOP_IN:
901     case BINOP_RANGE:
902     case BINOP_END:
903     case STRUCTOP_MEMBER:
904     case STRUCTOP_MPTR:
905       elt = dump_subexp (exp, stream, elt);
906     case UNOP_NEG:
907     case UNOP_LOGICAL_NOT:
908     case UNOP_COMPLEMENT:
909     case UNOP_IND:
910     case UNOP_ADDR:
911     case UNOP_PREINCREMENT:
912     case UNOP_POSTINCREMENT:
913     case UNOP_PREDECREMENT:
914     case UNOP_POSTDECREMENT:
915     case UNOP_SIZEOF:
916     case UNOP_PLUS:
917     case UNOP_CAP:
918     case UNOP_CHR:
919     case UNOP_ORD:
920     case UNOP_ABS:
921     case UNOP_FLOAT:
922     case UNOP_HIGH:
923     case UNOP_MAX:
924     case UNOP_MIN:
925     case UNOP_ODD:
926     case UNOP_TRUNC:
927     case UNOP_LOWER:
928     case UNOP_UPPER:
929     case UNOP_LENGTH:
930     case UNOP_CARD:
931     case UNOP_CHMAX:
932     case UNOP_CHMIN:
933       elt = dump_subexp (exp, stream, elt);
934       break;
935     case OP_LONG:
936       fprintf_filtered (stream, "Type @");
937       gdb_print_host_address (exp->elts[elt].type, stream);
938       fprintf_filtered (stream, " (");
939       type_print (exp->elts[elt].type, NULL, stream, 0);
940       fprintf_filtered (stream, "), value %ld (0x%lx)",
941                         (long) exp->elts[elt + 1].longconst,
942                         (long) exp->elts[elt + 1].longconst);
943       elt += 3;
944       break;
945     case OP_DOUBLE:
946       fprintf_filtered (stream, "Type @");
947       gdb_print_host_address (exp->elts[elt].type, stream);
948       fprintf_filtered (stream, " (");
949       type_print (exp->elts[elt].type, NULL, stream, 0);
950       fprintf_filtered (stream, "), value %g",
951                         (double) exp->elts[elt + 1].doubleconst);
952       elt += 3;
953       break;
954     case OP_VAR_VALUE:
955       fprintf_filtered (stream, "Block @");
956       gdb_print_host_address (exp->elts[elt].block, stream);
957       fprintf_filtered (stream, ", symbol @");
958       gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
959       fprintf_filtered (stream, " (%s)",
960                         DEPRECATED_SYMBOL_NAME (exp->elts[elt + 1].symbol));
961       elt += 3;
962       break;
963     case OP_LAST:
964       fprintf_filtered (stream, "History element %ld",
965                         (long) exp->elts[elt].longconst);
966       elt += 2;
967       break;
968     case OP_REGISTER:
969       fprintf_filtered (stream, "Register %ld",
970                         (long) exp->elts[elt].longconst);
971       elt += 2;
972       break;
973     case OP_INTERNALVAR:
974       fprintf_filtered (stream, "Internal var @");
975       gdb_print_host_address (exp->elts[elt].internalvar, stream);
976       fprintf_filtered (stream, " (%s)",
977                         exp->elts[elt].internalvar->name);
978       elt += 2;
979       break;
980     case OP_FUNCALL:
981       {
982         int i, nargs;
983
984         nargs = longest_to_int (exp->elts[elt].longconst);
985
986         fprintf_filtered (stream, "Number of args: %d", nargs);
987         elt += 2;
988
989         for (i = 1; i <= nargs + 1; i++)
990           elt = dump_subexp (exp, stream, elt);
991       }
992       break;
993     case OP_ARRAY:
994       {
995         int lower, upper;
996         int i;
997
998         lower = longest_to_int (exp->elts[elt].longconst);
999         upper = longest_to_int (exp->elts[elt + 1].longconst);
1000
1001         fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
1002         elt += 3;
1003
1004         for (i = 1; i <= upper - lower + 1; i++)
1005           elt = dump_subexp (exp, stream, elt);
1006       }
1007       break;
1008     case UNOP_MEMVAL:
1009     case UNOP_CAST:
1010       fprintf_filtered (stream, "Type @");
1011       gdb_print_host_address (exp->elts[elt].type, stream);
1012       fprintf_filtered (stream, " (");
1013       type_print (exp->elts[elt].type, NULL, stream, 0);
1014       fprintf_filtered (stream, ")");
1015       elt = dump_subexp (exp, stream, elt + 2);
1016       break;
1017     case UNOP_MEMVAL_TLS:
1018       fprintf_filtered (stream, "TLS type @");
1019       gdb_print_host_address (exp->elts[elt + 1].type, stream);
1020       fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
1021                         (exp->elts[elt].objfile == NULL ? "(null)"
1022                          : exp->elts[elt].objfile->name));
1023       type_print (exp->elts[elt + 1].type, NULL, stream, 0);
1024       fprintf_filtered (stream, ")");
1025       elt = dump_subexp (exp, stream, elt + 3);
1026       break;
1027     case OP_TYPE:
1028       fprintf_filtered (stream, "Type @");
1029       gdb_print_host_address (exp->elts[elt].type, stream);
1030       fprintf_filtered (stream, " (");
1031       type_print (exp->elts[elt].type, NULL, stream, 0);
1032       fprintf_filtered (stream, ")");
1033       elt += 2;
1034       break;
1035     case STRUCTOP_STRUCT:
1036     case STRUCTOP_PTR:
1037       {
1038         char *elem_name;
1039         int len;
1040
1041         len = longest_to_int (exp->elts[elt].longconst);
1042         elem_name = &exp->elts[elt + 1].string;
1043
1044         fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
1045         elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
1046       }
1047       break;
1048     case OP_SCOPE:
1049       {
1050         char *elem_name;
1051         int len;
1052
1053         fprintf_filtered (stream, "Type @");
1054         gdb_print_host_address (exp->elts[elt].type, stream);
1055         fprintf_filtered (stream, " (");
1056         type_print (exp->elts[elt].type, NULL, stream, 0);
1057         fprintf_filtered (stream, ") ");
1058
1059         len = longest_to_int (exp->elts[elt + 1].longconst);
1060         elem_name = &exp->elts[elt + 2].string;
1061
1062         fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
1063         elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
1064       }
1065       break;
1066     default:
1067     case OP_NULL:
1068     case MULTI_SUBSCRIPT:
1069     case OP_F77_UNDETERMINED_ARGLIST:
1070     case OP_COMPLEX:
1071     case OP_STRING:
1072     case OP_BITSTRING:
1073     case OP_BOOL:
1074     case OP_M2_STRING:
1075     case OP_THIS:
1076     case OP_LABELED:
1077     case OP_NAME:
1078     case OP_EXPRSTRING:
1079       fprintf_filtered (stream, "Unknown format");
1080     }
1081
1082   return elt;
1083 }
1084
1085 void
1086 dump_prefix_expression (struct expression *exp, struct ui_file *stream)
1087 {
1088   int elt;
1089
1090   fprintf_filtered (stream, "Dump of expression @ ");
1091   gdb_print_host_address (exp, stream);
1092   fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
1093   if (exp->elts[0].opcode != OP_TYPE)
1094     print_expression (exp, stream);
1095   else
1096     fputs_filtered ("Type printing not yet supported....", stream);
1097   fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
1098                     exp->language_defn->la_name, exp->nelts,
1099                     (long) sizeof (union exp_element));
1100   fputs_filtered ("\n", stream);
1101
1102   for (elt = 0; elt < exp->nelts;)
1103     elt = dump_subexp (exp, stream, elt);
1104   fputs_filtered ("\n", stream);
1105 }