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