pike.git/src/operators.c:54:
/* One extra char for the sign and one for the \0 terminator. */
#define MAX_INT_SPRINTF_LEN (2 + (SIZEOF_INT_TYPE * 5 + 1) / 2)
/* Enough to hold a Pike float or int in textform
*/
#define MAX_NUM_BUF (MAXIMUM(MAX_INT_SPRINTF_LEN,MAX_FLOAT_SPRINTF_LEN))
void index_no_free(struct svalue *to,struct svalue *what,struct svalue *ind)
{
#ifdef PIKE_SECURITY
- if(what->type <= MAX_COMPLEX)
+ if(TYPEOF(*what) <= MAX_COMPLEX)
if(!CHECK_DATA_SECURITY(what->u.array, SECURITY_BIT_INDEX))
Pike_error("Index permission denied.\n");
#endif
- switch(what->type)
+ switch(TYPEOF(*what))
{
case T_ARRAY:
simple_array_index_no_free(to,what->u.array,ind);
break;
case T_MAPPING:
mapping_index_no_free(to,what->u.mapping,ind);
break;
case T_OBJECT:
- object_index_no_free(to, what->u.object, what->subtype, ind);
+ object_index_no_free(to, what->u.object, SUBTYPEOF(*what), ind);
break;
case T_MULTISET: {
int i=multiset_member(what->u.multiset, ind);
- to->type=T_INT;
- to->subtype=i ? 0 : NUMBER_UNDEFINED;
- to->u.integer=i;
+ SET_SVAL(*to, T_INT, i ? NUMBER_NUMBER : NUMBER_UNDEFINED, integer, i);
break;
}
case T_STRING:
- if(ind->type==T_INT)
+ if(TYPEOF(*ind) == T_INT)
{
ptrdiff_t len = what->u.string->len;
INT_TYPE p = ind->u.integer;
INT_TYPE i = p < 0 ? p + len : p;
if(i<0 || i>=len)
{
if(len == 0)
Pike_error("Attempt to index the empty string with %"PRINTPIKEINT"d.\n", i);
else
Pike_error("Index %"PRINTPIKEINT"d is out of string range "
"%"PRINTPTRDIFFT"d..%"PRINTPTRDIFFT"d.\n",
i, -len, len - 1);
} else
i=index_shared_string(what->u.string,i);
- to->type=T_INT;
- to->subtype=NUMBER_NUMBER;
- to->u.integer=i;
+ SET_SVAL(*to, T_INT, NUMBER_NUMBER, integer, i);
break;
}else{
- if (ind->type == T_STRING)
+ if (TYPEOF(*ind) == T_STRING)
Pike_error ("Expected integer as string index, got \"%S\".\n",
ind->u.string);
else
Pike_error ("Expected integer as string index, got %s.\n",
- get_name_of_type (ind->type));
+ get_name_of_type (TYPEOF(*ind)));
}
case T_FUNCTION:
case T_PROGRAM:
if (program_index_no_free(to, what, ind)) break;
goto index_error;
#ifdef AUTO_BIGNUM
case T_INT:
- if (ind->type == T_STRING && !IS_UNDEFINED (what)) {
+ if (TYPEOF(*ind) == T_STRING && !IS_UNDEFINED (what)) {
INT_TYPE val = what->u.integer;
convert_svalue_to_bignum(what);
index_no_free(to, what, ind);
if(IS_UNDEFINED(to)) {
if (val) {
Pike_error("Indexing the integer %"PRINTPIKEINT"d "
"with unknown method \"%S\".\n",
val, ind->u.string);
} else {
pike.git/src/operators.c:140: Inside #if defined(AUTO_BIGNUM)
}
}
break;
}
/* FALL_THROUGH */
#endif /* AUTO_BIGNUM */
default:
index_error:
- if (ind->type == T_INT)
+ if (TYPEOF(*ind) == T_INT)
Pike_error ("Cannot index %s with %"PRINTPIKEINT"d.\n",
- (what->type == T_INT && !what->u.integer)?
- "the NULL value":get_name_of_type(what->type),
+ (TYPEOF(*what) == T_INT && !what->u.integer)?
+ "the NULL value":get_name_of_type(TYPEOF(*what)),
ind->u.integer);
- else if (ind->type == T_FLOAT)
+ else if (TYPEOF(*ind) == T_FLOAT)
Pike_error ("Cannot index %s with %"PRINTPIKEFLOAT"e.\n",
- (what->type == T_INT && !what->u.integer)?
- "the NULL value":get_name_of_type(what->type),
+ (TYPEOF(*what) == T_INT && !what->u.integer)?
+ "the NULL value":get_name_of_type(TYPEOF(*what)),
ind->u.float_number);
- else if (ind->type == T_STRING)
+ else if (TYPEOF(*ind) == T_STRING)
Pike_error ("Cannot index %s with \"%S\".\n",
- (what->type == T_INT && !what->u.integer)?
- "the NULL value":get_name_of_type(what->type),
+ (TYPEOF(*what) == T_INT && !what->u.integer)?
+ "the NULL value":get_name_of_type(TYPEOF(*what)),
ind->u.string);
else
Pike_error ("Cannot index %s with %s.\n",
- (what->type == T_INT && !what->u.integer)?
- "the NULL value":get_name_of_type(what->type),
- get_name_of_type (ind->type));
+ (TYPEOF(*what) == T_INT && !what->u.integer)?
+ "the NULL value":get_name_of_type(TYPEOF(*what)),
+ get_name_of_type (TYPEOF(*ind)));
}
}
void o_index(void)
{
struct svalue s;
index_no_free(&s,sp-2,sp-1);
pop_n_elems(2);
*sp=s;
dmalloc_touch_svalue(sp);
pike.git/src/operators.c:217:
*! @seealso
*! @[cast_to_object()]
*/
/*! @endclass
*/
/* Special case for casting to int. */
PMOD_EXPORT void o_cast_to_int(void)
{
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_OBJECT:
if(!sp[-1].u.object->prog) {
/* Casting a destructed object should be like casting a zero. */
pop_stack();
push_int (0);
}
else {
{
struct object *o = sp[-1].u.object;
struct pike_string *s;
- struct program *p = o->prog->inherits[sp[-1].subtype].prog;
+ struct program *p = o->prog->inherits[SUBTYPEOF(sp[-1])].prog;
int f = FIND_LFUN(p, LFUN_CAST);
if(f == -1)
Pike_error("No cast method in object.\n");
REF_MAKE_CONST_STRING(s, "int");
push_string(s);
apply_low(o, f, 1);
stack_pop_keep_top();
}
- if(sp[-1].type != PIKE_T_INT)
+ if(TYPEOF(sp[-1]) != PIKE_T_INT)
{
- if(sp[-1].type == T_OBJECT && sp[-1].u.object->prog)
+ if(TYPEOF(sp[-1]) == T_OBJECT && sp[-1].u.object->prog)
{
struct object *o = sp[-1].u.object;
- int f = FIND_LFUN(o->prog->inherits[sp[-1].subtype].prog,
+ int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(sp[-1])].prog,
LFUN__IS_TYPE);
if( f != -1)
{
struct pike_string *s;
REF_MAKE_CONST_STRING(s, "int");
push_string(s);
apply_low(o, f, 1);
f=!UNSAFE_IS_ZERO(sp-1);
pop_stack();
if(f) return;
}
}
Pike_error("Cast failed, wanted int, got %s\n",
- get_name_of_type(sp[-1].type));
+ get_name_of_type(TYPEOF(sp[-1])));
}
}
break;
case T_FLOAT:
if (
#ifdef HAVE_ISINF
isinf(sp[-1].u.float_number) ||
#endif
pike.git/src/operators.c:292: Inside #if defined(AUTO_BIGNUM)
convert_stack_top_to_bignum();
return; /* FIXME: OK to return? Cast tests below indicates
we have to do this, at least for now... /Noring */
/* Yes, it is ok to return, it is actually an optimization :)
* /Hubbe
*/
}
else
#endif /* AUTO_BIGNUM */
{
- sp[-1].type=T_INT;
- sp[-1].subtype = NUMBER_NUMBER;
- sp[-1].u.integer=i;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, i);
}
}
break;
case T_STRING:
/* This can be here independently of AUTO_BIGNUM. Besides,
we really want to reduce the number of number parsers
around here. :) /Noring */
#ifdef AUTO_BIGNUM
/* The generic function is rather slow, so I added this
* code for benchmark purposes. :-) /per
*/
if( (sp[-1].u.string->len >= 10) || sp[-1].u.string->size_shift )
convert_stack_top_string_to_inumber(10);
else
#endif /* AUTO_BIGNUM */
{
INT_TYPE i = STRTOL(sp[-1].u.string->str, 0, 10);
free_string(sp[-1].u.string);
- sp[-1].type=T_INT;
- sp[-1].subtype = NUMBER_NUMBER;
- sp[-1].u.integer=i;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, i);
}
break;
case PIKE_T_INT:
break;
default:
- Pike_error("Cannot cast %s to int.\n", get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to int.\n", get_name_of_type(TYPEOF(sp[-1])));
}
}
/* Special case for casting to string. */
PMOD_EXPORT void o_cast_to_string(void)
{
char buf[MAX_NUM_BUF];
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_OBJECT:
if(!sp[-1].u.object->prog) {
/* Casting a destructed object should be like casting a zero. */
pop_stack();
push_constant_text("0");
} else {
{
struct object *o = sp[-1].u.object;
- int f = FIND_LFUN(o->prog->inherits[sp[-1].subtype].prog, LFUN_CAST);
+ int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(sp[-1])].prog, LFUN_CAST);
if(f == -1)
Pike_error("No cast method in object.\n");
push_constant_text("string");
apply_low(o, f, 1);
stack_pop_keep_top();
}
- if(sp[-1].type != PIKE_T_STRING)
+ if(TYPEOF(sp[-1]) != PIKE_T_STRING)
{
- if(sp[-1].type == T_OBJECT && sp[-1].u.object->prog)
+ if(TYPEOF(sp[-1]) == T_OBJECT && sp[-1].u.object->prog)
{
struct object *o = sp[-1].u.object;
- int f = FIND_LFUN(o->prog->inherits[sp[-1].subtype].prog,
+ int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(sp[-1])].prog,
LFUN__IS_TYPE);
if( f != -1)
{
struct pike_string *s;
REF_MAKE_CONST_STRING(s, "string");
push_string(s);
apply_low(o, f, 1);
f=!UNSAFE_IS_ZERO(sp-1);
pop_stack();
if(f) return;
}
}
Pike_error("Cast failed, wanted string, got %s\n",
- get_name_of_type(sp[-1].type));
+ get_name_of_type(TYPEOF(sp[-1])));
}
}
return;
case T_ARRAY:
{
int i, alen;
struct array *a = sp[-1].u.array;
struct pike_string *s;
int shift = 0;
alen = a->size;
for(i = 0; i<alen; i++) {
INT_TYPE val;
- if (a->item[i].type != T_INT) {
+ if (TYPEOF(a->item[i]) != T_INT) {
Pike_error(
"Can only cast array(int) to string, item %d is not an integer: %O\n",
i, a->item + i);
}
val = a->item[i].u.integer;
switch (shift) { /* Trust the compiler to strength reduce this. */
case 0:
if ((unsigned INT32) val <= 0xff)
break;
shift = 1;
pike.git/src/operators.c:449:
}
break;
}
s = end_shared_string(s);
pop_stack();
push_string(s);
}
return;
default:
- Pike_error("Cannot cast %s to string.\n", get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to string.\n", get_name_of_type(TYPEOF(sp[-1])));
case PIKE_T_STRING:
return;
case T_FLOAT:
format_pike_float (buf, sp[-1].u.float_number);
break;
case T_INT:
sprintf(buf, "%"PRINTPIKEINT"d", sp[-1].u.integer);
break;
}
- sp[-1].type = PIKE_T_STRING;
- sp[-1].u.string = make_shared_string(buf);
+ SET_SVAL(sp[-1], PIKE_T_STRING, 0, string, make_shared_string(buf));
}
PMOD_EXPORT void o_cast(struct pike_type *type, INT32 run_time_type)
{
- if(run_time_type != sp[-1].type)
+ if(run_time_type != TYPEOF(sp[-1]))
{
if(run_time_type == T_MIXED)
return;
- if (sp[-1].type == T_OBJECT && !sp[-1].u.object->prog) {
+ if (TYPEOF(sp[-1]) == T_OBJECT && !sp[-1].u.object->prog) {
/* Casting a destructed object should be like casting a zero. */
pop_stack();
push_int (0);
}
- if(sp[-1].type == T_OBJECT)
+ if(TYPEOF(sp[-1]) == T_OBJECT)
{
struct object *o = sp[-1].u.object;
- int f = FIND_LFUN(o->prog->inherits[sp[-1].subtype].prog, LFUN_CAST);
+ int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(sp[-1])].prog, LFUN_CAST);
if(f == -1)
Pike_error("No cast method in object.\n");
push_string(describe_type(type));
apply_low(o, f, 1);
stack_pop_keep_top();
}else
switch(run_time_type)
{
default:
Pike_error("Cannot perform cast to that type.\n");
case T_MIXED:
return;
case T_MULTISET:
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_ARRAY:
{
extern void f_mkmultiset(INT32);
f_mkmultiset(1);
break;
}
default:
- Pike_error("Cannot cast %s to multiset.\n",get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to multiset.\n",
+ get_name_of_type(TYPEOF(sp[-1])));
}
break;
case T_MAPPING:
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_ARRAY:
{
struct array *a=sp[-1].u.array;
struct array *b;
struct mapping *m;
INT32 i;
m=allocate_mapping(a->size); /* MAP_SLOTS(a->size) */
push_mapping(m);
for (i=0; i<a->size; i++)
{
- if (ITEM(a)[i].type!=T_ARRAY)
+ if (TYPEOF(ITEM(a)[i]) != T_ARRAY)
Pike_error("Cast array to mapping: "
"element %d is not an array\n", i);
b=ITEM(a)[i].u.array;
if (b->size!=2)
Pike_error("Cast array to mapping: "
"element %d is not an array of size 2\n", i);
mapping_insert(m,ITEM(b)+0,ITEM(b)+1);
}
stack_swap();
pop_n_elems(1);
break;
}
default:
- Pike_error("Cannot cast %s to mapping.\n",get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to mapping.\n",
+ get_name_of_type(TYPEOF(sp[-1])));
}
break;
case T_ARRAY:
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_MAPPING:
{
struct array *a=mapping_to_array(sp[-1].u.mapping);
pop_stack();
push_array(a);
break;
}
case T_STRING:
f_values(1);
break;
case T_MULTISET:
f_indices(1);
break;
default:
- Pike_error("Cannot cast %s to array.\n",get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to array.\n",
+ get_name_of_type(TYPEOF(sp[-1])));
}
break;
case T_INT:
o_cast_to_int();
return;
case T_STRING:
o_cast_to_string();
return;
case T_FLOAT:
{
FLOAT_TYPE f = 0.0;
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_INT:
f=(FLOAT_TYPE)(sp[-1].u.integer);
break;
case T_STRING:
f =
(FLOAT_TYPE)STRTOD_PCHARP(MKPCHARP(sp[-1].u.string->str,
sp[-1].u.string->size_shift),
0);
free_string(sp[-1].u.string);
break;
default:
- Pike_error("Cannot cast %s to float.\n",get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to float.\n",
+ get_name_of_type(TYPEOF(sp[-1])));
}
- sp[-1].type=T_FLOAT;
- sp[-1].u.float_number=f;
+ SET_SVAL(sp[-1], T_FLOAT, 0, float_number, f);
break;
}
case T_OBJECT:
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_STRING: {
struct pike_string *file;
INT32 lineno;
if(Pike_fp->pc &&
(file = low_get_line(Pike_fp->pc, Pike_fp->context->prog, &lineno))) {
push_string(file);
}else{
push_int(0);
}
/* FIXME: Ought to allow compile_handler to override.
*/
APPLY_MASTER("cast_to_object",2);
return;
}
case T_FUNCTION:
- if (Pike_sp[-1].subtype == FUNCTION_BUILTIN) {
+ if (SUBTYPEOF(Pike_sp[-1]) == FUNCTION_BUILTIN) {
Pike_error("Cannot cast builtin functions to object.\n");
} else if (Pike_sp[-1].u.object->prog == pike_trampoline_program) {
ref_push_object(((struct pike_trampoline *)
(Pike_sp[-1].u.object->storage))->
frame->current_object);
stack_pop_keep_top();
} else {
- Pike_sp[-1].type = T_OBJECT;
- Pike_sp[-1].subtype = 0;
+ SET_SVAL_TYPE(Pike_sp[-1], T_OBJECT);
+ SET_SVAL_SUBTYPE(Pike_sp[-1], 0);
}
break;
default:
- Pike_error("Cannot cast %s to object.\n",get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to object.\n",
+ get_name_of_type(TYPEOF(sp[-1])));
}
break;
case T_PROGRAM:
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_STRING: {
struct pike_string *file;
INT32 lineno;
if(Pike_fp->pc &&
(file = low_get_line(Pike_fp->pc, Pike_fp->context->prog, &lineno))) {
push_string(file);
}else{
push_int(0);
}
pike.git/src/operators.c:677:
pop_stack();
push_program(p);
}else{
pop_stack();
push_int(0);
}
}
return;
default:
- Pike_error("Cannot cast %s to a program.\n",get_name_of_type(sp[-1].type));
+ Pike_error("Cannot cast %s to a program.\n",
+ get_name_of_type(TYPEOF(sp[-1])));
}
}
}
- if(run_time_type != sp[-1].type)
+ if(run_time_type != TYPEOF(sp[-1]))
{
- if(sp[-1].type == T_OBJECT && sp[-1].u.object->prog)
+ if(TYPEOF(sp[-1]) == T_OBJECT && sp[-1].u.object->prog)
{
struct object *o = sp[-1].u.object;
- int f = FIND_LFUN(o->prog->inherits[sp[-1].subtype].prog, LFUN__IS_TYPE);
+ int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(sp[-1])].prog,
+ LFUN__IS_TYPE);
if( f != -1)
{
push_text(get_name_of_type(run_time_type));
apply_low(o, f, 1);
f=!UNSAFE_IS_ZERO(sp-1);
pop_stack();
if(f) goto emulated_type_ok;
}
}
Pike_error("Cast failed, wanted %s, got %s\n",
get_name_of_type(run_time_type),
- get_name_of_type(sp[-1].type));
+ get_name_of_type(TYPEOF(sp[-1])));
}
emulated_type_ok:
if (!type) return;
switch(run_time_type)
{
case T_ARRAY:
{
pike.git/src/operators.c:739:
struct svalue *save_sp=sp+1;
#endif
push_array(a=allocate_array(tmp->size));
SET_CYCLIC_RET(a);
for(e=0;e<a->size;e++)
{
push_svalue(tmp->item+e);
o_cast(itype, run_time_itype);
stack_pop_to_no_free (ITEM(a) + e);
- types |= 1 << ITEM(a)[e].type;
+ types |= 1 << TYPEOF(ITEM(a)[e]);
}
a->type_field = types;
#ifdef PIKE_DEBUG
if(save_sp!=sp)
Pike_fatal("o_cast left stack droppings.\n");
#endif
}
END_CYCLIC();
assign_svalue(sp-3,sp-1);
pop_stack();
pike.git/src/operators.c:873:
}
pop_n_elems(2);
}
}
}
PMOD_EXPORT void f_cast(void)
{
#ifdef PIKE_DEBUG
struct svalue *save_sp=sp;
- if(sp[-2].type != T_TYPE)
+ if(TYPEOF(sp[-2]) != T_TYPE)
Pike_fatal("Cast expression destroyed stack or left droppings! (Type:%d)\n",
- sp[-2].type);
+ TYPEOF(sp[-2]));
#endif
o_cast(sp[-2].u.type,
compile_type_to_runtime_type(sp[-2].u.type));
#ifdef PIKE_DEBUG
if(save_sp != sp)
Pike_fatal("Internal error: o_cast() left droppings on stack.\n");
#endif
free_svalue(sp-2);
sp[-2]=sp[-1];
sp--;
dmalloc_touch_svalue(sp);
}
/* Returns 1 if s is a valid in the type type. */
int low_check_soft_cast(struct svalue *s, struct pike_type *type)
{
loop:
switch(type->type) {
case T_MIXED: return 1;
case T_ZERO:
- switch(s->type) {
+ switch(TYPEOF(*s)) {
case PIKE_T_INT:
return !s->u.integer;
case PIKE_T_FUNCTION:
- if (s->subtype == FUNCTION_BUILTIN) return 0;
+ if (SUBTYPEOF(*s) == FUNCTION_BUILTIN) return 0;
/* FALL_THROUGH */
case PIKE_T_OBJECT:
return !s->u.object->prog;
}
return 0;
case T_ASSIGN:
case PIKE_T_NAME:
type = type->cdr;
goto loop;
case T_AND:
if (!low_check_soft_cast(s, type->car)) return 0;
type = type->cdr;
goto loop;
case T_OR:
if (low_check_soft_cast(s, type->car)) return 1;
type = type->cdr;
goto loop;
case T_NOT:
return !low_check_soft_cast(s, type->car);
}
- if ((s->type == PIKE_T_INT) && !s->u.integer) return 1;
- if (s->type == type->type) {
+ if ((TYPEOF(*s) == PIKE_T_INT) && !s->u.integer) return 1;
+ if (TYPEOF(*s) == type->type) {
if (type->type == PIKE_T_INT) {
if (((((INT32)CAR_TO_INT(type)) != MIN_INT32) &&
(s->u.integer < (INT32)CAR_TO_INT(type))) ||
((((INT32)CDR_TO_INT(type)) != MAX_INT32) &&
(s->u.integer > (INT32)CDR_TO_INT(type)))) {
return 0;
}
return 1;
}
if (type->type == PIKE_T_FLOAT) return 1;
pike.git/src/operators.c:984:
break;
case PIKE_T_FUNCTION:
/* FIXME: Add code here. */
break;
case PIKE_T_TYPE:
/* FIXME: Add code here. */
break;
}
return 1;
}
- if (s->type == PIKE_T_OBJECT) {
+ if (TYPEOF(*s) == PIKE_T_OBJECT) {
int lfun;
if (!s->u.object->prog) return 0;
if (type->type == PIKE_T_FUNCTION) {
if ((lfun = FIND_LFUN(s->u.object->prog, LFUN_CALL)) != -1) {
/* FIXME: Add code here. */
return 1;
}
}
if ((lfun = FIND_LFUN(s->u.object->prog, LFUN__IS_TYPE)) != -1) {
int ret;
push_text(get_name_of_type(type->type));
apply_low(s->u.object, lfun, 1);
ret = !UNSAFE_IS_ZERO(Pike_sp-1);
pop_stack();
return ret;
}
return 0;
}
- if ((s->type == PIKE_T_FUNCTION) && (type->type == PIKE_T_PROGRAM)) {
+ if ((TYPEOF(*s) == PIKE_T_FUNCTION) && (type->type == PIKE_T_PROGRAM)) {
/* FIXME: Add code here. */
return 1;
}
- if ((s->type == PIKE_T_FUNCTION) && (type->type == T_MANY)) {
+ if ((TYPEOF(*s) == PIKE_T_FUNCTION) && (type->type == T_MANY)) {
/* FIXME: Add code here. */
return 1;
}
return 0;
}
void o_check_soft_cast(struct svalue *s, struct pike_type *type)
{
if (!low_check_soft_cast(s, type)) {
pike.git/src/operators.c:1243:
*/
COMPARISON(f_ge,"`>=",is_ge)
#define CALL_OPERATOR(OP, args) do { \
struct object *o_ = sp[-args].u.object; \
int i; \
if(!o_->prog) \
bad_arg_error(lfun_names[OP], sp-args, args, 1, "object", sp-args, \
"Called in destructed object.\n"); \
- if((i = FIND_LFUN(o_->prog->inherits[sp[-args].subtype].prog, \
+ if((i = FIND_LFUN(o_->prog->inherits[SUBTYPEOF(sp[-args])].prog, \
OP)) == -1) \
bad_arg_error(lfun_names[OP], sp-args, args, 1, "object", sp-args, \
"Operator not in object.\n"); \
apply_low(o_, i, args-1); \
stack_pop_keep_top(); \
} while (0)
/* Helper function for calling ``-operators.
*
* Assumes o is at Pike_sp[e - args].
pike.git/src/operators.c:1297:
*
* -args object with the lfun.
* ...
* ... other arguments
* ...
* -e first argument.
* ...
* -1 last argument before the object.
*/
#ifdef PIKE_DEBUG
- if (Pike_sp[-args].type != T_OBJECT ||
+ if (TYPEOF(Pike_sp[-args]) != T_OBJECT ||
Pike_sp[-args].u.object != o ||
!o->prog) {
Pike_fatal("low_rop() Lost track of object.\n");
}
#endif /* PIKE_DEBUG */
apply_low(o, i, e);
args -= e;
/* Replace the object with the result. */
assign_svalue(Pike_sp-(args+1), Pike_sp-1);
pop_stack();
pike.git/src/operators.c:1422:
*/
PMOD_EXPORT void f_add(INT32 args)
{
INT_TYPE e,size;
TYPE_FIELD types;
tail_recurse:
if (args == 1) return;
types=0;
- for(e=-args;e<0;e++) types|=1<<sp[e].type;
+ for(e=-args;e<0;e++) types |= 1<<TYPEOF(sp[e]);
switch(types)
{
default:
if(!args)
{
SIMPLE_TOO_FEW_ARGS_ERROR("`+", 1);
}else{
if(types & BIT_OBJECT)
{
struct object *o;
struct program *p;
int i;
if (args == 1)
return;
- if(sp[-args].type == T_OBJECT && sp[-args].u.object->prog)
+ if(TYPEOF(sp[-args]) == T_OBJECT && sp[-args].u.object->prog)
{
/* The first argument is an object. */
o = sp[-args].u.object;
- p = o->prog->inherits[sp[-args].subtype].prog;
+ p = o->prog->inherits[SUBTYPEOF(sp[-args])].prog;
if(o->refs==1 &&
(i = FIND_LFUN(p, LFUN_ADD_EQ)) != -1)
{
apply_low(o, i, args-1);
stack_pop_keep_top();
return;
}
if((i = FIND_LFUN(p, LFUN_ADD)) != -1)
{
apply_low(o, i, args-1);
free_svalue(sp-2);
sp[-2]=sp[-1];
sp--;
dmalloc_touch_svalue(sp);
return;
}
}
for(e=1;e<args;e++)
{
- if(sp[e-args].type == T_OBJECT &&
+ if(TYPEOF(sp[e-args]) == T_OBJECT &&
(p = (o = sp[e-args].u.object)->prog) &&
- (i = FIND_LFUN(p->inherits[sp[e-args].subtype].prog,
+ (i = FIND_LFUN(p->inherits[SUBTYPEOF(sp[e-args])].prog,
LFUN_RADD)) != -1)
{
/* There's an object with a lfun::``+() at argument @[e]. */
if ((args = low_rop(o, i, e, args)) > 1) {
goto tail_recurse;
}
return;
}
}
}
}
- switch(sp[-args].type)
+ switch(TYPEOF(sp[-args]))
{
case T_PROGRAM:
case T_FUNCTION:
SIMPLE_BAD_ARG_ERROR("`+", 1,
"string|object|int|float|array|mapping|multiset");
}
bad_arg_error("`+", sp-args, args, 1,
"string|object|int|float|array|mapping|multiset", sp-args,
"Incompatible types\n");
return; /* compiler hint */
pike.git/src/operators.c:1524:
tmp=sp[-args].u.string->len;
r=new_realloc_shared_string(sp[-args].u.string,size,max_shift);
mark_free_svalue (sp - args);
buf=MKPCHARP_STR_OFF(r,tmp);
for(e=-args+1;e<0;e++)
{
pike_string_cpy(buf,sp[e].u.string);
INC_PCHARP(buf,sp[e].u.string->len);
}
- sp[-args].u.string=low_end_shared_string(r);
- sp[-args].type=T_STRING;
+ SET_SVAL(sp[-args], T_STRING, 0, string, low_end_shared_string(r));
for(e=-args+1;e<0;e++) free_string(sp[e].u.string);
sp-=args-1;
break;
}
case BIT_STRING | BIT_INT:
case BIT_STRING | BIT_FLOAT:
case BIT_STRING | BIT_FLOAT | BIT_INT:
{
struct pike_string *r;
PCHARP buf;
char buffer[MAX_NUM_BUF];
int max_shift=0;
- if ((sp[-args].type != T_STRING) && (sp[1-args].type != T_STRING)) {
+ if ((TYPEOF(sp[-args]) != T_STRING) && (TYPEOF(sp[1-args]) != T_STRING)) {
struct svalue *save_sp = sp;
/* We need to perform a normal addition first.
*/
for (e=-args; e < 0; e++) {
- if (save_sp[e].type == T_STRING)
+ if (TYPEOF(save_sp[e]) == T_STRING)
break;
*(sp++) = save_sp[e];
dmalloc_touch_svalue(Pike_sp-1);
}
/* Perform the addition. */
f_add(args+e);
dmalloc_touch_svalue(Pike_sp-1);
save_sp[--e] = *(--sp);
#ifdef PIKE_DEBUG
if (sp != save_sp) {
pike.git/src/operators.c:1579:
save_sp[-args] = sp[-1];
sp = save_sp + 1 - args;
return;
} else {
e = -args;
}
size=0;
for(e=-args;e<0;e++)
{
- switch(sp[e].type)
+ switch(TYPEOF(sp[e]))
{
case T_STRING:
size+=sp[e].u.string->len;
if(sp[e].u.string->size_shift > max_shift)
max_shift=sp[e].u.string->size_shift;
break;
case T_INT:
size += MAX_INT_SPRINTF_LEN;
break;
pike.git/src/operators.c:1603:
break;
}
}
r=begin_wide_shared_string(size,max_shift);
buf=MKPCHARP_STR(r);
size=0;
for(e=-args;e<0;e++)
{
- switch(sp[e].type)
+ switch(TYPEOF(sp[e]))
{
case T_STRING:
pike_string_cpy(buf,sp[e].u.string);
INC_PCHARP(buf,sp[e].u.string->len);
break;
case T_INT:
sprintf(buffer,"%"PRINTPIKEINT"d",sp[e].u.integer);
#ifdef PIKE_DEBUG
if (strlen (buffer) > MAX_INT_SPRINTF_LEN)
pike.git/src/operators.c:1683: Inside #if defined(AUTO_BIGNUM)
{
size += sp[e].u.integer;
}
}
sp-=args;
push_int(size);
#else
size=0;
for(e=-args; e<0; e++) size+=sp[e].u.integer;
sp-=args-1;
- sp[-1].u.integer=size;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer, size);
#endif /* AUTO_BIGNUM */
break;
case BIT_FLOAT:
if (args > 2) {
/* Attempt to minimize the accumulated summation error
* by adding the smallest (absolute) values first.
*
* Large accumulated errors can occur eg when the number
* of values to add is of the same order as the largest
pike.git/src/operators.c:1729:
case BIT_FLOAT|BIT_INT:
{
/* For improved precision; partition the values
* into floats followed by ints, so that we
* can add the integers exactly.
*/
int i = args-1;
e = 0;
while (e < i) {
for(;e < i; i--) {
- if (sp[i-args].type == T_FLOAT) break;
+ if (TYPEOF(sp[i-args]) == T_FLOAT) break;
}
for(;e < i; e++) {
- if (sp[e-args].type == T_INT) break;
+ if (TYPEOF(sp[e-args]) == T_INT) break;
}
if (e < i) {
/* Swap */
struct svalue sval = sp[e-args];
sp[e-args] = sp[i-args];
sp[i-args] = sval;
}
}
- if (sp[e-args].type == T_FLOAT) e++;
+ if (TYPEOF(sp[e-args]) == T_FLOAT) e++;
/* Sum the integers. */
if (args - e > 1) {
f_add(args-e);
}
args = e+1;
o_cast(float_type_string, PIKE_T_FLOAT);
/* Now all the values should be floats. */
goto tail_recurse;
}
#define ADD_WITH_UNDEFINED(TYPE, T_TYPEID, ADD_FUNC, PUSH_FUNC) do { \
int e; \
- if (sp[-args].type == T_INT) { \
+ if (TYPEOF(sp[-args]) == T_INT) { \
if(IS_UNDEFINED(sp-args)) \
{ \
struct TYPE *x; \
\
for(e=1;e<args;e++) \
- if(sp[e-args].type != T_TYPEID) \
+ if(TYPEOF(sp[e-args]) != T_TYPEID) \
SIMPLE_ARG_TYPE_ERROR("`+", e+1, #TYPE); \
\
x = ADD_FUNC(sp-args+1,args-1); \
pop_n_elems(args); \
PUSH_FUNC(x); \
return; \
} \
\
for(e=1;e<args;e++) \
- if (sp[e-args].type != T_INT) \
+ if (TYPEOF(sp[e-args]) != T_INT) \
SIMPLE_ARG_TYPE_ERROR("`+", e+1, "int"); \
} \
\
else { \
for(e=1;e<args;e++) \
- if (sp[e-args].type != T_TYPEID) \
+ if (TYPEOF(sp[e-args]) != T_TYPEID) \
SIMPLE_ARG_TYPE_ERROR("`+", e+1, #TYPE); \
} \
\
DO_IF_DEBUG (Pike_fatal ("Shouldn't be reached.\n")); \
break; \
} while (0)
#define ADD(TYPE, ADD_FUNC, PUSH_FUNC) do { \
struct TYPE *x = ADD_FUNC (sp - args, args); \
pop_n_elems (args); \
pike.git/src/operators.c:1933: Inside #if 0
if(node_is_false(*second_arg) && !node_may_overload(*first_arg,LFUN_EQ))
{
ret=*first_arg;
ADD_NODE_REF(*first_arg);
return mkopernode("`!",ret,0);
}
#endif
if (((*second_arg)->token == F_CONSTANT) &&
- ((*second_arg)->u.sval.type == T_STRING) &&
+ (TYPEOF((*second_arg)->u.sval) == T_STRING) &&
((*first_arg)->token == F_RANGE)) {
node *low = CADR (*first_arg), *high = CDDR (*first_arg);
INT_TYPE c;
if ((low->token == F_RANGE_OPEN ||
(low->token == F_RANGE_FROM_BEG &&
(CAR (low)->token == F_CONSTANT) &&
- (CAR (low)->u.sval.type == T_INT) &&
+ (TYPEOF(CAR (low)->u.sval) == T_INT) &&
(!(CAR (low)->u.sval.u.integer)))) &&
(high->token == F_RANGE_OPEN ||
(high->token == F_RANGE_FROM_BEG &&
(CAR (high)->token == F_CONSTANT) &&
- (CAR (high)->u.sval.type == T_INT) &&
+ (TYPEOF(CAR (high)->u.sval) == T_INT) &&
(c = CAR (high)->u.sval.u.integer, 1)))) {
/* str[..c] == "foo" or str[0..c] == "foo" or
* str[..] == "foo" or str[0..] == "foo" */
if (high->token == F_RANGE_OPEN ||
(*second_arg)->u.sval.u.string->len <= c) {
/* str[..4] == "foo"
* ==>
* str == "foo"
*/
pike.git/src/operators.c:2174:
CAR(n)->u.sval.u.efun->function,
f_eq, f_ne, f_lt, f_le, f_gt, f_ge);
modify_stack_depth(-1);
return 1;
}
return 0;
}
static int float_promote(void)
{
- if(sp[-2].type==T_INT && sp[-1].type==T_FLOAT)
+ if(TYPEOF(sp[-2]) == T_INT && TYPEOF(sp[-1]) == T_FLOAT)
{
- sp[-2].u.float_number=(FLOAT_TYPE)sp[-2].u.integer;
- sp[-2].type=T_FLOAT;
+ SET_SVAL(sp[-2], T_FLOAT, 0, float_number, (FLOAT_TYPE)sp[-2].u.integer);
return 1;
}
- else if(sp[-1].type==T_INT && sp[-2].type==T_FLOAT)
+ else if(TYPEOF(sp[-1]) == T_INT && TYPEOF(sp[-2]) == T_FLOAT)
{
- sp[-1].u.float_number=(FLOAT_TYPE)sp[-1].u.integer;
- sp[-1].type=T_FLOAT;
+ SET_SVAL(sp[-1], T_FLOAT, 0, float_number, (FLOAT_TYPE)sp[-1].u.integer);
return 1;
}
#ifdef AUTO_BIGNUM
- if(is_bignum_object_in_svalue(sp-2) && sp[-1].type==T_FLOAT)
+ if(is_bignum_object_in_svalue(sp-2) && TYPEOF(sp[-1]) == T_FLOAT)
{
stack_swap();
ref_push_type_value(float_type_string);
stack_swap();
f_cast();
stack_swap();
return 1;
}
- else if(is_bignum_object_in_svalue(sp-1) && sp[-2].type==T_FLOAT)
+ else if(is_bignum_object_in_svalue(sp-1) && TYPEOF(sp[-2]) == T_FLOAT)
{
ref_push_type_value(float_type_string);
stack_swap();
f_cast();
return 1;
}
#endif
return 0;
}
static int call_lfun(int left, int right)
{
struct object *o;
struct program *p;
int i;
- if(sp[-2].type == T_OBJECT &&
+ if(TYPEOF(sp[-2]) == T_OBJECT &&
(p = (o = sp[-2].u.object)->prog) &&
- (i = FIND_LFUN(p->inherits[sp[-2].subtype].prog, left)) != -1)
+ (i = FIND_LFUN(p->inherits[SUBTYPEOF(sp[-2])].prog, left)) != -1)
{
apply_low(o, i, 1);
free_svalue(sp-2);
sp[-2]=sp[-1];
sp--;
dmalloc_touch_svalue(sp);
return 1;
}
- if(sp[-1].type == T_OBJECT &&
+ if(TYPEOF(sp[-1]) == T_OBJECT &&
(p = (o = sp[-1].u.object)->prog) &&
- (i = FIND_LFUN(p->inherits[sp[-1].subtype].prog, right)) != -1)
+ (i = FIND_LFUN(p->inherits[SUBTYPEOF(sp[-1])].prog, right)) != -1)
{
push_svalue(sp-2);
apply_low(o, i, 1);
free_svalue(sp-3);
sp[-3]=sp[-1];
sp--;
dmalloc_touch_svalue(sp);
pop_stack();
return 1;
}
pike.git/src/operators.c:2250:
return 0;
}
struct mapping *merge_mapping_array_ordered(struct mapping *a,
struct array *b, INT32 op);
struct mapping *merge_mapping_array_unordered(struct mapping *a,
struct array *b, INT32 op);
PMOD_EXPORT void o_subtract(void)
{
- if (sp[-2].type != sp[-1].type && !float_promote())
+ if (TYPEOF(sp[-2]) != TYPEOF(sp[-1]) && !float_promote())
{
if(call_lfun(LFUN_SUBTRACT, LFUN_RSUBTRACT))
return;
- if (sp[-2].type==T_MAPPING)
- switch (sp[-1].type)
+ if (TYPEOF(sp[-2]) == T_MAPPING)
+ switch (TYPEOF(sp[-1]))
{
case T_ARRAY:
{
struct mapping *m;
m=merge_mapping_array_unordered(sp[-2].u.mapping,
sp[-1].u.array,
PIKE_ARRAY_OP_SUB);
pop_n_elems(2);
push_mapping(m);
pike.git/src/operators.c:2291:
else
m=merge_mapping_array_ordered(sp[-2].u.mapping,
sp[-1].u.array,
PIKE_ARRAY_OP_SUB);
pop_n_elems(2);
push_mapping(m);
return;
}
}
- bad_arg_error("`-", sp-2, 2, 2, get_name_of_type(sp[-2].type),
+ bad_arg_error("`-", sp-2, 2, 2, get_name_of_type(TYPEOF(sp[-2])),
sp-1, "Subtract on different types.\n");
}
- switch(sp[-2].type)
+ switch(TYPEOF(sp[-2]))
{
case T_OBJECT:
CALL_OPERATOR(LFUN_SUBTRACT,2);
break;
case T_ARRAY:
{
struct array *a;
check_array_for_destruct(sp[-2].u.array);
pike.git/src/operators.c:2352: Inside #if defined(AUTO_BIGNUM)
case T_INT:
#ifdef AUTO_BIGNUM
if(INT_TYPE_SUB_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer))
{
convert_stack_top_to_bignum();
f_minus(2);
return;
}
#endif /* AUTO_BIGNUM */
sp--;
- sp[-1].u.integer -= sp[0].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer,
+ sp[-1].u.integer - sp[0].u.integer);
return;
case T_STRING:
{
struct pike_string *s,*ret;
s=make_shared_string("");
ret=string_replace(sp[-2].u.string,sp[-1].u.string,s);
free_string(sp[-2].u.string);
free_string(sp[-1].u.string);
free_string(s);
pike.git/src/operators.c:2455:
{
case 0: SIMPLE_TOO_FEW_ARGS_ERROR("`-", 1);
case 1: o_negate(); break;
case 2: o_subtract(); break;
default:
{
INT32 e;
TYPE_FIELD types = 0;
struct svalue *s=sp-args;
- for(e=-args;e<0;e++) types|=1<<sp[e].type;
+ for(e=-args;e<0;e++) types |= 1<<TYPEOF(sp[e]);
if ((types | BIT_INT | BIT_FLOAT) == (BIT_INT | BIT_FLOAT)) {
INT32 carry = 0;
if (types == BIT_INT) {
f_add(args-1);
o_subtract();
break;
}
/* Take advantage of the precision control in f_add(). */
for(e = 1; e < args; e++) {
- if (s[e].type == PIKE_T_INT) {
+ if (TYPEOF(s[e]) == PIKE_T_INT) {
INT_TYPE val = s[e].u.integer;
if (val >= -0x7fffffff) {
s[e].u.integer = -val;
} else {
/* Protect against negative overflow. */
s[e].u.integer = ~val;
carry++;
}
} else {
s[e].u.float_number = -s[e].u.float_number;
pike.git/src/operators.c:2520:
do_docode(CDR(n),DO_NOT_COPY_TOPLEVEL);
emit0(F_SUBTRACT);
modify_stack_depth(-1);
return 1;
}
return 0;
}
PMOD_EXPORT void o_and(void)
{
- if(sp[-1].type != sp[-2].type)
+ if(TYPEOF(sp[-1]) != TYPEOF(sp[-2]))
{
if(call_lfun(LFUN_AND, LFUN_RAND))
return;
- else if (((sp[-1].type == T_TYPE) || (sp[-1].type == T_PROGRAM) ||
- (sp[-1].type == T_FUNCTION)) &&
- ((sp[-2].type == T_TYPE) || (sp[-2].type == T_PROGRAM) ||
- (sp[-2].type == T_FUNCTION)))
+ else if (((TYPEOF(sp[-1]) == T_TYPE) || (TYPEOF(sp[-1]) == T_PROGRAM) ||
+ (TYPEOF(sp[-1]) == T_FUNCTION)) &&
+ ((TYPEOF(sp[-2]) == T_TYPE) || (TYPEOF(sp[-2]) == T_PROGRAM) ||
+ (TYPEOF(sp[-2]) == T_FUNCTION)))
{
- if (sp[-2].type != T_TYPE)
+ if (TYPEOF(sp[-2]) != T_TYPE)
{
struct program *p = program_from_svalue(sp - 2);
if (!p) {
int args = 2;
SIMPLE_BAD_ARG_ERROR("`&", 1, "type");
}
type_stack_mark();
push_object_type(0, p->id);
free_svalue(sp - 2);
- sp[-2].u.type = pop_unfinished_type();
- sp[-2].type = T_TYPE;
+ SET_SVAL(sp[-2], T_TYPE, 0, type, pop_unfinished_type());
}
- if (sp[-1].type != T_TYPE)
+ if (TYPEOF(sp[-1]) != T_TYPE)
{
struct program *p = program_from_svalue(sp - 1);
if (!p)
{
int args = 2;
SIMPLE_BAD_ARG_ERROR("`&", 2, "type");
}
type_stack_mark();
push_object_type(0, p->id);
free_svalue(sp - 1);
- sp[-1].u.type = pop_unfinished_type();
- sp[-1].type = T_TYPE;
+ SET_SVAL(sp[-1], T_TYPE, 0, type, pop_unfinished_type());
}
}
- else if (sp[-2].type==T_MAPPING)
- switch (sp[-1].type)
+ else if (TYPEOF(sp[-2]) == T_MAPPING)
+ switch (TYPEOF(sp[-1]))
{
case T_ARRAY:
{
struct mapping *m;
m=merge_mapping_array_unordered(sp[-2].u.mapping,
sp[-1].u.array,
PIKE_ARRAY_OP_AND);
pop_n_elems(2);
push_mapping(m);
pike.git/src/operators.c:2600:
}
default:
{
int args = 2;
SIMPLE_BAD_ARG_ERROR("`&", 2, "mapping");
}
}
else
{
int args = 2;
- SIMPLE_BAD_ARG_ERROR("`&", 2, get_name_of_type(sp[-2].type));
+ SIMPLE_BAD_ARG_ERROR("`&", 2, get_name_of_type(TYPEOF(sp[-2])));
}
}
- switch(sp[-2].type)
+ switch(TYPEOF(sp[-2]))
{
case T_OBJECT:
CALL_OPERATOR(LFUN_AND,2);
break;
case T_INT:
sp--;
- sp[-1].u.integer &= sp[0].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer,
+ sp[-1].u.integer & sp[0].u.integer);
break;
case T_MAPPING:
{
struct mapping *m;
m=merge_mappings(sp[-2].u.mapping, sp[-1].u.mapping, PIKE_ARRAY_OP_AND);
pop_n_elems(2);
push_mapping(m);
return;
}
pike.git/src/operators.c:2758:
tmp=*--sp;
SET_ONERROR(err,do_free_svalue,&tmp);
r_speedup(args>>1,func);
UNSET_ONERROR(err);
sp++[0]=tmp;
func();
}
}
static void speedup(INT32 args, void (*func)(void))
{
- switch(sp[-args].type)
+ switch(TYPEOF(sp[-args]))
{
/* Binary balanced tree method for types where
* a op b may or may not be equal to b op a
*/
case T_ARRAY:
case T_MAPPING:
r_speedup(args,func);
return;
default:
pike.git/src/operators.c:2835:
*! @[`|()], @[lfun::`&()], @[lfun::``&()]
*/
PMOD_EXPORT void f_and(INT32 args)
{
switch(args)
{
case 0: SIMPLE_TOO_FEW_ARGS_ERROR("`&", 1);
case 1: return;
case 2: o_and(); return;
default:
- if(sp[-args].type == T_OBJECT)
+ if(TYPEOF(sp[-args]) == T_OBJECT)
{
CALL_OPERATOR(LFUN_AND, args);
}else{
speedup(args, o_and);
}
}
}
static int generate_and(node *n)
{
pike.git/src/operators.c:2866:
modify_stack_depth(-1);
return 1;
default:
return 0;
}
}
PMOD_EXPORT void o_or(void)
{
- if(sp[-1].type != sp[-2].type)
+ if(TYPEOF(sp[-1]) != TYPEOF(sp[-2]))
{
if(call_lfun(LFUN_OR, LFUN_ROR)) {
return;
- } else if (((sp[-1].type == T_TYPE) || (sp[-1].type == T_PROGRAM) ||
- (sp[-1].type == T_FUNCTION)) &&
- ((sp[-2].type == T_TYPE) || (sp[-2].type == T_PROGRAM) ||
- (sp[-2].type == T_FUNCTION))) {
- if (sp[-2].type != T_TYPE) {
+ } else if (((TYPEOF(sp[-1]) == T_TYPE) || (TYPEOF(sp[-1]) == T_PROGRAM) ||
+ (TYPEOF(sp[-1]) == T_FUNCTION)) &&
+ ((TYPEOF(sp[-2]) == T_TYPE) || (TYPEOF(sp[-2]) == T_PROGRAM) ||
+ (TYPEOF(sp[-2]) == T_FUNCTION))) {
+ if (TYPEOF(sp[-2]) != T_TYPE) {
struct program *p = program_from_svalue(sp - 2);
if (!p) {
int args = 2;
SIMPLE_BAD_ARG_ERROR("`|", 1, "type");
}
type_stack_mark();
push_object_type(0, p->id);
free_svalue(sp - 2);
- sp[-2].u.type = pop_unfinished_type();
- sp[-2].type = T_TYPE;
+ SET_SVAL(sp[-2], T_TYPE, 0, type, pop_unfinished_type());
}
- if (sp[-1].type != T_TYPE) {
+ if (TYPEOF(sp[-1]) != T_TYPE) {
struct program *p = program_from_svalue(sp - 1);
if (!p) {
int args = 2;
SIMPLE_BAD_ARG_ERROR("`|", 2, "type");
}
type_stack_mark();
push_object_type(0, p->id);
free_svalue(sp - 1);
- sp[-1].u.type = pop_unfinished_type();
- sp[-1].type = T_TYPE;
+ SET_SVAL(sp[-1], T_TYPE, 0, type, pop_unfinished_type());
}
} else {
int args = 2;
- SIMPLE_BAD_ARG_ERROR("`|", 2, get_name_of_type(sp[-2].type));
+ SIMPLE_BAD_ARG_ERROR("`|", 2, get_name_of_type(TYPEOF(sp[-2])));
}
}
- switch(sp[-2].type)
+ switch(TYPEOF(sp[-2]))
{
case T_OBJECT:
CALL_OPERATOR(LFUN_OR,2);
break;
case T_INT:
sp--;
- sp[-1].u.integer |= sp[0].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
+ sp[-1].u.integer | sp[0].u.integer);
break;
case T_MAPPING:
{
struct mapping *m;
m=merge_mappings(sp[-2].u.mapping, sp[-1].u.mapping, PIKE_ARRAY_OP_OR);
pop_n_elems(2);
push_mapping(m);
return;
}
pike.git/src/operators.c:3092:
*! @[`&()], @[lfun::`|()], @[lfun::``|()]
*/
PMOD_EXPORT void f_or(INT32 args)
{
switch(args)
{
case 0: SIMPLE_TOO_FEW_ARGS_ERROR("`|", 1);
case 1: return;
case 2: o_or(); return;
default:
- if(sp[-args].type==T_OBJECT)
+ if(TYPEOF(sp[-args]) == T_OBJECT)
{
CALL_OPERATOR(LFUN_OR, args);
} else {
speedup(args, o_or);
}
}
}
static int generate_or(node *n)
{
pike.git/src/operators.c:3124:
return 1;
default:
return 0;
}
}
PMOD_EXPORT void o_xor(void)
{
- if(sp[-1].type != sp[-2].type)
+ if(TYPEOF(sp[-1]) != TYPEOF(sp[-2]))
{
if(call_lfun(LFUN_XOR, LFUN_RXOR)) {
return;
- } else if (((sp[-1].type == T_TYPE) || (sp[-1].type == T_PROGRAM) ||
- (sp[-1].type == T_FUNCTION)) &&
- ((sp[-2].type == T_TYPE) || (sp[-2].type == T_PROGRAM) ||
- (sp[-2].type == T_FUNCTION))) {
- if (sp[-2].type != T_TYPE) {
+ } else if (((TYPEOF(sp[-1]) == T_TYPE) || (TYPEOF(sp[-1]) == T_PROGRAM) ||
+ (TYPEOF(sp[-1]) == T_FUNCTION)) &&
+ ((TYPEOF(sp[-2]) == T_TYPE) || (TYPEOF(sp[-2]) == T_PROGRAM) ||
+ (TYPEOF(sp[-2]) == T_FUNCTION))) {
+ if (TYPEOF(sp[-2]) != T_TYPE) {
struct program *p = program_from_svalue(sp - 2);
if (!p) {
int args = 2;
SIMPLE_BAD_ARG_ERROR("`^", 1, "type");
}
type_stack_mark();
push_object_type(0, p->id);
free_svalue(sp - 2);
- sp[-2].u.type = pop_unfinished_type();
- sp[-2].type = T_TYPE;
+ SET_SVAL(sp[-2], T_TYPE, 0, type, pop_unfinished_type());
}
- if (sp[-1].type != T_TYPE) {
+ if (TYPEOF(sp[-1]) != T_TYPE) {
struct program *p = program_from_svalue(sp - 1);
if (!p) {
int args = 2;
SIMPLE_BAD_ARG_ERROR("`^", 2, "type");
}
type_stack_mark();
push_object_type(0, p->id);
free_svalue(sp - 1);
- sp[-1].u.type = pop_unfinished_type();
- sp[-1].type = T_TYPE;
+ SET_SVAL(sp[-1], T_TYPE, 0, type, pop_unfinished_type());
}
} else {
int args = 2;
- SIMPLE_BAD_ARG_ERROR("`^", 2, get_name_of_type(sp[-2].type));
+ SIMPLE_BAD_ARG_ERROR("`^", 2, get_name_of_type(TYPEOF(sp[-2])));
}
}
- switch(sp[-2].type)
+ switch(TYPEOF(sp[-2]))
{
case T_OBJECT:
CALL_OPERATOR(LFUN_XOR,2);
break;
case T_INT:
sp--;
- sp[-1].u.integer ^= sp[0].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
+ sp[-1].u.integer ^ sp[0].u.integer);
break;
case T_MAPPING:
{
struct mapping *m;
m=merge_mappings(sp[-2].u.mapping, sp[-1].u.mapping, PIKE_ARRAY_OP_XOR);
pop_n_elems(2);
push_mapping(m);
return;
}
pike.git/src/operators.c:3339:
*! @[`&()], @[`|()], @[lfun::`^()], @[lfun::``^()]
*/
PMOD_EXPORT void f_xor(INT32 args)
{
switch(args)
{
case 0: SIMPLE_TOO_FEW_ARGS_ERROR("`^", 1);
case 1: return;
case 2: o_xor(); return;
default:
- if(sp[-args].type==T_OBJECT)
+ if(TYPEOF(sp[-args]) == T_OBJECT)
{
CALL_OPERATOR(LFUN_XOR, args);
} else {
speedup(args, o_xor);
}
}
}
static int generate_xor(node *n)
{
pike.git/src/operators.c:3371:
return 1;
default:
return 0;
}
}
PMOD_EXPORT void o_lsh(void)
{
#ifdef AUTO_BIGNUM
- if ((sp[-1].type == T_INT) && (sp[-2].type == T_INT) &&
+ if ((TYPEOF(sp[-1]) == T_INT) && (TYPEOF(sp[-2]) == T_INT) &&
INT_TYPE_LSH_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer))
convert_stack_top_to_bignum();
#endif /* AUTO_BIGNUM */
- if(sp[-1].type != T_INT || sp[-2].type != T_INT)
+ if(TYPEOF(sp[-1]) != T_INT || TYPEOF(sp[-2]) != T_INT)
{
int args = 2;
if(call_lfun(LFUN_LSH, LFUN_RLSH))
return;
- if(sp[-2].type != T_INT)
+ if(TYPEOF(sp[-2]) != T_INT)
SIMPLE_BAD_ARG_ERROR("`<<", 1, "int|object");
SIMPLE_BAD_ARG_ERROR("`<<", 2, "int(0..)|object");
}
#ifndef AUTO_BIGNUM
if (sp[-1].u.integer > 31) {
sp--;
- sp[-1].u.integer = 0;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, 0);
return;
}
#endif /* !AUTO_BIGNUM */
if (sp[-1].u.integer < 0) {
int args = 2;
SIMPLE_BAD_ARG_ERROR("`<<", 2, "int(0..)|object");
}
sp--;
- sp[-1].u.integer = sp[-1].u.integer << sp->u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
+ sp[-1].u.integer << sp->u.integer);
}
/*! @decl int `<<(int arg1, int arg2)
*! @decl mixed `<<(object arg1, int|object arg2)
*! @decl mixed `<<(int arg1, object arg2)
*!
*! Left shift.
*!
*! Every expression with the @expr{<<@} operator becomes a call to
*! this function, i.e. @expr{a<<b@} is the same as
pike.git/src/operators.c:3448:
do_docode(CDR(n),DO_NOT_COPY_TOPLEVEL);
emit0(F_LSH);
modify_stack_depth(-1);
return 1;
}
return 0;
}
PMOD_EXPORT void o_rsh(void)
{
- if(sp[-2].type != T_INT || sp[-1].type != T_INT)
+ if(TYPEOF(sp[-2]) != T_INT || TYPEOF(sp[-1]) != T_INT)
{
int args = 2;
if(call_lfun(LFUN_RSH, LFUN_RRSH))
return;
- if(sp[-2].type != T_INT)
+ if(TYPEOF(sp[-2]) != T_INT)
SIMPLE_BAD_ARG_ERROR("`>>", 1, "int|object");
SIMPLE_BAD_ARG_ERROR("`>>", 2, "int(0..)|object");
}
if (sp[-1].u.integer < 0) {
int args = 2;
SIMPLE_BAD_ARG_ERROR("`>>", 2, "int(0..)|object");
}
if(
#ifdef AUTO_BIGNUM
(INT_TYPE_RSH_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer))
#else /* !AUTO_BIGNUM */
(sp[-1].u.integer > 31)
#endif /* AUTO_BIGNUM */
)
{
sp--;
if (sp[-1].u.integer < 0) {
- sp[-1].u.integer = -1;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, -1);
} else {
- sp[-1].u.integer = 0;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, 0);
}
- sp[-1].subtype = NUMBER_NUMBER;
+
return;
}
sp--;
- sp[-1].u.integer = sp[-1].u.integer >> sp->u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
+ sp[-1].u.integer >> sp->u.integer);
}
/*! @decl int `>>(int arg1, int arg2)
*! @decl mixed `>>(object arg1, int|object arg2)
*! @decl mixed `>>(int arg1, object arg2)
*!
*! Right shift.
*!
*! Every expression with the @expr{>>@} operator becomes a call to
*! this function, i.e. @expr{a>>b@} is the same as
pike.git/src/operators.c:3534:
return 1;
}
return 0;
}
#define TWO_TYPES(X,Y) (((X)<<8)|(Y))
PMOD_EXPORT void o_multiply(void)
{
int args = 2;
- switch(TWO_TYPES(sp[-2].type,sp[-1].type))
+ switch(TWO_TYPES(TYPEOF(sp[-2]), TYPEOF(sp[-1])))
{
case TWO_TYPES(T_ARRAY, T_INT):
{
struct array *ret;
struct svalue *pos;
INT32 e;
if(sp[-1].u.integer < 0)
SIMPLE_BAD_ARG_ERROR("`*", 2, "int(0..)");
ret=allocate_array(sp[-2].u.array->size * sp[-1].u.integer);
pos=ret->item;
pike.git/src/operators.c:3662:
push_string(low_end_shared_string(ret));
return;
}
case TWO_TYPES(T_ARRAY,T_STRING):
{
struct pike_string *ret;
ret=implode(sp[-2].u.array,sp[-1].u.string);
free_string(sp[-1].u.string);
free_array(sp[-2].u.array);
- sp[-2].type=T_STRING;
- sp[-2].u.string=ret;
+ SET_SVAL(sp[-2], T_STRING, 0, string, ret);
sp--;
return;
}
case TWO_TYPES(T_ARRAY,T_ARRAY):
{
struct array *ret;
ret=implode_array(sp[-2].u.array, sp[-1].u.array);
pop_n_elems(2);
push_array(ret);
pike.git/src/operators.c:3691:
case TWO_TYPES(T_FLOAT,T_INT):
sp--;
sp[-1].u.float_number *= (FLOAT_TYPE)sp[0].u.integer;
return;
case TWO_TYPES(T_INT,T_FLOAT):
sp--;
sp[-1].u.float_number=
(FLOAT_TYPE) sp[-1].u.integer * sp[0].u.float_number;
- sp[-1].type=T_FLOAT;
+ SET_SVAL_TYPE(sp[-1], T_FLOAT);
return;
case TWO_TYPES(T_INT,T_INT):
#ifdef AUTO_BIGNUM
if(INT_TYPE_MUL_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer))
{
convert_stack_top_to_bignum();
goto do_lfun_multiply;
}
#endif /* AUTO_BIGNUM */
sp--;
- sp[-1].u.integer *= sp[0].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
+ sp[-1].u.integer * sp[0].u.integer);
return;
default:
do_lfun_multiply:
if(call_lfun(LFUN_MULTIPLY, LFUN_RMULTIPLY))
return;
PIKE_ERROR("`*", "Bad arguments.\n", sp, 2);
}
}
pike.git/src/operators.c:3781:
*! @[`+()], @[`-()], @[`/()], @[lfun::`*()], @[lfun::``*()]
*/
PMOD_EXPORT void f_multiply(INT32 args)
{
switch(args)
{
case 0: SIMPLE_TOO_FEW_ARGS_ERROR("`*", 1);
case 1: return;
case 2: o_multiply(); return;
default:
- if(sp[-args].type==T_OBJECT)
+ if(TYPEOF(sp[-args]) == T_OBJECT)
{
CALL_OPERATOR(LFUN_MULTIPLY, args);
} else {
INT32 i = -args, j = -1;
/* Reverse the arguments */
while(i < j) {
struct svalue tmp = sp[i];
sp[i++] = sp[j];
sp[j--] = tmp;
}
pike.git/src/operators.c:3823:
modify_stack_depth(-1);
return 1;
default:
return 0;
}
}
PMOD_EXPORT void o_divide(void)
{
- if(sp[-2].type!=sp[-1].type && !float_promote())
+ if(TYPEOF(sp[-2]) != TYPEOF(sp[-1]) && !float_promote())
{
if(call_lfun(LFUN_DIVIDE, LFUN_RDIVIDE))
return;
- switch(TWO_TYPES(sp[-2].type,sp[-1].type))
+ switch(TWO_TYPES(TYPEOF(sp[-2]), TYPEOF(sp[-1])))
{
case TWO_TYPES(T_STRING,T_INT):
{
struct array *a;
INT_TYPE len;
ptrdiff_t size,e,pos=0;
len=sp[-1].u.integer;
if(!len)
OP_DIVISION_BY_ZERO_ERROR("`/");
pike.git/src/operators.c:3851:
{
len=-len;
size=sp[-2].u.string->len / len;
pos+=sp[-2].u.string->len % len;
}else{
size=sp[-2].u.string->len / len;
}
a=allocate_array(size);
for(e=0;e<size;e++)
{
- a->item[e].u.string=string_slice(sp[-2].u.string, pos,len);
- a->item[e].type=T_STRING;
+ SET_SVAL(a->item[e], T_STRING, 0, string,
+ string_slice(sp[-2].u.string, pos,len));
pos+=len;
}
a->type_field=BIT_STRING;
pop_n_elems(2);
push_array(a);
return;
}
case TWO_TYPES(T_STRING,T_FLOAT):
{
pike.git/src/operators.c:3880:
if(len<0)
{
len=-len;
size=(ptrdiff_t)ceil( ((double)sp[-2].u.string->len) / len);
a=allocate_array(size);
for(last=sp[-2].u.string->len,e=0;e<size-1;e++)
{
pos=sp[-2].u.string->len - (ptrdiff_t)((e+1)*len+0.5);
- a->item[size-1-e].u.string=string_slice(sp[-2].u.string,
- pos,
- last-pos);
- a->item[size-1-e].type=T_STRING;
+ SET_SVAL(a->item[size-1-e], T_STRING, 0, string,
+ string_slice(sp[-2].u.string, pos, last-pos));
last=pos;
}
pos=0;
- a->item[0].u.string=string_slice(sp[-2].u.string,
- pos,
- last-pos);
- a->item[0].type=T_STRING;
+ SET_SVAL(a->item[0], T_STRING, 0, string,
+ string_slice(sp[-2].u.string, pos, last-pos));
}else{
size=(ptrdiff_t)ceil( ((double)sp[-2].u.string->len) / len);
a=allocate_array(size);
for(last=0,e=0;e<size-1;e++)
{
pos = DO_NOT_WARN((ptrdiff_t)((e+1)*len+0.5));
- a->item[e].u.string=string_slice(sp[-2].u.string,
- last,
- pos-last);
- a->item[e].type=T_STRING;
+ SET_SVAL(a->item[e], T_STRING, 0, string,
+ string_slice(sp[-2].u.string, last, pos-last));
last=pos;
}
pos=sp[-2].u.string->len;
- a->item[e].u.string=string_slice(sp[-2].u.string,
- last,
- pos-last);
- a->item[e].type=T_STRING;
+ SET_SVAL(a->item[e], T_STRING, 0, string,
+ string_slice(sp[-2].u.string, last, pos-last));
}
a->type_field=BIT_STRING;
pop_n_elems(2);
push_array(a);
return;
}
case TWO_TYPES(T_ARRAY, T_INT):
{
pike.git/src/operators.c:3944:
len = -len;
pos = sp[-2].u.array->size % len;
}else{
pos = 0;
}
size = sp[-2].u.array->size / len;
a=allocate_array(size);
for(e=0;e<size;e++)
{
- a->item[e].u.array=friendly_slice_array(sp[-2].u.array,
- pos,
- pos+len);
+ SET_SVAL(a->item[e], T_ARRAY, 0, array,
+ friendly_slice_array(sp[-2].u.array, pos, pos+len));
pos+=len;
- a->item[e].type=T_ARRAY;
+
}
a->type_field=BIT_ARRAY;
pop_n_elems(2);
push_array(a);
return;
}
case TWO_TYPES(T_ARRAY,T_FLOAT):
{
struct array *a;
pike.git/src/operators.c:3981:
if(len<0)
{
len=-len;
size = (ptrdiff_t)ceil( ((double)sp[-2].u.array->size) / len);
a=allocate_array(size);
for(last=sp[-2].u.array->size,e=0;e<size-1;e++)
{
pos=sp[-2].u.array->size - (ptrdiff_t)((e+1)*len+0.5);
- a->item[size-1-e].u.array=friendly_slice_array(sp[-2].u.array,
- pos,
- last);
- a->item[size-1-e].type=T_ARRAY;
+ SET_SVAL(a->item[size-1-e], T_ARRAY, 0, array,
+ friendly_slice_array(sp[-2].u.array, pos, last));
last=pos;
}
- a->item[0].u.array=slice_array(sp[-2].u.array,
- 0,
- last);
- a->item[0].type=T_ARRAY;
+ SET_SVAL(a->item[0], T_ARRAY, 0, array,
+ slice_array(sp[-2].u.array, 0, last));
}else{
size = (ptrdiff_t)ceil( ((double)sp[-2].u.array->size) / len);
a=allocate_array(size);
for(last=0,e=0;e<size-1;e++)
{
pos = (ptrdiff_t)((e+1)*len+0.5);
- a->item[e].u.array=friendly_slice_array(sp[-2].u.array,
- last,
- pos);
- a->item[e].type=T_ARRAY;
+ SET_SVAL(a->item[e], T_ARRAY, 0, array,
+ friendly_slice_array(sp[-2].u.array, last, pos));
last=pos;
}
- a->item[e].u.array=slice_array(sp[-2].u.array,
- last,
- sp[-2].u.array->size);
- a->item[e].type=T_ARRAY;
+ SET_SVAL(a->item[e], T_ARRAY, 0, array,
+ slice_array(sp[-2].u.array, last, sp[-2].u.array->size));
}
a->type_field=BIT_ARRAY;
pop_n_elems(2);
push_array(a);
return;
}
}
PIKE_ERROR("`/", "Division on different types.\n", sp, 2);
}
- switch(sp[-2].type)
+ switch(TYPEOF(sp[-2]))
{
case T_OBJECT:
do_lfun_division:
CALL_OPERATOR(LFUN_DIVIDE,2);
break;
case T_STRING:
{
struct array *ret;
ret=explode(sp[-2].u.string,sp[-1].u.string);
free_string(sp[-2].u.string);
free_string(sp[-1].u.string);
- sp[-2].type=T_ARRAY;
- sp[-2].u.array=ret;
+ SET_SVAL(sp[-2], T_ARRAY, 0, array, ret);
sp--;
return;
}
case T_ARRAY:
{
struct array *ret=explode_array(sp[-2].u.array, sp[-1].u.array);
pop_n_elems(2);
push_array(ret);
return;
pike.git/src/operators.c:4082:
}
else
tmp = sp[-2].u.integer/sp[-1].u.integer;
sp--;
/* What is this trying to solve? /Noring */
/* It fixes rounding towards negative infinity. /mast */
if((sp[-1].u.integer<0) != (sp[0].u.integer<0))
if(tmp*sp[0].u.integer!=sp[-1].u.integer)
tmp--;
- sp[-1].u.integer=tmp;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, tmp);
return;
}
default:
PIKE_ERROR("`/", "Bad argument 1.\n", sp, 2);
}
}
/*! @decl mixed `/(object arg1, mixed arg2)
*! @decl mixed `/(mixed arg1, object arg2)
pike.git/src/operators.c:4198:
do_docode(CDR(n),DO_NOT_COPY_TOPLEVEL);
emit0(F_DIVIDE);
modify_stack_depth(-1);
return 1;
}
return 0;
}
PMOD_EXPORT void o_mod(void)
{
- if(sp[-2].type != sp[-1].type && !float_promote())
+ if(TYPEOF(sp[-2]) != TYPEOF(sp[-1]) && !float_promote())
{
if(call_lfun(LFUN_MOD, LFUN_RMOD))
return;
- switch(TWO_TYPES(sp[-2].type,sp[-1].type))
+ switch(TWO_TYPES(TYPEOF(sp[-2]), TYPEOF(sp[-1])))
{
case TWO_TYPES(T_STRING,T_INT):
{
struct pike_string *s=sp[-2].u.string;
ptrdiff_t tmp,base;
if(!sp[-1].u.integer)
OP_MODULO_BY_ZERO_ERROR("`%");
if(sp[-1].u.integer<0)
pike.git/src/operators.c:4254:
a=slice_array(a,base,base+tmp);
pop_n_elems(2);
push_array(a);
return;
}
}
PIKE_ERROR("`%", "Modulo on different types.\n", sp, 2);
}
- switch(sp[-2].type)
+ switch(TYPEOF(sp[-2]))
{
case T_OBJECT:
CALL_OPERATOR(LFUN_MOD,2);
break;
case T_FLOAT:
{
FLOAT_TYPE foo;
if(sp[-1].u.float_number == 0.0)
OP_MODULO_BY_ZERO_ERROR("`%");
pike.git/src/operators.c:4293:
sp[-1].u.integer=((sp[-1].u.integer+~sp[0].u.integer)%-sp[0].u.integer)-~sp[0].u.integer;
}
}else{
if(sp[0].u.integer>=0)
{
sp[-1].u.integer=sp[0].u.integer+~((~sp[-1].u.integer) % sp[0].u.integer);
}else{
sp[-1].u.integer=-(-sp[-1].u.integer % -sp[0].u.integer);
}
}
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL_SUBTYPE(sp[-1], NUMBER_NUMBER);
return;
default:
PIKE_ERROR("`%", "Bad argument 1.\n", sp, 2);
}
}
/*! @decl mixed `%(object arg1, mixed arg2)
*! @decl mixed `%(mixed arg1, object arg2)
*! @decl string `%(string arg1, int arg2)
pike.git/src/operators.c:4380:
do_docode(CDR(n),DO_NOT_COPY_TOPLEVEL);
emit0(F_MOD);
modify_stack_depth(-1);
return 1;
}
return 0;
}
PMOD_EXPORT void o_not(void)
{
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_INT:
- sp[-1].u.integer = !sp[-1].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, !sp[-1].u.integer);
break;
case T_FUNCTION:
case T_OBJECT:
if(UNSAFE_IS_ZERO(sp-1))
{
pop_stack();
push_int(1);
}else{
pop_stack();
push_int(0);
}
break;
default:
free_svalue(sp-1);
- sp[-1].type=T_INT;
- sp[-1].subtype = NUMBER_NUMBER;
- sp[-1].u.integer=0;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, 0);
}
}
/*! @decl int(0..1) `!(object|function arg)
*! @decl int(1..1) `!(int(0..0) arg)
*! @decl int(0..0) `!(mixed arg)
*!
*! Logical not.
*!
*! Every expression with the @expr{!@} operator becomes a call to
pike.git/src/operators.c:4460:
struct compilation *c = THIS_COMPILATION;
do_docode(CDR(n),DO_NOT_COPY);
emit0(F_NOT);
return 1;
}
return 0;
}
PMOD_EXPORT void o_compl(void)
{
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_OBJECT:
CALL_OPERATOR(LFUN_COMPL,1);
break;
case T_INT:
- sp[-1].u.integer = ~ sp[-1].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, ~sp[-1].u.integer);
break;
case T_FLOAT:
sp[-1].u.float_number = (FLOAT_TYPE) -1.0 - sp[-1].u.float_number;
break;
case T_TYPE:
type_stack_mark();
if (sp[-1].u.type->type == T_NOT) {
push_finished_type(sp[-1].u.type->car);
pike.git/src/operators.c:4582:
struct compilation *c = THIS_COMPILATION;
do_docode(CDR(n),DO_NOT_COPY);
emit0(F_COMPL);
return 1;
}
return 0;
}
PMOD_EXPORT void o_negate(void)
{
- switch(sp[-1].type)
+ switch(TYPEOF(sp[-1]))
{
case T_OBJECT:
do_lfun_negate:
CALL_OPERATOR(LFUN_SUBTRACT,1);
break;
case T_FLOAT:
sp[-1].u.float_number=-sp[-1].u.float_number;
return;
case T_INT:
#ifdef AUTO_BIGNUM
if(INT_TYPE_NEG_OVERFLOW(sp[-1].u.integer))
{
convert_stack_top_to_bignum();
goto do_lfun_negate;
}
#endif /* AUTO_BIGNUM */
- sp[-1].u.integer = - sp[-1].u.integer;
- sp[-1].subtype = NUMBER_NUMBER;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, -sp[-1].u.integer);
return;
default:
PIKE_ERROR("`-", "Bad argument to unary minus.\n", sp, 1);
}
}
static void string_or_array_range (int bound_types,
struct svalue *ind,
INT_TYPE low,
INT_TYPE high)
/* ind is modified to point to the range. low and high are INT_TYPE to
* avoid truncation problems when they come from int svalues. */
{
INT32 from, to, len; /* to and len are not inclusive. */
- if (ind->type == T_STRING)
+ if (TYPEOF(*ind) == T_STRING)
len = ind->u.string->len;
else {
#ifdef PIKE_DEBUG
- if (!ind || ind->type != T_ARRAY) Pike_fatal ("Invalid ind svalue.\n");
+ if (!ind || TYPEOF(*ind) != T_ARRAY) Pike_fatal ("Invalid ind svalue.\n");
#endif
len = ind->u.array->size;
}
if (bound_types & RANGE_LOW_OPEN)
from = 0;
else {
if (bound_types & RANGE_LOW_FROM_END) {
if (low >= len) from = 0;
else if (low < 0) from = len;
pike.git/src/operators.c:4656:
if (high > len - from) to = from;
else if (high <= 0) to = len;
else to = len - high;
} else {
if (high < from) to = from;
else if (high >= len) to = len;
else to = high + 1;
}
}
- if (ind->type == T_STRING) {
+ if (TYPEOF(*ind) == T_STRING) {
struct pike_string *s;
if (from == 0 && to == len) return;
s=string_slice(ind->u.string, from, to-from);
free_string(ind->u.string);
ind->u.string=s;
}
else {
struct array *a;
pike.git/src/operators.c:4787:
PMOD_EXPORT void o_range2 (int bound_types)
/* This takes between one and three args depending on whether
* RANGE_LOW_OPEN and/or RANGE_HIGH_OPEN is set in bound_types. */
{
struct svalue *ind, *low, *high;
high = bound_types & RANGE_HIGH_OPEN ? sp : sp - 1;
low = bound_types & RANGE_LOW_OPEN ? high : high - 1;
ind = low - 1;
- switch (ind->type) {
+ switch (TYPEOF(*ind)) {
case T_OBJECT: {
struct object *o = ind->u.object;
int f;
if (!o->prog)
bad_arg_error (range_func_name (bound_types),
ind, sp - ind, 1, "object", ind,
"Cannot call `[..] in destructed object.\n");
- if ((f = FIND_LFUN(o->prog->inherits[ind->subtype].prog,
+ if ((f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(*ind)].prog,
LFUN_RANGE)) != -1) {
struct svalue h;
if (!(bound_types & RANGE_HIGH_OPEN)) {
move_svalue (&h, high);
sp = high;
}
if (bound_types & RANGE_LOW_FROM_BEG)
push_int (INDEX_FROM_BEG);
else if (bound_types & RANGE_LOW_OPEN) {
pike.git/src/operators.c:4859:
sp = ind + 1;
}
break;
}
case T_STRING:
case T_ARRAY: {
INT_TYPE l=0, h=0;
if (!(bound_types & RANGE_LOW_OPEN)) {
- if (low->type != T_INT)
+ if (TYPEOF(*low) != T_INT)
bad_arg_error (range_func_name (bound_types),
ind, sp - ind, 2, "int", low,
"Bad lower bound. Expected int, got %s.\n",
- get_name_of_type (low->type));
+ get_name_of_type (TYPEOF(*low)));
l = low->u.integer;
}
if (!(bound_types & RANGE_HIGH_OPEN)) {
- if (high->type != T_INT)
+ if (TYPEOF(*high) != T_INT)
bad_arg_error (range_func_name (bound_types),
ind, sp - ind, high - ind + 1, "int", high,
"Bad upper bound. Expected int, got %s.\n",
- get_name_of_type (high->type));
+ get_name_of_type (TYPEOF(*high)));
h = high->u.integer;
}
/* Can pop off the bounds without fuzz since they're simple integers. */
sp = ind + 1;
string_or_array_range (bound_types, ind, l, h);
break;
}
default:
bad_arg_error (range_func_name (bound_types),
ind, sp - ind, 1, "string|array|object", ind,
"Cannot use [..] on a %s. Expected string, array or object.\n",
- get_name_of_type (ind->type));
+ get_name_of_type (TYPEOF(*ind)));
}
}
/*! @decl mixed `[..](object arg, mixed start, int start_type, mixed end, int end_type)
*! @decl string `[..](string arg, int start, int start_type, int end, int end_type)
*! @decl array `[..](array arg, int start, int start_type, int end, int end_type)
*!
*! Extracts a subrange.
*!
*! This is the function form of expressions with the @expr{[..]@}
pike.git/src/operators.c:5002:
*! @[lfun::`[..]], @[`[]]
*/
PMOD_EXPORT void f_range(INT32 args)
{
struct svalue *ind;
if (args != 5)
SIMPLE_WRONG_NUM_ARGS_ERROR ("predef::`[..]", 5);
ind = sp - 5;
#define CALC_BOUND_TYPES(bound_types) do { \
- if (ind[2].type != T_INT) \
+ if (TYPEOF(ind[2]) != T_INT) \
SIMPLE_ARG_TYPE_ERROR ("predef::`[..]", 3, "int"); \
switch (ind[2].u.integer) { \
case INDEX_FROM_BEG: bound_types = RANGE_LOW_FROM_BEG; break; \
case INDEX_FROM_END: bound_types = RANGE_LOW_FROM_END; break; \
case OPEN_BOUND: bound_types = RANGE_LOW_OPEN; break; \
default: \
SIMPLE_ARG_ERROR ("predef::`[..]", 3, "Unrecognized bound type."); \
} \
\
- if (ind[4].type != T_INT) \
+ if (TYPEOF(ind[4]) != T_INT) \
SIMPLE_ARG_TYPE_ERROR ("predef::`[..]", 5, "int"); \
switch (ind[4].u.integer) { \
case INDEX_FROM_BEG: bound_types |= RANGE_HIGH_FROM_BEG; break; \
case INDEX_FROM_END: bound_types |= RANGE_HIGH_FROM_END; break; \
case OPEN_BOUND: bound_types |= RANGE_HIGH_OPEN; break; \
default: \
SIMPLE_ARG_ERROR ("predef::`[..]", 5, "Unrecognized bound type."); \
} \
} while (0)
- switch (ind->type) {
+ switch (TYPEOF(*ind)) {
case T_OBJECT: {
struct object *o = ind->u.object;
int f;
if (!o->prog)
SIMPLE_ARG_ERROR ("predef::`[..]", 1,
"Cannot call `[..] in destructed object.\n");
- if ((f = FIND_LFUN(o->prog->inherits[ind->subtype].prog,
+ if ((f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(*ind)].prog,
LFUN_RANGE)) != -1) {
apply_low (o, f, 4);
stack_pop_keep_top();
}
else {
int bound_types;
CALC_BOUND_TYPES (bound_types);
switch (call_old_range_lfun (bound_types, o, ind + 1, ind + 3)) {
case 1:
pike.git/src/operators.c:5070:
break;
}
case T_STRING:
case T_ARRAY: {
INT_TYPE l=0, h=0;
int bound_types;
CALC_BOUND_TYPES (bound_types);
if (!(bound_types & RANGE_LOW_OPEN)) {
- if (ind[1].type != T_INT)
+ if (TYPEOF(ind[1]) != T_INT)
SIMPLE_ARG_TYPE_ERROR ("predef::`[..]", 2, "int");
l = ind[1].u.integer;
}
if (!(bound_types & RANGE_HIGH_OPEN)) {
- if (ind[3].type != T_INT)
+ if (TYPEOF(ind[3]) != T_INT)
SIMPLE_ARG_TYPE_ERROR ("predef::`[..]", 4, "int");
h = ind[3].u.integer;
}
pop_n_elems (4);
string_or_array_range (bound_types, ind, l, h);
break;
}
default:
pike.git/src/operators.c:5180:
*! this function.
*!
*! @seealso
*! @[`->()], @[lfun::`[]()], @[`[]=], @[`[..]]
*/
PMOD_EXPORT void f_index(INT32 args)
{
switch(args)
{
case 2:
- if(sp[-1].type==T_STRING) sp[-1].subtype=0;
+ if(TYPEOF(sp[-1]) == T_STRING) SET_SVAL_SUBTYPE(sp[-1], 0);
o_index();
break;
case 3:
move_svalue (sp, sp - 1);
sp += 2;
- sp[-3].type = sp[-1].type = T_INT;
- sp[-3].subtype = sp[-1].subtype = NUMBER_NUMBER;
- sp[-3].u.integer = sp[-1].u.integer = INDEX_FROM_BEG;
+ SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, INDEX_FROM_BEG);
+ sp[-3] = sp[-1];
f_range (5);
break;
default:
SIMPLE_WRONG_NUM_ARGS_ERROR ("predef::`[]", args);
break;
}
}
/*! @decl mixed `->(object arg, string index)
*! @decl mixed `->(int arg, string index)
pike.git/src/operators.c:5261:
*/
PMOD_EXPORT void f_arrow(INT32 args)
{
switch(args)
{
case 0:
case 1:
PIKE_ERROR("`->", "Too few arguments.\n", sp, args);
break;
case 2:
- if(sp[-1].type==T_STRING)
- sp[-1].subtype=1;
+ if(TYPEOF(sp[-1]) == T_STRING)
+ SET_SVAL_SUBTYPE(sp[-1], 1);
o_index();
break;
default:
PIKE_ERROR("`->", "Too many arguments.\n", sp, args);
}
}
/*! @decl mixed `[]=(object arg, mixed index, mixed val)
*! @decl mixed `[]=(object arg, string index, mixed val)
*! @decl mixed `[]=(array arg, int index, mixed val)
pike.git/src/operators.c:5317:
*/
PMOD_EXPORT void f_index_assign(INT32 args)
{
switch (args) {
case 0:
case 1:
case 2:
PIKE_ERROR("`[]=", "Too few arguments.\n", sp, args);
break;
case 3:
- if(sp[-2].type==T_STRING) sp[-2].subtype=0;
+ if(TYPEOF(sp[-2]) == T_STRING) SET_SVAL_SUBTYPE(sp[-2], 0);
assign_lvalue (sp-3, sp-1);
stack_pop_n_elems_keep_top (2);
break;
default:
PIKE_ERROR("`[]=", "Too many arguments.\n", sp, args);
}
}
/*! @decl mixed `->=(object arg, string index, mixed val)
*! @decl mixed `->=(mapping arg, string index, mixed val)
pike.git/src/operators.c:5380:
*/
PMOD_EXPORT void f_arrow_assign(INT32 args)
{
switch (args) {
case 0:
case 1:
case 2:
PIKE_ERROR("`->=", "Too few arguments.\n", sp, args);
break;
case 3:
- if(sp[-2].type==T_STRING) sp[-2].subtype=1;
+ if(TYPEOF(sp[-2]) == T_STRING) SET_SVAL_SUBTYPE(sp[-2], 1);
assign_lvalue (sp-3, sp-1);
assign_svalue (sp-3, sp-1);
pop_n_elems (args-1);
break;
default:
PIKE_ERROR("`->=", "Too many arguments.\n", sp, args);
}
}
/*! @decl int sizeof(string arg)
pike.git/src/operators.c:5432:
tmp=pike_sizeof(sp-args);
pop_n_elems(args);
push_int(tmp);
}
static node *optimize_sizeof(node *n)
{
if (CDR(n) && (CDR(n)->token == F_APPLY) &&
(CADR(n)) && (CADR(n)->token == F_CONSTANT) &&
- (CADR(n)->u.sval.type == T_FUNCTION) &&
- (CADR(n)->u.sval.subtype == FUNCTION_BUILTIN)) {
+ (TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
+ (SUBTYPEOF(CADR(n)->u.sval) == FUNCTION_BUILTIN)) {
extern struct program *string_split_iterator_program;
/* sizeof(efun(...)) */
if ((CADR(n)->u.sval.u.efun->function == f_divide) &&
CDDR(n) && (CDDR(n)->token == F_ARG_LIST) &&
CADDR(n) && pike_types_le(CADDR(n)->type, string_type_string) &&
CDDDR(n) && (CDDDR(n)->token == F_CONSTANT) &&
- (CDDDR(n)->u.sval.type == T_STRING) &&
+ (TYPEOF(CDDDR(n)->u.sval) == T_STRING) &&
(CDDDR(n)->u.sval.u.string->len == 1)) {
p_wchar2 split = index_shared_string(CDDDR(n)->u.sval.u.string, 0);
/* sizeof(`/(str, "x")) */
ADD_NODE_REF2(CADDR(n),
return mkefuncallnode("sizeof",
mkapplynode(mkprgnode(string_split_iterator_program),
mknode(F_ARG_LIST, CADDR(n),
mkintnode(split))));
);
}
if ((CADR(n)->u.sval.u.efun->function == f_minus) &&
CDDR(n) && (CDDR(n)->token == F_ARG_LIST) &&
CADDR(n) && (CADDR(n)->token == F_APPLY) &&
CAADDR(n) && (CAADDR(n)->token == F_CONSTANT) &&
- (CAADDR(n)->u.sval.type == T_FUNCTION) &&
- (CAADDR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
+ (TYPEOF(CAADDR(n)->u.sval) == T_FUNCTION) &&
+ (SUBTYPEOF(CAADDR(n)->u.sval) == FUNCTION_BUILTIN) &&
(CAADDR(n)->u.sval.u.efun->function == f_divide) &&
CDADDR(n) && (CDADDR(n)->token == F_ARG_LIST) &&
CADADDR(n) && pike_types_le(CADADDR(n)->type, string_type_string) &&
CDDADDR(n) && (CDDADDR(n)->token == F_CONSTANT) &&
- (CDDADDR(n)->u.sval.type == T_STRING) &&
+ (TYPEOF(CDDADDR(n)->u.sval) == T_STRING) &&
(CDDADDR(n)->u.sval.u.string->len == 1) &&
CDDDR(n)) {
/* sizeof(`-(`/(str, "x"), y)) */
if (((CDDDR(n)->token == F_CONSTANT) &&
- (CDDDR(n)->u.sval.type == T_ARRAY) &&
+ (TYPEOF(CDDDR(n)->u.sval) == T_ARRAY) &&
(CDDDR(n)->u.sval.u.array->size == 1) &&
- (CDDDR(n)->u.sval.u.array->item[0].type == T_STRING) &&
+ (TYPEOF(CDDDR(n)->u.sval.u.array->item[0]) == T_STRING) &&
(CDDDR(n)->u.sval.u.array->item[0].u.string->len == 0)) ||
((CDDDR(n)->token == F_APPLY) &&
CADDDR(n) && (CADDDR(n)->token == F_CONSTANT) &&
- (CADDDR(n)->u.sval.type == T_FUNCTION) &&
- (CADDDR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
+ (TYPEOF(CADDDR(n)->u.sval) == T_FUNCTION) &&
+ (SUBTYPEOF(CADDDR(n)->u.sval) == FUNCTION_BUILTIN) &&
(CADDDR(n)->u.sval.u.efun->function == f_allocate) &&
CDDDDR(n) && (CDDDDR(n)->token == F_ARG_LIST) &&
CADDDDR(n) && (CADDDDR(n)->token == F_CONSTANT) &&
- (CADDDDR(n)->u.sval.type == T_INT) &&
+ (TYPEOF(CADDDDR(n)->u.sval) == T_INT) &&
(CADDDDR(n)->u.sval.u.integer == 1) &&
CDDDDDR(n) && (CDDDDDR(n)->token == F_CONSTANT) &&
- (CDDDDDR(n)->u.sval.type == T_STRING) &&
+ (TYPEOF(CDDDDDR(n)->u.sval) == T_STRING) &&
(CDDDDDR(n)->u.sval.u.string->len == 0))) {
/* sizeof(`-(`/(str, "x"), ({""}))) */
p_wchar2 split = index_shared_string(CDDADDR(n)->u.sval.u.string, 0);
ADD_NODE_REF2(CADADDR(n),
return mkefuncallnode("sizeof",
mkapplynode(mkprgnode(string_split_iterator_program),
mknode(F_ARG_LIST, CADADDR(n),
mknode(F_ARG_LIST,
mkintnode(split),
mkintnode(1)))));
pike.git/src/operators.c:5574:
p, -len, len - 1);
if (THIS->s) free_string(THIS->s);
u->string=modify_shared_string(u->string,i,j);
copy_shared_string(THIS->s, u->string);
}
else{
lvalue_to_svalue_no_free(sp,THIS->lval);
sp++;
dmalloc_touch_svalue(Pike_sp-1);
- if(sp[-1].type != T_STRING) Pike_error("string[]= failed.\n");
+ if(TYPEOF(sp[-1]) != T_STRING) Pike_error("string[]= failed.\n");
len = sp[-1].u.string->len;
i = p < 0 ? p + len : p;
if(i<0 || i>=len)
Pike_error("Index %"PRINTPIKEINT"d is out of string range "
"%"PRINTPTRDIFFT"d..%"PRINTPTRDIFFT"d.\n",
p, -len, len - 1);
sp[-1].u.string=modify_shared_string(sp[-1].u.string,i,j);
assign_lvalue(THIS->lval, sp-1);
pop_stack();
}
pop_n_elems(args);
push_int(j);
}
static void init_string_assignment_storage(struct object *o)
{
- THIS->lval[0].type = T_INT;
- THIS->lval[0].subtype = PIKE_T_FREE;
- THIS->lval[1].type = T_INT;
- THIS->lval[1].subtype = PIKE_T_FREE;
+ SET_SVAL(THIS->lval[0], T_INT, PIKE_T_FREE, integer, 0);
+ SET_SVAL(THIS->lval[1], T_INT, PIKE_T_FREE, integer, 0);
THIS->s = NULL;
}
static void exit_string_assignment_storage(struct object *o)
{
free_svalues(THIS->lval, 2, BIT_MIXED);
if(THIS->s)
free_string(THIS->s);
}