1 /* Print in infix form a struct expression.
3 Copyright (C) 1986, 1988-1989, 1991-2000, 2003, 2007-2012 Free
4 Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
24 #include "expression.h"
27 #include "parser-defs.h"
28 #include "user-regs.h" /* For user_reg_map_regnum_to_name. */
30 #include "gdb_string.h"
33 #include "gdb_assert.h"
41 print_expression (struct expression *exp, struct ui_file *stream)
45 print_subexp (exp, &pc, stream, PREC_NULL);
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. */
54 print_subexp (struct expression *exp, int *pos,
55 struct ui_file *stream, enum precedence prec)
57 exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec);
60 /* Standard implementation of print_subexp for use in language_defn
63 print_subexp_standard (struct expression *exp, int *pos,
64 struct ui_file *stream, enum precedence prec)
67 const struct op_print *op_print_tab;
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. */
79 op_print_tab = exp->language_defn->la_op_print_tab;
81 opcode = exp->elts[pc].opcode;
88 type_print (exp->elts[pc + 1].type, "", stream, 0);
94 fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
95 fputs_filtered ("::", stream);
96 nargs = longest_to_int (exp->elts[pc + 2].longconst);
97 (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
98 fputs_filtered (&exp->elts[pc + 3].string, stream);
103 struct value_print_options opts;
105 get_raw_print_options (&opts);
107 value_print (value_from_longest (exp->elts[pc + 1].type,
108 exp->elts[pc + 2].longconst),
115 struct value_print_options opts;
117 get_raw_print_options (&opts);
119 value_print (value_from_double (exp->elts[pc + 1].type,
120 exp->elts[pc + 2].doubleconst),
130 b = exp->elts[pc + 1].block;
132 && BLOCK_FUNCTION (b) != NULL
133 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
135 fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
136 fputs_filtered ("::", stream);
138 fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
142 case OP_VAR_ENTRY_VALUE:
145 fprintf_filtered (stream, "%s@entry",
146 SYMBOL_PRINT_NAME (exp->elts[pc + 1].symbol));
152 fprintf_filtered (stream, "$%d",
153 longest_to_int (exp->elts[pc + 1].longconst));
158 const char *name = &exp->elts[pc + 2].string;
160 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
161 fprintf_filtered (stream, "$%s", name);
167 fprintf_filtered (stream, "%s",
168 longest_to_int (exp->elts[pc + 1].longconst)
174 fprintf_filtered (stream, "$%s",
175 internalvar_name (exp->elts[pc + 1].internalvar));
180 nargs = longest_to_int (exp->elts[pc + 1].longconst);
181 print_subexp (exp, pos, stream, PREC_SUFFIX);
182 fputs_filtered (" (", stream);
183 for (tem = 0; tem < nargs; tem++)
186 fputs_filtered (", ", stream);
187 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
189 fputs_filtered (")", stream);
193 nargs = longest_to_int (exp->elts[pc + 1].longconst);
194 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
195 fputs_filtered (&exp->elts[pc + 2].string, stream);
200 struct value_print_options opts;
202 nargs = longest_to_int (exp->elts[pc + 1].longconst);
203 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
204 /* LA_PRINT_STRING will print using the current repeat count threshold.
205 If necessary, we can temporarily set it to zero, or pass it as an
206 additional parameter to LA_PRINT_STRING. -fnf */
207 get_user_print_options (&opts);
208 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
209 &exp->elts[pc + 2].string, nargs, NULL, 0, &opts);
213 case OP_OBJC_NSSTRING: /* Objective-C Foundation Class
214 NSString constant. */
216 struct value_print_options opts;
218 nargs = longest_to_int (exp->elts[pc + 1].longconst);
219 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
220 fputs_filtered ("@\"", stream);
221 get_user_print_options (&opts);
222 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
223 &exp->elts[pc + 2].string, nargs, NULL, 0, &opts);
224 fputs_filtered ("\"", stream);
228 case OP_OBJC_MSGCALL:
229 { /* Objective C message (method) call. */
233 nargs = longest_to_int (exp->elts[pc + 2].longconst);
234 fprintf_unfiltered (stream, "[");
235 print_subexp (exp, pos, stream, PREC_SUFFIX);
236 if (0 == target_read_string (exp->elts[pc + 1].longconst,
237 &selector, 1024, NULL))
239 error (_("bad selector"));
246 s = alloca (strlen (selector) + 1);
247 strcpy (s, selector);
248 for (tem = 0; tem < nargs; tem++)
250 nextS = strchr (s, ':');
251 gdb_assert (nextS); /* Make sure we found ':'. */
253 fprintf_unfiltered (stream, " %s: ", s);
255 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
260 fprintf_unfiltered (stream, " %s", selector);
262 fprintf_unfiltered (stream, "]");
263 /* "selector" was malloc'd by target_read_string. Free it. */
270 nargs = longest_to_int (exp->elts[pc + 2].longconst);
271 nargs -= longest_to_int (exp->elts[pc + 1].longconst);
274 if (exp->elts[pc + 4].opcode == OP_LONG
275 && exp->elts[pc + 5].type
276 == builtin_type (exp->gdbarch)->builtin_char
277 && exp->language_defn->la_language == language_c)
279 /* Attempt to print C character arrays using string syntax.
280 Walk through the args, picking up one character from each
281 of the OP_LONG expression elements. If any array element
282 does not match our expection of what we should find for
283 a simple string, revert back to array printing. Note that
284 the last expression element is an explicit null terminator
285 byte, which doesn't get printed. */
286 tempstr = alloca (nargs);
290 if (exp->elts[pc].opcode != OP_LONG
291 || exp->elts[pc + 1].type
292 != builtin_type (exp->gdbarch)->builtin_char)
294 /* Not a simple array of char, use regular array
302 longest_to_int (exp->elts[pc + 2].longconst);
309 struct value_print_options opts;
311 get_user_print_options (&opts);
312 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
313 tempstr, nargs - 1, NULL, 0, &opts);
318 fputs_filtered (" {", stream);
319 for (tem = 0; tem < nargs; tem++)
323 fputs_filtered (", ", stream);
325 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
327 fputs_filtered ("}", stream);
332 tem = longest_to_int (exp->elts[pc + 1].longconst);
333 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
334 /* Gcc support both these syntaxes. Unsure which is preferred. */
336 fputs_filtered (&exp->elts[pc + 2].string, stream);
337 fputs_filtered (": ", stream);
339 fputs_filtered (".", stream);
340 fputs_filtered (&exp->elts[pc + 2].string, stream);
341 fputs_filtered ("=", stream);
343 print_subexp (exp, pos, stream, PREC_SUFFIX);
347 if ((int) prec > (int) PREC_COMMA)
348 fputs_filtered ("(", stream);
349 /* Print the subexpressions, forcing parentheses
350 around any binary operations within them.
351 This is more parentheses than are strictly necessary,
352 but it looks clearer. */
353 print_subexp (exp, pos, stream, PREC_HYPER);
354 fputs_filtered (" ? ", stream);
355 print_subexp (exp, pos, stream, PREC_HYPER);
356 fputs_filtered (" : ", stream);
357 print_subexp (exp, pos, stream, PREC_HYPER);
358 if ((int) prec > (int) PREC_COMMA)
359 fputs_filtered (")", stream);
363 case TERNOP_SLICE_COUNT:
364 print_subexp (exp, pos, stream, PREC_SUFFIX);
365 fputs_filtered ("(", stream);
366 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
367 fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
368 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
369 fputs_filtered (")", stream);
372 case STRUCTOP_STRUCT:
373 tem = longest_to_int (exp->elts[pc + 1].longconst);
374 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
375 print_subexp (exp, pos, stream, PREC_SUFFIX);
376 fputs_filtered (".", stream);
377 fputs_filtered (&exp->elts[pc + 2].string, stream);
380 /* Will not occur for Modula-2. */
382 tem = longest_to_int (exp->elts[pc + 1].longconst);
383 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
384 print_subexp (exp, pos, stream, PREC_SUFFIX);
385 fputs_filtered ("->", stream);
386 fputs_filtered (&exp->elts[pc + 2].string, stream);
389 case STRUCTOP_MEMBER:
390 print_subexp (exp, pos, stream, PREC_SUFFIX);
391 fputs_filtered (".*", stream);
392 print_subexp (exp, pos, stream, PREC_SUFFIX);
396 print_subexp (exp, pos, stream, PREC_SUFFIX);
397 fputs_filtered ("->*", stream);
398 print_subexp (exp, pos, stream, PREC_SUFFIX);
401 case BINOP_SUBSCRIPT:
402 print_subexp (exp, pos, stream, PREC_SUFFIX);
403 fputs_filtered ("[", stream);
404 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
405 fputs_filtered ("]", stream);
408 case UNOP_POSTINCREMENT:
409 print_subexp (exp, pos, stream, PREC_SUFFIX);
410 fputs_filtered ("++", stream);
413 case UNOP_POSTDECREMENT:
414 print_subexp (exp, pos, stream, PREC_SUFFIX);
415 fputs_filtered ("--", stream);
420 if ((int) prec > (int) PREC_PREFIX)
421 fputs_filtered ("(", stream);
422 fputs_filtered ("(", stream);
423 type_print (exp->elts[pc + 1].type, "", stream, 0);
424 fputs_filtered (") ", stream);
425 print_subexp (exp, pos, stream, PREC_PREFIX);
426 if ((int) prec > (int) PREC_PREFIX)
427 fputs_filtered (")", stream);
431 if ((int) prec > (int) PREC_PREFIX)
432 fputs_filtered ("(", stream);
433 fputs_filtered ("(", stream);
434 print_subexp (exp, pos, stream, PREC_PREFIX);
435 fputs_filtered (") ", stream);
436 print_subexp (exp, pos, stream, PREC_PREFIX);
437 if ((int) prec > (int) PREC_PREFIX)
438 fputs_filtered (")", stream);
441 case UNOP_DYNAMIC_CAST:
442 case UNOP_REINTERPRET_CAST:
443 fputs_filtered (opcode == UNOP_DYNAMIC_CAST ? "dynamic_cast"
444 : "reinterpret_cast", stream);
445 fputs_filtered ("<", stream);
446 print_subexp (exp, pos, stream, PREC_PREFIX);
447 fputs_filtered ("> (", stream);
448 print_subexp (exp, pos, stream, PREC_PREFIX);
449 fputs_filtered (")", stream);
454 if ((int) prec > (int) PREC_PREFIX)
455 fputs_filtered ("(", stream);
456 if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC
457 && exp->elts[pc + 3].opcode == OP_LONG)
459 struct value_print_options opts;
461 /* We have a minimal symbol fn, probably. It's encoded
462 as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
463 Swallow the OP_LONG (including both its opcodes); ignore
464 its type; print the value in the type of the MEMVAL. */
466 val = value_at_lazy (exp->elts[pc + 1].type,
467 (CORE_ADDR) exp->elts[pc + 5].longconst);
468 get_raw_print_options (&opts);
469 value_print (val, stream, &opts);
473 fputs_filtered ("{", stream);
474 type_print (exp->elts[pc + 1].type, "", stream, 0);
475 fputs_filtered ("} ", stream);
476 print_subexp (exp, pos, stream, PREC_PREFIX);
478 if ((int) prec > (int) PREC_PREFIX)
479 fputs_filtered (")", stream);
482 case UNOP_MEMVAL_TYPE:
483 if ((int) prec > (int) PREC_PREFIX)
484 fputs_filtered ("(", stream);
485 fputs_filtered ("{", stream);
486 print_subexp (exp, pos, stream, PREC_PREFIX);
487 fputs_filtered ("} ", stream);
488 print_subexp (exp, pos, stream, PREC_PREFIX);
489 if ((int) prec > (int) PREC_PREFIX)
490 fputs_filtered (")", stream);
493 case UNOP_MEMVAL_TLS:
495 if ((int) prec > (int) PREC_PREFIX)
496 fputs_filtered ("(", stream);
497 fputs_filtered ("{", stream);
498 type_print (exp->elts[pc + 2].type, "", stream, 0);
499 fputs_filtered ("} ", stream);
500 print_subexp (exp, pos, stream, PREC_PREFIX);
501 if ((int) prec > (int) PREC_PREFIX)
502 fputs_filtered (")", stream);
505 case BINOP_ASSIGN_MODIFY:
506 opcode = exp->elts[pc + 1].opcode;
508 myprec = PREC_ASSIGN;
512 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
513 if (op_print_tab[tem].opcode == opcode)
515 op_str = op_print_tab[tem].string;
518 if (op_print_tab[tem].opcode != opcode)
519 /* Not found; don't try to keep going because we don't know how
520 to interpret further elements. */
521 error (_("Invalid expression"));
528 if (exp->language_defn->la_name_of_this)
529 fputs_filtered (exp->language_defn->la_name_of_this, stream);
531 fprintf_filtered (stream, _("<language %s has no 'this'>"),
532 exp->language_defn->la_name);
537 case MULTI_SUBSCRIPT:
539 nargs = longest_to_int (exp->elts[pc + 1].longconst);
540 print_subexp (exp, pos, stream, PREC_SUFFIX);
541 fprintf_unfiltered (stream, " [");
542 for (tem = 0; tem < nargs; tem++)
545 fprintf_unfiltered (stream, ", ");
546 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
548 fprintf_unfiltered (stream, "]");
553 fprintf_unfiltered (stream, "VAL(");
554 type_print (exp->elts[pc + 1].type, "", stream, 0);
555 fprintf_unfiltered (stream, ",");
556 print_subexp (exp, pos, stream, PREC_PREFIX);
557 fprintf_unfiltered (stream, ")");
562 LONGEST count = exp->elts[pc + 1].longconst;
566 fputs_unfiltered ("TypesInstance(", stream);
569 type_print (exp->elts[(*pos)++].type, "", stream, 0);
571 fputs_unfiltered (",", stream);
573 fputs_unfiltered (",", stream);
574 /* Ending COUNT and ending TYPE_INSTANCE. */
576 print_subexp (exp, pos, stream, PREC_PREFIX);
577 fputs_unfiltered (")", stream);
585 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
586 if (op_print_tab[tem].opcode == opcode)
588 op_str = op_print_tab[tem].string;
589 myprec = op_print_tab[tem].precedence;
590 assoc = op_print_tab[tem].right_assoc;
593 if (op_print_tab[tem].opcode != opcode)
594 /* Not found; don't try to keep going because we don't know how
595 to interpret further elements. For example, this happens
596 if opcode is OP_TYPE. */
597 error (_("Invalid expression"));
600 /* Note that PREC_BUILTIN will always emit parentheses. */
601 if ((int) myprec < (int) prec)
602 fputs_filtered ("(", stream);
603 if ((int) opcode > (int) BINOP_END)
607 /* Unary postfix operator. */
608 print_subexp (exp, pos, stream, PREC_SUFFIX);
609 fputs_filtered (op_str, stream);
613 /* Unary prefix operator. */
614 fputs_filtered (op_str, stream);
615 if (myprec == PREC_BUILTIN_FUNCTION)
616 fputs_filtered ("(", stream);
617 print_subexp (exp, pos, stream, PREC_PREFIX);
618 if (myprec == PREC_BUILTIN_FUNCTION)
619 fputs_filtered (")", stream);
624 /* Binary operator. */
625 /* Print left operand.
626 If operator is right-associative,
627 increment precedence for this operand. */
628 print_subexp (exp, pos, stream,
629 (enum precedence) ((int) myprec + assoc));
630 /* Print the operator itself. */
632 fprintf_filtered (stream, " %s= ", op_str);
633 else if (op_str[0] == ',')
634 fprintf_filtered (stream, "%s ", op_str);
636 fprintf_filtered (stream, " %s ", op_str);
637 /* Print right operand.
638 If operator is left-associative,
639 increment precedence for this operand. */
640 print_subexp (exp, pos, stream,
641 (enum precedence) ((int) myprec + !assoc));
644 if ((int) myprec < (int) prec)
645 fputs_filtered (")", stream);
648 /* Return the operator corresponding to opcode OP as
649 a string. NULL indicates that the opcode was not found in the
650 current language table. */
652 op_string (enum exp_opcode op)
655 const struct op_print *op_print_tab;
657 op_print_tab = current_language->la_op_print_tab;
658 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
659 if (op_print_tab[tem].opcode == op)
660 return op_print_tab[tem].string;
664 /* Support for dumping the raw data from expressions in a human readable
667 static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
669 /* Name for OPCODE, when it appears in expression EXP. */
672 op_name (struct expression *exp, enum exp_opcode opcode)
674 return exp->language_defn->la_exp_desc->op_name (opcode);
677 /* Default name for the standard operator OPCODE (i.e., one defined in
678 the definition of enum exp_opcode). */
681 op_name_standard (enum exp_opcode opcode)
689 sprintf (buf, "<unknown %d>", opcode);
695 #include "std-operator.def"
700 /* Print a raw dump of expression EXP to STREAM.
701 NOTE, if non-NULL, is printed as extra explanatory text. */
704 dump_raw_expression (struct expression *exp, struct ui_file *stream,
712 fprintf_filtered (stream, "Dump of expression @ ");
713 gdb_print_host_address (exp, stream);
715 fprintf_filtered (stream, ", %s:", note);
716 fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n",
717 exp->language_defn->la_name, exp->nelts,
718 (long) sizeof (union exp_element));
719 fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
720 "Hex Value", "String Value");
721 for (elt = 0; elt < exp->nelts; elt++)
723 fprintf_filtered (stream, "\t%5d ", elt);
724 opcode_name = op_name (exp, exp->elts[elt].opcode);
726 fprintf_filtered (stream, "%20s ", opcode_name);
727 print_longest (stream, 'd', 0, exp->elts[elt].longconst);
728 fprintf_filtered (stream, " ");
730 for (eltscan = (char *) &exp->elts[elt],
731 eltsize = sizeof (union exp_element);
735 fprintf_filtered (stream, "%c",
736 isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
738 fprintf_filtered (stream, "\n");
742 /* Dump the subexpression of prefix expression EXP whose operator is at
743 position ELT onto STREAM. Returns the position of the next
744 subexpression in EXP. */
747 dump_subexp (struct expression *exp, struct ui_file *stream, int elt)
749 static int indent = 0;
752 fprintf_filtered (stream, "\n");
753 fprintf_filtered (stream, "\t%5d ", elt);
755 for (i = 1; i <= indent; i++)
756 fprintf_filtered (stream, " ");
759 fprintf_filtered (stream, "%-20s ", op_name (exp, exp->elts[elt].opcode));
761 elt = dump_subexp_body (exp, stream, elt);
768 /* Dump the operands of prefix expression EXP whose opcode is at
769 position ELT onto STREAM. Returns the position of the next
770 subexpression in EXP. */
773 dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
775 return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt);
778 /* Default value for subexp_body in exp_descriptor vector. */
781 dump_subexp_body_standard (struct expression *exp,
782 struct ui_file *stream, int elt)
784 int opcode = exp->elts[elt++].opcode;
790 case TERNOP_SLICE_COUNT:
791 elt = dump_subexp (exp, stream, elt);
801 case BINOP_LOGICAL_AND:
802 case BINOP_LOGICAL_OR:
803 case BINOP_BITWISE_AND:
804 case BINOP_BITWISE_IOR:
805 case BINOP_BITWISE_XOR:
815 case BINOP_SUBSCRIPT:
820 case BINOP_ASSIGN_MODIFY:
826 case STRUCTOP_MEMBER:
828 elt = dump_subexp (exp, stream, elt);
831 case UNOP_LOGICAL_NOT:
832 case UNOP_COMPLEMENT:
835 case UNOP_PREINCREMENT:
836 case UNOP_POSTINCREMENT:
837 case UNOP_PREDECREMENT:
838 case UNOP_POSTDECREMENT:
851 elt = dump_subexp (exp, stream, elt);
854 fprintf_filtered (stream, "Type @");
855 gdb_print_host_address (exp->elts[elt].type, stream);
856 fprintf_filtered (stream, " (");
857 type_print (exp->elts[elt].type, NULL, stream, 0);
858 fprintf_filtered (stream, "), value %ld (0x%lx)",
859 (long) exp->elts[elt + 1].longconst,
860 (long) exp->elts[elt + 1].longconst);
864 fprintf_filtered (stream, "Type @");
865 gdb_print_host_address (exp->elts[elt].type, stream);
866 fprintf_filtered (stream, " (");
867 type_print (exp->elts[elt].type, NULL, stream, 0);
868 fprintf_filtered (stream, "), value %g",
869 (double) exp->elts[elt + 1].doubleconst);
873 fprintf_filtered (stream, "Block @");
874 gdb_print_host_address (exp->elts[elt].block, stream);
875 fprintf_filtered (stream, ", symbol @");
876 gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
877 fprintf_filtered (stream, " (%s)",
878 SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
881 case OP_VAR_ENTRY_VALUE:
882 fprintf_filtered (stream, "Entry value of symbol @");
883 gdb_print_host_address (exp->elts[elt].symbol, stream);
884 fprintf_filtered (stream, " (%s)",
885 SYMBOL_PRINT_NAME (exp->elts[elt].symbol));
889 fprintf_filtered (stream, "History element %ld",
890 (long) exp->elts[elt].longconst);
894 fprintf_filtered (stream, "Register $%s", &exp->elts[elt + 1].string);
895 elt += 3 + BYTES_TO_EXP_ELEM (exp->elts[elt].longconst + 1);
898 fprintf_filtered (stream, "Internal var @");
899 gdb_print_host_address (exp->elts[elt].internalvar, stream);
900 fprintf_filtered (stream, " (%s)",
901 internalvar_name (exp->elts[elt].internalvar));
908 nargs = longest_to_int (exp->elts[elt].longconst);
910 fprintf_filtered (stream, "Number of args: %d", nargs);
913 for (i = 1; i <= nargs + 1; i++)
914 elt = dump_subexp (exp, stream, elt);
922 lower = longest_to_int (exp->elts[elt].longconst);
923 upper = longest_to_int (exp->elts[elt + 1].longconst);
925 fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
928 for (i = 1; i <= upper - lower + 1; i++)
929 elt = dump_subexp (exp, stream, elt);
932 case UNOP_DYNAMIC_CAST:
933 case UNOP_REINTERPRET_CAST:
935 case UNOP_MEMVAL_TYPE:
936 fprintf_filtered (stream, " (");
937 elt = dump_subexp (exp, stream, elt);
938 fprintf_filtered (stream, ")");
939 elt = dump_subexp (exp, stream, elt);
943 fprintf_filtered (stream, "Type @");
944 gdb_print_host_address (exp->elts[elt].type, stream);
945 fprintf_filtered (stream, " (");
946 type_print (exp->elts[elt].type, NULL, stream, 0);
947 fprintf_filtered (stream, ")");
948 elt = dump_subexp (exp, stream, elt + 2);
950 case UNOP_MEMVAL_TLS:
951 fprintf_filtered (stream, "TLS type @");
952 gdb_print_host_address (exp->elts[elt + 1].type, stream);
953 fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
954 (exp->elts[elt].objfile == NULL ? "(null)"
955 : exp->elts[elt].objfile->name));
956 type_print (exp->elts[elt + 1].type, NULL, stream, 0);
957 fprintf_filtered (stream, ")");
958 elt = dump_subexp (exp, stream, elt + 3);
961 fprintf_filtered (stream, "Type @");
962 gdb_print_host_address (exp->elts[elt].type, stream);
963 fprintf_filtered (stream, " (");
964 type_print (exp->elts[elt].type, NULL, stream, 0);
965 fprintf_filtered (stream, ")");
970 fprintf_filtered (stream, "Typeof (");
971 elt = dump_subexp (exp, stream, elt);
972 fprintf_filtered (stream, ")");
974 case STRUCTOP_STRUCT:
980 len = longest_to_int (exp->elts[elt].longconst);
981 elem_name = &exp->elts[elt + 1].string;
983 fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
984 elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
992 fprintf_filtered (stream, "Type @");
993 gdb_print_host_address (exp->elts[elt].type, stream);
994 fprintf_filtered (stream, " (");
995 type_print (exp->elts[elt].type, NULL, stream, 0);
996 fprintf_filtered (stream, ") ");
998 len = longest_to_int (exp->elts[elt + 1].longconst);
999 elem_name = &exp->elts[elt + 2].string;
1001 fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
1002 elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
1009 len = exp->elts[elt++].longconst;
1010 fprintf_filtered (stream, "%s TypeInstance: ", plongest (len));
1013 fprintf_filtered (stream, "Type @");
1014 gdb_print_host_address (exp->elts[elt].type, stream);
1015 fprintf_filtered (stream, " (");
1016 type_print (exp->elts[elt].type, NULL, stream, 0);
1017 fprintf_filtered (stream, ")");
1020 fputs_filtered (", ", stream);
1022 /* Ending LEN and ending TYPE_INSTANCE. */
1024 elt = dump_subexp (exp, stream, elt);
1029 case MULTI_SUBSCRIPT:
1030 case OP_F77_UNDETERMINED_ARGLIST:
1038 fprintf_filtered (stream, "Unknown format");
1045 dump_prefix_expression (struct expression *exp, struct ui_file *stream)
1049 fprintf_filtered (stream, "Dump of expression @ ");
1050 gdb_print_host_address (exp, stream);
1051 fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
1052 print_expression (exp, stream);
1053 fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
1054 exp->language_defn->la_name, exp->nelts,
1055 (long) sizeof (union exp_element));
1056 fputs_filtered ("\n", stream);
1058 for (elt = 0; elt < exp->nelts;)
1059 elt = dump_subexp (exp, stream, elt);
1060 fputs_filtered ("\n", stream);