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