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);
}
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_modula2 (struct type *expect_type, struct expression *exp,
int *pos, enum noside noside)
{
enum exp_opcode op = exp->elts[*pos].opcode;
struct value *arg1;
struct value *arg2;
struct type *type;
switch (op)
{
case UNOP_HIGH:
(*pos)++;
arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
else
{
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
if (m2_is_unbounded_array (type))
{
struct value *temp = arg1;
type = TYPE_FIELD_TYPE (type, 1);
/* i18n: Do not translate the "_m2_high" part! */
arg1 = value_struct_elt (&temp, NULL, "_m2_high", NULL,
_("unbounded structure "
"missing _m2_high field"));
if (value_type (arg1) != type)
arg1 = value_cast (type, arg1);
}
}
return 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 (m2_is_unbounded_array (type))
{
struct value *temp = arg1;
type = TYPE_FIELD_TYPE (type, 0);
if (type == NULL || (TYPE_CODE (type) != TYPE_CODE_PTR))
{
warning (_("internal error: unbounded "
"array structure is unknown"));
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
/* i18n: Do not translate the "_m2_contents" part! */
arg1 = value_struct_elt (&temp, NULL, "_m2_contents", NULL,
_("unbounded structure "
"missing _m2_contents field"));
if (value_type (arg1) != type)
arg1 = value_cast (type, arg1);
check_typedef (value_type (arg1));
return value_ind (value_ptradd (arg1, value_as_long (arg2)));
}
else
if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
{
if (TYPE_NAME (type))
error (_("cannot subscript something of type `%s'"),
TYPE_NAME (type));
else
error (_("cannot subscript requested type"));
}
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));
default:
return evaluate_subexp_standard (expect_type, exp, pos, noside);
}
nosideret:
return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
}
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);
}
