static struct value *
evaluate_subexp_java (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
int pc = *pos;
int i;
const char *name;
enum exp_opcode op = exp->elts[*pos].opcode;
struct value *arg1;
struct value *arg2;
struct type *type;
switch (op)
{
case UNOP_IND:
if (noside == EVAL_SKIP)
goto standard;
(*pos)++;
arg1 = evaluate_subexp_java (NULL_TYPE, exp, pos, EVAL_NORMAL);
if (is_object_type (value_type (arg1)))
{
struct type *type;
type = type_from_class (exp->gdbarch, java_class_from_object (arg1));
arg1 = value_cast (lookup_pointer_type (type), arg1);
}
return value_ind (arg1);
case BINOP_SUBSCRIPT:
(*pos)++;
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
/* If the user attempts to subscript something that is not an
array or pointer type (like a plain int variable for example),
then report this as an error. */
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_PTR)
type = check_typedef (TYPE_TARGET_TYPE (type));
name = TYPE_NAME (type);
if (name == NULL)
name = TYPE_TAG_NAME (type);
i = name == NULL ? 0 : strlen (name);
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& i > 2 && name[i - 1] == ']')
{
enum bfd_endian byte_order = gdbarch_byte_order (exp->gdbarch);
CORE_ADDR address;
long length, index;
struct type *el_type;
gdb_byte buf4[4];
struct value *clas = java_class_from_object (arg1);
struct value *temp = clas;
/* Get CLASS_ELEMENT_TYPE of the array type. */
temp = value_struct_elt (&temp, NULL, "methods",
NULL, "structure");
deprecated_set_value_type (temp, value_type (clas));
el_type = type_from_class (exp->gdbarch, temp);
if (TYPE_CODE (el_type) == TYPE_CODE_STRUCT)
el_type = lookup_pointer_type (el_type);
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (el_type, VALUE_LVAL (arg1));
address = value_as_address (arg1);
address += get_java_object_header_size (exp->gdbarch);
read_memory (address, buf4, 4);
length = (long) extract_signed_integer (buf4, 4, byte_order);
index = (long) value_as_long (arg2);
if (index >= length || index < 0)
error (_("array index (%ld) out of bounds (length: %ld)"),
index, length);
address = (address + 4) + index * TYPE_LENGTH (el_type);
return value_at (el_type, address);
}
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
else
return value_subscript (arg1, value_as_long (arg2));
}
if (name)
error (_("cannot subscript something of type `%s'"), name);
else
error (_("cannot subscript requested type"));
case OP_STRING:
(*pos)++;
i = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (i + 1);
if (noside == EVAL_SKIP)
goto nosideret;
return java_value_string (&exp->elts[pc + 2].string, i);
case STRUCTOP_PTR:
arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
/* Convert object field (such as TYPE.class) to reference. */
if (TYPE_CODE (value_type (arg1)) == TYPE_CODE_STRUCT)
arg1 = value_addr (arg1);
return arg1;
default:
break;
}
standard:
return evaluate_subexp_standard (expect_type, exp, pos, noside);
nosideret:
return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
}
int
dump_subexp_body_standard (struct expression *exp,
struct ui_file *stream, int elt)
{
int opcode = exp->elts[elt++].opcode;
switch (opcode)
{
case TERNOP_COND:
case TERNOP_SLICE:
case TERNOP_SLICE_COUNT:
elt = dump_subexp (exp, stream, elt);
case BINOP_ADD:
case BINOP_SUB:
case BINOP_MUL:
case BINOP_DIV:
case BINOP_REM:
case BINOP_MOD:
case BINOP_LSH:
case BINOP_RSH:
case BINOP_LOGICAL_AND:
case BINOP_LOGICAL_OR:
case BINOP_BITWISE_AND:
case BINOP_BITWISE_IOR:
case BINOP_BITWISE_XOR:
case BINOP_EQUAL:
case BINOP_NOTEQUAL:
case BINOP_LESS:
case BINOP_GTR:
case BINOP_LEQ:
case BINOP_GEQ:
case BINOP_REPEAT:
case BINOP_ASSIGN:
case BINOP_COMMA:
case BINOP_SUBSCRIPT:
case BINOP_EXP:
case BINOP_MIN:
case BINOP_MAX:
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 BINOP_END:
elt = dump_subexp (exp, stream, elt);
case UNOP_NEG:
case UNOP_LOGICAL_NOT:
case UNOP_COMPLEMENT:
case UNOP_IND:
case UNOP_ADDR:
case UNOP_PREINCREMENT:
case UNOP_POSTINCREMENT:
case UNOP_PREDECREMENT:
case UNOP_POSTDECREMENT:
case UNOP_SIZEOF:
case UNOP_PLUS:
case UNOP_CAP:
case UNOP_CHR:
case UNOP_ORD:
case UNOP_ABS:
case UNOP_FLOAT:
case UNOP_HIGH:
case UNOP_MAX:
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, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, "), value %ld (0x%lx)",
(long) exp->elts[elt + 1].longconst,
(long) exp->elts[elt + 1].longconst);
elt += 3;
break;
case OP_DOUBLE:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, "), value %g",
(double) exp->elts[elt + 1].doubleconst);
elt += 3;
break;
case OP_VAR_VALUE:
fprintf_filtered (stream, "Block @");
gdb_print_host_address (exp->elts[elt].block, stream);
fprintf_filtered (stream, ", symbol @");
gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
fprintf_filtered (stream, " (%s)",
DEPRECATED_SYMBOL_NAME (exp->elts[elt + 1].symbol));
elt += 3;
break;
case OP_LAST:
fprintf_filtered (stream, "History element %ld",
(long) exp->elts[elt].longconst);
elt += 2;
break;
case OP_REGISTER:
fprintf_filtered (stream, "Register %ld",
(long) exp->elts[elt].longconst);
elt += 2;
break;
case OP_INTERNALVAR:
fprintf_filtered (stream, "Internal var @");
gdb_print_host_address (exp->elts[elt].internalvar, stream);
fprintf_filtered (stream, " (%s)",
exp->elts[elt].internalvar->name);
elt += 2;
break;
case OP_FUNCALL:
{
int i, nargs;
nargs = longest_to_int (exp->elts[elt].longconst);
fprintf_filtered (stream, "Number of args: %d", nargs);
elt += 2;
for (i = 1; i <= nargs + 1; i++)
elt = dump_subexp (exp, stream, elt);
}
break;
case OP_ARRAY:
{
int lower, upper;
int i;
lower = longest_to_int (exp->elts[elt].longconst);
upper = longest_to_int (exp->elts[elt + 1].longconst);
fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
elt += 3;
for (i = 1; i <= upper - lower + 1; i++)
elt = dump_subexp (exp, stream, elt);
}
break;
case UNOP_MEMVAL:
case UNOP_CAST:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, ")");
elt = dump_subexp (exp, stream, elt + 2);
break;
case OP_TYPE:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, ")");
elt += 2;
break;
case STRUCTOP_STRUCT:
case STRUCTOP_PTR:
{
char *elem_name;
int len;
len = longest_to_int (exp->elts[elt].longconst);
elem_name = &exp->elts[elt + 1].string;
fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
}
break;
case OP_SCOPE:
{
char *elem_name;
int len;
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, ") ");
len = longest_to_int (exp->elts[elt + 1].longconst);
elem_name = &exp->elts[elt + 2].string;
fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
}
break;
default:
case OP_NULL:
case STRUCTOP_MEMBER:
case STRUCTOP_MPTR:
case MULTI_SUBSCRIPT:
case OP_F77_UNDETERMINED_ARGLIST:
case OP_COMPLEX:
case OP_STRING:
case OP_BITSTRING:
case OP_BOOL:
case OP_M2_STRING:
case OP_THIS:
case OP_LABELED:
case OP_NAME:
case OP_EXPRSTRING:
fprintf_filtered (stream, "Unknown format");
}
return elt;
}
/* Standard implementation of print_subexp for use in language_defn
vectors. */
void
print_subexp_standard (struct expression *exp, int *pos,
struct ui_file *stream, enum precedence prec)
{
unsigned tem;
const struct op_print *op_print_tab;
int pc;
unsigned nargs;
char *op_str;
int assign_modify = 0;
enum exp_opcode opcode;
enum precedence myprec = PREC_NULL;
/* Set to 1 for a right-associative operator. */
int assoc = 0;
struct value *val;
char *tempstr = NULL;
op_print_tab = exp->language_defn->la_op_print_tab;
pc = (*pos)++;
opcode = exp->elts[pc].opcode;
switch (opcode)
{
/* Common ops */
case OP_SCOPE:
myprec = PREC_PREFIX;
assoc = 0;
fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
fputs_filtered ("::", stream);
nargs = longest_to_int (exp->elts[pc + 2].longconst);
(*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
fputs_filtered (&exp->elts[pc + 3].string, stream);
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);
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);
return;
case OP_VAR_VALUE:
{
struct block *b;
(*pos) += 3;
b = exp->elts[pc + 1].block;
if (b != NULL
&& BLOCK_FUNCTION (b) != NULL
&& SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
{
fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
fputs_filtered ("::", stream);
}
fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
}
return;
case OP_LAST:
(*pos) += 2;
fprintf_filtered (stream, "$%d",
longest_to_int (exp->elts[pc + 1].longconst));
return;
case OP_REGISTER:
{
int regnum = longest_to_int (exp->elts[pc + 1].longconst);
const char *name = user_reg_map_regnum_to_name (current_gdbarch,
regnum);
(*pos) += 2;
fprintf_filtered (stream, "$%s", name);
return;
}
case OP_BOOL:
(*pos) += 2;
fprintf_filtered (stream, "%s",
longest_to_int (exp->elts[pc + 1].longconst)
? "TRUE" : "FALSE");
return;
case OP_INTERNALVAR:
(*pos) += 2;
fprintf_filtered (stream, "$%s",
internalvar_name (exp->elts[pc + 1].internalvar));
return;
case OP_FUNCALL:
(*pos) += 2;
nargs = longest_to_int (exp->elts[pc + 1].longconst);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (" (", stream);
for (tem = 0; tem < nargs; tem++)
{
if (tem != 0)
fputs_filtered (", ", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
fputs_filtered (")", stream);
return;
case OP_NAME:
case OP_EXPRSTRING:
nargs = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
fputs_filtered (&exp->elts[pc + 2].string, stream);
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);
return;
case OP_BITSTRING:
nargs = longest_to_int (exp->elts[pc + 1].longconst);
(*pos)
+= 3 + BYTES_TO_EXP_ELEM ((nargs + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
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);
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, "[");
print_subexp (exp, pos, stream, PREC_SUFFIX);
if (0 == target_read_string (exp->elts[pc + 1].longconst,
&selector, 1024, NULL))
{
error (_("bad selector"));
return;
}
if (nargs)
{
char *s, *nextS;
s = alloca (strlen (selector) + 1);
strcpy (s, selector);
for (tem = 0; tem < nargs; tem++)
{
nextS = strchr (s, ':');
*nextS = '\0';
fprintf_unfiltered (stream, " %s: ", s);
s = nextS + 1;
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
}
else
{
fprintf_unfiltered (stream, " %s", selector);
}
fprintf_unfiltered (stream, "]");
/* "selector" was malloc'd by target_read_string. Free it. */
xfree (selector);
return;
}
case OP_ARRAY:
(*pos) += 3;
nargs = longest_to_int (exp->elts[pc + 2].longconst);
nargs -= longest_to_int (exp->elts[pc + 1].longconst);
nargs++;
tem = 0;
if (exp->elts[pc + 4].opcode == OP_LONG
&& exp->elts[pc + 5].type == builtin_type_char
&& exp->language_defn->la_language == language_c)
{
/* Attempt to print C character arrays using string syntax.
Walk through the args, picking up one character from each
of the OP_LONG expression elements. If any array element
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. */
tempstr = alloca (nargs);
pc += 4;
while (tem < nargs)
{
if (exp->elts[pc].opcode != OP_LONG
|| exp->elts[pc + 1].type != builtin_type_char)
{
/* Not a simple array of char, use regular array printing. */
tem = 0;
break;
}
else
{
tempstr[tem++] =
longest_to_int (exp->elts[pc + 2].longconst);
pc += 4;
}
}
}
if (tem > 0)
{
LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0);
(*pos) = pc;
}
else
{
fputs_filtered (" {", stream);
for (tem = 0; tem < nargs; tem++)
{
if (tem != 0)
{
fputs_filtered (", ", stream);
}
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
fputs_filtered ("}", stream);
}
return;
case OP_LABELED:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
/* Gcc support both these syntaxes. Unsure which is preferred. */
#if 1
fputs_filtered (&exp->elts[pc + 2].string, stream);
fputs_filtered (": ", stream);
#else
fputs_filtered (".", stream);
fputs_filtered (&exp->elts[pc + 2].string, stream);
fputs_filtered ("=", stream);
#endif
print_subexp (exp, pos, stream, PREC_SUFFIX);
return;
case TERNOP_COND:
if ((int) prec > (int) PREC_COMMA)
fputs_filtered ("(", stream);
/* Print the subexpressions, forcing parentheses
around any binary operations within them.
This is more parentheses than are strictly necessary,
but it looks clearer. */
print_subexp (exp, pos, stream, PREC_HYPER);
fputs_filtered (" ? ", stream);
print_subexp (exp, pos, stream, PREC_HYPER);
fputs_filtered (" : ", stream);
print_subexp (exp, pos, stream, PREC_HYPER);
if ((int) prec > (int) PREC_COMMA)
fputs_filtered (")", stream);
return;
case TERNOP_SLICE:
case TERNOP_SLICE_COUNT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("(", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
fputs_filtered (")", stream);
return;
case STRUCTOP_STRUCT:
tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (".", stream);
fputs_filtered (&exp->elts[pc + 2].string, stream);
return;
/* 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);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("->", stream);
fputs_filtered (&exp->elts[pc + 2].string, stream);
return;
case BINOP_SUBSCRIPT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("[", stream);
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
fputs_filtered ("]", stream);
return;
case UNOP_POSTINCREMENT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("++", stream);
return;
case UNOP_POSTDECREMENT:
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered ("--", stream);
return;
case UNOP_CAST:
(*pos) += 2;
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered ("(", stream);
fputs_filtered ("(", stream);
type_print (exp->elts[pc + 1].type, "", stream, 0);
fputs_filtered (") ", stream);
print_subexp (exp, pos, stream, PREC_PREFIX);
if ((int) prec > (int) 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)
{
/* 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
its type; print the value in the type of the MEMVAL. */
(*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);
}
else
{
fputs_filtered ("{", stream);
type_print (exp->elts[pc + 1].type, "", stream, 0);
fputs_filtered ("} ", stream);
print_subexp (exp, pos, stream, PREC_PREFIX);
}
if ((int) prec > (int) PREC_PREFIX)
fputs_filtered (")", stream);
return;
case BINOP_ASSIGN_MODIFY:
opcode = exp->elts[pc + 1].opcode;
(*pos) += 2;
myprec = PREC_ASSIGN;
assoc = 1;
assign_modify = 1;
op_str = "???";
for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
if (op_print_tab[tem].opcode == opcode)
{
op_str = op_print_tab[tem].string;
break;
}
if (op_print_tab[tem].opcode != opcode)
/* Not found; don't try to keep going because we don't know how
to interpret further elements. */
error (_("Invalid expression"));
break;
/* C++ ops */
case OP_THIS:
++(*pos);
fputs_filtered ("this", stream);
return;
/* Objective-C ops */
case OP_OBJC_SELF:
++(*pos);
fputs_filtered ("self", stream); /* The ObjC equivalent of "this". */
return;
/* Modula-2 ops */
case MULTI_SUBSCRIPT:
(*pos) += 2;
nargs = longest_to_int (exp->elts[pc + 1].longconst);
print_subexp (exp, pos, stream, PREC_SUFFIX);
fprintf_unfiltered (stream, " [");
for (tem = 0; tem < nargs; tem++)
{
if (tem != 0)
fprintf_unfiltered (stream, ", ");
print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
}
fprintf_unfiltered (stream, "]");
return;
case BINOP_VAL:
(*pos) += 2;
fprintf_unfiltered (stream, "VAL(");
type_print (exp->elts[pc + 1].type, "", stream, 0);
fprintf_unfiltered (stream, ",");
print_subexp (exp, pos, stream, PREC_PREFIX);
fprintf_unfiltered (stream, ")");
return;
case BINOP_INCL:
case BINOP_EXCL:
error (_("print_subexp: Not implemented."));
/* Default ops */
default:
op_str = "???";
for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
if (op_print_tab[tem].opcode == opcode)
{
op_str = op_print_tab[tem].string;
myprec = op_print_tab[tem].precedence;
assoc = op_print_tab[tem].right_assoc;
break;
}
if (op_print_tab[tem].opcode != opcode)
/* Not found; don't try to keep going because we don't know how
to interpret further elements. For example, this happens
if opcode is OP_TYPE. */
error (_("Invalid expression"));
}
/* Note that PREC_BUILTIN will always emit parentheses. */
if ((int) myprec < (int) prec)
fputs_filtered ("(", stream);
if ((int) opcode > (int) BINOP_END)
{
if (assoc)
{
/* Unary postfix operator. */
print_subexp (exp, pos, stream, PREC_SUFFIX);
fputs_filtered (op_str, stream);
}
else
{
/* Unary prefix operator. */
fputs_filtered (op_str, stream);
if (myprec == PREC_BUILTIN_FUNCTION)
fputs_filtered ("(", stream);
print_subexp (exp, pos, stream, PREC_PREFIX);
if (myprec == PREC_BUILTIN_FUNCTION)
fputs_filtered (")", stream);
}
}
else
{
/* Binary operator. */
/* Print left operand.
If operator is right-associative,
increment precedence for this operand. */
print_subexp (exp, pos, stream,
(enum precedence) ((int) myprec + assoc));
/* Print the operator itself. */
if (assign_modify)
fprintf_filtered (stream, " %s= ", op_str);
else if (op_str[0] == ',')
fprintf_filtered (stream, "%s ", op_str);
else
fprintf_filtered (stream, " %s ", op_str);
/* Print right operand.
If operator is left-associative,
increment precedence for this operand. */
print_subexp (exp, pos, stream,
(enum precedence) ((int) myprec + !assoc));
}
if ((int) myprec < (int) prec)
fputs_filtered (")", stream);
}
int
dump_subexp_body_standard (struct expression *exp,
struct ui_file *stream, int elt)
{
int opcode = exp->elts[elt++].opcode;
switch (opcode)
{
case TERNOP_COND:
case TERNOP_SLICE:
elt = dump_subexp (exp, stream, elt);
/* FALL THROUGH */
case BINOP_ADD:
case BINOP_SUB:
case BINOP_MUL:
case BINOP_DIV:
case BINOP_REM:
case BINOP_MOD:
case BINOP_LSH:
case BINOP_RSH:
case BINOP_LOGICAL_AND:
case BINOP_LOGICAL_OR:
case BINOP_BITWISE_AND:
case BINOP_BITWISE_IOR:
case BINOP_BITWISE_XOR:
case BINOP_EQUAL:
case BINOP_NOTEQUAL:
case BINOP_LESS:
case BINOP_GTR:
case BINOP_LEQ:
case BINOP_GEQ:
case BINOP_REPEAT:
case BINOP_ASSIGN:
case BINOP_COMMA:
case BINOP_SUBSCRIPT:
case BINOP_EXP:
case BINOP_MIN:
case BINOP_MAX:
case BINOP_INTDIV:
case BINOP_ASSIGN_MODIFY:
case BINOP_VAL:
case BINOP_CONCAT:
case BINOP_IN:
case BINOP_RANGE:
case BINOP_END:
case STRUCTOP_MEMBER:
case STRUCTOP_MPTR:
elt = dump_subexp (exp, stream, elt);
/* FALL THROUGH */
case UNOP_NEG:
case UNOP_LOGICAL_NOT:
case UNOP_COMPLEMENT:
case UNOP_IND:
case UNOP_ADDR:
case UNOP_PREINCREMENT:
case UNOP_POSTINCREMENT:
case UNOP_PREDECREMENT:
case UNOP_POSTDECREMENT:
case UNOP_SIZEOF:
case UNOP_PLUS:
case UNOP_CAP:
case UNOP_CHR:
case UNOP_ORD:
case UNOP_ABS:
case UNOP_FLOAT:
case UNOP_HIGH:
case UNOP_MAX:
case UNOP_MIN:
case UNOP_ODD:
case UNOP_TRUNC:
elt = dump_subexp (exp, stream, elt);
break;
case OP_LONG:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, "), value %ld (0x%lx)",
(long) exp->elts[elt + 1].longconst,
(long) exp->elts[elt + 1].longconst);
elt += 3;
break;
case OP_DOUBLE:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, "), value %g",
(double) exp->elts[elt + 1].doubleconst);
elt += 3;
break;
case OP_VAR_VALUE:
fprintf_filtered (stream, "Block @");
gdb_print_host_address (exp->elts[elt].block, stream);
fprintf_filtered (stream, ", symbol @");
gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
fprintf_filtered (stream, " (%s)",
SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
elt += 3;
break;
case OP_VAR_ENTRY_VALUE:
fprintf_filtered (stream, "Entry value of symbol @");
gdb_print_host_address (exp->elts[elt].symbol, stream);
fprintf_filtered (stream, " (%s)",
SYMBOL_PRINT_NAME (exp->elts[elt].symbol));
elt += 2;
break;
case OP_LAST:
fprintf_filtered (stream, "History element %ld",
(long) exp->elts[elt].longconst);
elt += 2;
break;
case OP_REGISTER:
fprintf_filtered (stream, "Register $%s", &exp->elts[elt + 1].string);
elt += 3 + BYTES_TO_EXP_ELEM (exp->elts[elt].longconst + 1);
break;
case OP_INTERNALVAR:
fprintf_filtered (stream, "Internal var @");
gdb_print_host_address (exp->elts[elt].internalvar, stream);
fprintf_filtered (stream, " (%s)",
internalvar_name (exp->elts[elt].internalvar));
elt += 2;
break;
case OP_FUNCALL:
{
int i, nargs;
nargs = longest_to_int (exp->elts[elt].longconst);
fprintf_filtered (stream, "Number of args: %d", nargs);
elt += 2;
for (i = 1; i <= nargs + 1; i++)
elt = dump_subexp (exp, stream, elt);
}
break;
case OP_ARRAY:
{
int lower, upper;
int i;
lower = longest_to_int (exp->elts[elt].longconst);
upper = longest_to_int (exp->elts[elt + 1].longconst);
fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
elt += 3;
for (i = 1; i <= upper - lower + 1; i++)
elt = dump_subexp (exp, stream, elt);
}
break;
case UNOP_DYNAMIC_CAST:
case UNOP_REINTERPRET_CAST:
case UNOP_CAST_TYPE:
case UNOP_MEMVAL_TYPE:
fprintf_filtered (stream, " (");
elt = dump_subexp (exp, stream, elt);
fprintf_filtered (stream, ")");
elt = dump_subexp (exp, stream, elt);
break;
case UNOP_MEMVAL:
case UNOP_CAST:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, ")");
elt = dump_subexp (exp, stream, elt + 2);
break;
case UNOP_MEMVAL_TLS:
fprintf_filtered (stream, "TLS type @");
gdb_print_host_address (exp->elts[elt + 1].type, stream);
fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
(exp->elts[elt].objfile == NULL ? "(null)"
: exp->elts[elt].objfile->name));
type_print (exp->elts[elt + 1].type, NULL, stream, 0);
fprintf_filtered (stream, ")");
elt = dump_subexp (exp, stream, elt + 3);
break;
case OP_TYPE:
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, ")");
elt += 2;
break;
case OP_TYPEOF:
case OP_DECLTYPE:
fprintf_filtered (stream, "Typeof (");
elt = dump_subexp (exp, stream, elt);
fprintf_filtered (stream, ")");
break;
case OP_TYPEID:
fprintf_filtered (stream, "typeid (");
elt = dump_subexp (exp, stream, elt);
fprintf_filtered (stream, ")");
break;
case STRUCTOP_STRUCT:
case STRUCTOP_PTR:
{
char *elem_name;
int len;
len = longest_to_int (exp->elts[elt].longconst);
elem_name = &exp->elts[elt + 1].string;
fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
}
break;
case OP_SCOPE:
{
char *elem_name;
int len;
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, ") ");
len = longest_to_int (exp->elts[elt + 1].longconst);
elem_name = &exp->elts[elt + 2].string;
fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
}
break;
case TYPE_INSTANCE:
{
LONGEST len;
len = exp->elts[elt++].longconst;
fprintf_filtered (stream, "%s TypeInstance: ", plongest (len));
while (len-- > 0)
{
fprintf_filtered (stream, "Type @");
gdb_print_host_address (exp->elts[elt].type, stream);
fprintf_filtered (stream, " (");
type_print (exp->elts[elt].type, NULL, stream, 0);
fprintf_filtered (stream, ")");
elt++;
if (len > 0)
fputs_filtered (", ", stream);
}
/* Ending LEN and ending TYPE_INSTANCE. */
elt += 2;
elt = dump_subexp (exp, stream, elt);
}
break;
default:
case OP_NULL:
case MULTI_SUBSCRIPT:
case OP_F77_UNDETERMINED_ARGLIST:
case OP_COMPLEX:
case OP_STRING:
case OP_BOOL:
case OP_M2_STRING:
case OP_THIS:
case OP_NAME:
fprintf_filtered (stream, "Unknown format");
}
return elt;
}
struct value *
evaluate_subexp_c (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
enum exp_opcode op = exp->elts[*pos].opcode;
switch (op)
{
case OP_STRING:
{
int oplen, limit;
struct type *type;
struct obstack output;
struct cleanup *cleanup;
struct value *result;
enum c_string_type dest_type;
const char *dest_charset;
int satisfy_expected = 0;
obstack_init (&output);
cleanup = make_cleanup_obstack_free (&output);
++*pos;
oplen = longest_to_int (exp->elts[*pos].longconst);
++*pos;
limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
dest_type
= (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
switch (dest_type & ~C_CHAR)
{
case C_STRING:
type = language_string_char_type (exp->language_defn,
exp->gdbarch);
break;
case C_WIDE_STRING:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"wchar_t", NULL, 0);
break;
case C_STRING_16:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char16_t", NULL, 0);
break;
case C_STRING_32:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char32_t", NULL, 0);
break;
default:
internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
}
/* Ensure TYPE_LENGTH is valid for TYPE. */
check_typedef (type);
/* If the caller expects an array of some integral type,
satisfy them. If something odder is expected, rely on the
caller to cast. */
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
{
struct type *element_type
= check_typedef (TYPE_TARGET_TYPE (expect_type));
if (TYPE_CODE (element_type) == TYPE_CODE_INT
|| TYPE_CODE (element_type) == TYPE_CODE_CHAR)
{
type = element_type;
satisfy_expected = 1;
}
}
dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
++*pos;
while (*pos < limit)
{
int len;
len = longest_to_int (exp->elts[*pos].longconst);
++*pos;
if (noside != EVAL_SKIP)
parse_one_string (&output, &exp->elts[*pos].string, len,
dest_charset, type);
*pos += BYTES_TO_EXP_ELEM (len);
}
/* Skip the trailing length and opcode. */
*pos += 2;
if (noside == EVAL_SKIP)
{
/* Return a dummy value of the appropriate type. */
if (expect_type != NULL)
result = allocate_value (expect_type);
else if ((dest_type & C_CHAR) != 0)
result = allocate_value (type);
else
result = value_cstring ("", 0, type);
do_cleanups (cleanup);
return result;
}
if ((dest_type & C_CHAR) != 0)
{
LONGEST value;
if (obstack_object_size (&output) != TYPE_LENGTH (type))
error (_("Could not convert character "
"constant to target character set"));
value = unpack_long (type, (gdb_byte *) obstack_base (&output));
result = value_from_longest (type, value);
}
else
{
int i;
/* Write the terminating character. */
for (i = 0; i < TYPE_LENGTH (type); ++i)
obstack_1grow (&output, 0);
if (satisfy_expected)
{
LONGEST low_bound, high_bound;
int element_size = TYPE_LENGTH (type);
if (get_discrete_bounds (TYPE_INDEX_TYPE (expect_type),
&low_bound, &high_bound) < 0)
{
low_bound = 0;
high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1;
}
if (obstack_object_size (&output) / element_size
> (high_bound - low_bound + 1))
error (_("Too many array elements"));
result = allocate_value (expect_type);
memcpy (value_contents_raw (result), obstack_base (&output),
obstack_object_size (&output));
}
else
result = value_cstring (obstack_base (&output),
obstack_object_size (&output),
type);
}
do_cleanups (cleanup);
return result;
}
break;
default:
break;
}
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
static struct value *
evaluate_subexp_c (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
enum exp_opcode op = exp->elts[*pos].opcode;
switch (op)
{
case OP_STRING:
{
int oplen, limit;
struct type *type;
struct obstack output;
struct cleanup *cleanup;
struct value *result;
enum c_string_type dest_type;
const char *dest_charset;
obstack_init (&output);
cleanup = make_cleanup_obstack_free (&output);
++*pos;
oplen = longest_to_int (exp->elts[*pos].longconst);
++*pos;
limit = *pos + BYTES_TO_EXP_ELEM (oplen + 1);
dest_type
= (enum c_string_type) longest_to_int (exp->elts[*pos].longconst);
switch (dest_type & ~C_CHAR)
{
case C_STRING:
type = language_string_char_type (exp->language_defn,
exp->gdbarch);
break;
case C_WIDE_STRING:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"wchar_t", NULL, 0);
break;
case C_STRING_16:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char16_t", NULL, 0);
break;
case C_STRING_32:
type = lookup_typename (exp->language_defn, exp->gdbarch,
"char32_t", NULL, 0);
break;
default:
internal_error (__FILE__, __LINE__, "unhandled c_string_type");
}
/* Ensure TYPE_LENGTH is valid for TYPE. */
check_typedef (type);
dest_charset = charset_for_string_type (dest_type, exp->gdbarch);
++*pos;
while (*pos < limit)
{
int len;
len = longest_to_int (exp->elts[*pos].longconst);
++*pos;
if (noside != EVAL_SKIP)
parse_one_string (&output, &exp->elts[*pos].string, len,
dest_charset, type);
*pos += BYTES_TO_EXP_ELEM (len);
}
/* Skip the trailing length and opcode. */
*pos += 2;
if (noside == EVAL_SKIP)
{
/* Return a dummy value of the appropriate type. */
if ((dest_type & C_CHAR) != 0)
result = allocate_value (type);
else
result = value_cstring ("", 0, type);
do_cleanups (cleanup);
return result;
}
if ((dest_type & C_CHAR) != 0)
{
LONGEST value;
if (obstack_object_size (&output) != TYPE_LENGTH (type))
error (_("Could not convert character constant to target character set"));
value = unpack_long (type, obstack_base (&output));
result = value_from_longest (type, value);
}
else
{
int i;
/* Write the terminating character. */
for (i = 0; i < TYPE_LENGTH (type); ++i)
obstack_1grow (&output, 0);
result = value_cstring (obstack_base (&output),
obstack_object_size (&output),
type);
}
do_cleanups (cleanup);
return result;
}
break;
default:
break;
}
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
