1 /* Print in infix form a struct expression.
3 Copyright (C) 1986-2016 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. */
36 print_expression (struct expression *exp, struct ui_file *stream)
40 print_subexp (exp, &pc, stream, PREC_NULL);
43 /* Print the subexpression of EXP that starts in position POS, on STREAM.
44 PREC is the precedence of the surrounding operator;
45 if the precedence of the main operator of this subexpression is less,
46 parentheses are needed here. */
49 print_subexp (struct expression *exp, int *pos,
50 struct ui_file *stream, enum precedence prec)
52 exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec);
55 /* Standard implementation of print_subexp for use in language_defn
58 print_subexp_standard (struct expression *exp, int *pos,
59 struct ui_file *stream, enum precedence prec)
62 const struct op_print *op_print_tab;
66 int assign_modify = 0;
67 enum exp_opcode opcode;
68 enum precedence myprec = PREC_NULL;
69 /* Set to 1 for a right-associative operator. */
74 op_print_tab = exp->language_defn->la_op_print_tab;
76 opcode = exp->elts[pc].opcode;
83 type_print (exp->elts[pc + 1].type, "", stream, 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);
98 struct value_print_options opts;
100 get_no_prettyformat_print_options (&opts);
102 value_print (value_from_longest (exp->elts[pc + 1].type,
103 exp->elts[pc + 2].longconst),
110 struct value_print_options opts;
112 get_no_prettyformat_print_options (&opts);
114 value_print (value_from_double (exp->elts[pc + 1].type,
115 exp->elts[pc + 2].doubleconst),
122 const struct block *b;
125 b = exp->elts[pc + 1].block;
127 && BLOCK_FUNCTION (b) != NULL
128 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
130 fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
131 fputs_filtered ("::", stream);
133 fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
137 case OP_VAR_ENTRY_VALUE:
140 fprintf_filtered (stream, "%s@entry",
141 SYMBOL_PRINT_NAME (exp->elts[pc + 1].symbol));
147 fprintf_filtered (stream, "$%d",
148 longest_to_int (exp->elts[pc + 1].longconst));
153 const char *name = &exp->elts[pc + 2].string;
155 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
156 fprintf_filtered (stream, "$%s", name);
162 fprintf_filtered (stream, "%s",
163 longest_to_int (exp->elts[pc + 1].longconst)
169 fprintf_filtered (stream, "$%s",
170 internalvar_name (exp->elts[pc + 1].internalvar));
175 nargs = longest_to_int (exp->elts[pc + 1].longconst);
176 print_subexp (exp, pos, stream, PREC_SUFFIX);
177 fputs_filtered (" (", stream);
178 for (tem = 0; tem < nargs; tem++)
181 fputs_filtered (", ", stream);
182 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
184 fputs_filtered (")", stream);
188 nargs = longest_to_int (exp->elts[pc + 1].longconst);
189 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
190 fputs_filtered (&exp->elts[pc + 2].string, stream);
195 struct value_print_options opts;
197 nargs = longest_to_int (exp->elts[pc + 1].longconst);
198 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
199 /* LA_PRINT_STRING will print using the current repeat count threshold.
200 If necessary, we can temporarily set it to zero, or pass it as an
201 additional parameter to LA_PRINT_STRING. -fnf */
202 get_user_print_options (&opts);
203 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
204 (gdb_byte *) &exp->elts[pc + 2].string, nargs,
209 case OP_OBJC_NSSTRING: /* Objective-C Foundation Class
210 NSString constant. */
212 struct value_print_options opts;
214 nargs = longest_to_int (exp->elts[pc + 1].longconst);
215 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
216 fputs_filtered ("@\"", stream);
217 get_user_print_options (&opts);
218 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
219 (gdb_byte *) &exp->elts[pc + 2].string, nargs,
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 = (char *) 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 = (char *) 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 (gdb_byte *) 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_no_prettyformat_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);
564 enum range_type range_type;
566 range_type = (enum range_type)
567 longest_to_int (exp->elts[pc + 1].longconst);
570 fputs_filtered ("RANGE(", stream);
571 if (range_type == HIGH_BOUND_DEFAULT
572 || range_type == NONE_BOUND_DEFAULT)
573 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
574 fputs_filtered ("..", stream);
575 if (range_type == LOW_BOUND_DEFAULT
576 || range_type == NONE_BOUND_DEFAULT)
577 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
578 fputs_filtered (")", stream);
586 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
587 if (op_print_tab[tem].opcode == opcode)
589 op_str = op_print_tab[tem].string;
590 myprec = op_print_tab[tem].precedence;
591 assoc = op_print_tab[tem].right_assoc;
594 if (op_print_tab[tem].opcode != opcode)
595 /* Not found; don't try to keep going because we don't know how
596 to interpret further elements. For example, this happens
597 if opcode is OP_TYPE. */
598 error (_("Invalid expression"));
601 /* Note that PREC_BUILTIN will always emit parentheses. */
602 if ((int) myprec < (int) prec)
603 fputs_filtered ("(", stream);
604 if ((int) opcode > (int) BINOP_END)
608 /* Unary postfix operator. */
609 print_subexp (exp, pos, stream, PREC_SUFFIX);
610 fputs_filtered (op_str, stream);
614 /* Unary prefix operator. */
615 fputs_filtered (op_str, stream);
616 if (myprec == PREC_BUILTIN_FUNCTION)
617 fputs_filtered ("(", stream);
618 print_subexp (exp, pos, stream, PREC_PREFIX);
619 if (myprec == PREC_BUILTIN_FUNCTION)
620 fputs_filtered (")", stream);
625 /* Binary operator. */
626 /* Print left operand.
627 If operator is right-associative,
628 increment precedence for this operand. */
629 print_subexp (exp, pos, stream,
630 (enum precedence) ((int) myprec + assoc));
631 /* Print the operator itself. */
633 fprintf_filtered (stream, " %s= ", op_str);
634 else if (op_str[0] == ',')
635 fprintf_filtered (stream, "%s ", op_str);
637 fprintf_filtered (stream, " %s ", op_str);
638 /* Print right operand.
639 If operator is left-associative,
640 increment precedence for this operand. */
641 print_subexp (exp, pos, stream,
642 (enum precedence) ((int) myprec + !assoc));
645 if ((int) myprec < (int) prec)
646 fputs_filtered (")", stream);
649 /* Return the operator corresponding to opcode OP as
650 a string. NULL indicates that the opcode was not found in the
651 current language table. */
653 op_string (enum exp_opcode op)
656 const struct op_print *op_print_tab;
658 op_print_tab = current_language->la_op_print_tab;
659 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
660 if (op_print_tab[tem].opcode == op)
661 return op_print_tab[tem].string;
665 /* Support for dumping the raw data from expressions in a human readable
668 static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
670 /* Name for OPCODE, when it appears in expression EXP. */
673 op_name (struct expression *exp, enum exp_opcode opcode)
675 return exp->language_defn->la_exp_desc->op_name (opcode);
678 /* Default name for the standard operator OPCODE (i.e., one defined in
679 the definition of enum exp_opcode). */
682 op_name_standard (enum exp_opcode opcode)
690 xsnprintf (buf, sizeof (buf), "<unknown %d>", opcode);
696 #include "std-operator.def"
701 /* Print a raw dump of expression EXP to STREAM.
702 NOTE, if non-NULL, is printed as extra explanatory text. */
705 dump_raw_expression (struct expression *exp, struct ui_file *stream,
713 fprintf_filtered (stream, "Dump of expression @ ");
714 gdb_print_host_address (exp, stream);
716 fprintf_filtered (stream, ", %s:", note);
717 fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n",
718 exp->language_defn->la_name, exp->nelts,
719 (long) sizeof (union exp_element));
720 fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
721 "Hex Value", "String Value");
722 for (elt = 0; elt < exp->nelts; elt++)
724 fprintf_filtered (stream, "\t%5d ", elt);
725 opcode_name = op_name (exp, exp->elts[elt].opcode);
727 fprintf_filtered (stream, "%20s ", opcode_name);
728 print_longest (stream, 'd', 0, exp->elts[elt].longconst);
729 fprintf_filtered (stream, " ");
731 for (eltscan = (char *) &exp->elts[elt],
732 eltsize = sizeof (union exp_element);
736 fprintf_filtered (stream, "%c",
737 isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
739 fprintf_filtered (stream, "\n");
743 /* Dump the subexpression of prefix expression EXP whose operator is at
744 position ELT onto STREAM. Returns the position of the next
745 subexpression in EXP. */
748 dump_subexp (struct expression *exp, struct ui_file *stream, int elt)
750 static int indent = 0;
753 fprintf_filtered (stream, "\n");
754 fprintf_filtered (stream, "\t%5d ", elt);
756 for (i = 1; i <= indent; i++)
757 fprintf_filtered (stream, " ");
760 fprintf_filtered (stream, "%-20s ", op_name (exp, exp->elts[elt].opcode));
762 elt = dump_subexp_body (exp, stream, elt);
769 /* Dump the operands of prefix expression EXP whose opcode is at
770 position ELT onto STREAM. Returns the position of the next
771 subexpression in EXP. */
774 dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
776 return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt);
779 /* Default value for subexp_body in exp_descriptor vector. */
782 dump_subexp_body_standard (struct expression *exp,
783 struct ui_file *stream, int elt)
785 int opcode = exp->elts[elt++].opcode;
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:
824 case STRUCTOP_MEMBER:
826 elt = dump_subexp (exp, stream, elt);
829 case UNOP_LOGICAL_NOT:
830 case UNOP_COMPLEMENT:
833 case UNOP_PREINCREMENT:
834 case UNOP_POSTINCREMENT:
835 case UNOP_PREDECREMENT:
836 case UNOP_POSTDECREMENT:
849 elt = dump_subexp (exp, stream, elt);
852 fprintf_filtered (stream, "Type @");
853 gdb_print_host_address (exp->elts[elt].type, stream);
854 fprintf_filtered (stream, " (");
855 type_print (exp->elts[elt].type, NULL, stream, 0);
856 fprintf_filtered (stream, "), value %ld (0x%lx)",
857 (long) exp->elts[elt + 1].longconst,
858 (long) exp->elts[elt + 1].longconst);
862 fprintf_filtered (stream, "Type @");
863 gdb_print_host_address (exp->elts[elt].type, stream);
864 fprintf_filtered (stream, " (");
865 type_print (exp->elts[elt].type, NULL, stream, 0);
866 fprintf_filtered (stream, "), value %g",
867 (double) exp->elts[elt + 1].doubleconst);
871 fprintf_filtered (stream, "Block @");
872 gdb_print_host_address (exp->elts[elt].block, stream);
873 fprintf_filtered (stream, ", symbol @");
874 gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
875 fprintf_filtered (stream, " (%s)",
876 SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
879 case OP_VAR_ENTRY_VALUE:
880 fprintf_filtered (stream, "Entry value of symbol @");
881 gdb_print_host_address (exp->elts[elt].symbol, stream);
882 fprintf_filtered (stream, " (%s)",
883 SYMBOL_PRINT_NAME (exp->elts[elt].symbol));
887 fprintf_filtered (stream, "History element %ld",
888 (long) exp->elts[elt].longconst);
892 fprintf_filtered (stream, "Register $%s", &exp->elts[elt + 1].string);
893 elt += 3 + BYTES_TO_EXP_ELEM (exp->elts[elt].longconst + 1);
896 fprintf_filtered (stream, "Internal var @");
897 gdb_print_host_address (exp->elts[elt].internalvar, stream);
898 fprintf_filtered (stream, " (%s)",
899 internalvar_name (exp->elts[elt].internalvar));
906 nargs = longest_to_int (exp->elts[elt].longconst);
908 fprintf_filtered (stream, "Number of args: %d", nargs);
911 for (i = 1; i <= nargs + 1; i++)
912 elt = dump_subexp (exp, stream, elt);
920 lower = longest_to_int (exp->elts[elt].longconst);
921 upper = longest_to_int (exp->elts[elt + 1].longconst);
923 fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
926 for (i = 1; i <= upper - lower + 1; i++)
927 elt = dump_subexp (exp, stream, elt);
930 case UNOP_DYNAMIC_CAST:
931 case UNOP_REINTERPRET_CAST:
933 case UNOP_MEMVAL_TYPE:
934 fprintf_filtered (stream, " (");
935 elt = dump_subexp (exp, stream, elt);
936 fprintf_filtered (stream, ")");
937 elt = dump_subexp (exp, stream, elt);
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);
948 case UNOP_MEMVAL_TLS:
949 fprintf_filtered (stream, "TLS type @");
950 gdb_print_host_address (exp->elts[elt + 1].type, stream);
951 fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
952 (exp->elts[elt].objfile == NULL ? "(null)"
953 : objfile_name (exp->elts[elt].objfile)));
954 type_print (exp->elts[elt + 1].type, NULL, stream, 0);
955 fprintf_filtered (stream, ")");
956 elt = dump_subexp (exp, stream, elt + 3);
959 fprintf_filtered (stream, "Type @");
960 gdb_print_host_address (exp->elts[elt].type, stream);
961 fprintf_filtered (stream, " (");
962 type_print (exp->elts[elt].type, NULL, stream, 0);
963 fprintf_filtered (stream, ")");
968 fprintf_filtered (stream, "Typeof (");
969 elt = dump_subexp (exp, stream, elt);
970 fprintf_filtered (stream, ")");
973 fprintf_filtered (stream, "typeid (");
974 elt = dump_subexp (exp, stream, elt);
975 fprintf_filtered (stream, ")");
977 case STRUCTOP_STRUCT:
983 len = longest_to_int (exp->elts[elt].longconst);
984 elem_name = &exp->elts[elt + 1].string;
986 fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
987 elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
995 fprintf_filtered (stream, "Type @");
996 gdb_print_host_address (exp->elts[elt].type, stream);
997 fprintf_filtered (stream, " (");
998 type_print (exp->elts[elt].type, NULL, stream, 0);
999 fprintf_filtered (stream, ") ");
1001 len = longest_to_int (exp->elts[elt + 1].longconst);
1002 elem_name = &exp->elts[elt + 2].string;
1004 fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
1005 elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
1012 len = exp->elts[elt++].longconst;
1013 fprintf_filtered (stream, "%s TypeInstance: ", plongest (len));
1016 fprintf_filtered (stream, "Type @");
1017 gdb_print_host_address (exp->elts[elt].type, stream);
1018 fprintf_filtered (stream, " (");
1019 type_print (exp->elts[elt].type, NULL, stream, 0);
1020 fprintf_filtered (stream, ")");
1023 fputs_filtered (", ", stream);
1025 /* Ending LEN and ending TYPE_INSTANCE. */
1027 elt = dump_subexp (exp, stream, elt);
1032 LONGEST len = exp->elts[elt].longconst;
1033 LONGEST type = exp->elts[elt + 1].longconst;
1035 fprintf_filtered (stream, "Language-specific string type: %s",
1041 /* Skip string content. */
1042 elt += BYTES_TO_EXP_ELEM (len);
1044 /* Skip length and ending OP_STRING. */
1050 enum range_type range_type;
1052 range_type = (enum range_type)
1053 longest_to_int (exp->elts[elt].longconst);
1058 case BOTH_BOUND_DEFAULT:
1059 fputs_filtered ("Range '..'", stream);
1061 case LOW_BOUND_DEFAULT:
1062 fputs_filtered ("Range '..EXP'", stream);
1064 case HIGH_BOUND_DEFAULT:
1065 fputs_filtered ("Range 'EXP..'", stream);
1067 case NONE_BOUND_DEFAULT:
1068 fputs_filtered ("Range 'EXP..EXP'", stream);
1071 fputs_filtered ("Invalid Range!", stream);
1075 if (range_type == HIGH_BOUND_DEFAULT
1076 || range_type == NONE_BOUND_DEFAULT)
1077 elt = dump_subexp (exp, stream, elt);
1078 if (range_type == LOW_BOUND_DEFAULT
1079 || range_type == NONE_BOUND_DEFAULT)
1080 elt = dump_subexp (exp, stream, elt);
1086 case MULTI_SUBSCRIPT:
1087 case OP_F77_UNDETERMINED_ARGLIST:
1093 fprintf_filtered (stream, "Unknown format");
1100 dump_prefix_expression (struct expression *exp, struct ui_file *stream)
1104 fprintf_filtered (stream, "Dump of expression @ ");
1105 gdb_print_host_address (exp, stream);
1106 fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
1107 print_expression (exp, stream);
1108 fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
1109 exp->language_defn->la_name, exp->nelts,
1110 (long) sizeof (union exp_element));
1111 fputs_filtered ("\n", stream);
1113 for (elt = 0; elt < exp->nelts;)
1114 elt = dump_subexp (exp, stream, elt);
1115 fputs_filtered ("\n", stream);