pike.git
/
src
/
operators.c
version
»
Context lines:
10
20
40
80
file
none
3
pike.git/src/operators.c:23:
#include "program.h" #include "object.h" #include "pike_types.h" #include "module_support.h" #include "pike_macros.h" #include "bignum.h" #include "builtin_functions.h" #include "cyclic.h" #include "pike_compiler.h"
-
#define sp Pike_sp
-
+
#define OP_DIVISION_BY_ZERO_ERROR(FUNC) \
-
math_error(FUNC, sp-2, 2, 0, "Division by zero.\n")
+
math_error(FUNC,
Pike_
sp-2, 2, 0, "Division by zero.\n")
#define OP_MODULO_BY_ZERO_ERROR(FUNC) \
-
math_error(FUNC, sp-2, 2, 0, "Modulo by zero.\n")
+
math_error(FUNC,
Pike_
sp-2, 2, 0, "Modulo by zero.\n")
/* This calculation should always give some margin based on the size. */ /* It utilizes that log10(256) ~= 2.4 < 5/2. */ /* 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))
pike.git/src/operators.c:146:
Pike_error ("Cannot index %s with %s.\n", (TYPEOF(*what) == T_INT && !what->u.integer)? "the NULL value":get_name_of_type(TYPEOF(*what)), get_name_of_type (TYPEOF(*ind))); } } PMOD_EXPORT void o_index(void) { struct svalue s;
-
index_no_free(&s,sp-2,sp-1);
+
index_no_free(&s,
Pike_
sp-2,
Pike_
sp-1);
pop_n_elems(2);
-
*sp=s;
-
dmalloc_touch_svalue(sp);
-
sp++;
+
*
Pike_
sp=s;
+
dmalloc_touch_svalue(
Pike_
sp);
+
Pike_
sp++;
dmalloc_touch_svalue(Pike_sp-1); } /*! @class MasterObject */ /*! @decl object cast_to_object(string str, string|void current_file) *! *! Called by the Pike runtime to cast strings to objects. *!
pike.git/src/operators.c:197:
*! @seealso *! @[cast_to_object()] */ /*! @endclass */ /* Special case for casting to int. */ PMOD_EXPORT void o_cast_to_int(void) {
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_OBJECT:
-
if(!sp[-1].u.object->prog) {
+
if(!
Pike_
sp[-1].u.object->prog) {
/* Casting a destructed object should be like casting a zero. */ pop_stack(); push_int (0); } else {
-
if( sp[-1].u.object->prog == bignum_program )
+
if(
Pike_
sp[-1].u.object->prog == bignum_program )
return; ref_push_string(literal_int_string); if(!call_lhs_lfun(LFUN_CAST,2)) Pike_error("No cast method in object <2>.\n"); stack_pop_keep_top(); /* pop object. */
-
if(TYPEOF(sp[-1]) != PIKE_T_INT)
+
if(TYPEOF(
Pike_
sp[-1]) != PIKE_T_INT)
{
-
if(TYPEOF(sp[-1]) == T_OBJECT)
+
if(TYPEOF(
Pike_
sp[-1]) == T_OBJECT)
{
-
struct object *o = sp[-1].u.object;
+
struct object *o =
Pike_
sp[-1].u.object;
if( o->prog == bignum_program ) return; else if( o->prog ) { ref_push_string(literal_int_string); if( call_lhs_lfun(LFUN__IS_TYPE,2) )
-
if( !UNSAFE_IS_ZERO(sp-1) )
+
if( !UNSAFE_IS_ZERO(
Pike_
sp-1) )
{ pop_stack(); return; } pop_stack(); } } Pike_error("Cast failed, wanted int, got %s\n",
-
get_name_of_type(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
}
-
else if(SUBTYPEOF(sp[-1]) == NUMBER_UNDEFINED)
+
else if(SUBTYPEOF(
Pike_
sp[-1]) == NUMBER_UNDEFINED)
Pike_error("Cannot cast this object to int.\n"); } break; case T_FLOAT: {
-
FLOAT_TYPE f = sp[-1].u.float_number;
+
FLOAT_TYPE f =
Pike_
sp[-1].u.float_number;
if ( PIKE_ISINF(f) || PIKE_ISNAN(f) ) Pike_error("Can't cast infinites or NaN to int.\n"); /* should perhaps convert to Int.Inf now that we have them? */ if (UNLIKELY(f > MAX_INT_TYPE || f < MIN_INT_TYPE)) { convert_stack_top_to_bignum(); } else {
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, f);
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, f);
} break; } case T_STRING: /* 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 )
+
if( (
Pike_
sp[-1].u.string->len >= 10) ||
Pike_
sp[-1].u.string->size_shift )
convert_stack_top_string_to_inumber(10); else {
-
INT_TYPE i = strtol(sp[-1].u.string->str, 0, 10);
-
free_string(sp[-1].u.string);
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, i);
+
INT_TYPE i = strtol(
Pike_
sp[-1].u.string->str, 0, 10);
+
free_string(
Pike_
sp[-1].u.string);
+
SET_SVAL(
Pike_
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(TYPEOF(sp[-1])));
+
Pike_error("Cannot cast %s to int.\n", get_name_of_type(TYPEOF(
Pike_
sp[-1])));
break; } } /* Special case for casting to string. */ PMOD_EXPORT void o_cast_to_string(void) { struct pike_string *s;
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_OBJECT:
-
if(!sp[-1].u.object->prog) {
+
if(!
Pike_
sp[-1].u.object->prog) {
/* Casting a destructed object should be like casting a zero. */ pop_stack(); push_constant_text("0"); } else { ref_push_string(literal_string_string); if(!call_lhs_lfun(LFUN_CAST,2)) Pike_error("No cast method in object.\n"); stack_pop_keep_top();
-
if(TYPEOF(sp[-1]) != PIKE_T_STRING)
+
if(TYPEOF(
Pike_
sp[-1]) != PIKE_T_STRING)
{
-
if(TYPEOF(sp[-1])==PIKE_T_INT && SUBTYPEOF(sp[-1])==NUMBER_UNDEFINED)
+
if(TYPEOF(
Pike_
sp[-1])==PIKE_T_INT && SUBTYPEOF(
Pike_
sp[-1])==NUMBER_UNDEFINED)
Pike_error("Cannot cast this object to string.\n");
-
if(TYPEOF(sp[-1]) == T_OBJECT && sp[-1].u.object->prog)
+
if(TYPEOF(
Pike_
sp[-1]) == T_OBJECT &&
Pike_
sp[-1].u.object->prog)
{ ref_push_string(literal_string_string); if( call_lhs_lfun( LFUN__IS_TYPE,2 ) )
-
if( !UNSAFE_IS_ZERO(sp-1) )
+
if( !UNSAFE_IS_ZERO(
Pike_
sp-1) )
{ pop_stack(); return; } pop_stack(); } Pike_error("Cast failed, wanted string, got %s\n",
-
get_name_of_type(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
} } return; case T_ARRAY: { int i, alen;
-
struct array *a = sp[-1].u.array;
+
struct array *a =
Pike_
sp[-1].u.array;
int shift = 0; alen = a->size; for(i = 0; i<alen; i++) { INT_TYPE val; 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); }
pike.git/src/operators.c:388:
} } break; } pop_stack(); push_string(end_shared_string(s)); } return; default:
-
Pike_error("Cannot cast %s to string.\n", get_name_of_type(TYPEOF(sp[-1])));
+
Pike_error("Cannot cast %s to string.\n", get_name_of_type(TYPEOF(
Pike_
sp[-1])));
break; case PIKE_T_STRING: return; case T_FLOAT: { char buf[MAX_FLOAT_SPRINTF_LEN+1];
-
format_pike_float (buf, sp[-1].u.float_number);
+
format_pike_float (buf,
Pike_
sp[-1].u.float_number);
s = make_shared_string(buf); break; } case T_INT: { INT_TYPE org; char buf[MAX_INT_SPRINTF_LEN]; char *b = buf+sizeof buf-1; unsigned INT_TYPE i;
-
org = sp[-1].u.integer;
+
org =
Pike_
sp[-1].u.integer;
*b-- = '\0'; i = org; if( org < 0 ) i = -i; goto jin; /* C as a macro assembler :-) */ do { i /= 10;
pike.git/src/operators.c:432:
if( org < 0 ) *b = '-'; else b++; s = make_shared_string(b); } break; }
-
SET_SVAL(sp[-1], PIKE_T_STRING, 0, string, s);
+
SET_SVAL(
Pike_
sp[-1], PIKE_T_STRING, 0, string, s);
} PMOD_EXPORT void o_cast(struct pike_type *type, INT32 run_time_type) {
-
if(run_time_type != TYPEOF(sp[-1]))
+
if(run_time_type != TYPEOF(
Pike_
sp[-1]))
{ if(run_time_type == T_MIXED) return;
-
if (TYPEOF(sp[-1]) == T_OBJECT && !sp[-1].u.object->prog) {
+
if (TYPEOF(
Pike_
sp[-1]) == T_OBJECT && !
Pike_
sp[-1].u.object->prog) {
/* Casting a destructed object should be like casting a zero. */ pop_stack(); push_int (0); }
-
if(TYPEOF(sp[-1]) == T_OBJECT)
+
if(TYPEOF(
Pike_
sp[-1]) == T_OBJECT)
{
-
struct object *o = sp[-1].u.object;
-
int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(sp[-1])].prog, LFUN_CAST);
+
struct object *o =
Pike_
sp[-1].u.object;
+
int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(
Pike_
sp[-1])].prog, LFUN_CAST);
if(f == -1) { if (run_time_type == T_MAPPING) { stack_dup(); f_indices(1); stack_swap(); f_values(1); f_mkmapping(2); goto emulated_type_ok; } if (run_time_type != T_PROGRAM) {
pike.git/src/operators.c:480:
if (run_time_type == T_PROGRAM) { if (IS_UNDEFINED(Pike_sp-1)) { pop_stack(); f_object_program(1); return; } } stack_pop_keep_top();
-
if(TYPEOF(sp[-1]) == T_INT &&
-
SUBTYPEOF(sp[-1]) == NUMBER_UNDEFINED)
+
if(TYPEOF(
Pike_
sp[-1]) == T_INT &&
+
SUBTYPEOF(
Pike_
sp[-1]) == NUMBER_UNDEFINED)
Pike_error("Cannot cast this object to %s.\n", get_name_of_type(type->type)); } else switch(run_time_type) { default: Pike_error("Cannot perform cast to that type.\n"); break; case T_MULTISET:
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
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(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
} break; case T_MAPPING:
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_ARRAY: {
-
struct array *a=sp[-1].u.array;
+
struct array *a=
Pike_
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 (TYPEOF(ITEM(a)[i]) != T_ARRAY) Pike_error("Cast array to mapping: " "element %d is not an array\n", i);
pike.git/src/operators.c:538:
"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(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
} break; case T_ARRAY:
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_MAPPING: {
-
struct array *a=mapping_to_array(sp[-1].u.mapping);
+
struct array *a=mapping_to_array(
Pike_
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(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
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(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_INT:
-
f=(FLOAT_TYPE)(sp[-1].u.integer);
+
f=(FLOAT_TYPE)(
Pike_
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),
+
(FLOAT_TYPE)STRTOD_PCHARP(MKPCHARP(
Pike_
sp[-1].u.string->str,
+
Pike_
sp[-1].u.string->size_shift),
0);
-
free_string(sp[-1].u.string);
+
free_string(
Pike_
sp[-1].u.string);
break; default: Pike_error("Cannot cast %s to float.\n",
-
get_name_of_type(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
}
-
SET_SVAL(sp[-1], T_FLOAT, 0, float_number, f);
+
SET_SVAL(
Pike_
sp[-1], T_FLOAT, 0, float_number, f);
break; } case T_OBJECT:
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_STRING: { struct pike_string *file; INT_TYPE 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:636:
frame->current_object); stack_pop_keep_top(); } else { 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(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
} break; case T_PROGRAM:
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_STRING: { struct pike_string *file; INT_TYPE 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_program",2); return; } case T_FUNCTION: {
-
struct program *p=program_from_function(sp-1);
+
struct program *p=program_from_function(
Pike_
sp-1);
if(p) { add_ref(p); pop_stack(); push_program(p); }else{ pop_stack(); push_int(0); } }
pike.git/src/operators.c:688:
if (p) { ref_push_program(p); } else { push_int(0); } return; } default: Pike_error("Cannot cast %s to a program.\n",
-
get_name_of_type(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
} } }
-
if(run_time_type != TYPEOF(sp[-1]))
+
if(run_time_type != TYPEOF(
Pike_
sp[-1]))
{
-
switch(TYPEOF(sp[-1])) {
+
switch(TYPEOF(
Pike_
sp[-1])) {
case T_OBJECT:
-
if(sp[-1].u.object->prog)
+
if(
Pike_
sp[-1].u.object->prog)
{
-
struct object *o = sp[-1].u.object;
-
int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(sp[-1])].prog,
+
struct object *o =
Pike_
sp[-1].u.object;
+
int f = FIND_LFUN(o->prog->inherits[SUBTYPEOF(
Pike_
sp[-1])].prog,
LFUN__IS_TYPE); if( f != -1) { push_static_text(get_name_of_type(run_time_type)); apply_low(o, f, 1);
-
f=!UNSAFE_IS_ZERO(sp-1);
+
f=!UNSAFE_IS_ZERO(
Pike_
sp-1);
pop_stack(); if(f) goto emulated_type_ok; } } break; case T_FUNCTION: /* Check that the function actually is a program. */ if ((run_time_type == T_PROGRAM) &&
-
program_from_function(sp-1)) {
+
program_from_function(
Pike_
sp-1)) {
return; /* No need for further post-processing. */ } break; } Pike_error("Cast failed, wanted %s, got %s\n", get_name_of_type(run_time_type),
-
get_name_of_type(TYPEOF(sp[-1])));
+
get_name_of_type(TYPEOF(
Pike_
sp[-1])));
} emulated_type_ok: if (!type) return; switch(run_time_type) { case T_ARRAY: { struct pike_type *itype; INT32 run_time_itype; push_type_value(itype = index_type(type, int_type_string, 0)); run_time_itype = compile_type_to_runtime_type(itype); if(run_time_itype != T_MIXED) { struct array *a;
-
struct array *tmp=sp[-2].u.array;
+
struct array *tmp=
Pike_
sp[-2].u.array;
DECLARE_CYCLIC(); if((a=(struct array *)BEGIN_CYCLIC(tmp,0))) { ref_push_array(a); }else{ INT32 e; TYPE_FIELD types = 0; #ifdef PIKE_DEBUG
-
struct svalue *save_sp=sp+1;
+
struct svalue *save_sp=
Pike_
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 << TYPEOF(ITEM(a)[e]); } a->type_field = types; #ifdef PIKE_DEBUG
-
if(save_sp!=sp)
+
if(save_sp!=
Pike_
sp)
Pike_fatal("o_cast left stack droppings.\n"); #endif } END_CYCLIC();
-
assign_svalue(sp-3,sp-1);
+
assign_svalue(
Pike_
sp-3,
Pike_
sp-1);
pop_stack(); } pop_stack(); } break; case T_MULTISET: { struct pike_type *itype; INT32 run_time_itype; push_type_value(itype = key_type(type, 0)); run_time_itype = compile_type_to_runtime_type(itype); if(run_time_itype != T_MIXED) { struct multiset *m;
-
struct multiset *tmp=sp[-2].u.multiset;
+
struct multiset *tmp=
Pike_
sp[-2].u.multiset;
DECLARE_CYCLIC(); if((m=(struct multiset *)BEGIN_CYCLIC(tmp,0))) { ref_push_multiset(m); }else{ #ifdef PIKE_DEBUG
-
struct svalue *save_sp=sp+1;
+
struct svalue *save_sp=
Pike_
sp+1;
#endif ptrdiff_t nodepos; push_multiset (m = allocate_multiset (multiset_sizeof (tmp), multiset_get_flags (tmp), multiset_get_cmp_less (tmp))); SET_CYCLIC_RET(m); if ((nodepos = multiset_first (tmp)) >= 0) { ONERROR uwp; SET_ONERROR (uwp, do_sub_msnode_ref, tmp); do { push_multiset_index (tmp, nodepos); o_cast(itype, run_time_itype);
-
multiset_insert (m, sp - 1);
+
multiset_insert (m,
Pike_
sp - 1);
pop_stack(); } while ((nodepos = multiset_next (tmp, nodepos)) >= 0); UNSET_ONERROR (uwp); sub_msnode_ref (tmp); } #ifdef PIKE_DEBUG
-
if(save_sp!=sp)
+
if(save_sp!=
Pike_
sp)
Pike_fatal("o_cast left stack droppings.\n"); #endif } END_CYCLIC();
-
assign_svalue(sp-3,sp-1);
+
assign_svalue(
Pike_
sp-3,
Pike_
sp-1);
pop_stack(); } pop_stack(); } break; case T_MAPPING: { struct pike_type *itype, *vtype; INT32 run_time_itype;
pike.git/src/operators.c:849:
push_type_value(itype = key_type(type, 0)); run_time_itype = compile_type_to_runtime_type(itype); push_type_value(vtype = index_type(type, mixed_type_string, 0)); run_time_vtype = compile_type_to_runtime_type(vtype); if(run_time_itype != T_MIXED || run_time_vtype != T_MIXED) { struct mapping *m;
-
struct mapping *tmp=sp[-3].u.mapping;
+
struct mapping *tmp=
Pike_
sp[-3].u.mapping;
DECLARE_CYCLIC(); if((m=(struct mapping *)BEGIN_CYCLIC(tmp,0))) { ref_push_mapping(m); }else{ INT32 e; struct keypair *k; struct mapping_data *md; #ifdef PIKE_DEBUG
-
struct svalue *save_sp=sp+1;
+
struct svalue *save_sp=
Pike_
sp+1;
#endif push_mapping(m=allocate_mapping(m_sizeof(tmp))); SET_CYCLIC_RET(m); md = tmp->data; NEW_MAPPING_LOOP(md) { push_svalue(& k->ind); o_cast(itype, run_time_itype); push_svalue(& k->val); o_cast(vtype, run_time_vtype);
-
mapping_insert(m,sp-2,sp-1);
+
mapping_insert(m,
Pike_
sp-2,
Pike_
sp-1);
pop_n_elems(2); } #ifdef PIKE_DEBUG
-
if(save_sp!=sp)
+
if(save_sp!=
Pike_
sp)
Pike_fatal("o_cast left stack droppings.\n"); #endif } END_CYCLIC();
-
assign_svalue(sp-4,sp-1);
+
assign_svalue(
Pike_
sp-4,
Pike_
sp-1);
pop_stack(); } pop_n_elems(2); } } } PMOD_EXPORT void f_cast(void) { #ifdef PIKE_DEBUG
-
struct svalue *save_sp=sp;
-
if(TYPEOF(sp[-2]) != T_TYPE)
+
struct svalue *save_sp=
Pike_
sp;
+
if(TYPEOF(
Pike_
sp[-2]) != T_TYPE)
Pike_fatal("Cast expression destroyed stack or left droppings! (Type:%d)\n",
-
TYPEOF(sp[-2]));
+
TYPEOF(
Pike_
sp[-2]));
#endif
-
o_cast(sp[-2].u.type,
-
compile_type_to_runtime_type(sp[-2].u.type));
+
o_cast(
Pike_
sp[-2].u.type,
+
compile_type_to_runtime_type(
Pike_
sp[-2].u.type));
#ifdef PIKE_DEBUG
-
if(save_sp != sp)
+
if(save_sp !=
Pike_
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);
+
free_svalue(
Pike_
sp-2);
+
Pike_
sp[-2]=
Pike_
sp[-1];
+
Pike_
sp--;
+
dmalloc_touch_svalue(
Pike_
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(TYPEOF(*s)) {
pike.git/src/operators.c:1087:
#define COMPARISON(ID,NAME,FUN) \ PMOD_EXPORT void ID(INT32 args) \ { \ int i; \ switch(args) \ { \ case 0: case 1: \ SIMPLE_WRONG_NUM_ARGS_ERROR(NAME, 2); \ case 2: \
-
i=FUN (sp-2,sp-1);
\
+
i=FUN (
Pike_
sp-2,
Pike_
sp-1); \
pop_n_elems(2); \ push_int(i); \ break; \ default: \ for(i=1;i<args;i++) \
-
if(! ( FUN (sp-args+i-1, sp-args+i)))
\
+
if(! ( FUN (
Pike_
sp-args+i-1,
Pike_
sp-args+i))) \
break; \ pop_n_elems(args); \ push_int(i==args); \ } \ } /*! @decl int(0..1) `!=(mixed arg1, mixed arg2, mixed ... extras) *! *! Inequality test. *!
pike.git/src/operators.c:1331:
{ struct pike_string *r; PCHARP buf; ptrdiff_t tmp; int max_shift=0; ptrdiff_t size=0,e; int num=0; for(e=-args;e<0;e++) {
-
if(sp[e].u.string->len != 0) num++;
-
size += sp[e].u.string->len;
-
if(sp[e].u.string->size_shift > max_shift)
-
max_shift=sp[e].u.string->size_shift;
+
if(
Pike_
sp[e].u.string->len != 0) num++;
+
size +=
Pike_
sp[e].u.string->len;
+
if(
Pike_
sp[e].u.string->size_shift > max_shift)
+
max_shift=
Pike_
sp[e].u.string->size_shift;
} /* All strings are empty. */ if(num == 0) { pop_n_elems(args-1); return; } /* Only one string has length. */ if(num == 1) { for(e=-args;e<0;e++) {
-
if( sp[e].u.string->len )
+
if(
Pike_
sp[e].u.string->len )
{ if( e != -args ) {
-
r = sp[e].u.string;
-
sp[e].u.string = sp[-args].u.string;
-
sp[-args].u.string = r;
+
r =
Pike_
sp[e].u.string;
+
Pike_
sp[e].u.string =
Pike_
sp[-args].u.string;
+
Pike_
sp[-args].u.string = r;
} } } pop_n_elems(args-1); return; }
-
tmp=sp[-args].u.string->len;
-
r=new_realloc_shared_string(sp[-args].u.string,size,max_shift);
-
mark_free_svalue (sp - args);
+
tmp=
Pike_
sp[-args].u.string->len;
+
r=new_realloc_shared_string(
Pike_
sp[-args].u.string,size,max_shift);
+
mark_free_svalue (
Pike_
sp - args);
buf=MKPCHARP_STR_OFF(r,tmp); for(e=-args+1;e<0;e++) {
-
if( sp[e].u.string->len )
+
if(
Pike_
sp[e].u.string->len )
{
-
update_flags_for_add( r, sp[e].u.string );
-
pike_string_cpy(buf,sp[e].u.string);
-
INC_PCHARP(buf,sp[e].u.string->len);
-
free_string(sp[e].u.string);
+
update_flags_for_add( r,
Pike_
sp[e].u.string );
+
pike_string_cpy(buf,
Pike_
sp[e].u.string);
+
INC_PCHARP(buf,
Pike_
sp[e].u.string->len);
+
free_string(
Pike_
sp[e].u.string);
} } Pike_sp -= args-1;
-
SET_SVAL(sp[-1], T_STRING, 0, string, low_end_shared_string(r));
+
SET_SVAL(
Pike_
sp[-1], T_STRING, 0, string, low_end_shared_string(r));
} static int pair_add() {
-
if(TYPEOF(sp[-1]) == PIKE_T_OBJECT ||
-
TYPEOF(sp[-2]) == PIKE_T_OBJECT)
+
if(TYPEOF(
Pike_
sp[-1]) == PIKE_T_OBJECT ||
+
TYPEOF(
Pike_
sp[-2]) == PIKE_T_OBJECT)
{
-
if(TYPEOF(sp[-2]) == PIKE_T_OBJECT &&
+
if(TYPEOF(
Pike_
sp[-2]) == PIKE_T_OBJECT &&
/* Note: pairwise add always has an extra reference! */
-
sp[-2].u.object->refs == 2 &&
+
Pike_
sp[-2].u.object->refs == 2 &&
call_lhs_lfun(LFUN_ADD_EQ,2)) return 1; /* optimized version of +. */ if(call_lfun(LFUN_ADD, LFUN_RADD))
-
return !IS_UNDEFINED(sp-1);
+
return !IS_UNDEFINED(
Pike_
sp-1);
}
-
if (TYPEOF(sp[-2]) != TYPEOF(sp[-1]))
+
if (TYPEOF(
Pike_
sp[-2]) != TYPEOF(
Pike_
sp[-1]))
{
-
if(IS_UNDEFINED(sp-2))
+
if(IS_UNDEFINED(
Pike_
sp-2))
{ stack_swap(); pop_stack(); return 1; }
-
if(IS_UNDEFINED(sp-1))
+
if(IS_UNDEFINED(
Pike_
sp-1))
{ pop_stack(); return 1; } /* string + X && X + string -> string */ if( TYPEOF(Pike_sp[-2]) == PIKE_T_STRING ) o_cast_to_string(); else if( TYPEOF(Pike_sp[-1]) == PIKE_T_STRING ) {
pike.git/src/operators.c:1436:
} else if( TYPEOF(Pike_sp[-1]) == PIKE_T_FLOAT ) { if( TYPEOF(Pike_sp[-2]) == PIKE_T_INT ) { Pike_sp[-2].u.float_number = Pike_sp[-2].u.integer; TYPEOF(Pike_sp[-2]) = PIKE_T_FLOAT; } }
-
if (TYPEOF(sp[-2]) != TYPEOF(sp[-1]))
+
if (TYPEOF(
Pike_
sp[-2]) != TYPEOF(
Pike_
sp[-1]))
return 0; } /* types now identical. */
-
switch(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ /* Note: these cases mainly tend to happen when there is an object in the argument list. otherwise pairwise addition is not done using this code. */ case PIKE_T_INT: { INT_TYPE res;
-
if (DO_INT_TYPE_ADD_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer, &res))
+
if (DO_INT_TYPE_ADD_OVERFLOW(
Pike_
sp[-2].u.integer,
Pike_
sp[-1].u.integer, &res))
{
-
convert_svalue_to_bignum(sp-2);
+
convert_svalue_to_bignum(
Pike_
sp-2);
call_lfun(LFUN_ADD,LFUN_RADD); return 1; }
-
sp[-2].u.integer = res;
-
sp--;
+
Pike_
sp[-2].u.integer = res;
+
Pike_
sp--;
} return 1; case PIKE_T_FLOAT:
-
sp[-2].u.float_number += sp[-1].u.float_number;
-
sp--;
+
Pike_
sp[-2].u.float_number +=
Pike_
sp[-1].u.float_number;
+
Pike_
sp--;
return 1; case PIKE_T_STRING: Pike_sp[-2].u.string = add_and_free_shared_strings(Pike_sp[-2].u.string, Pike_sp[-1].u.string); Pike_sp--; return 1; case PIKE_T_ARRAY:
-
push_array( add_arrays(sp-2,2) );
+
push_array( add_arrays(
Pike_
sp-2,2) );
stack_swap(); pop_stack(); stack_swap(); pop_stack(); return 1; case PIKE_T_MAPPING:
-
push_mapping( add_mappings(sp-2,2) );
+
push_mapping( add_mappings(
Pike_
sp-2,2) );
stack_swap(); pop_stack(); stack_swap(); pop_stack(); return 1; case PIKE_T_MULTISET:
-
push_multiset( add_multisets(sp-2,2) );
+
push_multiset( add_multisets(
Pike_
sp-2,2) );
stack_swap(); pop_stack(); stack_swap(); pop_stack(); return 1; case PIKE_T_OBJECT: return call_lfun(LFUN_ADD,LFUN_RADD); } return 0; } /*! @decl mixed `+(mixed arg)
pike.git/src/operators.c:1576:
PMOD_EXPORT void f_add(INT32 args) { INT_TYPE e; TYPE_FIELD types=0; if(!args) SIMPLE_WRONG_NUM_ARGS_ERROR("`+", 1); if (args == 1) return;
-
for(e=-args;e<0;e++) types |= 1<<TYPEOF(sp[e]);
+
for(e=-args;e<0;e++) types |= 1<<TYPEOF(
Pike_
sp[e]);
switch(types) { default: pairwise_add: {
-
struct svalue *s=sp-args;
+
struct svalue *s=
Pike_
sp-args;
push_svalue(s); for(e=1;e<args;e++) { push_svalue(s+e); if(!pair_add()) { Pike_error("Addition on unsupported types: %s + %s\nm", get_name_of_type(TYPEOF(*(s+e))), get_name_of_type(TYPEOF(*s))); } }
-
assign_svalue(s,sp-1);
-
pop_n_elems(sp-s-1);
+
assign_svalue(s,
Pike_
sp-1);
+
pop_n_elems(
Pike_
sp-s-1);
return; } case BIT_STRING: add_strings(args); return; case BIT_STRING | BIT_INT: case BIT_STRING | BIT_FLOAT: case BIT_STRING | BIT_FLOAT | BIT_INT:
-
if ((TYPEOF(sp[-args]) != T_STRING) && (TYPEOF(sp[1-args]) != T_STRING))
+
if ((TYPEOF(
Pike_
sp[-args]) != T_STRING) && (TYPEOF(
Pike_
sp[1-args]) != T_STRING))
{ /* Note: Could easily use pairwise add until at first string. */ goto pairwise_add; } for(e=-args;e<0;e++) {
-
if( TYPEOF(sp[e]) != PIKE_T_STRING )
+
if( TYPEOF(
Pike_
sp[e]) != PIKE_T_STRING )
{
-
*Pike_sp = sp[e];
+
*Pike_sp =
Pike_
sp[e];
Pike_sp++;
-
o_cast_to_string(); /* free:s old sp[e] */
-
sp[e-1] = Pike_sp[-1];
+
o_cast_to_string(); /* free:s old
Pike_
sp[e] */
+
Pike_
sp[e-1] = Pike_sp[-1];
Pike_sp--; } } add_strings(args); return; case BIT_INT: {
-
INT_TYPE size = sp[-args].u.integer;
+
INT_TYPE size =
Pike_
sp[-args].u.integer;
for(e = -args+1; e < 0; e++) {
-
if (DO_INT_TYPE_ADD_OVERFLOW(size, sp[e].u.integer, &size))
+
if (DO_INT_TYPE_ADD_OVERFLOW(size,
Pike_
sp[e].u.integer, &size))
{
-
convert_svalue_to_bignum(sp-args);
+
convert_svalue_to_bignum(
Pike_
sp-args);
f_add(args); return; } }
-
sp-=args;
+
Pike_
sp-=args;
push_int(size); break; } case BIT_FLOAT: { double res = Pike_sp[-args].u.float_number; for(e=args-1; e>0; e-- )
-
res += sp[-e].u.float_number;
+
res +=
Pike_
sp[-e].u.float_number;
Pike_sp -= args-1; Pike_sp[-1].u.float_number = res; } break; case BIT_FLOAT|BIT_INT: { double res = 0.0; for(int i=0;i<args;i++)
-
if (TYPEOF(sp[i-args]) == T_FLOAT)
+
if (TYPEOF(
Pike_
sp[i-args]) == T_FLOAT)
res += Pike_sp[i-args].u.float_number; else res += (double)Pike_sp[i-args].u.integer; Pike_sp-=args; push_float(res); return; } #define ADD(TYPE, ADD_FUNC, PUSH_FUNC) do { \
-
struct TYPE *x = ADD_FUNC (sp - args, args);
\
+
struct TYPE *x = ADD_FUNC (
Pike_
sp - args, args); \
pop_n_elems (args); \ PUSH_FUNC (x); \ return; \ } while (0) #define REMOVE_UNDEFINED(TYPE) \ do { \ int to = -args, i=-args; \ for(; i<0; i++) \ { \
pike.git/src/operators.c:2059:
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(TYPEOF(sp[-2]) == T_INT && TYPEOF(sp[-1]) == T_FLOAT)
+
if(TYPEOF(
Pike_
sp[-2]) == T_INT && TYPEOF(
Pike_
sp[-1]) == T_FLOAT)
{
-
SET_SVAL(sp[-2], T_FLOAT, 0, float_number, (FLOAT_TYPE)sp[-2].u.integer);
+
SET_SVAL(
Pike_
sp[-2], T_FLOAT, 0, float_number, (FLOAT_TYPE)
Pike_
sp[-2].u.integer);
return 1; }
-
else if(TYPEOF(sp[-1]) == T_INT && TYPEOF(sp[-2]) == T_FLOAT)
+
else if(TYPEOF(
Pike_
sp[-1]) == T_INT && TYPEOF(
Pike_
sp[-2]) == T_FLOAT)
{
-
SET_SVAL(sp[-1], T_FLOAT, 0, float_number, (FLOAT_TYPE)sp[-1].u.integer);
+
SET_SVAL(
Pike_
sp[-1], T_FLOAT, 0, float_number, (FLOAT_TYPE)
Pike_
sp[-1].u.integer);
return 1; }
-
if(is_bignum_object_in_svalue(sp-2) && TYPEOF(sp[-1]) == T_FLOAT)
+
if(is_bignum_object_in_svalue(
Pike_
sp-2) && TYPEOF(
Pike_
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) && TYPEOF(sp[-2]) == T_FLOAT)
+
else if(is_bignum_object_in_svalue(
Pike_
sp-1) && TYPEOF(
Pike_
sp[-2]) == T_FLOAT)
{ ref_push_type_value(float_type_string); stack_swap(); f_cast(); return 1; } return 0; } static int has_lfun(enum LFUN lfun, int arg) { struct program *p;
-
if(TYPEOF(sp[-arg]) == T_OBJECT && (p = sp[-arg].u.object->prog))
-
return FIND_LFUN(p->inherits[SUBTYPEOF(sp[-arg])].prog, lfun);
+
if(TYPEOF(
Pike_
sp[-arg]) == T_OBJECT && (p =
Pike_
sp[-arg].u.object->prog))
+
return FIND_LFUN(p->inherits[SUBTYPEOF(
Pike_
sp[-arg])].prog, lfun);
return -1; } static int call_lhs_lfun( enum LFUN lfun, int arg ) { int i = has_lfun(lfun,arg); if(i != -1) { apply_low(Pike_sp[-arg].u.object, i, arg-1);
pike.git/src/operators.c:2117:
} return 0; } static int call_lfun(enum LFUN left, enum LFUN right) { struct object *o; struct program *p; int i;
-
if(TYPEOF(sp[-2]) == T_OBJECT &&
-
(p = (o = sp[-2].u.object)->prog) &&
-
(i = FIND_LFUN(p->inherits[SUBTYPEOF(sp[-2])].prog, left)) != -1)
+
if(TYPEOF(
Pike_
sp[-2]) == T_OBJECT &&
+
(p = (o =
Pike_
sp[-2].u.object)->prog) &&
+
(i = FIND_LFUN(p->inherits[SUBTYPEOF(
Pike_
sp[-2])].prog, left)) != -1)
{ apply_low(o, i, 1);
-
free_svalue(sp-2);
-
sp[-2]=sp[-1];
-
sp--;
-
dmalloc_touch_svalue(sp);
+
free_svalue(
Pike_
sp-2);
+
Pike_
sp[-2]=
Pike_
sp[-1];
+
Pike_
sp--;
+
dmalloc_touch_svalue(
Pike_
sp);
return 1; }
-
if(TYPEOF(sp[-1]) == T_OBJECT &&
-
(p = (o = sp[-1].u.object)->prog) &&
-
(i = FIND_LFUN(p->inherits[SUBTYPEOF(sp[-1])].prog, right)) != -1)
+
if(TYPEOF(
Pike_
sp[-1]) == T_OBJECT &&
+
(p = (o =
Pike_
sp[-1].u.object)->prog) &&
+
(i = FIND_LFUN(p->inherits[SUBTYPEOF(
Pike_
sp[-1])].prog, right)) != -1)
{
-
push_svalue(sp-2);
+
push_svalue(
Pike_
sp-2);
apply_low(o, i, 1);
-
free_svalue(sp-3);
-
sp[-3]=sp[-1];
-
sp--;
-
dmalloc_touch_svalue(sp);
+
free_svalue(
Pike_
sp-3);
+
Pike_
sp[-3]=
Pike_
sp[-1];
+
Pike_
sp--;
+
dmalloc_touch_svalue(
Pike_
sp);
pop_stack(); return 1; } 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 (TYPEOF(sp[-2]) != TYPEOF(sp[-1]) && !float_promote())
+
if (TYPEOF(
Pike_
sp[-2]) != TYPEOF(
Pike_
sp[-1]) && !float_promote())
{ if(call_lfun(LFUN_SUBTRACT, LFUN_RSUBTRACT)) return;
-
if (TYPEOF(sp[-2]) == T_MAPPING)
-
switch (TYPEOF(sp[-1]))
+
if (TYPEOF(
Pike_
sp[-2]) == T_MAPPING)
+
switch (TYPEOF(
Pike_
sp[-1]))
{ case T_ARRAY: { struct mapping *m;
-
m=merge_mapping_array_unordered(sp[-2].u.mapping,
-
sp[-1].u.array,
+
m=merge_mapping_array_unordered(
Pike_
sp[-2].u.mapping,
+
Pike_
sp[-1].u.array,
PIKE_ARRAY_OP_SUB); pop_n_elems(2); push_mapping(m); return; } case T_MULTISET: { struct mapping *m;
-
int got_cmp_less = !!multiset_get_cmp_less (sp[-1].u.multiset);
-
struct array *ind = multiset_indices (sp[-1].u.multiset);
+
int got_cmp_less = !!multiset_get_cmp_less (
Pike_
sp[-1].u.multiset);
+
struct array *ind = multiset_indices (
Pike_
sp[-1].u.multiset);
pop_stack(); push_array (ind); if (got_cmp_less)
-
m=merge_mapping_array_unordered(sp[-2].u.mapping,
-
sp[-1].u.array,
+
m=merge_mapping_array_unordered(
Pike_
sp[-2].u.mapping,
+
Pike_
sp[-1].u.array,
PIKE_ARRAY_OP_SUB); else
-
m=merge_mapping_array_ordered(sp[-2].u.mapping,
-
sp[-1].u.array,
+
m=merge_mapping_array_ordered(
Pike_
sp[-2].u.mapping,
+
Pike_
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(TYPEOF(sp[-2])),
-
sp-1, "Subtract on different types.\n");
+
bad_arg_error("`-",
Pike_
sp-2, 2, 2, get_name_of_type(TYPEOF(
Pike_
sp[-2])),
+
Pike_
sp-1, "Subtract on different types.\n");
}
-
switch(TYPEOF(sp[-2]))
+
switch(TYPEOF(
Pike_
sp[-2]))
{ case T_OBJECT: if(!call_lfun(LFUN_SUBTRACT, LFUN_RSUBTRACT))
-
PIKE_ERROR("`-", "Subtract on objects without `- operator.\n", sp, 2);
+
PIKE_ERROR("`-", "Subtract on objects without `- operator.\n",
Pike_
sp, 2);
return; case T_ARRAY: { struct array *a;
-
check_array_for_destruct(sp[-2].u.array);
-
check_array_for_destruct(sp[-1].u.array);
-
a = subtract_arrays(sp[-2].u.array, sp[-1].u.array);
+
check_array_for_destruct(
Pike_
sp[-2].u.array);
+
check_array_for_destruct(
Pike_
sp[-1].u.array);
+
a = subtract_arrays(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.array);
pop_n_elems(2); push_array(a); return; } case T_MAPPING: { struct mapping *m;
-
m=merge_mappings(sp[-2].u.mapping, sp[-1].u.mapping,PIKE_ARRAY_OP_SUB);
+
m=merge_mappings(
Pike_
sp[-2].u.mapping,
Pike_
sp[-1].u.mapping,PIKE_ARRAY_OP_SUB);
pop_n_elems(2); push_mapping(m); return; } case T_MULTISET: { struct multiset *l;
-
l=merge_multisets(sp[-2].u.multiset, sp[-1].u.multiset,
+
l=merge_multisets(
Pike_
sp[-2].u.multiset,
Pike_
sp[-1].u.multiset,
PIKE_ARRAY_OP_SUB); pop_n_elems(2); push_multiset(l); return; } case T_FLOAT:
-
sp--;
-
sp[-1].u.float_number -= sp[0].u.float_number;
+
Pike_
sp--;
+
Pike_
sp[-1].u.float_number -=
Pike_
sp[0].u.float_number;
return; case T_INT:
-
if(INT_TYPE_SUB_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer))
+
if(INT_TYPE_SUB_OVERFLOW(
Pike_
sp[-2].u.integer,
Pike_
sp[-1].u.integer))
{ convert_stack_top_to_bignum(); call_lfun(LFUN_SUBTRACT, LFUN_RSUBTRACT); return; }
-
sp--;
-
SET_SVAL(sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer,
-
sp[-1].u.integer - sp[0].u.integer);
+
Pike_
sp--;
+
SET_SVAL(
Pike_
sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer,
+
Pike_
sp[-1].u.integer -
Pike_
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);
+
ret=string_replace(
Pike_
sp[-2].u.string,
Pike_
sp[-1].u.string,s);
+
free_string(
Pike_
sp[-2].u.string);
+
free_string(
Pike_
sp[-1].u.string);
free_string(s);
-
sp[-2].u.string=ret;
-
sp--;
+
Pike_
sp[-2].u.string=ret;
+
Pike_
sp--;
return; } /* FIXME: Support types? */ default: { int args = 2; SIMPLE_ARG_TYPE_ERROR("`-", 1, "int|float|string|mapping|multiset|array|object");
pike.git/src/operators.c:2350:
{ switch(args) { case 0: SIMPLE_WRONG_NUM_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;
+
struct svalue *s=
Pike_
sp-args;
-
for(e=-args;e<0;e++) types |= 1<<TYPEOF(sp[e]);
+
for(e=-args;e<0;e++) types |= 1<<TYPEOF(
Pike_
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++) {
pike.git/src/operators.c:2390:
f_add(args); break; } push_svalue(s); for(e=1;e<args;e++) { push_svalue(s+e); o_subtract(); }
-
assign_svalue(s,sp-1);
-
pop_n_elems(sp-s-1);
+
assign_svalue(s,
Pike_
sp-1);
+
pop_n_elems(
Pike_
sp-s-1);
} } } static int generate_minus(node *n) { struct compilation *c = THIS_COMPILATION; switch(count_args(CDR(n))) { case 1:
pike.git/src/operators.c:2417:
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(UNLIKELY(TYPEOF(sp[-1]) != TYPEOF(sp[-2])))
+
if(UNLIKELY(TYPEOF(
Pike_
sp[-1]) != TYPEOF(
Pike_
sp[-2])))
{ if(call_lfun(LFUN_AND, LFUN_RAND)) return;
-
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)))
+
else if (((TYPEOF(
Pike_
sp[-1]) == T_TYPE) || (TYPEOF(
Pike_
sp[-1]) == T_PROGRAM) ||
+
(TYPEOF(
Pike_
sp[-1]) == T_FUNCTION)) &&
+
((TYPEOF(
Pike_
sp[-2]) == T_TYPE) || (TYPEOF(
Pike_
sp[-2]) == T_PROGRAM) ||
+
(TYPEOF(
Pike_
sp[-2]) == T_FUNCTION)))
{
-
if (TYPEOF(sp[-2]) != T_TYPE)
+
if (TYPEOF(
Pike_
sp[-2]) != T_TYPE)
{
-
struct program *p = program_from_svalue(sp - 2);
+
struct program *p = program_from_svalue(
Pike_
sp - 2);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`&", 1, "type"); } type_stack_mark(); push_object_type(0, p->id);
-
free_svalue(sp - 2);
-
SET_SVAL(sp[-2], T_TYPE, 0, type, pop_unfinished_type());
+
free_svalue(
Pike_
sp - 2);
+
SET_SVAL(
Pike_
sp[-2], T_TYPE, 0, type, pop_unfinished_type());
}
-
if (TYPEOF(sp[-1]) != T_TYPE)
+
if (TYPEOF(
Pike_
sp[-1]) != T_TYPE)
{
-
struct program *p = program_from_svalue(sp - 1);
+
struct program *p = program_from_svalue(
Pike_
sp - 1);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`&", 2, "type"); } type_stack_mark(); push_object_type(0, p->id);
-
free_svalue(sp - 1);
-
SET_SVAL(sp[-1], T_TYPE, 0, type, pop_unfinished_type());
+
free_svalue(
Pike_
sp - 1);
+
SET_SVAL(
Pike_
sp[-1], T_TYPE, 0, type, pop_unfinished_type());
} }
-
else if (TYPEOF(sp[-2]) == T_MAPPING)
-
switch (TYPEOF(sp[-1]))
+
else if (TYPEOF(
Pike_
sp[-2]) == T_MAPPING)
+
switch (TYPEOF(
Pike_
sp[-1]))
{ case T_ARRAY: { struct mapping *m;
-
m=merge_mapping_array_unordered(sp[-2].u.mapping,
-
sp[-1].u.array,
+
m=merge_mapping_array_unordered(
Pike_
sp[-2].u.mapping,
+
Pike_
sp[-1].u.array,
PIKE_ARRAY_OP_AND); pop_n_elems(2); push_mapping(m); return; } case T_MULTISET: { struct mapping *m;
-
int got_cmp_less = !!multiset_get_cmp_less (sp[-1].u.multiset);
-
struct array *ind = multiset_indices (sp[-1].u.multiset);
+
int got_cmp_less = !!multiset_get_cmp_less (
Pike_
sp[-1].u.multiset);
+
struct array *ind = multiset_indices (
Pike_
sp[-1].u.multiset);
pop_stack(); push_array (ind); if (got_cmp_less)
-
m=merge_mapping_array_unordered(sp[-2].u.mapping,
-
sp[-1].u.array,
+
m=merge_mapping_array_unordered(
Pike_
sp[-2].u.mapping,
+
Pike_
sp[-1].u.array,
PIKE_ARRAY_OP_AND); else
-
m=merge_mapping_array_ordered(sp[-2].u.mapping,
-
sp[-1].u.array,
+
m=merge_mapping_array_ordered(
Pike_
sp[-2].u.mapping,
+
Pike_
sp[-1].u.array,
PIKE_ARRAY_OP_AND); pop_n_elems(2); push_mapping(m); return; } default: { int args = 2; SIMPLE_ARG_TYPE_ERROR("`&", 2, "mapping"); } } else { int args = 2;
-
SIMPLE_ARG_TYPE_ERROR("`&", 2, get_name_of_type(TYPEOF(sp[-2])));
+
SIMPLE_ARG_TYPE_ERROR("`&", 2, get_name_of_type(TYPEOF(
Pike_
sp[-2])));
} }
-
switch(TYPEOF(sp[-2]))
+
switch(TYPEOF(
Pike_
sp[-2]))
{ case T_OBJECT: if(!call_lfun(LFUN_AND,LFUN_RAND))
-
PIKE_ERROR("`&", "Bitwise and on objects without `& operator.\n", sp, 2);
+
PIKE_ERROR("`&", "Bitwise and on objects without `& operator.\n",
Pike_
sp, 2);
return; case T_INT:
-
sp--;
-
SET_SVAL(sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer,
-
sp[-1].u.integer & sp[0].u.integer);
+
Pike_
sp--;
+
SET_SVAL(
Pike_
sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer,
+
Pike_
sp[-1].u.integer &
Pike_
sp[0].u.integer);
return; case T_MAPPING: { struct mapping *m;
-
m=merge_mappings(sp[-2].u.mapping, sp[-1].u.mapping, PIKE_ARRAY_OP_AND);
+
m=merge_mappings(
Pike_
sp[-2].u.mapping,
Pike_
sp[-1].u.mapping, PIKE_ARRAY_OP_AND);
pop_n_elems(2); push_mapping(m); return; } case T_MULTISET: { struct multiset *l;
-
l=merge_multisets(sp[-2].u.multiset, sp[-1].u.multiset,
+
l=merge_multisets(
Pike_
sp[-2].u.multiset,
Pike_
sp[-1].u.multiset,
PIKE_ARRAY_OP_AND); pop_n_elems(2); push_multiset(l); return; } case T_ARRAY: { struct array *a;
-
a=and_arrays(sp[-2].u.array, sp[-1].u.array);
+
a=and_arrays(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.array);
pop_n_elems(2); push_array(a); return; } case T_TYPE: { struct pike_type *t;
-
t = and_pike_types(sp[-2].u.type, sp[-1].u.type);
+
t = and_pike_types(
Pike_
sp[-2].u.type,
Pike_
sp[-1].u.type);
pop_n_elems(2); push_type_value(t); return; } case T_FUNCTION: case T_PROGRAM: { struct program *p; struct pike_type *a; struct pike_type *b; struct pike_type *t;
-
p = program_from_svalue(sp - 2);
+
p = program_from_svalue(
Pike_
sp - 2);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`&", 1, "type"); } type_stack_mark(); push_object_type(0, p->id); a = pop_unfinished_type();
-
p = program_from_svalue(sp - 1);
+
p = program_from_svalue(
Pike_
sp - 1);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`&", 2, "type"); } type_stack_mark(); push_object_type(0, p->id); b = pop_unfinished_type(); t = and_pike_types(a, b);
pike.git/src/operators.c:2590:
free_type(b); return; } #define STRING_BITOP(OP,STROP) \ case T_STRING: \ { \ struct pike_string *s; \ ptrdiff_t len, i; \ \
-
len = sp[-2].u.string->len;
\
-
if (len != sp[-1].u.string->len)
\
-
PIKE_ERROR("`" #OP, "Bitwise "STROP \
-
" on strings of different lengths.\n", sp, 2);
\
-
if(!sp[-2].u.string->size_shift && !sp[-1].u.string->size_shift)
\
+
len =
Pike_
sp[-2].u.string->len; \
+
if (len !=
Pike_
sp[-1].u.string->len) \
+
PIKE_ERROR("`" #OP, "Bitwise "STROP \
+
" on strings of different lengths.\n",
Pike_
sp, 2); \
+
if(!
Pike_
sp[-2].u.string->size_shift && !
Pike_
sp[-1].u.string->size_shift) \
{ \ s = begin_shared_string(len); \ for (i=0; i<len; i++) \
-
s->str[i] = sp[-2].u.string->str[i] OP sp[-1].u.string->str[i];
\
+
s->str[i] =
Pike_
sp[-2].u.string->str[i] OP
Pike_
sp[-1].u.string->str[i]; \
}else{ \ s = begin_wide_shared_string(len, \
-
MAXIMUM(sp[-2].u.string->size_shift,
\
-
sp[-1].u.string->size_shift)); \
+
MAXIMUM(
Pike_
sp[-2].u.string->size_shift, \
+
Pike_
sp[-1].u.string->size_shift)); \
for (i=0; i<len; i++) \
-
low_set_index(s,i,index_shared_string(sp[-2].u.string,i) OP
\
-
index_shared_string(sp[-1].u.string,i));
\
+
low_set_index(s,i,index_shared_string(
Pike_
sp[-2].u.string,i) OP \
+
index_shared_string(
Pike_
sp[-1].u.string,i)); \
} \ pop_n_elems(2); \ push_string(end_shared_string(s)); \ return; \ } STRING_BITOP(&,"AND") default:
-
PIKE_ERROR("`&", "Bitwise AND on illegal type.\n", sp, 2);
+
PIKE_ERROR("`&", "Bitwise AND on illegal type.\n",
Pike_
sp, 2);
} } /* This function is used to speed up or/xor/and on * arrays multisets and mappings. This is done by * calling the operator for each pair of arguments * first, then recursively doing the same on the * results until only one value remains. */ static void r_speedup(INT32 args, void (*func)(void))
pike.git/src/operators.c:2639:
switch(args) { case 3: func(); case 2: func(); case 1: return; default: r_speedup((args+1)>>1,func); dmalloc_touch_svalue(Pike_sp-1);
-
tmp=*--sp;
+
tmp=*--
Pike_
sp;
SET_ONERROR(err,do_free_svalue,&tmp); r_speedup(args>>1,func); UNSET_ONERROR(err);
-
sp++[0]=tmp;
+
Pike_
sp++[0]=tmp;
func(); } } static void speedup(INT32 args, void (*func)(void)) {
-
switch(TYPEOF(sp[-args]))
+
switch(TYPEOF(
Pike_
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:2752:
modify_stack_depth(-1); return 1; default: return 0; } } PMOD_EXPORT void o_or(void) {
-
if(TYPEOF(sp[-1]) != TYPEOF(sp[-2]))
+
if(TYPEOF(
Pike_
sp[-1]) != TYPEOF(
Pike_
sp[-2]))
{ if(call_lfun(LFUN_OR, LFUN_ROR)) { return;
-
} 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);
+
} else if (((TYPEOF(
Pike_
sp[-1]) == T_TYPE) ||
+
(TYPEOF(
Pike_
sp[-1]) == T_PROGRAM) ||
+
(TYPEOF(
Pike_
sp[-1]) == T_FUNCTION)) &&
+
((TYPEOF(
Pike_
sp[-2]) == T_TYPE) ||
+
(TYPEOF(
Pike_
sp[-2]) == T_PROGRAM) ||
+
(TYPEOF(
Pike_
sp[-2]) == T_FUNCTION))) {
+
if (TYPEOF(
Pike_
sp[-2]) != T_TYPE) {
+
struct program *p = program_from_svalue(
Pike_
sp - 2);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`|", 1, "type"); } type_stack_mark(); push_object_type(0, p->id);
-
free_svalue(sp - 2);
-
SET_SVAL(sp[-2], T_TYPE, 0, type, pop_unfinished_type());
+
free_svalue(
Pike_
sp - 2);
+
SET_SVAL(
Pike_
sp[-2], T_TYPE, 0, type, pop_unfinished_type());
}
-
if (TYPEOF(sp[-1]) != T_TYPE) {
-
struct program *p = program_from_svalue(sp - 1);
+
if (TYPEOF(
Pike_
sp[-1]) != T_TYPE) {
+
struct program *p = program_from_svalue(
Pike_
sp - 1);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`|", 2, "type"); } type_stack_mark(); push_object_type(0, p->id);
-
free_svalue(sp - 1);
-
SET_SVAL(sp[-1], T_TYPE, 0, type, pop_unfinished_type());
+
free_svalue(
Pike_
sp - 1);
+
SET_SVAL(
Pike_
sp[-1], T_TYPE, 0, type, pop_unfinished_type());
} } else { int args = 2;
-
SIMPLE_ARG_TYPE_ERROR("`|", 2, get_name_of_type(TYPEOF(sp[-2])));
+
SIMPLE_ARG_TYPE_ERROR("`|", 2, get_name_of_type(TYPEOF(
Pike_
sp[-2])));
} }
-
switch(TYPEOF(sp[-2]))
+
switch(TYPEOF(
Pike_
sp[-2]))
{ case T_OBJECT: if(!call_lfun(LFUN_OR,LFUN_ROR))
-
PIKE_ERROR("`|", "Bitwise or on objects without `| operator.\n", sp, 2);
+
PIKE_ERROR("`|", "Bitwise or on objects without `| operator.\n",
Pike_
sp, 2);
return; case T_INT:
-
sp--;
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
-
sp[-1].u.integer | sp[0].u.integer);
+
Pike_
sp--;
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer,
+
Pike_
sp[-1].u.integer |
Pike_
sp[0].u.integer);
return; case T_MAPPING: { struct mapping *m;
-
m=merge_mappings(sp[-2].u.mapping, sp[-1].u.mapping, PIKE_ARRAY_OP_OR);
+
m=merge_mappings(
Pike_
sp[-2].u.mapping,
Pike_
sp[-1].u.mapping, PIKE_ARRAY_OP_OR);
pop_n_elems(2); push_mapping(m); return; } case T_MULTISET: { struct multiset *l;
-
l=merge_multisets(sp[-2].u.multiset, sp[-1].u.multiset,
+
l=merge_multisets(
Pike_
sp[-2].u.multiset,
Pike_
sp[-1].u.multiset,
PIKE_ARRAY_OP_OR_LEFT); pop_n_elems(2); push_multiset(l); return; } case T_ARRAY: {
-
if (sp[-1].u.array->size == 1) {
+
if (
Pike_
sp[-1].u.array->size == 1) {
/* Common case (typically the |= operator). */
-
int i = array_search(sp[-2].u.array, sp[-1].u.array->item, 0);
+
int i = array_search(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.array->item, 0);
if (i == -1) { f_add(2); } else { pop_stack(); }
-
} else if ((sp[-2].u.array == sp[-1].u.array) &&
-
(sp[-1].u.array->refs == 2)) {
+
} else if ((
Pike_
sp[-2].u.array ==
Pike_
sp[-1].u.array) &&
+
(
Pike_
sp[-1].u.array->refs == 2)) {
/* Not common, but easy to detect... */ pop_stack(); } else { struct array *a;
-
a=merge_array_with_order(sp[-2].u.array, sp[-1].u.array,
+
a=merge_array_with_order(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.array,
PIKE_ARRAY_OP_OR_LEFT); pop_n_elems(2); push_array(a); } return; } case T_TYPE: { struct pike_type *t;
-
t = or_pike_types(sp[-2].u.type, sp[-1].u.type, 0);
+
t = or_pike_types(
Pike_
sp[-2].u.type,
Pike_
sp[-1].u.type, 0);
pop_n_elems(2); push_type_value(t); return; } case T_FUNCTION: case T_PROGRAM: { struct program *p; struct pike_type *a; struct pike_type *b; struct pike_type *t;
-
p = program_from_svalue(sp - 2);
+
p = program_from_svalue(
Pike_
sp - 2);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`|", 1, "type"); } type_stack_mark(); push_object_type(0, p->id); a = pop_unfinished_type();
-
p = program_from_svalue(sp - 1);
+
p = program_from_svalue(
Pike_
sp - 1);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`|", 2, "type"); } type_stack_mark(); push_object_type(0, p->id); b = pop_unfinished_type(); t = or_pike_types(a, b, 0); pop_n_elems(2); push_type_value(t); free_type(a); free_type(b); return; } STRING_BITOP(|,"OR") default:
-
PIKE_ERROR("`|", "Bitwise OR on illegal type.\n", sp, 2);
+
PIKE_ERROR("`|", "Bitwise OR on illegal type.\n",
Pike_
sp, 2);
} } /*! @decl mixed `|(mixed arg1) *! @decl mixed `|(mixed arg1, mixed arg2, mixed ... extras) *! @decl mixed `|(object arg1, mixed arg2) *! @decl mixed `|(mixed arg1, object arg2) *! @decl int `|(int arg1, int arg2) *! @decl string `|(string arg1, string arg2) *! @decl array `|(array arg1, array arg2)
pike.git/src/operators.c:2999:
return 1; default: return 0; } } PMOD_EXPORT void o_xor(void) {
-
if(TYPEOF(sp[-1]) != TYPEOF(sp[-2]))
+
if(TYPEOF(
Pike_
sp[-1]) != TYPEOF(
Pike_
sp[-2]))
{ if(call_lfun(LFUN_XOR, LFUN_RXOR)) { return;
-
} 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);
+
} else if (((TYPEOF(
Pike_
sp[-1]) == T_TYPE) ||
+
(TYPEOF(
Pike_
sp[-1]) == T_PROGRAM) ||
+
(TYPEOF(
Pike_
sp[-1]) == T_FUNCTION)) &&
+
((TYPEOF(
Pike_
sp[-2]) == T_TYPE) ||
+
(TYPEOF(
Pike_
sp[-2]) == T_PROGRAM) ||
+
(TYPEOF(
Pike_
sp[-2]) == T_FUNCTION))) {
+
if (TYPEOF(
Pike_
sp[-2]) != T_TYPE) {
+
struct program *p = program_from_svalue(
Pike_
sp - 2);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`^", 1, "type"); } type_stack_mark(); push_object_type(0, p->id);
-
free_svalue(sp - 2);
-
SET_SVAL(sp[-2], T_TYPE, 0, type, pop_unfinished_type());
+
free_svalue(
Pike_
sp - 2);
+
SET_SVAL(
Pike_
sp[-2], T_TYPE, 0, type, pop_unfinished_type());
}
-
if (TYPEOF(sp[-1]) != T_TYPE) {
-
struct program *p = program_from_svalue(sp - 1);
+
if (TYPEOF(
Pike_
sp[-1]) != T_TYPE) {
+
struct program *p = program_from_svalue(
Pike_
sp - 1);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`^", 2, "type"); } type_stack_mark(); push_object_type(0, p->id);
-
free_svalue(sp - 1);
-
SET_SVAL(sp[-1], T_TYPE, 0, type, pop_unfinished_type());
+
free_svalue(
Pike_
sp - 1);
+
SET_SVAL(
Pike_
sp[-1], T_TYPE, 0, type, pop_unfinished_type());
} } else { int args = 2;
-
SIMPLE_ARG_TYPE_ERROR("`^", 2, get_name_of_type(TYPEOF(sp[-2])));
+
SIMPLE_ARG_TYPE_ERROR("`^", 2, get_name_of_type(TYPEOF(
Pike_
sp[-2])));
} }
-
switch(TYPEOF(sp[-2]))
+
switch(TYPEOF(
Pike_
sp[-2]))
{ case T_OBJECT: if(!call_lfun(LFUN_XOR,LFUN_RXOR))
-
PIKE_ERROR("`^", "Bitwise xor on objects without `^ operator.\n", sp, 2);
+
PIKE_ERROR("`^", "Bitwise xor on objects without `^ operator.\n",
Pike_
sp, 2);
return; case T_INT:
-
sp--;
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
-
sp[-1].u.integer ^ sp[0].u.integer);
+
Pike_
sp--;
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer,
+
Pike_
sp[-1].u.integer ^
Pike_
sp[0].u.integer);
return; case T_MAPPING: { struct mapping *m;
-
m=merge_mappings(sp[-2].u.mapping, sp[-1].u.mapping, PIKE_ARRAY_OP_XOR);
+
m=merge_mappings(
Pike_
sp[-2].u.mapping,
Pike_
sp[-1].u.mapping, PIKE_ARRAY_OP_XOR);
pop_n_elems(2); push_mapping(m); return; } case T_MULTISET: { struct multiset *l;
-
l=merge_multisets(sp[-2].u.multiset, sp[-1].u.multiset,
+
l=merge_multisets(
Pike_
sp[-2].u.multiset,
Pike_
sp[-1].u.multiset,
PIKE_ARRAY_OP_XOR); pop_n_elems(2); push_multiset(l); return; } case T_ARRAY: { struct array *a;
-
a=merge_array_with_order(sp[-2].u.array, sp[-1].u.array, PIKE_ARRAY_OP_XOR);
+
a=merge_array_with_order(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.array, PIKE_ARRAY_OP_XOR);
pop_n_elems(2); push_array(a); return; } case T_FUNCTION: case T_PROGRAM: { struct program *p;
-
p = program_from_svalue(sp - 1);
+
p = program_from_svalue(
Pike_
sp - 1);
if (!p) { int args = 2; SIMPLE_ARG_TYPE_ERROR("`^", 2, "type"); } type_stack_mark(); push_object_type(0, p->id); pop_stack(); push_type_value(pop_unfinished_type()); stack_swap();
-
p = program_from_svalue(sp - 1);
+
p = program_from_svalue(
Pike_
sp - 1);
if (!p) { int args = 2; stack_swap(); SIMPLE_ARG_TYPE_ERROR("`^", 1, "type"); } type_stack_mark(); push_object_type(0, p->id); pop_stack(); push_type_value(pop_unfinished_type()); } /* FALL_THROUGH */ case T_TYPE: { /* a ^ b == (a&~b)|(~a&b) */ struct pike_type *a; struct pike_type *b;
-
copy_pike_type(a, sp[-2].u.type);
-
copy_pike_type(b, sp[-1].u.type);
+
copy_pike_type(a,
Pike_
sp[-2].u.type);
+
copy_pike_type(b,
Pike_
sp[-1].u.type);
o_compl(); /* ~b */ o_and(); /* a&~b */ push_type_value(a); o_compl(); /* ~a */ push_type_value(b); o_and(); /* ~a&b */ o_or(); /* (a&~b)|(~a&b) */ return; } STRING_BITOP(^,"XOR") default:
-
PIKE_ERROR("`^", "Bitwise XOR on illegal type.\n", sp, 2);
+
PIKE_ERROR("`^", "Bitwise XOR on illegal type.\n",
Pike_
sp, 2);
} } /*! @decl mixed `^(mixed arg1) *! @decl mixed `^(mixed arg1, mixed arg2, mixed ... extras) *! @decl mixed `^(object arg1, mixed arg2) *! @decl mixed `^(mixed arg1, object arg2) *! @decl int `^(int arg1, int arg2) *! @decl string `^(string arg1, string arg2) *! @decl array `^(array arg1, array arg2)
pike.git/src/operators.c:3235:
return 1; default: return 0; } } PMOD_EXPORT void o_lsh(void) { int args = 2;
-
if ((TYPEOF(sp[-2]) == T_OBJECT) ||
-
(TYPEOF(sp[-1]) == T_OBJECT))
+
if ((TYPEOF(
Pike_
sp[-2]) == T_OBJECT) ||
+
(TYPEOF(
Pike_
sp[-1]) == T_OBJECT))
goto call_lfun;
-
if ((TYPEOF(sp[-1]) != T_INT) || (sp[-1].u.integer < 0)) {
+
if ((TYPEOF(
Pike_
sp[-1]) != T_INT) || (
Pike_
sp[-1].u.integer < 0)) {
SIMPLE_ARG_TYPE_ERROR("`<<", 2, "int(0..)|object"); }
-
switch(TYPEOF(sp[-2])) {
+
switch(TYPEOF(
Pike_
sp[-2])) {
case T_INT:
-
if (!INT_TYPE_LSH_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer))
+
if (!INT_TYPE_LSH_OVERFLOW(
Pike_
sp[-2].u.integer,
Pike_
sp[-1].u.integer))
break; convert_stack_top_to_bignum(); /* FALL_THROUGH */ case T_OBJECT: call_lfun: if(call_lfun(LFUN_LSH, LFUN_RLSH)) return;
-
if(TYPEOF(sp[-2]) != T_INT)
+
if(TYPEOF(
Pike_
sp[-2]) != T_INT)
SIMPLE_ARG_TYPE_ERROR("`<<", 1, "int|float|object"); SIMPLE_ARG_TYPE_ERROR("`<<", 2, "int(0..)|object"); break; case T_FLOAT:
-
sp--;
-
sp[-1].u.float_number = ldexp(sp[-1].u.float_number, sp->u.integer);
+
Pike_
sp--;
+
Pike_
sp[-1].u.float_number = ldexp(
Pike_
sp[-1].u.float_number,
+
Pike_
sp->u.integer);
return; default: SIMPLE_ARG_TYPE_ERROR("`<<", 1, "int|float|object"); break; }
-
sp--;
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
-
sp[-1].u.integer << sp->u.integer);
+
Pike_
sp--;
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer,
+
Pike_
sp[-1].u.integer <<
Pike_
sp->u.integer);
} /*! @decl int `<<(int arg1, int(0..) arg2) *! @decl mixed `<<(object arg1, int(0..)|object arg2) *! @decl mixed `<<(int arg1, object arg2) *! @decl mixed `<<(float arg1, int(0..) arg2) *! *! Left shift. *! *! Every expression with the @expr{<<@} operator becomes a call to
pike.git/src/operators.c:3324:
emit0(F_LSH); modify_stack_depth(-1); return 1; } return 0; } PMOD_EXPORT void o_rsh(void) { int args = 2;
-
if ((TYPEOF(sp[-2]) == T_OBJECT) || (TYPEOF(sp[-1]) == T_OBJECT))
+
if ((TYPEOF(
Pike_
sp[-2]) == T_OBJECT) || (TYPEOF(
Pike_
sp[-1]) == T_OBJECT))
{ if(call_lfun(LFUN_RSH, LFUN_RRSH)) return;
-
if(TYPEOF(sp[-2]) != T_INT)
+
if(TYPEOF(
Pike_
sp[-2]) != T_INT)
SIMPLE_ARG_TYPE_ERROR("`>>", 1, "int|object"); SIMPLE_ARG_TYPE_ERROR("`>>", 2, "int(0..)|object"); }
-
if ((TYPEOF(sp[-1]) != T_INT) || (sp[-1].u.integer < 0)) {
+
if ((TYPEOF(
Pike_
sp[-1]) != T_INT) || (
Pike_
sp[-1].u.integer < 0)) {
SIMPLE_ARG_TYPE_ERROR("`>>", 2, "int(0..)|object"); }
-
sp--;
-
switch(TYPEOF(sp[-1])) {
+
Pike_
sp--;
+
switch(TYPEOF(
Pike_
sp[-1])) {
case T_INT:
-
if( INT_TYPE_RSH_OVERFLOW(sp[-1].u.integer, sp->u.integer) )
+
if( INT_TYPE_RSH_OVERFLOW(
Pike_
sp[-1].u.integer,
Pike_
sp->u.integer) )
{
-
if (sp[-1].u.integer < 0) {
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, -1);
+
if (
Pike_
sp[-1].u.integer < 0) {
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, -1);
} else {
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, 0);
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, 0);
} return; } break; case T_FLOAT:
-
sp[-1].u.float_number = ldexp(sp[-1].u.float_number, -sp->u.integer);
+
Pike_
sp[-1].u.float_number = ldexp(
Pike_
sp[-1].u.float_number,
+
-
Pike_
sp->u.integer);
return; default: SIMPLE_ARG_TYPE_ERROR("`>>", 1, "int|float|object"); break; }
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer,
-
sp[-1].u.integer >> sp->u.integer);
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer,
+
Pike_
sp[-1].u.integer >>
Pike_
sp->u.integer);
} /*! @decl int `>>(int arg1, int(0..) arg2) *! @decl mixed `>>(object arg1, int(0..)|object arg2) *! @decl mixed `>>(int arg1, object arg2) *! @decl float `>>(float arg1, int(0..) arg2) *! *! Right shift. *! *! Every expression with the @expr{>>@} operator becomes a call to
pike.git/src/operators.c:3412:
return 1; } return 0; } #define TWO_TYPES(X,Y) (((X)<<8)|(Y)) PMOD_EXPORT void o_multiply(void) { int args = 2;
-
switch(TWO_TYPES(TYPEOF(sp[-2]), TYPEOF(sp[-1])))
+
switch(TWO_TYPES(TYPEOF(
Pike_
sp[-2]), TYPEOF(
Pike_
sp[-1])))
{ case TWO_TYPES(T_ARRAY, T_INT): { struct array *ret; struct svalue *pos; INT32 e;
-
if(sp[-1].u.integer < 0)
+
if(
Pike_
sp[-1].u.integer < 0)
SIMPLE_ARG_TYPE_ERROR("`*", 2, "int(0..)");
-
ret=allocate_array(sp[-2].u.array->size * sp[-1].u.integer);
+
ret=allocate_array(
Pike_
sp[-2].u.array->size *
Pike_
sp[-1].u.integer);
pos=ret->item;
-
for(e=0;e<sp[-1].u.integer;e++,pos+=sp[-2].u.array->size)
+
for(e=0;e<
Pike_
sp[-1].u.integer;e++,pos+=
Pike_
sp[-2].u.array->size)
assign_svalues_no_free(pos,
-
sp[-2].u.array->item,
-
sp[-2].u.array->size,
-
sp[-2].u.array->type_field);
-
ret->type_field=sp[-2].u.array->type_field;
+
Pike_
sp[-2].u.array->item,
+
Pike_
sp[-2].u.array->size,
+
Pike_
sp[-2].u.array->type_field);
+
ret->type_field=
Pike_
sp[-2].u.array->type_field;
pop_n_elems(2); push_array(ret); return; } case TWO_TYPES(T_ARRAY, T_FLOAT): { struct array *src; struct array *ret; struct svalue *pos; ptrdiff_t asize, delta;
-
if(sp[-1].u.float_number < 0)
+
if(
Pike_
sp[-1].u.float_number < 0)
SIMPLE_ARG_TYPE_ERROR("`*", 2, "float(0..)");
-
src = sp[-2].u.array;
+
src =
Pike_
sp[-2].u.array;
delta = src->size;
-
asize = (ptrdiff_t)floor(delta * sp[-1].u.float_number + 0.5);
+
asize = (ptrdiff_t)floor(delta *
Pike_
sp[-1].u.float_number + 0.5);
ret = allocate_array(asize); pos = ret->item; if (asize > delta) { ret->type_field = src->type_field; assign_svalues_no_free(pos, src->item, delta, src->type_field); pos += delta; asize -= delta;
pike.git/src/operators.c:3484:
return; } case TWO_TYPES(T_STRING, T_FLOAT): { struct pike_string *src; struct pike_string *ret; char *pos; ptrdiff_t len, delta;
-
if(sp[-1].u.float_number < 0)
+
if(
Pike_
sp[-1].u.float_number < 0)
SIMPLE_ARG_TYPE_ERROR("`*", 2, "float(0..)");
-
src = sp[-2].u.string;
-
len = (ptrdiff_t)floor(src->len * sp[-1].u.float_number + 0.5);
+
src =
Pike_
sp[-2].u.string;
+
len = (ptrdiff_t)floor(src->len *
Pike_
sp[-1].u.float_number + 0.5);
ret = begin_wide_shared_string(len, src->size_shift); len <<= src->size_shift; delta = src->len << src->size_shift; pos = ret->str; if (len > delta) { memcpy(pos, src->str, delta); pos += delta; len -= delta; while (len > delta) {
pike.git/src/operators.c:3521:
return; } case TWO_TYPES(T_STRING, T_INT): { struct pike_string *ret; char *pos; INT_TYPE e; ptrdiff_t len;
-
if(sp[-1].u.integer < 0)
+
if(
Pike_
sp[-1].u.integer < 0)
SIMPLE_ARG_TYPE_ERROR("`*", 2, "int(0..)");
-
ret=begin_wide_shared_string(sp[-2].u.string->len * sp[-1].u.integer,
-
sp[-2].u.string->size_shift);
+
ret=begin_wide_shared_string(
Pike_
sp[-2].u.string->len *
Pike_
sp[-1].u.integer,
+
Pike_
sp[-2].u.string->size_shift);
pos=ret->str;
-
len=sp[-2].u.string->len << sp[-2].u.string->size_shift;
-
for(e=0;e<sp[-1].u.integer;e++,pos+=len)
-
memcpy(pos,sp[-2].u.string->str,len);
+
len=
Pike_
sp[-2].u.string->len <<
Pike_
sp[-2].u.string->size_shift;
+
for(e=0;e<
Pike_
sp[-1].u.integer;e++,pos+=len)
+
memcpy(pos,
Pike_
sp[-2].u.string->str,len);
pop_n_elems(2); 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);
-
SET_SVAL(sp[-2], T_STRING, 0, string, ret);
-
sp--;
+
ret=implode(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.string);
+
free_string(
Pike_
sp[-1].u.string);
+
free_array(
Pike_
sp[-2].u.array);
+
SET_SVAL(
Pike_
sp[-2], T_STRING, 0, string, ret);
+
Pike_
sp--;
return; } case TWO_TYPES(T_ARRAY,T_ARRAY): { struct array *ret;
-
ret=implode_array(sp[-2].u.array, sp[-1].u.array);
+
ret=implode_array(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.array);
pop_n_elems(2); push_array(ret); return; } case TWO_TYPES(T_FLOAT,T_FLOAT):
-
sp--;
-
sp[-1].u.float_number *= sp[0].u.float_number;
+
Pike_
sp--;
+
Pike_
sp[-1].u.float_number *=
Pike_
sp[0].u.float_number;
return; case TWO_TYPES(T_FLOAT,T_INT):
-
sp--;
-
sp[-1].u.float_number *= (FLOAT_TYPE)sp[0].u.integer;
+
Pike_
sp--;
+
Pike_
sp[-1].u.float_number *= (FLOAT_TYPE)
Pike_
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;
-
SET_SVAL_TYPE(sp[-1], T_FLOAT);
+
Pike_
sp--;
+
Pike_
sp[-1].u.float_number=
+
(FLOAT_TYPE)
Pike_
sp[-1].u.integer *
Pike_
sp[0].u.float_number;
+
SET_SVAL_TYPE(
Pike_
sp[-1], T_FLOAT);
return; case TWO_TYPES(T_INT,T_INT): { INT_TYPE res;
-
if (DO_INT_TYPE_MUL_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer, &res))
+
if (DO_INT_TYPE_MUL_OVERFLOW(
Pike_
sp[-2].u.integer,
Pike_
sp[-1].u.integer, &res))
{ convert_stack_top_to_bignum(); goto do_lfun_multiply; }
-
sp--;
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, res);
+
Pike_
sp--;
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, res);
return; } default: do_lfun_multiply: if(!call_lfun(LFUN_MULTIPLY, LFUN_RMULTIPLY))
-
PIKE_ERROR("`*", "Multiplication on objects without `* operator.\n", sp, 2);
+
PIKE_ERROR("`*", "Multiplication on objects without `* operator.\n",
Pike_
sp, 2);
return; } } /*! @decl object|int|float `**(object|int|float arg1, object|int|float arg2) *! *! Exponentiation. Raise arg1 to the power of arg2. *! */ PMOD_EXPORT void f_exponent(INT32 args) { double a, b; if(args != 2 ) SIMPLE_WRONG_NUM_ARGS_ERROR("`**",2);
-
switch( TWO_TYPES(TYPEOF(sp[-2]), TYPEOF(sp[-1])) )
+
switch( TWO_TYPES(TYPEOF(
Pike_
sp[-2]), TYPEOF(
Pike_
sp[-1])) )
{ case TWO_TYPES(T_FLOAT,T_FLOAT):
-
a = sp[-2].u.float_number;
-
b = sp[-1].u.float_number;
+
a =
Pike_
sp[-2].u.float_number;
+
b =
Pike_
sp[-1].u.float_number;
goto res_is_powf; case TWO_TYPES(T_FLOAT,T_INT):
-
a = sp[-2].u.float_number;
-
b = (double)sp[-1].u.integer;
+
a =
Pike_
sp[-2].u.float_number;
+
b = (double)
Pike_
sp[-1].u.integer;
goto res_is_powf; case TWO_TYPES(T_INT,T_FLOAT):
-
a = (double)sp[-2].u.integer;
-
b = (double)sp[-1].u.float_number;
+
a = (double)
Pike_
sp[-2].u.integer;
+
b = (double)
Pike_
sp[-1].u.float_number;
res_is_powf: {
-
sp-=2;
+
Pike_
sp-=2;
push_float( pow( a, b ) ); return; } default: stack_swap(); convert_stack_top_to_bignum(); stack_swap(); /* fallthrough again (this is the slow path).. */ case TWO_TYPES(T_OBJECT,T_INT): case TWO_TYPES(T_OBJECT,T_FLOAT): case TWO_TYPES(T_OBJECT,T_OBJECT): case TWO_TYPES(T_INT,T_OBJECT): case TWO_TYPES(T_FLOAT,T_OBJECT): if( !call_lfun( LFUN_POW, LFUN_RPOW ) ) {
-
if( TYPEOF(sp[-2]) != PIKE_T_OBJECT )
+
if( TYPEOF(
Pike_
sp[-2]) != PIKE_T_OBJECT )
{ stack_swap(); convert_stack_top_to_bignum(); stack_swap(); if( call_lfun( LFUN_POW, LFUN_RPOW ) ) return; } Pike_error("Illegal argument 1 to `** (object missing implementation of `**).\n"); } return;
pike.git/src/operators.c:3728:
switch(args) { case 0: SIMPLE_WRONG_NUM_ARGS_ERROR("`*", 1); case 1: return; case 2: o_multiply(); return; default: { INT32 i = -args, j = -1; /* Reverse the arguments */ while(i < j) {
-
struct svalue tmp = sp[i];
-
sp[i++] = sp[j];
-
sp[j--] = tmp;
+
struct svalue tmp =
Pike_
sp[i];
+
Pike_
sp[i++] =
Pike_
sp[j];
+
Pike_
sp[j--] = tmp;
} while(--args > 0) { /* Restore the order, and multiply */ stack_swap(); o_multiply(); } } } }
pike.git/src/operators.c:3763:
modify_stack_depth(-1); return 1; default: return 0; } } PMOD_EXPORT void o_divide(void) {
-
if(TYPEOF(sp[-2]) != TYPEOF(sp[-1]) && !float_promote())
+
if(TYPEOF(
Pike_
sp[-2]) != TYPEOF(
Pike_
sp[-1]) && !float_promote())
{ if(call_lfun(LFUN_DIVIDE, LFUN_RDIVIDE)) return;
-
switch(TWO_TYPES(TYPEOF(sp[-2]), TYPEOF(sp[-1])))
+
switch(TWO_TYPES(TYPEOF(
Pike_
sp[-2]), TYPEOF(
Pike_
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;
+
len=
Pike_
sp[-1].u.integer;
if(!len) OP_DIVISION_BY_ZERO_ERROR("`/"); if(len<0) { len=-len;
-
size=sp[-2].u.string->len / len;
-
pos+=sp[-2].u.string->len % len;
+
size=
Pike_
sp[-2].u.string->len / len;
+
pos+=
Pike_
sp[-2].u.string->len % len;
}else{
-
size=sp[-2].u.string->len / len;
+
size=
Pike_
sp[-2].u.string->len / len;
} a=allocate_array(size); for(e=0;e<size;e++) { SET_SVAL(a->item[e], T_STRING, 0, string,
-
string_slice(sp[-2].u.string, pos,len));
+
string_slice(
Pike_
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): { struct array *a; ptrdiff_t size, pos, last, e; FLOAT_ARG_TYPE len;
-
len=sp[-1].u.float_number;
+
len=
Pike_
sp[-1].u.float_number;
if(len==0.0) OP_DIVISION_BY_ZERO_ERROR("`/"); if(len<0) { len=-len;
-
size=(ptrdiff_t)ceil( ((double)sp[-2].u.string->len) / len);
+
size=(ptrdiff_t)ceil( ((double)
Pike_
sp[-2].u.string->len) / len);
a=allocate_array(size);
-
for(last=sp[-2].u.string->len,e=0;e<size-1;e++)
+
for(last=
Pike_
sp[-2].u.string->len,e=0;e<size-1;e++)
{
-
pos=sp[-2].u.string->len - (ptrdiff_t)((e+1)*len+0.5);
+
pos=
Pike_
sp[-2].u.string->len - (ptrdiff_t)((e+1)*len+0.5);
SET_SVAL(a->item[size-1-e], T_STRING, 0, string,
-
string_slice(sp[-2].u.string, pos, last-pos));
+
string_slice(
Pike_
sp[-2].u.string, pos, last-pos));
last=pos; } pos=0; SET_SVAL(a->item[0], T_STRING, 0, string,
-
string_slice(sp[-2].u.string, pos, last-pos));
+
string_slice(
Pike_
sp[-2].u.string, pos, last-pos));
}else{
-
size=(ptrdiff_t)ceil( ((double)sp[-2].u.string->len) / len);
+
size=(ptrdiff_t)ceil( ((double)
Pike_
sp[-2].u.string->len) / len);
a=allocate_array(size); for(last=0,e=0;e<size-1;e++) { pos = (ptrdiff_t)((e+1)*len+0.5); SET_SVAL(a->item[e], T_STRING, 0, string,
-
string_slice(sp[-2].u.string, last, pos-last));
+
string_slice(
Pike_
sp[-2].u.string, last, pos-last));
last=pos; }
-
pos=sp[-2].u.string->len;
+
pos=
Pike_
sp[-2].u.string->len;
SET_SVAL(a->item[e], T_STRING, 0, string,
-
string_slice(sp[-2].u.string, last, pos-last));
+
string_slice(
Pike_
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): { struct array *a; ptrdiff_t size,e,pos;
-
INT_TYPE len=sp[-1].u.integer;
+
INT_TYPE len=
Pike_
sp[-1].u.integer;
if(!len) OP_DIVISION_BY_ZERO_ERROR("`/"); if (!Pike_sp[-2].u.array->size) { pop_n_elems (2); ref_push_array (&empty_array); return; } if(len<0) { len = -len;
-
pos = sp[-2].u.array->size % len;
+
pos =
Pike_
sp[-2].u.array->size % len;
}else{ pos = 0; }
-
size = sp[-2].u.array->size / len;
+
size =
Pike_
sp[-2].u.array->size / len;
a=allocate_array(size); for(e=0;e<size;e++) { SET_SVAL(a->item[e], T_ARRAY, 0, array,
-
friendly_slice_array(sp[-2].u.array, pos, pos+len));
+
friendly_slice_array(
Pike_
sp[-2].u.array, pos, pos+len));
pos+=len; } a->type_field=BIT_ARRAY; pop_n_elems(2); push_array(a); return; } case TWO_TYPES(T_ARRAY,T_FLOAT): { struct array *a; ptrdiff_t last,pos,e,size; FLOAT_ARG_TYPE len;
-
len=sp[-1].u.float_number;
+
len=
Pike_
sp[-1].u.float_number;
if(len==0.0) OP_DIVISION_BY_ZERO_ERROR("`/"); if (!Pike_sp[-2].u.array->size) { pop_n_elems (2); ref_push_array (&empty_array); return; } if(len<0) { len=-len;
-
size = (ptrdiff_t)ceil( ((double)sp[-2].u.array->size) / len);
+
size = (ptrdiff_t)ceil( ((double)
Pike_
sp[-2].u.array->size) / len);
a=allocate_array(size);
-
for(last=sp[-2].u.array->size,e=0;e<size-1;e++)
+
for(last=
Pike_
sp[-2].u.array->size,e=0;e<size-1;e++)
{
-
pos=sp[-2].u.array->size - (ptrdiff_t)((e+1)*len+0.5);
+
pos=
Pike_
sp[-2].u.array->size - (ptrdiff_t)((e+1)*len+0.5);
SET_SVAL(a->item[size-1-e], T_ARRAY, 0, array,
-
friendly_slice_array(sp[-2].u.array, pos, last));
+
friendly_slice_array(
Pike_
sp[-2].u.array, pos, last));
last=pos; } SET_SVAL(a->item[0], T_ARRAY, 0, array,
-
slice_array(sp[-2].u.array, 0, last));
+
slice_array(
Pike_
sp[-2].u.array, 0, last));
}else{
-
size = (ptrdiff_t)ceil( ((double)sp[-2].u.array->size) / len);
+
size = (ptrdiff_t)ceil( ((double)
Pike_
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); SET_SVAL(a->item[e], T_ARRAY, 0, array,
-
friendly_slice_array(sp[-2].u.array, last, pos));
+
friendly_slice_array(
Pike_
sp[-2].u.array, last, pos));
last=pos; } SET_SVAL(a->item[e], T_ARRAY, 0, array,
-
slice_array(sp[-2].u.array, last, sp[-2].u.array->size));
+
slice_array(
Pike_
sp[-2].u.array, last,
Pike_
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);
+
PIKE_ERROR("`/", "Division on different types.\n",
Pike_
sp, 2);
}
-
switch(TYPEOF(sp[-2]))
+
switch(TYPEOF(
Pike_
sp[-2]))
{ case T_OBJECT: if(!call_lfun(LFUN_DIVIDE,LFUN_RDIVIDE))
-
PIKE_ERROR("`/", "Division on objects without `/ operator.\n", sp, 2);
+
PIKE_ERROR("`/", "Division on objects without `/ operator.\n",
Pike_
sp, 2);
return; 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);
-
SET_SVAL(sp[-2], T_ARRAY, 0, array, ret);
-
sp--;
+
ret=explode(
Pike_
sp[-2].u.string,
Pike_
sp[-1].u.string);
+
free_string(
Pike_
sp[-2].u.string);
+
free_string(
Pike_
sp[-1].u.string);
+
SET_SVAL(
Pike_
sp[-2], T_ARRAY, 0, array, ret);
+
Pike_
sp--;
return; } case T_ARRAY: {
-
struct array *ret=explode_array(sp[-2].u.array, sp[-1].u.array);
+
struct array *ret=explode_array(
Pike_
sp[-2].u.array,
Pike_
sp[-1].u.array);
pop_n_elems(2); push_array(ret); return; } case T_FLOAT:
-
if(sp[-1].u.float_number == 0.0)
+
if(
Pike_
sp[-1].u.float_number == 0.0)
OP_DIVISION_BY_ZERO_ERROR("`/");
-
sp--;
-
sp[-1].u.float_number /= sp[0].u.float_number;
+
Pike_
sp--;
+
Pike_
sp[-1].u.float_number /=
Pike_
sp[0].u.float_number;
return; case T_INT: { INT_TYPE tmp;
-
if (sp[-1].u.integer == 0)
+
if (
Pike_
sp[-1].u.integer == 0)
OP_DIVISION_BY_ZERO_ERROR("`/");
-
if(INT_TYPE_DIV_OVERFLOW(sp[-2].u.integer, sp[-1].u.integer))
+
if(INT_TYPE_DIV_OVERFLOW(
Pike_
sp[-2].u.integer,
Pike_
sp[-1].u.integer))
{ stack_swap(); convert_stack_top_to_bignum(); stack_swap(); call_lfun(LFUN_DIVIDE,LFUN_RDIVIDE); return; } else
-
tmp = sp[-2].u.integer/sp[-1].u.integer;
-
sp--;
+
tmp =
Pike_
sp[-2].u.integer/
Pike_
sp[-1].u.integer;
+
Pike_
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)
+
if((
Pike_
sp[-1].u.integer<0) != (
Pike_
sp[0].u.integer<0))
+
if(tmp*
Pike_
sp[0].u.integer!=
Pike_
sp[-1].u.integer)
tmp--;
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, tmp);
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, tmp);
return; } default:
-
PIKE_ERROR("`/", "Bad argument 1.\n", sp, 2);
+
PIKE_ERROR("`/", "Bad argument 1.\n",
Pike_
sp, 2);
} } /*! @decl mixed `/(object arg1, mixed arg2) *! @decl mixed `/(mixed arg1, object arg2) *! @decl array(string) `/(string arg1, int arg2) *! @decl array(string) `/(string arg1, float arg2) *! @decl array(array) `/(array arg1, int arg2) *! @decl array(array) `/(array arg1, float arg2) *! @decl array(string) `/(string arg1, string arg2)
pike.git/src/operators.c:4085:
PMOD_EXPORT void f_divide(INT32 args) { switch(args) { case 0: case 1: SIMPLE_WRONG_NUM_ARGS_ERROR("`/", 2); case 2: o_divide(); break; default: { INT32 e;
-
struct svalue *s=sp-args;
+
struct svalue *s=
Pike_
sp-args;
push_svalue(s); for(e=1;e<args;e++) { push_svalue(s+e); o_divide(); }
-
assign_svalue(s,sp-1);
-
pop_n_elems(sp-s-1);
+
assign_svalue(s,
Pike_
sp-1);
+
pop_n_elems(
Pike_
sp-s-1);
} } } static int generate_divide(node *n) { if(count_args(CDR(n))==2) { struct compilation *c = THIS_COMPILATION; 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(TYPEOF(sp[-2]) != TYPEOF(sp[-1]) && !float_promote())
+
if(TYPEOF(
Pike_
sp[-2]) != TYPEOF(
Pike_
sp[-1]) && !float_promote())
{ do_lfun_modulo: if(call_lfun(LFUN_MOD, LFUN_RMOD)) return;
-
switch(TWO_TYPES(TYPEOF(sp[-2]), TYPEOF(sp[-1])))
+
switch(TWO_TYPES(TYPEOF(
Pike_
sp[-2]), TYPEOF(
Pike_
sp[-1])))
{ case TWO_TYPES(T_STRING,T_INT): {
-
struct pike_string *s=sp[-2].u.string;
+
struct pike_string *s=
Pike_
sp[-2].u.string;
ptrdiff_t tmp,base;
-
if(!sp[-1].u.integer)
+
if(!
Pike_
sp[-1].u.integer)
OP_MODULO_BY_ZERO_ERROR("`%");
-
if(sp[-1].u.integer<0)
+
if(
Pike_
sp[-1].u.integer<0)
{
-
tmp=s->len % -sp[-1].u.integer;
+
tmp=s->len % -
Pike_
sp[-1].u.integer;
base=0; }else{
-
tmp=s->len % sp[-1].u.integer;
+
tmp=s->len %
Pike_
sp[-1].u.integer;
base=s->len - tmp; } s=string_slice(s, base, tmp); pop_n_elems(2); push_string(s); return; } case TWO_TYPES(T_ARRAY,T_INT): {
-
struct array *a=sp[-2].u.array;
+
struct array *a=
Pike_
sp[-2].u.array;
ptrdiff_t tmp,base;
-
if(!sp[-1].u.integer)
+
if(!
Pike_
sp[-1].u.integer)
OP_MODULO_BY_ZERO_ERROR("`%");
-
if(sp[-1].u.integer<0)
+
if(
Pike_
sp[-1].u.integer<0)
{
-
tmp=a->size % -sp[-1].u.integer;
+
tmp=a->size % -
Pike_
sp[-1].u.integer;
base=0; }else{
-
tmp=a->size % sp[-1].u.integer;
+
tmp=a->size %
Pike_
sp[-1].u.integer;
base=a->size - tmp; } a=slice_array(a,base,base+tmp); pop_n_elems(2); push_array(a); return; } }
-
PIKE_ERROR("`%", "Modulo on different types.\n", sp, 2);
+
PIKE_ERROR("`%", "Modulo on different types.\n",
Pike_
sp, 2);
}
-
switch(TYPEOF(sp[-2]))
+
switch(TYPEOF(
Pike_
sp[-2]))
{ case T_OBJECT: if(!call_lfun(LFUN_MOD,LFUN_RMOD))
-
PIKE_ERROR("`%", "Modulo on objects without `% operator.\n", sp, 2);
+
PIKE_ERROR("`%", "Modulo on objects without `% operator.\n",
Pike_
sp, 2);
return; case T_FLOAT: { FLOAT_TYPE foo;
-
if(sp[-1].u.float_number == 0.0)
+
if(
Pike_
sp[-1].u.float_number == 0.0)
OP_MODULO_BY_ZERO_ERROR("`%");
-
sp--;
-
foo = (FLOAT_TYPE)(sp[-1].u.float_number / sp[0].u.float_number);
-
foo = (FLOAT_TYPE)(sp[-1].u.float_number -
-
sp[0].u.float_number * floor(foo));
-
sp[-1].u.float_number=foo;
+
Pike_
sp--;
+
foo = (FLOAT_TYPE)(
Pike_
sp[-1].u.float_number /
Pike_
sp[0].u.float_number);
+
foo = (FLOAT_TYPE)(
Pike_
sp[-1].u.float_number -
+
Pike_
sp[0].u.float_number * floor(foo));
+
Pike_
sp[-1].u.float_number=foo;
return; } case T_INT: { int of = 0;
-
INT_TYPE a = sp[-2].u.integer,
-
b = sp[-1].u.integer;
+
INT_TYPE a =
Pike_
sp[-2].u.integer,
+
b =
Pike_
sp[-1].u.integer;
INT_TYPE res; if (b == 0) OP_MODULO_BY_ZERO_ERROR("`%"); if(a>=0) { if(b>=0) { res = a % b; }else{ /* res = ((a+~b)%-b)-~b */
pike.git/src/operators.c:4227:
* res = -(-a % -b) = a % b; */ of = DO_INT_TYPE_MOD_OVERFLOW(a, b, &res); } } if (of) { stack_swap(); convert_stack_top_to_bignum(); stack_swap(); goto do_lfun_modulo; }
-
sp--;
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, res);
+
Pike_
sp--;
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, res);
return; } default:
-
PIKE_ERROR("`%", "Bad argument 1.\n", sp, 2);
+
PIKE_ERROR("`%", "Bad argument 1.\n",
Pike_
sp, 2);
} } /*! @decl mixed `%(object arg1, mixed arg2) *! @decl mixed `%(mixed arg1, object arg2) *! @decl string `%(string arg1, int arg2) *! @decl array `%(array arg1, int arg2) *! @decl float `%(float arg1, float|int arg2) *! @decl float `%(int arg1, float arg2) *! @decl int `%(int arg1, int arg2)
pike.git/src/operators.c:4317:
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(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_INT:
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, !sp[-1].u.integer);
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, !
Pike_
sp[-1].u.integer);
break; case T_FUNCTION: case T_OBJECT:
-
if(UNSAFE_IS_ZERO(sp-1))
+
if(UNSAFE_IS_ZERO(
Pike_
sp-1))
{ pop_stack(); push_int(1); }else{ pop_stack(); push_int(0); } break; default:
-
free_svalue(sp-1);
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, 0);
+
free_svalue(
Pike_
sp-1);
+
SET_SVAL(
Pike_
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:4392:
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(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_OBJECT: if(!call_lhs_lfun(LFUN_COMPL,1))
-
PIKE_ERROR("`~", "Complement on object without `~ operator.\n", sp, 1);
+
PIKE_ERROR("`~", "Complement on object without `~ operator.\n",
Pike_
sp, 1);
stack_pop_keep_top(); break; case T_INT:
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, ~sp[-1].u.integer);
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, ~
Pike_
sp[-1].u.integer);
break; case T_FLOAT:
-
sp[-1].u.float_number = (FLOAT_TYPE) -1.0 - sp[-1].u.float_number;
+
Pike_
sp[-1].u.float_number = (FLOAT_TYPE) -1.0 -
Pike_
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);
+
if (
Pike_
sp[-1].u.type->type == T_NOT) {
+
push_finished_type(
Pike_
sp[-1].u.type->car);
} else {
-
push_finished_type(sp[-1].u.type);
+
push_finished_type(
Pike_
sp[-1].u.type);
push_type(T_NOT); } pop_stack(); push_type_value(pop_unfinished_type()); break; case T_FUNCTION: case T_PROGRAM: { /* !object(p) */
-
struct program *p = program_from_svalue(sp - 1);
+
struct program *p = program_from_svalue(
Pike_
sp - 1);
if (!p) {
-
PIKE_ERROR("`~", "Bad argument.\n", sp, 1);
+
PIKE_ERROR("`~", "Bad argument.\n",
Pike_
sp, 1);
} type_stack_mark(); push_object_type(0, p->id); push_type(T_NOT); pop_stack(); push_type_value(pop_unfinished_type()); } break; case T_STRING: { struct pike_string *s; ptrdiff_t len, i;
-
if(sp[-1].u.string->size_shift) {
-
bad_arg_error("`~", sp-1, 1, 1, "string(0)", sp-1,
+
if(
Pike_
sp[-1].u.string->size_shift) {
+
bad_arg_error("`~",
Pike_
sp-1, 1, 1, "string(0)",
Pike_
sp-1,
"Expected 8-bit string.\n"); }
-
len = sp[-1].u.string->len;
+
len =
Pike_
sp[-1].u.string->len;
s = begin_shared_string(len); for (i=0; i<len; i++)
-
s->str[i] = ~ sp[-1].u.string->str[i];
+
s->str[i] = ~
Pike_
sp[-1].u.string->str[i];
pop_n_elems(1); push_string(end_shared_string(s)); break; } default:
-
PIKE_ERROR("`~", "Bad argument.\n", sp, 1);
+
PIKE_ERROR("`~", "Bad argument.\n",
Pike_
sp, 1);
} } /*! @decl mixed `~(object arg) *! @decl int `~(int arg) *! @decl float `~(float arg) *! @decl type `~(type|program arg) *! @decl string `~(string arg) *! *! Complement/inversion.
pike.git/src/operators.c:4513:
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(TYPEOF(sp[-1]))
+
switch(TYPEOF(
Pike_
sp[-1]))
{ case T_OBJECT: do_lfun_negate: if(!call_lhs_lfun(LFUN_SUBTRACT,1))
-
PIKE_ERROR("`-", "Negate on object without `- operator.\n", sp, 1);
+
PIKE_ERROR("`-", "Negate on object without `- operator.\n",
Pike_
sp, 1);
stack_pop_keep_top(); break; case T_FLOAT:
-
sp[-1].u.float_number=-sp[-1].u.float_number;
+
Pike_
sp[-1].u.float_number=-
Pike_
sp[-1].u.float_number;
return; case T_INT:
-
if(INT_TYPE_NEG_OVERFLOW(sp[-1].u.integer))
+
if(INT_TYPE_NEG_OVERFLOW(
Pike_
sp[-1].u.integer))
{ convert_stack_top_to_bignum(); goto do_lfun_negate; }
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, -sp[-1].u.integer);
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, -
Pike_
sp[-1].u.integer);
return; default:
-
PIKE_ERROR("`-", "Bad argument to unary minus.\n", sp, 1);
+
PIKE_ERROR("`-", "Bad argument to unary minus.\n",
Pike_
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. */ {
pike.git/src/operators.c:4636:
* o[..] => o->`[] (0, Pike.NATIVE_MAX) */ if (bound_types & (RANGE_LOW_FROM_END|RANGE_HIGH_FROM_END)) { int f2 = FIND_LFUN (o->prog, LFUN__SIZEOF); if (f2 == -1) return 2; apply_low (o, f2, 0); push_int (1); o_subtract();
-
move_svalue (&end_pos, --sp);
+
move_svalue (&end_pos, --
Pike_
sp);
SET_ONERROR (uwp, do_free_svalue, &end_pos); } switch (bound_types & (RANGE_LOW_FROM_BEG|RANGE_LOW_FROM_END|RANGE_LOW_OPEN)) { case RANGE_LOW_FROM_BEG:
-
move_svalue (sp++, low);
+
move_svalue (
Pike_
sp++, low);
mark_free_svalue (low); break; case RANGE_LOW_OPEN: push_int (0); break; default: push_svalue (&end_pos);
-
move_svalue (sp++, low);
+
move_svalue (
Pike_
sp++, low);
mark_free_svalue (low); o_subtract(); break; } switch (bound_types & (RANGE_HIGH_FROM_BEG|RANGE_HIGH_FROM_END|RANGE_HIGH_OPEN)) { case RANGE_HIGH_FROM_BEG:
-
move_svalue (sp++, high);
+
move_svalue (
Pike_
sp++, high);
mark_free_svalue (high); break; case RANGE_HIGH_OPEN: push_int (MAX_INT_TYPE); break; default: push_svalue (&end_pos);
-
move_svalue (sp++, high);
+
move_svalue (
Pike_
sp++, high);
mark_free_svalue (high); o_subtract(); break; } if (bound_types & (RANGE_LOW_FROM_END|RANGE_HIGH_FROM_END)) { UNSET_ONERROR (uwp); free_svalue (&end_pos); /* Anything might have happened during the calls to * LFUN__SIZEOF and o_subtract above. */
pike.git/src/operators.c:4713:
} UNREACHABLE(return "Unexpected bound_types"); } 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;
+
high = bound_types & RANGE_HIGH_OPEN ?
Pike_
sp :
Pike_
sp - 1;
low = bound_types & RANGE_LOW_OPEN ? high : high - 1; ind = low - 1; 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,
+
ind,
Pike_
sp - ind, 1, "object", ind,
"Cannot call `[..] in destructed object.\n"); 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;
+
Pike_
sp = high;
} if (bound_types & RANGE_LOW_FROM_BEG) push_int (INDEX_FROM_BEG); else if (bound_types & RANGE_LOW_OPEN) { push_int (0); push_int (OPEN_BOUND); } else push_int (INDEX_FROM_END); if (bound_types & RANGE_HIGH_FROM_BEG) {
-
move_svalue (sp++, &h);
+
move_svalue (
Pike_
sp++, &h);
push_int (INDEX_FROM_BEG); } else if (bound_types & RANGE_HIGH_OPEN) { push_int (0); push_int (OPEN_BOUND); } else {
-
move_svalue (sp++, &h);
+
move_svalue (
Pike_
sp++, &h);
push_int (INDEX_FROM_END); } apply_low (o, f, 4); stack_pop_keep_top(); } else switch (call_old_range_lfun (bound_types, o, low, high)) { case 1: bad_arg_error (range_func_name (bound_types),
-
ind, sp - ind, 1, "object", ind,
+
ind,
Pike_
sp - ind, 1, "object", ind,
"Object got neither `[..] nor `[].\n"); break; case 2: bad_arg_error (range_func_name (bound_types),
-
ind, sp - ind, 1, "object", ind,
+
ind,
Pike_
sp - ind, 1, "object", ind,
"Object got no `[..] and there is no _sizeof to " "translate the from-the-end index to use `[].\n"); break; case 3: bad_arg_error (range_func_name (bound_types), ind, 3, 1, "object", ind, "Cannot call `[..] in destructed object.\n"); break; default: free_svalue (ind);
-
move_svalue (ind, sp - 1);
+
move_svalue (ind,
Pike_
sp - 1);
/* low and high have lost their refs in call_old_range_lfun. */
-
sp = ind + 1;
+
Pike_
sp = ind + 1;
break; } break; } case T_STRING: case T_ARRAY: { INT_TYPE l=0, h=0; if (!(bound_types & RANGE_LOW_OPEN)) { if (TYPEOF(*low) != T_INT) bad_arg_error (range_func_name (bound_types),
-
ind, sp - ind, 2, "int", low,
+
ind,
Pike_
sp - ind, 2, "int", low,
"Bad lower bound. Expected int, got %s.\n", get_name_of_type (TYPEOF(*low))); l = low->u.integer; } if (!(bound_types & RANGE_HIGH_OPEN)) { if (TYPEOF(*high) != T_INT) bad_arg_error (range_func_name (bound_types),
-
ind, sp - ind, high - ind + 1, "int", high,
+
ind,
Pike_
sp - ind, high - ind + 1, "int", high,
"Bad upper bound. Expected int, got %s.\n", 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;
+
Pike_
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,
+
ind,
Pike_
sp - ind, 1, "string|array|object", ind,
"Cannot use [..] on a %s. Expected string, array or object.\n", 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.
pike.git/src/operators.c:4933:
*! @endmixed *! *! @seealso *! @[lfun::`[..]], @[`[]] */ PMOD_EXPORT void f_range(INT32 args) { struct svalue *ind; if (args != 5) SIMPLE_WRONG_NUM_ARGS_ERROR ("predef::`[..]", 5);
-
ind = sp - 5;
+
ind =
Pike_
sp - 5;
#define CALC_BOUND_TYPES(bound_types) do { \ 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."); \
pike.git/src/operators.c:4990:
SIMPLE_ARG_ERROR ("predef::`[..]", 1, "Object got no `[..] and there is no _sizeof to " "translate the from-the-end index to use `[].\n"); break; case 3: SIMPLE_ARG_ERROR ("predef::`[..]", 1, "Cannot call `[..] in destructed object.\n"); break; default: free_svalue (ind);
-
move_svalue (ind, sp - 1);
+
move_svalue (ind,
Pike_
sp - 1);
/* The bound types are simple integers and the bounds * themselves have lost their refs in call_old_range_lfun. */
-
sp = ind + 1;
+
Pike_
sp = ind + 1;
break; } } break; } case T_STRING: case T_ARRAY: { INT_TYPE l=0, h=0;
pike.git/src/operators.c:5118:
*! this function. *! *! @seealso *! @[`->()], @[lfun::`[]()], @[`[]=], @[`[..]] */ PMOD_EXPORT void f_index(INT32 args) { switch(args) { case 2:
-
if(TYPEOF(sp[-1]) == T_STRING) SET_SVAL_SUBTYPE(sp[-1], 0);
+
if(TYPEOF(
Pike_
sp[-1]) == T_STRING) SET_SVAL_SUBTYPE(
Pike_
sp[-1], 0);
o_index(); break; case 3:
-
move_svalue (sp, sp - 1);
-
sp += 2;
-
SET_SVAL(sp[-1], T_INT, NUMBER_NUMBER, integer, INDEX_FROM_BEG);
-
sp[-3] = sp[-1];
+
move_svalue (
Pike_
sp,
Pike_
sp - 1);
+
Pike_
sp += 2;
+
SET_SVAL(
Pike_
sp[-1], T_INT, NUMBER_NUMBER, integer, INDEX_FROM_BEG);
+
Pike_
sp[-3] =
Pike_
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:5195:
*! *! @seealso *! @[`[]()], @[lfun::`->()], @[::`->()], @[`->=] */ PMOD_EXPORT void f_arrow(INT32 args) { switch(args) { case 0: case 1:
-
PIKE_ERROR("`->", "Too few arguments.\n", sp, args);
+
PIKE_ERROR("`->", "Too few arguments.\n",
Pike_
sp, args);
break; case 2:
-
if(TYPEOF(sp[-1]) == T_STRING)
-
SET_SVAL_SUBTYPE(sp[-1], 1);
+
if(TYPEOF(
Pike_
sp[-1]) == T_STRING)
+
SET_SVAL_SUBTYPE(
Pike_
sp[-1], 1);
o_index(); break; default:
-
PIKE_ERROR("`->", "Too many arguments.\n", sp, args);
+
PIKE_ERROR("`->", "Too many arguments.\n",
Pike_
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) *! @decl mixed `[]=(mapping arg, mixed index, mixed val) *! @decl int(0..1) `[]=(multiset arg, mixed index, int(0..1) val) *! *! Index assignment.
pike.git/src/operators.c:5251:
*! *! @seealso *! @[`->=()], @[lfun::`[]=()], @[`[]] */ PMOD_EXPORT void f_index_assign(INT32 args) { switch (args) { case 0: case 1: case 2:
-
PIKE_ERROR("`[]=", "Too few arguments.\n", sp, args);
+
PIKE_ERROR("`[]=", "Too few arguments.\n",
Pike_
sp, args);
break; case 3:
-
if(TYPEOF(sp[-2]) == T_STRING) SET_SVAL_SUBTYPE(sp[-2], 0);
-
assign_lvalue (sp-3, sp-1);
+
if(TYPEOF(
Pike_
sp[-2]) == T_STRING) SET_SVAL_SUBTYPE(
Pike_
sp[-2], 0);
+
assign_lvalue (
Pike_
sp-3,
Pike_
sp-1);
stack_pop_n_elems_keep_top (2); break; default:
-
PIKE_ERROR("`[]=", "Too many arguments.\n", sp, args);
+
PIKE_ERROR("`[]=", "Too many arguments.\n",
Pike_
sp, args);
} } /*! @decl mixed `->=(object arg, string index, mixed val) *! @decl mixed `->=(mapping arg, string index, mixed val) *! @decl int(0..1) `->=(multiset arg, string index, int(0..1) val) *! *! Arrow index assignment. *! *! Every lvalue expression with the @expr{->@} operator becomes a
pike.git/src/operators.c:5314:
*! *! @seealso *! @[`[]=()], @[lfun::`->=()], @[`->] */ PMOD_EXPORT void f_arrow_assign(INT32 args) { switch (args) { case 0: case 1: case 2:
-
PIKE_ERROR("`->=", "Too few arguments.\n", sp, args);
+
PIKE_ERROR("`->=", "Too few arguments.\n",
Pike_
sp, args);
break; case 3:
-
if(TYPEOF(sp[-2]) == T_STRING) SET_SVAL_SUBTYPE(sp[-2], 1);
-
assign_lvalue (sp-3, sp-1);
-
assign_svalue (sp-3, sp-1);
+
if(TYPEOF(
Pike_
sp[-2]) == T_STRING) SET_SVAL_SUBTYPE(
Pike_
sp[-2], 1);
+
assign_lvalue (
Pike_
sp-3,
Pike_
sp-1);
+
assign_svalue (
Pike_
sp-3,
Pike_
sp-1);
pop_n_elems (args-1); break; default:
-
PIKE_ERROR("`->=", "Too many arguments.\n", sp, args);
+
PIKE_ERROR("`->=", "Too many arguments.\n",
Pike_
sp, args);
} } /*! @decl int sizeof(string arg) *! @decl int sizeof(array arg) *! @decl int sizeof(mapping arg) *! @decl int sizeof(multiset arg) *! @decl int sizeof(object arg) *! *! Size query.
pike.git/src/operators.c:5357:
*! symbols in @[arg] will be returned. *! @endmixed *! *! @seealso *! @[lfun::_sizeof()] */ PMOD_EXPORT void f_sizeof(INT32 args) { INT32 tmp; if(args<1)
-
PIKE_ERROR("sizeof", "Too few arguments.\n", sp, args);
+
PIKE_ERROR("sizeof", "Too few arguments.\n",
Pike_
sp, args);
-
tmp=pike_sizeof(sp-args);
+
tmp=pike_sizeof(
Pike_
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) && (TYPEOF(CADR(n)->u.sval) == T_FUNCTION) &&
pike.git/src/operators.c:5561:
if(i<0 || i>=len) Pike_error("Index %"PRINTPIKEINT"d is out of string range " "%"PRINTPTRDIFFT"d..%"PRINTPTRDIFFT"d.\n", 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++;
+
lvalue_to_svalue_no_free(
Pike_
sp,THIS->lval);
+
Pike_
sp++;
dmalloc_touch_svalue(Pike_sp-1);
-
if(TYPEOF(sp[-1]) != T_STRING) Pike_error("string[]= failed.\n");
-
len = sp[-1].u.string->len;
+
if(TYPEOF(
Pike_
sp[-1]) != T_STRING) Pike_error("string[]= failed.\n");
+
len =
Pike_
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);
+
Pike_
sp[-1].u.string=modify_shared_string(
Pike_
sp[-1].u.string,i,j);
+
assign_lvalue(THIS->lval,
Pike_
sp-1);
pop_stack(); } pop_n_elems(args); push_int(j); } static void init_string_assignment_storage(struct object *UNUSED(o)) {