pike.git / src / operators.c

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, 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, 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:116:    "with unknown method \"%S\".\n",    val, ind->u.string);    } else {    Pike_error("Indexing the NULL value with \"%S\".\n",    ind->u.string);    }    }    break;    }    -  /* FALL_THROUGH */ +  /* FALLTHRU */       default:    index_error:    if (TYPEOF(*ind) == T_INT)    Pike_error ("Cannot index %s with %"PRINTPIKEINT"d.\n",    (TYPEOF(*what) == T_INT && !what->u.integer)?    "the NULL value":get_name_of_type(TYPEOF(*what)),    ind->u.integer);    else if (TYPEOF(*ind) == T_FLOAT)    Pike_error ("Cannot index %s with %"PRINTPIKEFLOAT"e.\n",
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);    }    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; -  /* FALL THROUGH */ +  /* FALLTHRU */       case 1:    if ((unsigned INT32) val <= 0xffff)    break;    shift = 2; -  /* FALL THROUGH */ +  /* FALLTHRU */       case 2:   #if SIZEOF_INT_TYPE > 4    if (val < MIN_INT32 || val > MAX_INT32)    Pike_error ("Item %d is too large: %"PRINTPIKEINT"x.\n",    i, val);   #endif    break;    }    }
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])) +     { -  +  struct program *p = program_from_type(type); +  if (p) { +  struct svalue s; +  SET_SVAL(s, T_PROGRAM, 0, program, p); +  apply_svalue(&s, 1); +  return; +  } +  } +  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.
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)) {    case PIKE_T_INT:    return !s->u.integer;    case PIKE_T_FUNCTION:    if (SUBTYPEOF(*s) == FUNCTION_BUILTIN) return 0; -  /* FALL_THROUGH */ +  /* FALLTHRU */    case PIKE_T_OBJECT:    return !s->u.object->prog;    }    return 0;    case T_ASSIGN:    case PIKE_T_NAME: -  case PIKE_T_ATTRIBUTE: +     type = type->cdr;    goto loop; -  +  case PIKE_T_ATTRIBUTE: +  { +  int ret; +  if (!low_check_soft_cast(s, type->cdr)) return 0; +  push_svalue(s); +  ref_push_string((struct pike_string *)type->car); +  SAFE_MAYBE_APPLY_MASTER("handle_attribute", 2); +  ret = !SAFE_IS_ZERO(Pike_sp-1) || IS_UNDEFINED(Pike_sp-1); +  pop_stack(); +  return ret; +  }    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);
pike.git/src/operators.c:1069:    ID_FROM_INT(Pike_fp->current_program, Pike_fp->fun)->name;    if ((!name->size_shift) && (name->len < 100))    fname = name->str;    }       t1 = describe_type(type);    SET_ONERROR(tmp1, do_free_string, t1);       free_type(sval_type);    -  bad_arg_error(NULL, Pike_sp-1, 1, 1, t1->str, Pike_sp-1, +  bad_arg_error(NULL, -1, 1, t1->str, Pike_sp-1,    "%s(): Soft cast failed.\n%S",    fname, s.s);       UNREACHABLE(CALL_AND_UNSET_ONERROR(tmp1));    UNREACHABLE(CALL_AND_UNSET_ONERROR(tmp0));    }   }      #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) +  int i; +  for(i=0; i<args; i++) +  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++) \    { \    if(TYPEOF(Pike_sp[i]) == PIKE_T_INT) \    { \    if(!IS_UNDEFINED(Pike_sp+i)) \    SIMPLE_ARG_TYPE_ERROR("`+", args+i, #TYPE); \    } \    else if(to!=i) \    Pike_sp[to++] = Pike_sp[i]; \    else to++; \    } \ -  for(int i=to; i<0; i++) \ +  for(i=to; i<0; i++) \    TYPEOF(Pike_sp[i])=PIKE_T_INT; \    Pike_sp += to; \    args += to; \    } while(0);       case BIT_ARRAY|BIT_INT:    REMOVE_UNDEFINED (array);    /* Fallthrough */    case BIT_ARRAY:    ADD (array, add_arrays, push_array);
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("`-", 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:2327:    *! @mixed arg1    *! @type int|float    *! The result is @expr{@[arg1] - @[arg2]@}, and is a float if    *! either @[arg1] or @[arg2] is a float.    *! @type string    *! The result is @[arg1] with all nonoverlapping occurrences of    *! the substring @[arg2] removed. In cases with two overlapping    *! occurrences, the leftmost is removed.    *! @type array|mapping|multiset    *! The result is like @[arg1] but without the elements/indices -  *! that match any in @[arg2] (according to @[`==] and, in the -  *! case of mappings, @[hash_value]). +  *! that match any in @[arg2] (according to @[`>], @[`<], @[`==] +  *! and, in the case of mappings, @[hash_value]).    *! @endmixed    *! The function is not destructive on the arguments - the result is    *! always a new instance.    *!    *! @note    *! In Pike 7.0 and earlier the subtraction order was unspecified.    *! -  +  *! @note +  *! If this operator is used with arrays or multisets containing objects +  *! which implement @[lfun::`==()] but @b{not@} @[lfun::`>()] and +  *! @[lfun::`<()], the result will be undefined. +  *!    *! @seealso    *! @[`+()]    */   PMOD_EXPORT void f_minus(INT32 args)   {    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))   {    struct svalue tmp;    ONERROR err;       switch(args)    { -  case 3: func(); -  case 2: func(); +  case 3: func(); /* FALLTHRU */ +  case 2: func(); /* FALLTHRU */    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:2708:    *! @mixed arg1    *! @type int    *! Bitwise and of @[arg1] and @[arg2].    *! @type string    *! The result is a string where each character is the bitwise    *! and of the characters in the same position in @[arg1] and    *! @[arg2]. The arguments must be strings of the same length.    *! @type array|mapping|multiset    *! The result is like @[arg1] but only with the    *! elements/indices that match any in @[arg2] (according to -  *! @[`==] and, in the case of mappings, @[hash_value]). +  *! @[`>], @[`<], @[`==] and, in the case of mappings, +  *! @[hash_value]).    *! @type type|program    *! Type intersection of @[arg1] and @[arg2].    *! @endmixed    *! The function is not destructive on the arguments - the result is    *! always a new instance.    *! -  +  *! @note +  *! If this operator is used with arrays or multisets containing objects +  *! which implement @[lfun::`==()] but @b{not@} @[lfun::`>()] and +  *! @[lfun::`<()], the result will be undefined. +  *!    *! @seealso    *! @[`|()], @[lfun::`&()], @[lfun::``&()]    */   PMOD_EXPORT void f_and(INT32 args)   {    switch(args)    {    case 0: SIMPLE_WRONG_NUM_ARGS_ERROR("`&", 1);    case 1: return;    case 2: o_and(); return;
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:2937:    *! @mixed arg1    *! @type int    *! Bitwise or of @[arg1] and @[arg2].    *! @type string    *! The result is a string where each character is the bitwise    *! or of the characters in the same position in @[arg1] and    *! @[arg2]. The arguments must be strings of the same length.    *! @type array    *! The result is an array with the elements in @[arg1]    *! concatenated with those in @[arg2] that doesn't occur in -  *! @[arg1] (according to @[`==]). The order between the -  *! elements that come from the same argument is kept. +  *! @[arg1] (according to @[`>], @[`<], @[`==]). The order +  *! between the elements that come from the same argument is kept.    *!    *! Every element in @[arg1] is only matched once against an    *! element in @[arg2], so if @[arg2] contains several elements    *! that are equal to each other and are more than their    *! counterparts in @[arg1], the rightmost remaining elements in    *! @[arg2] are kept.    *! @type mapping    *! The result is like @[arg1] but extended with the entries    *! from @[arg2]. If the same index (according to @[hash_value]    *! and @[`==]) occur in both, the value from @[arg2] is used.    *! @type multiset    *! The result is like @[arg1] but extended with the entries in    *! @[arg2] that doesn't already occur in @[arg1] (according to -  *! @[`==]). Subsequences with orderwise equal entries (i.e. -  *! where @[`<] returns false) are handled just like the array -  *! case above. +  *! @[`>], @[`<] and @[`==]). Subsequences with orderwise equal +  *! entries (i.e. where @[`<] returns false) are handled just +  *! like the array case above.    *! @type type|program    *! Type union of @[arg1] and @[arg2].    *! @endmixed    *! The function is not destructive on the arguments - the result is    *! always a new instance.    *! -  +  *! @note +  *! If this operator is used with arrays or multisets containing objects +  *! which implement @[lfun::`==()] but @b{not@} @[lfun::`>()] and +  *! @[lfun::`<()], the result will be undefined. +  *!    *! @seealso    *! @[`&()], @[lfun::`|()], @[lfun::``|()]    */   PMOD_EXPORT void f_or(INT32 args)   {    switch(args)    {    case 0: SIMPLE_WRONG_NUM_ARGS_ERROR("`|", 1);    case 1: return;    case 2: o_or(); return;
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 */ +  /* FALLTHRU */    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:3172:    *! @type int    *! Bitwise exclusive or of @[arg1] and @[arg2].    *! @type string    *! The result is a string where each character is the bitwise    *! exclusive or of the characters in the same position in    *! @[arg1] and @[arg2]. The arguments must be strings of the    *! same length.    *! @type array    *! The result is an array with the elements in @[arg1] that    *! doesn't occur in @[arg2] concatenated with those in @[arg2] -  *! that doesn't occur in @[arg1] (according to @[`==]). The -  *! order between the elements that come from the same argument -  *! is kept. +  *! that doesn't occur in @[arg1] (according to @[`>], @[`<] and +  *! @[`==]). The order between the elements that come from the +  *! same argument is kept.    *!    *! Every element is only matched once against an element in the    *! other array, so if one contains several elements that are    *! equal to each other and are more than their counterparts in    *! the other array, the rightmost remaining elements are kept.    *! @type mapping    *! The result is like @[arg1] but with the entries from @[arg1]    *! and @[arg2] whose indices are different between them    *! (according to @[hash_value] and @[`==]).    *! @type multiset    *! The result is like @[arg1] but with the entries from @[arg1]    *! and @[arg2] that are different between them (according to -  *! @[hash_value] and @[`==]). Subsequences with orderwise equal +  *! @[`>], @[`<] and @[`==]). Subsequences with orderwise equal    *! entries (i.e. where @[`<] returns false) are handled just    *! like the array case above.    *! @type type|program    *! The result is a type computed like this:    *! @expr{(@[arg1]&~@[arg2])|(~@[arg1]&@[arg2])@}.    *! @endmixed    *! The function is not destructive on the arguments - the result is    *! always a new instance.    *! -  +  *! @note +  *! If this operator is used with arrays or multisets containing objects +  *! which implement @[lfun::`==()] but @b{not@} @[lfun::`>()] and +  *! @[lfun::`<()], the result will be undefined. +  *!    *! @seealso    *! @[`&()], @[`|()], @[lfun::`^()], @[lfun::``^()]    */   PMOD_EXPORT void f_xor(INT32 args)   {    switch(args)    {    case 0: SIMPLE_WRONG_NUM_ARGS_ERROR("`^", 1);    case 1: return;    case 2: o_xor(); return;
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 */ +  /* FALLTHRU */       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).. */ +  /* FALLTHRU *//* 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("`~", 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, +  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, +  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, +  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, +  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, +  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, +  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, +  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:5517:   #define THIS ((struct string_assignment_storage *)(CURRENT_STORAGE))   /*! @decl int `[](int i)    *!    *! String index operator.    */   static void f_string_assignment_index(INT32 args)   {    ptrdiff_t len;    INT_TYPE i, p;    -  get_all_args("string[]", args, "%i", &p); +  get_all_args(NULL, args, "%i", &p);       if (!THIS->s) {    Pike_error("Indexing uninitialized string_assignment.\n");    }       len = THIS->s->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",
pike.git/src/operators.c:5545:   /*! @decl int `[]=(int i, int j)    *!    *! String assign index operator.    */   static void f_string_assignment_assign_index(INT32 args)   {    INT_TYPE p, i, j;    union anything *u;    ptrdiff_t len;    -  get_all_args("string[]=",args,"%i%i",&p,&j); +  get_all_args(NULL, args, "%i%i", &p, &j);       if((u=get_pointer_if_this_type(THIS->lval, T_STRING)))    {    len = 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);    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))   {
pike.git/src/operators.c:5677:      #define CMP_TYPE "!function(!(object|mixed)...:mixed)&function(mixed...:int(0..1))|function(int|float...:int(0..1))|function(string...:int(0..1))|function(type|program,type|program,type|program...:int(0..1))"    add_efun2("`<", f_lt,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison);    add_efun2("`<=",f_le,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison);    add_efun2("`>", f_gt,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison);    add_efun2("`>=",f_ge,CMP_TYPE,OPT_TRY_OPTIMIZE,0,generate_comparison);       ADD_EFUN2("`+",f_add,    tOr7(tIfnot(tFuncV(tNone,tNot(tOr(tObj,tMix)),tMix),    tFuncV(tNone,tMix,tMix)), -  tFuncV(tInt,tInt,tInt), +  tOr3(tFuncV(tIntPos,tIntPos,tIntPos), +  tFuncV(tIntNeg,tIntNeg,tIntNeg), +  tIfnot(tFuncV(tNone, tNot(tIntNeg), tMix), +  tIfnot(tFuncV(tNone, tNot(tIntPos), tMix), +  tFuncV(tInt, tInt, tInt)))),    tIfnot(tFuncV(tNone, tNot(tFlt), tMix),    tFuncV(tOr(tInt,tFlt),tOr(tInt,tFlt),tFlt)),    tIfnot(tFuncV(tNone, tNot(tStr), tMix),    tFuncV(tOr3(tSetvar(0, tStr),tInt,tFlt),    tOr3(tSetvar(1, tStr),tInt,tFlt),tOr(tVar(0),tVar(1)))),    tFuncV(tSetvar(0,tArray),tSetvar(1,tArray),    tOr(tVar(0),tVar(1))),    tFuncV(tSetvar(0,tMapping),tSetvar(1,tMapping),    tOr(tVar(0),tVar(1))),    tFuncV(tSetvar(0,tMultiset),tSetvar(1,tMultiset),    tOr(tVar(0),tVar(1)))),    OPT_TRY_OPTIMIZE,optimize_binary,generate_sum);       ADD_EFUN2("`-",f_minus,    tOr7(tIfnot(tFuncV(tNone,tNot(tOr(tObj,tMix)),tMix),    tFuncV(tNone,tMix,tMix)), -  tFuncV(tInt,tInt,tInt), +  tOr4(tFuncV(tIntNeg,tIntPos,tIntNeg), +  tFuncV(tIntPos,tIntNeg,tIntPos), +  tIfnot(tFuncV(tNot(tIntPos), tNot(tIntPos), tMix), +  tFuncV(tInt, tInt, tInt)), +  tIfnot(tFuncV(tNot(tIntNeg), tNot(tIntNeg), tMix), +  tFuncV(tInt, tInt, tInt))),    tIfnot(tFuncV(tNone,tNot(tFlt),tMix),    tFuncV(tOr(tInt,tFlt),tOr(tInt,tFlt),tFlt)),    tFuncV(tArr(tSetvar(0,tMix)),tArray,tArr(tVar(0))),    tFuncV(tMap(tSetvar(1,tMix),tSetvar(2,tMix)),    tOr3(tMapping,tArray,tMultiset),    tMap(tVar(1),tVar(2))),    tFunc(tSet(tSetvar(3,tMix)) tMultiset,tSet(tVar(3))),    tFuncV(tSetvar(0,tStr),tStr,tVar(0))),    OPT_TRY_OPTIMIZE,0,generate_minus);   
pike.git/src/operators.c:5808:    tFunc(tObj tMix, tOr3(tFloat,tInt,tObj)),    tFunc(tMix tObj, tOr3(tFloat,tInt,tObj)),    tFunc(tFloat tInt, tFloat)),    OPT_TRY_OPTIMIZE,0,0);       ADD_EFUN2("`*", f_multiply,    tOr9(tIfnot(tFuncV(tNone,tNot(tOr(tObj,tMix)),tMix),    tFuncV(tNone,tOr(tMix,tVoid),tMix)),    tFunc(tArr(tArr(tSetvar(1,tMix)))    tArr(tSetvar(1,tMix)),tArr(tVar(1))), -  tFuncV(tInt,tInt,tInt), +  tOr4(tFuncV(tIntPos,tIntPos,tIntPos), +  tFuncV(tIntNeg,tIntNeg,tIntPos), +  tFuncV(tIntPos,tIntNeg,tIntNeg), +  tFuncV(tIntNeg,tIntPos,tIntNeg)),    tIfnot(tFuncV(tNone,tNot(tFlt),tMix),    tFuncV(tOr(tFlt,tInt),tOr(tFlt,tInt),tFlt)),    tFunc(tArr(tStr) tStr,tStr),    tFunc(tArr(tSetvar(0,tMix)) tInt,tArr(tVar(0))),    tFunc(tArr(tSetvar(0,tMix)) tFlt,tArr(tVar(0))),    tFunc(tSetvar(0, tStr) tInt,tVar(0)),    tFunc(tSetvar(0, tStr) tFlt,tVar(0))),    OPT_TRY_OPTIMIZE,optimize_binary,generate_multiply);       /* !function(!object...:mixed)&function(mixed...:mixed)|"    "function(int,int...:int)|"    "!function(int...:mixed)&function(float|int...:float)|"    "function(array(0=mixed),array|int|float...:array(array(0)))|"    "function(string,string|int|float...:array(string)) */    ADD_EFUN2("`/", f_divide,    tOr5(tIfnot(tFuncV(tNone,tNot(tOr(tObj,tMix)),tMix),    tFuncV(tNone,tMix,tMix)), -  tFuncV(tInt, tInt, tInt), +  tOr4(tFuncV(tIntPos,tIntPos,tIntPos), +  tFuncV(tIntNeg,tIntNeg,tIntPos), +  tFuncV(tIntPos,tIntNeg,tIntNeg), +  tFuncV(tIntNeg,tIntPos,tIntNeg)),    tIfnot(tFuncV(tNone, tNot(tFlt), tMix),    tFuncV(tOr(tFlt,tInt),tOr(tFlt,tInt),tFlt)),    tFuncV(tArr(tSetvar(0,tMix)),    tOr3(tArray,tInt,tFlt),    tArr(tArr(tVar(0)))),    tFuncV(tStr,tOr3(tStr,tInt,tFlt),tArr(tStr))),    OPT_TRY_OPTIMIZE,0,generate_divide);       /* function(mixed,object:mixed)|"    "function(object,mixed:mixed)|"