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