/* Print in infix form a struct expression.
Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2003, 2007, 2008 Free Software Foundation, Inc.
+ 1998, 1999, 2000, 2003, 2007, 2008, 2009, 2010, 2011
+ Free Software Foundation, Inc.
This file is part of GDB.
#include "block.h"
#include "objfiles.h"
#include "gdb_assert.h"
+#include "valprint.h"
#ifdef HAVE_CTYPE_H
#include <ctype.h>
print_expression (struct expression *exp, struct ui_file *stream)
{
int pc = 0;
+
print_subexp (exp, &pc, stream, PREC_NULL);
}
return;
case OP_LONG:
- (*pos) += 3;
- value_print (value_from_longest (exp->elts[pc + 1].type,
- exp->elts[pc + 2].longconst),
- stream, 0, Val_no_prettyprint);
+ {
+ struct value_print_options opts;
+
+ get_raw_print_options (&opts);
+ (*pos) += 3;
+ value_print (value_from_longest (exp->elts[pc + 1].type,
+ exp->elts[pc + 2].longconst),
+ stream, &opts);
+ }
return;
case OP_DOUBLE:
- (*pos) += 3;
- value_print (value_from_double (exp->elts[pc + 1].type,
- exp->elts[pc + 2].doubleconst),
- stream, 0, Val_no_prettyprint);
+ {
+ struct value_print_options opts;
+
+ get_raw_print_options (&opts);
+ (*pos) += 3;
+ value_print (value_from_double (exp->elts[pc + 1].type,
+ exp->elts[pc + 2].doubleconst),
+ stream, &opts);
+ }
return;
case OP_VAR_VALUE:
{
struct block *b;
+
(*pos) += 3;
b = exp->elts[pc + 1].block;
if (b != NULL
case OP_REGISTER:
{
const char *name = &exp->elts[pc + 2].string;
+
(*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
fprintf_filtered (stream, "$%s", name);
return;
return;
case OP_STRING:
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
- /* LA_PRINT_STRING will print using the current repeat count threshold.
- If necessary, we can temporarily set it to zero, or pass it as an
- additional parameter to LA_PRINT_STRING. -fnf */
- LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
+ {
+ struct value_print_options opts;
+
+ nargs = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
+ /* LA_PRINT_STRING will print using the current repeat count threshold.
+ If necessary, we can temporarily set it to zero, or pass it as an
+ additional parameter to LA_PRINT_STRING. -fnf */
+ get_user_print_options (&opts);
+ LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
+ &exp->elts[pc + 2].string, nargs, NULL, 0, &opts);
+ }
return;
case OP_BITSTRING:
fprintf_unfiltered (stream, "B'<unimplemented>'");
return;
- case OP_OBJC_NSSTRING: /* Objective-C Foundation Class NSString constant. */
- nargs = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
- fputs_filtered ("@\"", stream);
- LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
- fputs_filtered ("\"", stream);
+ case OP_OBJC_NSSTRING: /* Objective-C Foundation Class
+ NSString constant. */
+ {
+ struct value_print_options opts;
+
+ nargs = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
+ fputs_filtered ("@\"", stream);
+ get_user_print_options (&opts);
+ LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
+ &exp->elts[pc + 2].string, nargs, NULL, 0, &opts);
+ fputs_filtered ("\"", stream);
+ }
return;
case OP_OBJC_MSGCALL:
{ /* Objective C message (method) call. */
char *selector;
+
(*pos) += 3;
nargs = longest_to_int (exp->elts[pc + 2].longconst);
fprintf_unfiltered (stream, "[");
if (nargs)
{
char *s, *nextS;
+
s = alloca (strlen (selector) + 1);
strcpy (s, selector);
for (tem = 0; tem < nargs; tem++)
fprintf_unfiltered (stream, " %s", selector);
}
fprintf_unfiltered (stream, "]");
- /* "selector" was malloc'd by target_read_string. Free it. */
+ /* "selector" was malloc'd by target_read_string. Free it. */
xfree (selector);
return;
}
does not match our expection of what we should find for
a simple string, revert back to array printing. Note that
the last expression element is an explicit null terminator
- byte, which doesn't get printed. */
+ byte, which doesn't get printed. */
tempstr = alloca (nargs);
pc += 4;
while (tem < nargs)
|| exp->elts[pc + 1].type
!= builtin_type (exp->gdbarch)->builtin_char)
{
- /* Not a simple array of char, use regular array printing. */
+ /* Not a simple array of char, use regular array
+ printing. */
tem = 0;
break;
}
}
if (tem > 0)
{
- LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0);
+ struct value_print_options opts;
+
+ get_user_print_options (&opts);
+ LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char,
+ tempstr, nargs - 1, NULL, 0, &opts);
(*pos) = pc;
}
else
fputs_filtered (&exp->elts[pc + 2].string, stream);
return;
- /* Will not occur for Modula-2 */
+ /* Will not occur for Modula-2. */
case STRUCTOP_PTR:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
fputs_filtered (")", stream);
return;
+ case UNOP_DYNAMIC_CAST:
+ case UNOP_REINTERPRET_CAST:
+ fputs_filtered (opcode == UNOP_DYNAMIC_CAST ? "dynamic_cast"
+ : "reinterpret_cast", stream);
+ fputs_filtered ("<", stream);
+ (*pos) += 2;
+ type_print (exp->elts[pc + 1].type, "", stream, 0);
+ fputs_filtered ("> (", stream);
+ print_subexp (exp, pos, stream, PREC_PREFIX);
+ fputs_filtered (")", stream);
+ return;
+
case UNOP_MEMVAL:
(*pos) += 2;
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered ("(", stream);
- if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC &&
- exp->elts[pc + 3].opcode == OP_LONG)
+ if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC
+ && exp->elts[pc + 3].opcode == OP_LONG)
{
+ struct value_print_options opts;
+
/* We have a minimal symbol fn, probably. It's encoded
as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
Swallow the OP_LONG (including both its opcodes); ignore
(*pos) += 4;
val = value_at_lazy (exp->elts[pc + 1].type,
(CORE_ADDR) exp->elts[pc + 5].longconst);
- value_print (val, stream, 0, Val_no_prettyprint);
+ get_raw_print_options (&opts);
+ value_print (val, stream, &opts);
}
else
{
fprintf_unfiltered (stream, ")");
return;
- case BINOP_INCL:
- case BINOP_EXCL:
- error (_("print_subexp: Not implemented."));
-
/* Default ops */
default:
error (_("Invalid expression"));
}
- /* Note that PREC_BUILTIN will always emit parentheses. */
+ /* Note that PREC_BUILTIN will always emit parentheses. */
if ((int) myprec < (int) prec)
fputs_filtered ("(", stream);
if ((int) opcode > (int) BINOP_END)
static char *op_name (struct expression *, enum exp_opcode);
static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
-/* Name for OPCODE, when it appears in expression EXP. */
+/* Name for OPCODE, when it appears in expression EXP. */
static char *
op_name (struct expression *exp, enum exp_opcode opcode)
return "BINOP_ASSIGN_MODIFY";
case BINOP_VAL:
return "BINOP_VAL";
- case BINOP_INCL:
- return "BINOP_INCL";
- case BINOP_EXCL:
- return "BINOP_EXCL";
case BINOP_CONCAT:
return "BINOP_CONCAT";
case BINOP_RANGE:
return "OP_ARRAY";
case UNOP_CAST:
return "UNOP_CAST";
+ case UNOP_DYNAMIC_CAST:
+ return "UNOP_DYNAMIC_CAST";
+ case UNOP_REINTERPRET_CAST:
+ return "UNOP_REINTERPRET_CAST";
case UNOP_MEMVAL:
return "UNOP_MEMVAL";
case UNOP_MEMVAL_TLS:
return "UNOP_POSTDECREMENT";
case UNOP_SIZEOF:
return "UNOP_SIZEOF";
- case UNOP_LOWER:
- return "UNOP_LOWER";
- case UNOP_UPPER:
- return "UNOP_UPPER";
- case UNOP_LENGTH:
- return "UNOP_LENGTH";
case UNOP_PLUS:
return "UNOP_PLUS";
case UNOP_CAP:
return "OP_TYPE";
case OP_LABELED:
return "OP_LABELED";
+ case OP_ADL_FUNC:
+ return "OP_ADL_FUNC";
}
}
+/* Print a raw dump of expression EXP to STREAM.
+ NOTE, if non-NULL, is printed as extra explanatory text. */
+
void
dump_raw_expression (struct expression *exp, struct ui_file *stream,
char *note)
fprintf_filtered (stream, "Dump of expression @ ");
gdb_print_host_address (exp, stream);
- fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
+ if (note)
+ fprintf_filtered (stream, ", %s:", note);
+ fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n",
exp->language_defn->la_name, exp->nelts,
(long) sizeof (union exp_element));
fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
case BINOP_INTDIV:
case BINOP_ASSIGN_MODIFY:
case BINOP_VAL:
- case BINOP_INCL:
- case BINOP_EXCL:
case BINOP_CONCAT:
case BINOP_IN:
case BINOP_RANGE:
case UNOP_MIN:
case UNOP_ODD:
case UNOP_TRUNC:
- case UNOP_LOWER:
- case UNOP_UPPER:
- case UNOP_LENGTH:
- case UNOP_CARD:
- case UNOP_CHMAX:
- case UNOP_CHMIN:
elt = dump_subexp (exp, stream, elt);
break;
case OP_LONG:
fprintf_filtered (stream, "Internal var @");
gdb_print_host_address (exp->elts[elt].internalvar, stream);
fprintf_filtered (stream, " (%s)",
- exp->elts[elt].internalvar->name);
+ internalvar_name (exp->elts[elt].internalvar));
elt += 2;
break;
case OP_FUNCALL:
break;
case UNOP_MEMVAL:
case UNOP_CAST:
+ case UNOP_DYNAMIC_CAST:
+ case UNOP_REINTERPRET_CAST:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
projects / deliverable / binutils-gdb.git / blobdiff