#include "expression.h"
#include "target.h"
#include "frame.h"
+#include "language.h" /* For CAST_IS_CONVERSION */
/* Values of NOSIDE argument to eval_subexp. */
enum noside
switch (op)
{
case OP_SCOPE:
- tem = strlen (&exp->elts[pc + 2].string);
- (*pos) += 3 + ((tem + sizeof (union exp_element))
+ tem = longest_to_int (exp->elts[pc + 2].longconst);
+ (*pos) += 4 + ((tem + sizeof (union exp_element))
/ sizeof (union exp_element));
arg1 = value_struct_elt_for_reference (exp->elts[pc + 1].type,
0,
exp->elts[pc + 1].type,
- &exp->elts[pc + 2].string,
+ &exp->elts[pc + 3].string,
expect_type);
if (arg1 == NULL)
- error ("There is no field named %s", &exp->elts[pc + 2].string);
+ error ("There is no field named %s", &exp->elts[pc + 3].string);
return arg1;
case OP_LONG:
(*pos) += 3;
return value_from_longest (exp->elts[pc + 1].type,
- exp->elts[pc + 2].longconst);
+ exp->elts[pc + 2].longconst);
case OP_DOUBLE:
(*pos) += 3;
(*pos) += 2;
return value_of_register (longest_to_int (exp->elts[pc + 1].longconst));
+ /* start-sanitize-chill */
+ case OP_BOOL:
+ (*pos) += 2;
+ return value_from_longest (builtin_type_chill_bool,
+ exp->elts[pc + 1].longconst);
+ /* end-sanitize-chill */
+
case OP_INTERNALVAR:
(*pos) += 2;
return value_of_internalvar (exp->elts[pc + 1].internalvar);
case OP_STRING:
- tem = strlen (&exp->elts[pc + 1].string);
- (*pos) += 2 + ((tem + sizeof (union exp_element))
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
+ (*pos) += 3 + ((tem + sizeof (union exp_element))
/ sizeof (union exp_element));
if (noside == EVAL_SKIP)
goto nosideret;
- return value_string (&exp->elts[pc + 1].string, tem);
+ return value_string (&exp->elts[pc + 2].string, tem);
case TERNOP_COND:
/* Skip third and second args to evaluate the first one. */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (value_zerop (arg1))
+ if (value_logical_not (arg1))
{
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
return evaluate_subexp (NULL_TYPE, exp, pos, noside);
nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
/* First, evaluate the structure into arg2 */
pc2 = (*pos)++;
- /* type = exp->elts[pc2 + 1].type; */
- tem2 = strlen (&exp->elts[pc2 + 2].string);
+ tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
*pos += 3 + (tem2 + sizeof (union exp_element)) / sizeof (union exp_element);
if (noside == EVAL_SKIP)
goto nosideret;
int static_memfuncp;
value temp = arg2;
- /* argvec[0] gets the method;
- argvec[1] gets the 'this' pointer (unless static) (from arg2);
- the remaining args go into the rest of argvec. */
-
argvec[1] = arg2;
argvec[0] =
value_struct_elt (&temp, argvec+1, &exp->elts[pc2 + 2].string,
return call_function_by_hand (argvec[0], nargs, argvec + 1);
case STRUCTOP_STRUCT:
- tem = strlen (&exp->elts[pc + 2].string);
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + ((tem + sizeof (union exp_element))
/ sizeof (union exp_element));
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
- goto handle_structop_ptr;
- type = exp->elts[pc + 1].type;
- if (type)
- arg1 = value_ind (value_cast (lookup_pointer_type (type),
- value_addr (arg1)));
if (noside == EVAL_SKIP)
goto nosideret;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
}
case STRUCTOP_PTR:
- tem = strlen (&exp->elts[pc + 2].string);
+ tem = longest_to_int (exp->elts[pc + 1].longconst);
(*pos) += 3 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- handle_structop_ptr:
- type = exp->elts[pc + 1].type;
- if (type)
- arg1 = value_cast (lookup_pointer_type (type), arg1);
if (noside == EVAL_SKIP)
goto nosideret;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
case BINOP_MUL:
case BINOP_DIV:
case BINOP_REM:
+ case BINOP_MOD:
case BINOP_LSH:
case BINOP_RSH:
- case BINOP_LOGAND:
- case BINOP_LOGIOR:
- case BINOP_LOGXOR:
+ case BINOP_BITWISE_AND:
+ case BINOP_BITWISE_IOR:
+ case BINOP_BITWISE_XOR:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
return value_x_binop (arg1, arg2, op, OP_NULL);
else
if (noside == EVAL_AVOID_SIDE_EFFECTS
- && (op == BINOP_DIV || op == BINOP_REM))
+ && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))
return value_zero (VALUE_TYPE (arg1), not_lval);
else
return value_binop (arg1, arg2, op);
else
return value_subscript (arg1, arg2);
- case BINOP_AND:
+ case MULTI_SUBSCRIPT:
+ (*pos) += 2;
+ nargs = longest_to_int (exp->elts[pc + 1].longconst);
+ arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
+ while (nargs-- > 0)
+ {
+ arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+ /* FIXME: EVAL_SKIP handling may not be correct. */
+ if (noside == EVAL_SKIP)
+ {
+ if (nargs > 0)
+ {
+ continue;
+ }
+ else
+ {
+ goto nosideret;
+ }
+ }
+ /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ {
+ /* If the user attempts to subscript something that has no target
+ type (like a plain int variable for example), then report this
+ as an error. */
+
+ type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
+ if (type != NULL)
+ {
+ arg1 = value_zero (type, VALUE_LVAL (arg1));
+ noside = EVAL_SKIP;
+ continue;
+ }
+ else
+ {
+ error ("cannot subscript something of type `%s'",
+ TYPE_NAME (VALUE_TYPE (arg1)));
+ }
+ }
+
+ if (binop_user_defined_p (op, arg1, arg2))
+ {
+ arg1 = value_x_binop (arg1, arg2, op, OP_NULL);
+ }
+ else
+ {
+ arg1 = value_subscript (arg1, arg2);
+ }
+ }
+ return (arg1);
+
+ case BINOP_LOGICAL_AND:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
{
}
else
{
- tem = value_zerop (arg1);
+ tem = value_logical_not (arg1);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
(tem ? EVAL_SKIP : noside));
return value_from_longest (builtin_type_int,
- (LONGEST) (!tem && !value_zerop (arg2)));
+ (LONGEST) (!tem && !value_logical_not (arg2)));
}
- case BINOP_OR:
+ case BINOP_LOGICAL_OR:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
{
}
else
{
- tem = value_zerop (arg1);
+ tem = value_logical_not (arg1);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
(!tem ? EVAL_SKIP : noside));
return value_from_longest (builtin_type_int,
- (LONGEST) (!tem || !value_zerop (arg2)));
+ (LONGEST) (!tem || !value_logical_not (arg2)));
}
case BINOP_EQUAL:
else
return value_neg (arg1);
- case UNOP_LOGNOT:
+ case UNOP_COMPLEMENT:
/* C++: check for and handle destructor names. */
op = exp->elts[*pos].opcode;
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if (unop_user_defined_p (UNOP_LOGNOT, arg1))
- return value_x_unop (arg1, UNOP_LOGNOT);
+ if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
+ return value_x_unop (arg1, UNOP_COMPLEMENT);
else
- return value_lognot (arg1);
+ return value_complement (arg1);
- case UNOP_ZEROP:
+ case UNOP_LOGICAL_NOT:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
return value_x_unop (arg1, op);
else
return value_from_longest (builtin_type_int,
- (LONGEST) value_zerop (arg1));
+ (LONGEST) value_logical_not (arg1));
case UNOP_IND:
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
{
if (op == OP_SCOPE)
{
- char *name = &exp->elts[pc+3].string;
- int temm = strlen (name);
- (*pos) += 2 + (temm + sizeof (union exp_element)) / sizeof (union exp_element);
+ int temm = longest_to_int (exp->elts[pc+3].longconst);
+ (*pos) += 3 + (temm + sizeof (union exp_element)) / sizeof (union exp_element);
}
else
evaluate_subexp (expect_type, exp, pos, EVAL_SKIP);
}
/* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
- When used in contexts where arrays will be coerced anyway,
- this is equivalent to `evaluate_subexp'
- but much faster because it avoids actually fetching array contents. */
+ When used in contexts where arrays will be coerced anyway, this is
+ equivalent to `evaluate_subexp' but much faster because it avoids
+ actually fetching array contents.
+
+ Note that we currently only do the coercion for C expressions, where
+ arrays are zero based and the coercion is correct. For other languages,
+ with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
+ to decide if coercion is appropriate.
+
+ */
static value
evaluate_subexp_with_coercion (exp, pos, noside)
{
case OP_VAR_VALUE:
var = exp->elts[pc + 1].symbol;
- if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ARRAY)
+ if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ARRAY
+ && CAST_IS_CONVERSION)
{
(*pos) += 3;
val = locate_var_value (var, (FRAME) 0);