1 /* Print in infix form a struct expression.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
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 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "expression.h"
26 #include "parser-defs.h"
27 #include "user-regs.h" /* For user_reg_map_regnum_to_name. */
29 #include "gdb_string.h"
32 #include "gdb_assert.h"
38 print_expression (struct expression *exp, struct ui_file *stream)
42 print_subexp (exp, &pc, stream, PREC_NULL);
45 /* Print the subexpression of EXP that starts in position POS, on STREAM.
46 PREC is the precedence of the surrounding operator;
47 if the precedence of the main operator of this subexpression is less,
48 parentheses are needed here. */
51 print_subexp (struct expression *exp, int *pos,
52 struct ui_file *stream, enum precedence prec)
54 exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec);
57 /* Standard implementation of print_subexp for use in language_defn
60 print_subexp_standard (struct expression *exp, int *pos,
61 struct ui_file *stream, enum precedence prec)
64 const struct op_print *op_print_tab;
68 int assign_modify = 0;
69 enum exp_opcode opcode;
70 enum precedence myprec = PREC_NULL;
71 /* Set to 1 for a right-associative operator. */
76 op_print_tab = exp->language_defn->la_op_print_tab;
78 opcode = exp->elts[pc].opcode;
85 type_print (exp->elts[pc + 1].type, "", stream, 0);
91 fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
92 fputs_filtered ("::", stream);
93 nargs = longest_to_int (exp->elts[pc + 2].longconst);
94 (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
95 fputs_filtered (&exp->elts[pc + 3].string, stream);
100 struct value_print_options opts;
102 get_raw_print_options (&opts);
104 value_print (value_from_longest (exp->elts[pc + 1].type,
105 exp->elts[pc + 2].longconst),
112 struct value_print_options opts;
114 get_raw_print_options (&opts);
116 value_print (value_from_double (exp->elts[pc + 1].type,
117 exp->elts[pc + 2].doubleconst),
124 const struct block *b;
127 b = exp->elts[pc + 1].block;
129 && BLOCK_FUNCTION (b) != NULL
130 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
132 fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
133 fputs_filtered ("::", stream);
135 fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
139 case OP_VAR_ENTRY_VALUE:
142 fprintf_filtered (stream, "%s@entry",
143 SYMBOL_PRINT_NAME (exp->elts[pc + 1].symbol));
149 fprintf_filtered (stream, "$%d",
150 longest_to_int (exp->elts[pc + 1].longconst));
155 const char *name = &exp->elts[pc + 2].string;
157 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
158 fprintf_filtered (stream, "$%s", name);
164 fprintf_filtered (stream, "%s",
165 longest_to_int (exp->elts[pc + 1].longconst)
171 fprintf_filtered (stream, "$%s",
172 internalvar_name (exp->elts[pc + 1].internalvar));
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++)
183 fputs_filtered (", ", stream);
184 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
186 fputs_filtered (")", stream);
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);
197 struct value_print_options opts;
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);
210 case OP_OBJC_NSSTRING: /* Objective-C Foundation Class
211 NSString constant. */
213 struct value_print_options opts;
215 nargs = longest_to_int (exp->elts[pc + 1].longconst);
216 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
217 fputs_filtered ("@\"", stream);
218 get_user_print_options (&opts);
219 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
220 &exp->elts[pc + 2].string, nargs, NULL, 0, &opts);
221 fputs_filtered ("\"", stream);
225 case OP_OBJC_MSGCALL:
226 { /* Objective C message (method) call. */
230 nargs = longest_to_int (exp->elts[pc + 2].longconst);
231 fprintf_unfiltered (stream, "[");
232 print_subexp (exp, pos, stream, PREC_SUFFIX);
233 if (0 == target_read_string (exp->elts[pc + 1].longconst,
234 &selector, 1024, NULL))
236 error (_("bad selector"));
243 s = alloca (strlen (selector) + 1);
244 strcpy (s, selector);
245 for (tem = 0; tem < nargs; tem++)
247 nextS = strchr (s, ':');
248 gdb_assert (nextS); /* Make sure we found ':'. */
250 fprintf_unfiltered (stream, " %s: ", s);
252 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
257 fprintf_unfiltered (stream, " %s", selector);
259 fprintf_unfiltered (stream, "]");
260 /* "selector" was malloc'd by target_read_string. Free it. */
267 nargs = longest_to_int (exp->elts[pc + 2].longconst);
268 nargs -= longest_to_int (exp->elts[pc + 1].longconst);
271 if (exp->elts[pc + 4].opcode == OP_LONG
272 && exp->elts[pc + 5].type
273 == builtin_type (exp->gdbarch)->builtin_char
274 && exp->language_defn->la_language == language_c)
276 /* Attempt to print C character arrays using string syntax.
277 Walk through the args, picking up one character from each
278 of the OP_LONG expression elements. If any array element
279 does not match our expection of what we should find for
280 a simple string, revert back to array printing. Note that
281 the last expression element is an explicit null terminator
282 byte, which doesn't get printed. */
283 tempstr = alloca (nargs);
287 if (exp->elts[pc].opcode != OP_LONG
288 || exp->elts[pc + 1].type
289 != builtin_type (exp->gdbarch)->builtin_char)
291 /* Not a simple array of char, use regular array
299 longest_to_int (exp->elts[pc + 2].longconst);
306 struct value_print_options opts;
308 get_user_print_options (&opts);
309 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
310 tempstr, nargs - 1, NULL, 0, &opts);
315 fputs_filtered (" {", stream);
316 for (tem = 0; tem < nargs; tem++)
320 fputs_filtered (", ", stream);
322 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
324 fputs_filtered ("}", stream);
329 if ((int) prec > (int) PREC_COMMA)
330 fputs_filtered ("(", stream);
331 /* Print the subexpressions, forcing parentheses
332 around any binary operations within them.
333 This is more parentheses than are strictly necessary,
334 but it looks clearer. */
335 print_subexp (exp, pos, stream, PREC_HYPER);
336 fputs_filtered (" ? ", stream);
337 print_subexp (exp, pos, stream, PREC_HYPER);
338 fputs_filtered (" : ", stream);
339 print_subexp (exp, pos, stream, PREC_HYPER);
340 if ((int) prec > (int) PREC_COMMA)
341 fputs_filtered (")", stream);
345 print_subexp (exp, pos, stream, PREC_SUFFIX);
346 fputs_filtered ("(", stream);
347 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
348 fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
349 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
350 fputs_filtered (")", stream);
353 case STRUCTOP_STRUCT:
354 tem = longest_to_int (exp->elts[pc + 1].longconst);
355 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
356 print_subexp (exp, pos, stream, PREC_SUFFIX);
357 fputs_filtered (".", stream);
358 fputs_filtered (&exp->elts[pc + 2].string, stream);
361 /* Will not occur for Modula-2. */
363 tem = longest_to_int (exp->elts[pc + 1].longconst);
364 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
365 print_subexp (exp, pos, stream, PREC_SUFFIX);
366 fputs_filtered ("->", stream);
367 fputs_filtered (&exp->elts[pc + 2].string, stream);
370 case STRUCTOP_MEMBER:
371 print_subexp (exp, pos, stream, PREC_SUFFIX);
372 fputs_filtered (".*", stream);
373 print_subexp (exp, pos, stream, PREC_SUFFIX);
377 print_subexp (exp, pos, stream, PREC_SUFFIX);
378 fputs_filtered ("->*", stream);
379 print_subexp (exp, pos, stream, PREC_SUFFIX);
382 case BINOP_SUBSCRIPT:
383 print_subexp (exp, pos, stream, PREC_SUFFIX);
384 fputs_filtered ("[", stream);
385 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
386 fputs_filtered ("]", stream);
389 case UNOP_POSTINCREMENT:
390 print_subexp (exp, pos, stream, PREC_SUFFIX);
391 fputs_filtered ("++", stream);
394 case UNOP_POSTDECREMENT:
395 print_subexp (exp, pos, stream, PREC_SUFFIX);
396 fputs_filtered ("--", stream);
401 if ((int) prec > (int) PREC_PREFIX)
402 fputs_filtered ("(", stream);
403 fputs_filtered ("(", stream);
404 type_print (exp->elts[pc + 1].type, "", stream, 0);
405 fputs_filtered (") ", stream);
406 print_subexp (exp, pos, stream, PREC_PREFIX);
407 if ((int) prec > (int) PREC_PREFIX)
408 fputs_filtered (")", stream);
412 if ((int) prec > (int) PREC_PREFIX)
413 fputs_filtered ("(", stream);
414 fputs_filtered ("(", stream);
415 print_subexp (exp, pos, stream, PREC_PREFIX);
416 fputs_filtered (") ", stream);
417 print_subexp (exp, pos, stream, PREC_PREFIX);
418 if ((int) prec > (int) PREC_PREFIX)
419 fputs_filtered (")", stream);
422 case UNOP_DYNAMIC_CAST:
423 case UNOP_REINTERPRET_CAST:
424 fputs_filtered (opcode == UNOP_DYNAMIC_CAST ? "dynamic_cast"
425 : "reinterpret_cast", stream);
426 fputs_filtered ("<", stream);
427 print_subexp (exp, pos, stream, PREC_PREFIX);
428 fputs_filtered ("> (", stream);
429 print_subexp (exp, pos, stream, PREC_PREFIX);
430 fputs_filtered (")", stream);
435 if ((int) prec > (int) PREC_PREFIX)
436 fputs_filtered ("(", stream);
437 if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC
438 && exp->elts[pc + 3].opcode == OP_LONG)
440 struct value_print_options opts;
442 /* We have a minimal symbol fn, probably. It's encoded
443 as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
444 Swallow the OP_LONG (including both its opcodes); ignore
445 its type; print the value in the type of the MEMVAL. */
447 val = value_at_lazy (exp->elts[pc + 1].type,
448 (CORE_ADDR) exp->elts[pc + 5].longconst);
449 get_raw_print_options (&opts);
450 value_print (val, stream, &opts);
454 fputs_filtered ("{", stream);
455 type_print (exp->elts[pc + 1].type, "", stream, 0);
456 fputs_filtered ("} ", stream);
457 print_subexp (exp, pos, stream, PREC_PREFIX);
459 if ((int) prec > (int) PREC_PREFIX)
460 fputs_filtered (")", stream);
463 case UNOP_MEMVAL_TYPE:
464 if ((int) prec > (int) PREC_PREFIX)
465 fputs_filtered ("(", stream);
466 fputs_filtered ("{", stream);
467 print_subexp (exp, pos, stream, PREC_PREFIX);
468 fputs_filtered ("} ", stream);
469 print_subexp (exp, pos, stream, PREC_PREFIX);
470 if ((int) prec > (int) PREC_PREFIX)
471 fputs_filtered (")", stream);
474 case UNOP_MEMVAL_TLS:
476 if ((int) prec > (int) PREC_PREFIX)
477 fputs_filtered ("(", stream);
478 fputs_filtered ("{", stream);
479 type_print (exp->elts[pc + 2].type, "", stream, 0);
480 fputs_filtered ("} ", stream);
481 print_subexp (exp, pos, stream, PREC_PREFIX);
482 if ((int) prec > (int) PREC_PREFIX)
483 fputs_filtered (")", stream);
486 case BINOP_ASSIGN_MODIFY:
487 opcode = exp->elts[pc + 1].opcode;
489 myprec = PREC_ASSIGN;
493 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
494 if (op_print_tab[tem].opcode == opcode)
496 op_str = op_print_tab[tem].string;
499 if (op_print_tab[tem].opcode != opcode)
500 /* Not found; don't try to keep going because we don't know how
501 to interpret further elements. */
502 error (_("Invalid expression"));
509 if (exp->language_defn->la_name_of_this)
510 fputs_filtered (exp->language_defn->la_name_of_this, stream);
512 fprintf_filtered (stream, _("<language %s has no 'this'>"),
513 exp->language_defn->la_name);
518 case MULTI_SUBSCRIPT:
520 nargs = longest_to_int (exp->elts[pc + 1].longconst);
521 print_subexp (exp, pos, stream, PREC_SUFFIX);
522 fprintf_unfiltered (stream, " [");
523 for (tem = 0; tem < nargs; tem++)
526 fprintf_unfiltered (stream, ", ");
527 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
529 fprintf_unfiltered (stream, "]");
534 fprintf_unfiltered (stream, "VAL(");
535 type_print (exp->elts[pc + 1].type, "", stream, 0);
536 fprintf_unfiltered (stream, ",");
537 print_subexp (exp, pos, stream, PREC_PREFIX);
538 fprintf_unfiltered (stream, ")");
543 LONGEST count = exp->elts[pc + 1].longconst;
547 fputs_unfiltered ("TypesInstance(", stream);
550 type_print (exp->elts[(*pos)++].type, "", stream, 0);
552 fputs_unfiltered (",", stream);
554 fputs_unfiltered (",", stream);
555 /* Ending COUNT and ending TYPE_INSTANCE. */
557 print_subexp (exp, pos, stream, PREC_PREFIX);
558 fputs_unfiltered (")", stream);
566 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
567 if (op_print_tab[tem].opcode == opcode)
569 op_str = op_print_tab[tem].string;
570 myprec = op_print_tab[tem].precedence;
571 assoc = op_print_tab[tem].right_assoc;
574 if (op_print_tab[tem].opcode != opcode)
575 /* Not found; don't try to keep going because we don't know how
576 to interpret further elements. For example, this happens
577 if opcode is OP_TYPE. */
578 error (_("Invalid expression"));
581 /* Note that PREC_BUILTIN will always emit parentheses. */
582 if ((int) myprec < (int) prec)
583 fputs_filtered ("(", stream);
584 if ((int) opcode > (int) BINOP_END)
588 /* Unary postfix operator. */
589 print_subexp (exp, pos, stream, PREC_SUFFIX);
590 fputs_filtered (op_str, stream);
594 /* Unary prefix operator. */
595 fputs_filtered (op_str, stream);
596 if (myprec == PREC_BUILTIN_FUNCTION)
597 fputs_filtered ("(", stream);
598 print_subexp (exp, pos, stream, PREC_PREFIX);
599 if (myprec == PREC_BUILTIN_FUNCTION)
600 fputs_filtered (")", stream);
605 /* Binary operator. */
606 /* Print left operand.
607 If operator is right-associative,
608 increment precedence for this operand. */
609 print_subexp (exp, pos, stream,
610 (enum precedence) ((int) myprec + assoc));
611 /* Print the operator itself. */
613 fprintf_filtered (stream, " %s= ", op_str);
614 else if (op_str[0] == ',')
615 fprintf_filtered (stream, "%s ", op_str);
617 fprintf_filtered (stream, " %s ", op_str);
618 /* Print right operand.
619 If operator is left-associative,
620 increment precedence for this operand. */
621 print_subexp (exp, pos, stream,
622 (enum precedence) ((int) myprec + !assoc));
625 if ((int) myprec < (int) prec)
626 fputs_filtered (")", stream);
629 /* Return the operator corresponding to opcode OP as
630 a string. NULL indicates that the opcode was not found in the
631 current language table. */
633 op_string (enum exp_opcode op)
636 const struct op_print *op_print_tab;
638 op_print_tab = current_language->la_op_print_tab;
639 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
640 if (op_print_tab[tem].opcode == op)
641 return op_print_tab[tem].string;
645 /* Support for dumping the raw data from expressions in a human readable
648 static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
650 /* Name for OPCODE, when it appears in expression EXP. */
653 op_name (struct expression *exp, enum exp_opcode opcode)
655 return exp->language_defn->la_exp_desc->op_name (opcode);
658 /* Default name for the standard operator OPCODE (i.e., one defined in
659 the definition of enum exp_opcode). */
662 op_name_standard (enum exp_opcode opcode)
670 xsnprintf (buf, sizeof (buf), "<unknown %d>", opcode);
676 #include "std-operator.def"
681 /* Print a raw dump of expression EXP to STREAM.
682 NOTE, if non-NULL, is printed as extra explanatory text. */
685 dump_raw_expression (struct expression *exp, struct ui_file *stream,
693 fprintf_filtered (stream, "Dump of expression @ ");
694 gdb_print_host_address (exp, stream);
696 fprintf_filtered (stream, ", %s:", note);
697 fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n",
698 exp->language_defn->la_name, exp->nelts,
699 (long) sizeof (union exp_element));
700 fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
701 "Hex Value", "String Value");
702 for (elt = 0; elt < exp->nelts; elt++)
704 fprintf_filtered (stream, "\t%5d ", elt);
705 opcode_name = op_name (exp, exp->elts[elt].opcode);
707 fprintf_filtered (stream, "%20s ", opcode_name);
708 print_longest (stream, 'd', 0, exp->elts[elt].longconst);
709 fprintf_filtered (stream, " ");
711 for (eltscan = (char *) &exp->elts[elt],
712 eltsize = sizeof (union exp_element);
716 fprintf_filtered (stream, "%c",
717 isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
719 fprintf_filtered (stream, "\n");
723 /* Dump the subexpression of prefix expression EXP whose operator is at
724 position ELT onto STREAM. Returns the position of the next
725 subexpression in EXP. */
728 dump_subexp (struct expression *exp, struct ui_file *stream, int elt)
730 static int indent = 0;
733 fprintf_filtered (stream, "\n");
734 fprintf_filtered (stream, "\t%5d ", elt);
736 for (i = 1; i <= indent; i++)
737 fprintf_filtered (stream, " ");
740 fprintf_filtered (stream, "%-20s ", op_name (exp, exp->elts[elt].opcode));
742 elt = dump_subexp_body (exp, stream, elt);
749 /* Dump the operands of prefix expression EXP whose opcode is at
750 position ELT onto STREAM. Returns the position of the next
751 subexpression in EXP. */
754 dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
756 return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt);
759 /* Default value for subexp_body in exp_descriptor vector. */
762 dump_subexp_body_standard (struct expression *exp,
763 struct ui_file *stream, int elt)
765 int opcode = exp->elts[elt++].opcode;
771 elt = dump_subexp (exp, stream, elt);
781 case BINOP_LOGICAL_AND:
782 case BINOP_LOGICAL_OR:
783 case BINOP_BITWISE_AND:
784 case BINOP_BITWISE_IOR:
785 case BINOP_BITWISE_XOR:
795 case BINOP_SUBSCRIPT:
800 case BINOP_ASSIGN_MODIFY:
806 case STRUCTOP_MEMBER:
808 elt = dump_subexp (exp, stream, elt);
811 case UNOP_LOGICAL_NOT:
812 case UNOP_COMPLEMENT:
815 case UNOP_PREINCREMENT:
816 case UNOP_POSTINCREMENT:
817 case UNOP_PREDECREMENT:
818 case UNOP_POSTDECREMENT:
831 elt = dump_subexp (exp, stream, elt);
834 fprintf_filtered (stream, "Type @");
835 gdb_print_host_address (exp->elts[elt].type, stream);
836 fprintf_filtered (stream, " (");
837 type_print (exp->elts[elt].type, NULL, stream, 0);
838 fprintf_filtered (stream, "), value %ld (0x%lx)",
839 (long) exp->elts[elt + 1].longconst,
840 (long) exp->elts[elt + 1].longconst);
844 fprintf_filtered (stream, "Type @");
845 gdb_print_host_address (exp->elts[elt].type, stream);
846 fprintf_filtered (stream, " (");
847 type_print (exp->elts[elt].type, NULL, stream, 0);
848 fprintf_filtered (stream, "), value %g",
849 (double) exp->elts[elt + 1].doubleconst);
853 fprintf_filtered (stream, "Block @");
854 gdb_print_host_address (exp->elts[elt].block, stream);
855 fprintf_filtered (stream, ", symbol @");
856 gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
857 fprintf_filtered (stream, " (%s)",
858 SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
861 case OP_VAR_ENTRY_VALUE:
862 fprintf_filtered (stream, "Entry value of symbol @");
863 gdb_print_host_address (exp->elts[elt].symbol, stream);
864 fprintf_filtered (stream, " (%s)",
865 SYMBOL_PRINT_NAME (exp->elts[elt].symbol));
869 fprintf_filtered (stream, "History element %ld",
870 (long) exp->elts[elt].longconst);
874 fprintf_filtered (stream, "Register $%s", &exp->elts[elt + 1].string);
875 elt += 3 + BYTES_TO_EXP_ELEM (exp->elts[elt].longconst + 1);
878 fprintf_filtered (stream, "Internal var @");
879 gdb_print_host_address (exp->elts[elt].internalvar, stream);
880 fprintf_filtered (stream, " (%s)",
881 internalvar_name (exp->elts[elt].internalvar));
888 nargs = longest_to_int (exp->elts[elt].longconst);
890 fprintf_filtered (stream, "Number of args: %d", nargs);
893 for (i = 1; i <= nargs + 1; i++)
894 elt = dump_subexp (exp, stream, elt);
902 lower = longest_to_int (exp->elts[elt].longconst);
903 upper = longest_to_int (exp->elts[elt + 1].longconst);
905 fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
908 for (i = 1; i <= upper - lower + 1; i++)
909 elt = dump_subexp (exp, stream, elt);
912 case UNOP_DYNAMIC_CAST:
913 case UNOP_REINTERPRET_CAST:
915 case UNOP_MEMVAL_TYPE:
916 fprintf_filtered (stream, " (");
917 elt = dump_subexp (exp, stream, elt);
918 fprintf_filtered (stream, ")");
919 elt = dump_subexp (exp, stream, elt);
923 fprintf_filtered (stream, "Type @");
924 gdb_print_host_address (exp->elts[elt].type, stream);
925 fprintf_filtered (stream, " (");
926 type_print (exp->elts[elt].type, NULL, stream, 0);
927 fprintf_filtered (stream, ")");
928 elt = dump_subexp (exp, stream, elt + 2);
930 case UNOP_MEMVAL_TLS:
931 fprintf_filtered (stream, "TLS type @");
932 gdb_print_host_address (exp->elts[elt + 1].type, stream);
933 fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
934 (exp->elts[elt].objfile == NULL ? "(null)"
935 : exp->elts[elt].objfile->name));
936 type_print (exp->elts[elt + 1].type, NULL, stream, 0);
937 fprintf_filtered (stream, ")");
938 elt = dump_subexp (exp, stream, elt + 3);
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, ")");
950 fprintf_filtered (stream, "Typeof (");
951 elt = dump_subexp (exp, stream, elt);
952 fprintf_filtered (stream, ")");
954 case STRUCTOP_STRUCT:
960 len = longest_to_int (exp->elts[elt].longconst);
961 elem_name = &exp->elts[elt + 1].string;
963 fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
964 elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
972 fprintf_filtered (stream, "Type @");
973 gdb_print_host_address (exp->elts[elt].type, stream);
974 fprintf_filtered (stream, " (");
975 type_print (exp->elts[elt].type, NULL, stream, 0);
976 fprintf_filtered (stream, ") ");
978 len = longest_to_int (exp->elts[elt + 1].longconst);
979 elem_name = &exp->elts[elt + 2].string;
981 fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
982 elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
989 len = exp->elts[elt++].longconst;
990 fprintf_filtered (stream, "%s TypeInstance: ", plongest (len));
993 fprintf_filtered (stream, "Type @");
994 gdb_print_host_address (exp->elts[elt].type, stream);
995 fprintf_filtered (stream, " (");
996 type_print (exp->elts[elt].type, NULL, stream, 0);
997 fprintf_filtered (stream, ")");
1000 fputs_filtered (", ", stream);
1002 /* Ending LEN and ending TYPE_INSTANCE. */
1004 elt = dump_subexp (exp, stream, elt);
1009 case MULTI_SUBSCRIPT:
1010 case OP_F77_UNDETERMINED_ARGLIST:
1017 fprintf_filtered (stream, "Unknown format");
1024 dump_prefix_expression (struct expression *exp, struct ui_file *stream)
1028 fprintf_filtered (stream, "Dump of expression @ ");
1029 gdb_print_host_address (exp, stream);
1030 fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
1031 print_expression (exp, stream);
1032 fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
1033 exp->language_defn->la_name, exp->nelts,
1034 (long) sizeof (union exp_element));
1035 fputs_filtered ("\n", stream);
1037 for (elt = 0; elt < exp->nelts;)
1038 elt = dump_subexp (exp, stream, elt);
1039 fputs_filtered ("\n", stream);