pike.git / src / interpret_functions.h

version» Context lines:

pike.git/src/interpret_functions.h:277:    MEMMOVE(Pike_sp-arg1-arg2,Pike_sp-arg1,sizeof(struct svalue)*arg1);    MEMCPY(Pike_sp-arg2,Pike_sp,sizeof(struct svalue)*arg2);   });      /* The rest of the basic 'push value' instructions */      OPCODE1_TAIL(F_MARK_AND_STRING, "mark & string", I_UPDATE_SP|I_UPDATE_M_SP, {    *(Pike_mark_sp++)=Pike_sp;       OPCODE1(F_STRING, "string", I_UPDATE_SP, { -  copy_shared_string(Pike_sp->u.string,Pike_fp->context->prog->strings[arg1]); -  Pike_sp->type=PIKE_T_STRING; -  Pike_sp->subtype=0; -  Pike_sp++; +  ref_push_string(Pike_fp->context->prog->strings[arg1]);    print_return_value();    });   });         OPCODE1(F_ARROW_STRING, "->string", I_UPDATE_SP, { -  copy_shared_string(Pike_sp->u.string,Pike_fp->context->prog->strings[arg1]); -  Pike_sp->type=PIKE_T_STRING; -  Pike_sp->subtype=1; /* Magic */ -  Pike_sp++; +  ref_push_string(Pike_fp->context->prog->strings[arg1]); +  SET_SVAL_SUBTYPE(Pike_sp[-1], 1); /* Magic */    print_return_value();   });      OPCODE1(F_LOOKUP_LFUN, "->lfun", 0, {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct svalue tmp);    LOCAL_VAR(struct program *p);    -  if ((Pike_sp[-1].type == T_OBJECT) && +  if ((TYPEOF(Pike_sp[-1]) == T_OBJECT) &&    (p = (o = Pike_sp[-1].u.object)->prog) && -  (FIND_LFUN(p = p->inherits[Pike_sp[-1].subtype].prog, +  (FIND_LFUN(p = p->inherits[SUBTYPEOF(Pike_sp[-1])].prog,    LFUN_ARROW) == -1)) {    int id = FIND_LFUN(p, arg1);    if ((id != -1) &&    (!(p->identifier_references[id].id_flags &    (ID_PROTECTED|ID_PRIVATE|ID_HIDDEN)))) { -  id += o->prog->inherits[Pike_sp[-1].subtype].identifier_level; +  id += o->prog->inherits[SUBTYPEOF(Pike_sp[-1])].identifier_level;    low_object_index_no_free(&tmp, o, id);    } else {    /* Not found. */ -  tmp.type = T_INT; -  tmp.subtype = NUMBER_UNDEFINED; -  tmp.u.integer = 0; +  SET_SVAL(tmp, T_INT, NUMBER_UNDEFINED, integer, 0);    }    } else {    LOCAL_VAR(struct svalue tmp2); -  tmp2.type = PIKE_T_STRING; -  tmp2.u.string = lfun_strings[arg1]; -  tmp2.subtype = 1; +  SET_SVAL(tmp2, PIKE_T_STRING, 1, string, lfun_strings[arg1]);    index_no_free(&tmp, Pike_sp-1, &tmp2);    }    free_svalue(Pike_sp-1);    move_svalue (Pike_sp - 1, &tmp);    print_return_value();   });      OPCODE1(F_LFUN, "local function", I_UPDATE_SP, {    ref_push_function (Pike_fp->current_object,    arg1+Pike_fp->context->identifier_level);
pike.git/src/interpret_functions.h:455:    Pike_fp->locals + arg2);   });      OPCODE2(F_GLOBAL_2_LOCAL, "local = global", 0, {    free_svalue(Pike_fp->locals + arg2);    mark_free_svalue (Pike_fp->locals + arg2);    low_index_current_object_no_free(Pike_fp->locals + arg2, arg1);   });      OPCODE1(F_LOCAL_LVALUE, "& local", I_UPDATE_SP, { -  Pike_sp[0].type = T_SVALUE_PTR; -  Pike_sp[0].u.lval = Pike_fp->locals + arg1; -  Pike_sp[1].type = T_VOID; +  SET_SVAL(Pike_sp[0], T_SVALUE_PTR, 0, lval, Pike_fp->locals + arg1); +  SET_SVAL_TYPE(Pike_sp[1], T_VOID);    Pike_sp += 2;   });      OPCODE2(F_LEXICAL_LOCAL, "lexical local", I_UPDATE_SP, {    struct pike_frame *f=Pike_fp;    while(arg2--)    {    f=f->scope;    if(!f) Pike_error("Lexical scope error.\n");    }
pike.git/src/interpret_functions.h:479:    print_return_value();   });      OPCODE2(F_LEXICAL_LOCAL_LVALUE, "&lexical local", I_UPDATE_SP, {    struct pike_frame *f=Pike_fp;    while(arg2--)    {    f=f->scope;    if(!f) Pike_error("Lexical scope error.\n");    } -  Pike_sp[0].type=T_SVALUE_PTR; -  Pike_sp[0].u.lval=f->locals+arg1; -  Pike_sp[1].type=T_VOID; +  SET_SVAL(Pike_sp[0], T_SVALUE_PTR, 0, lval, f->locals+arg1); +  SET_SVAL_TYPE(Pike_sp[1], T_VOID);    Pike_sp+=2;   });      OPCODE1(F_ARRAY_LVALUE, "[ lvalues ]", I_UPDATE_SP, {    f_aggregate(arg1*2);    Pike_sp[-1].u.array->flags |= ARRAY_LVALUE;    Pike_sp[-1].u.array->type_field |= BIT_UNFINISHED | BIT_MIXED;    /* FIXME: Shouldn't a ref be added here? */    move_svalue (Pike_sp, Pike_sp - 1); -  Pike_sp[-1].type = T_ARRAY_LVALUE; +  SET_SVAL_TYPE(Pike_sp[-1], T_ARRAY_LVALUE);    Pike_sp++;   });      OPCODE1(F_CLEAR_2_LOCAL, "clear 2 local", 0, {    free_mixed_svalues(Pike_fp->locals + arg1, 2); -  Pike_fp->locals[arg1].type = PIKE_T_INT; -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; -  Pike_fp->locals[arg1].u.integer = 0; -  Pike_fp->locals[arg1+1].type = PIKE_T_INT; -  Pike_fp->locals[arg1+1].subtype = NUMBER_NUMBER; -  Pike_fp->locals[arg1+1].u.integer = 0; +  SET_SVAL(Pike_fp->locals[arg1], PIKE_T_INT, NUMBER_NUMBER, integer, 0); +  SET_SVAL(Pike_fp->locals[arg1+1], PIKE_T_INT, NUMBER_NUMBER, integer, 0);   });      OPCODE1(F_CLEAR_4_LOCAL, "clear 4 local", 0, {    int e;    free_mixed_svalues(Pike_fp->locals + arg1, 4);    for(e = 0; e < 4; e++)    { -  Pike_fp->locals[arg1+e].type = PIKE_T_INT; -  Pike_fp->locals[arg1+e].subtype = NUMBER_NUMBER; -  Pike_fp->locals[arg1+e].u.integer = 0; +  SET_SVAL(Pike_fp->locals[arg1+e], PIKE_T_INT, NUMBER_NUMBER, integer, 0);    }   });      OPCODE1(F_CLEAR_LOCAL, "clear local", 0, {    free_svalue(Pike_fp->locals + arg1); -  Pike_fp->locals[arg1].type = PIKE_T_INT; -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; -  Pike_fp->locals[arg1].u.integer = 0; +  SET_SVAL(Pike_fp->locals[arg1], PIKE_T_INT, NUMBER_NUMBER, integer, 0);   });      OPCODE1(F_INC_LOCAL, "++local", I_UPDATE_SP, { -  if( (Pike_fp->locals[arg1].type == PIKE_T_INT) +  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT)    DO_IF_BIGNUM(    && (!INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1))    )    )    {    push_int(++(Pike_fp->locals[arg1].u.integer)); -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else {    push_svalue(Pike_fp->locals+arg1);    push_int(1);    f_add(2);    assign_svalue(Pike_fp->locals+arg1,Pike_sp-1);    }   });      OPCODE1(F_POST_INC_LOCAL, "local++", I_UPDATE_SP, {    push_svalue( Pike_fp->locals + arg1);    -  if( (Pike_fp->locals[arg1].type == PIKE_T_INT) +  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT)    DO_IF_BIGNUM(    && (!INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1))    )    )    {    Pike_fp->locals[arg1].u.integer++; -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else {    push_svalue(Pike_fp->locals + arg1);    push_int(1);    f_add(2);    stack_pop_to(Pike_fp->locals + arg1);    }   });      OPCODE1(F_INC_LOCAL_AND_POP, "++local and pop", 0, { -  if( (Pike_fp->locals[arg1].type == PIKE_T_INT) +  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT)    DO_IF_BIGNUM(    && (!INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1))    )    )    {    Pike_fp->locals[arg1].u.integer++; -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else {    push_svalue( Pike_fp->locals + arg1);    push_int(1);    f_add(2);    stack_pop_to(Pike_fp->locals + arg1);    }   });      OPCODE1(F_DEC_LOCAL, "--local", I_UPDATE_SP, { -  if( (Pike_fp->locals[arg1].type == PIKE_T_INT) +  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT)    DO_IF_BIGNUM(    && (!INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1))    )    )    {    push_int(--(Pike_fp->locals[arg1].u.integer)); -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else {    push_svalue(Pike_fp->locals+arg1);    push_int(1);    o_subtract();    assign_svalue(Pike_fp->locals+arg1,Pike_sp-1);    }   });      OPCODE1(F_POST_DEC_LOCAL, "local--", I_UPDATE_SP, {    push_svalue( Pike_fp->locals + arg1);    -  if( (Pike_fp->locals[arg1].type == PIKE_T_INT) +  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT)    DO_IF_BIGNUM(    && (!INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1))    )    )    {    Pike_fp->locals[arg1].u.integer--; -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else {    push_svalue(Pike_fp->locals + arg1);    push_int(1);    o_subtract();    stack_pop_to(Pike_fp->locals + arg1);    }   });      OPCODE1(F_DEC_LOCAL_AND_POP, "--local and pop", 0, { -  if( (Pike_fp->locals[arg1].type == PIKE_T_INT) +  if( (TYPEOF(Pike_fp->locals[arg1]) == PIKE_T_INT)    DO_IF_BIGNUM(    && (!INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[arg1].u.integer, 1))    )    )    {    Pike_fp->locals[arg1].u.integer--; -  Pike_fp->locals[arg1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_fp->locals[arg1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    } else {    push_svalue(Pike_fp->locals + arg1);    push_int(1);    o_subtract();    stack_pop_to(Pike_fp->locals + arg1);    }   });      /* lval[0], lval[1], *Pike_sp    * ->
pike.git/src/interpret_functions.h:674:   OPCODE0(F_LTOSVAL2_AND_FREE, "ltosval2 and free", I_UPDATE_SP, {    dmalloc_touch_svalue(Pike_sp-3);    dmalloc_touch_svalue(Pike_sp-2);    dmalloc_touch_svalue(Pike_sp-1);       move_svalue (Pike_sp, Pike_sp - 1);    mark_free_svalue (Pike_sp - 1);    Pike_sp++;    lvalue_to_svalue_no_free(Pike_sp-2, Pike_sp-4);    -  if( (1 << Pike_sp[-2].type) & +  if( (1 << TYPEOF(Pike_sp[-2])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    {    LOCAL_VAR(struct svalue tmp); -  tmp.type = PIKE_T_INT; -  tmp.subtype = NUMBER_NUMBER; -  tmp.u.integer = 0; +  SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-4, &tmp);    }   });      /* lval[0], lval[1], x, y, *Pike_sp    * ->    * lval[0], lval[1], result, x, y, *Pike_sp    */   OPCODE0(F_LTOSVAL3_AND_FREE, "ltosval3 and free", I_UPDATE_SP, {    dmalloc_touch_svalue(Pike_sp-4);
pike.git/src/interpret_functions.h:707:    mark_free_svalue (Pike_sp - 2);    Pike_sp++;    lvalue_to_svalue_no_free(Pike_sp-3, Pike_sp-5);       /* This is so that foo=foo[x..y] (and similar things) will be faster.    * It's done by freeing the old reference to foo after it has been    * pushed on the stack. That way foo can have only 1 reference if we    * are lucky, and then the low array/multiset/mapping manipulation    * routines can be destructive if they like.    */ -  if( (1 << Pike_sp[-3].type) & +  if( (1 << TYPEOF(Pike_sp[-3])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    {    LOCAL_VAR(struct svalue tmp); -  tmp.type = PIKE_T_INT; -  tmp.subtype = NUMBER_NUMBER; -  tmp.u.integer = 0; +  SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-5, &tmp);    }   });      /* lval[0], lval[1], *Pike_sp    * ->    * lval[0], lval[1], result, *Pike_sp    */   OPCODE0(F_LTOSVAL_AND_FREE, "ltosval and free", I_UPDATE_SP, {    dmalloc_touch_svalue(Pike_sp-2);    dmalloc_touch_svalue(Pike_sp-1);       lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2);    Pike_sp++;       /* See ltosval3. This opcode is used e.g. in foo = foo[..] where no    * bound arguments are pushed on the stack. */ -  if( (1 << Pike_sp[-1].type) & +  if( (1 << TYPEOF(Pike_sp[-1])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    {    LOCAL_VAR(struct svalue tmp); -  tmp.type = PIKE_T_INT; -  tmp.subtype = NUMBER_NUMBER; -  tmp.u.integer = 0; +  SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-3, &tmp);    }   });      OPCODE0(F_ADD_TO, "+=", I_UPDATE_SP, {    ONERROR uwp;    move_svalue (Pike_sp, Pike_sp - 1);    mark_free_svalue (Pike_sp - 1);    Pike_sp++;    lvalue_to_svalue_no_free(Pike_sp-2,Pike_sp-4);    -  if( Pike_sp[-1].type == PIKE_T_INT && -  Pike_sp[-2].type == PIKE_T_INT ) +  if( TYPEOF(Pike_sp[-1]) == PIKE_T_INT && +  TYPEOF(Pike_sp[-2]) == PIKE_T_INT )    {    DO_IF_BIGNUM(    if(!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, Pike_sp[-2].u.integer))    )    {    /* Optimization for a rather common case. Makes it 30% faster. */    INT_TYPE val = (Pike_sp[-1].u.integer += Pike_sp[-2].u.integer); -  Pike_sp[-1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    assign_lvalue(Pike_sp-4,Pike_sp-1);    Pike_sp-=2;    pop_2_elems();    push_int(val);    goto add_to_done;    }    }    /* This is so that foo+=bar (and similar things) will be faster.    * It's done by freeing the old reference to foo after it has been    * pushed on the stack. That way foo can have only 1 reference if we    * are lucky, and then the low array/multiset/mapping manipulation    * routines can be destructive if they like.    */ -  if( (1 << Pike_sp[-2].type) & +  if( (1 << TYPEOF(Pike_sp[-2])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    {    LOCAL_VAR(struct svalue tmp); -  tmp.type=PIKE_T_INT; -  tmp.subtype=NUMBER_NUMBER; -  tmp.u.integer=0; +  SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-4, &tmp); -  } else if (Pike_sp[-2].type == T_OBJECT) { +  } else if (TYPEOF(Pike_sp[-2]) == T_OBJECT) {    /* One ref in the lvalue, and one on the stack. */    int i;    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    if((o = Pike_sp[-2].u.object)->refs <= 2 &&    (p = o->prog) && -  (i = FIND_LFUN(p->inherits[Pike_sp[-2].subtype].prog, +  (i = FIND_LFUN(p->inherits[SUBTYPEOF(Pike_sp[-2])].prog,    LFUN_ADD_EQ)) != -1)    { -  apply_low(o, i + p->inherits[Pike_sp[-2].subtype].identifier_level, 1); +  apply_low(o, i + p->inherits[SUBTYPEOF(Pike_sp[-2])].identifier_level, 1);    /* NB: The lvalue already contains the object, so    * no need to reassign it.    */    pop_stack();    stack_pop_2_elems_keep_top();    goto add_to_done;    }    }    /* NOTE: Pike_sp-4 is the lvalue, Pike_sp-2 is the original value.    * If an error gets thrown, the original value will thus be restored.
pike.git/src/interpret_functions.h:818:    ; /* make gcc happy */   });      OPCODE0(F_ADD_TO_AND_POP, "+= and pop", I_UPDATE_SP, {    ONERROR uwp;    move_svalue (Pike_sp, Pike_sp - 1);    mark_free_svalue (Pike_sp - 1);    Pike_sp++;    lvalue_to_svalue_no_free(Pike_sp-2,Pike_sp-4);    -  if( Pike_sp[-1].type == PIKE_T_INT && -  Pike_sp[-2].type == PIKE_T_INT ) +  if( TYPEOF(Pike_sp[-1]) == PIKE_T_INT && +  TYPEOF(Pike_sp[-2]) == PIKE_T_INT )    {    DO_IF_BIGNUM(    if(!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, Pike_sp[-2].u.integer))    )    {    /* Optimization for a rather common case. Makes it 30% faster. */    Pike_sp[-1].u.integer += Pike_sp[-2].u.integer; -  Pike_sp[-1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    assign_lvalue(Pike_sp-4,Pike_sp-1);    Pike_sp-=2;    pop_2_elems();    goto add_to_and_pop_done;    }    }    /* This is so that foo+=bar (and similar things) will be faster.    * It's done by freeing the old reference to foo after it has been    * pushed on the stack. That way foo can have only 1 reference if we    * are lucky, and then the low array/multiset/mapping manipulation    * routines can be destructive if they like.    */ -  if( (1 << Pike_sp[-2].type) & +  if( (1 << TYPEOF(Pike_sp[-2])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    {    LOCAL_VAR(struct svalue tmp); -  tmp.type=PIKE_T_INT; -  tmp.subtype=NUMBER_NUMBER; -  tmp.u.integer=0; +  SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-4, &tmp); -  } else if (Pike_sp[-2].type == PIKE_T_OBJECT) { +  } else if (TYPEOF(Pike_sp[-2]) == PIKE_T_OBJECT) {    /* One ref in the lvalue, and one on the stack. */    int i;    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    if((o = Pike_sp[-2].u.object)->refs <= 2 &&    (p = o->prog) && -  (i = FIND_LFUN(p->inherits[Pike_sp[-2].subtype].prog, +  (i = FIND_LFUN(p->inherits[SUBTYPEOF(Pike_sp[-2])].prog,    LFUN_ADD_EQ)) != -1)    { -  apply_low(o, i + p->inherits[Pike_sp[-2].subtype].identifier_level, 1); +  apply_low(o, i + p->inherits[SUBTYPEOF(Pike_sp[-2])].identifier_level, 1);    /* NB: The lvalue already contains the object, so    * no need to reassign it.    */    pop_n_elems(4);    goto add_to_and_pop_done;    }    }    /* NOTE: Pike_sp-4 is the lvalue, Pike_sp-2 is the original value.    * If an error gets thrown, the original value will thus be restored.    * If f_add() succeeds, Pike_sp-2 will hold the result.
pike.git/src/interpret_functions.h:1117:    pop_n_elems(Pike_sp - *Pike_mark_sp);    Pike_fatal("Stack out of synch - "    "should be %"PRINTPTRDIFFT"d, is %"PRINTPTRDIFFT"d.\n",    should, is);    }    }    });   });      OPCODE0(F_CLEAR_STRING_SUBTYPE, "clear string subtype", 0, { -  if(Pike_sp[-1].type==PIKE_T_STRING) Pike_sp[-1].subtype=0; +  if(TYPEOF(Pike_sp[-1]) == PIKE_T_STRING) SET_SVAL_SUBTYPE(Pike_sp[-1], 0);   });       /* Jumps */   OPCODE0_BRANCH(F_BRANCH, "branch", 0, {    DO_BRANCH();   });      OPCODE2_BRANCH(F_BRANCH_IF_NOT_LOCAL_ARROW, "branch if !local->x", 0, {    LOCAL_VAR(struct svalue tmp); -  tmp.type=PIKE_T_STRING; -  tmp.u.string=Pike_fp->context->prog->strings[arg1]; -  tmp.subtype=1; +  SET_SVAL(tmp, PIKE_T_STRING, 1, string, +  Pike_fp->context->prog->strings[arg1]);    mark_free_svalue (Pike_sp);    Pike_sp++;    index_no_free(Pike_sp-1,Pike_fp->locals+arg2, &tmp);    print_return_value();       /* Fall through */       OPCODE0_TAILBRANCH(F_BRANCH_WHEN_ZERO, "branch if zero", I_UPDATE_SP, {    if(!UNSAFE_IS_ZERO(Pike_sp-1))    {
pike.git/src/interpret_functions.h:1164:    DONT_BRANCH();    }else{    DO_BRANCH();    }    pop_stack();   });      OPCODE1_BRANCH(F_BRANCH_IF_TYPE_IS_NOT, "branch if type is !=", I_UPDATE_SP, {   /* fprintf(stderr,"******BRANCH IF TYPE IS NOT***** %s\n",get_name_of_type(arg1)); */    LOCAL_VAR(struct object *o); -  if(Pike_sp[-1].type == T_OBJECT && +  if(TYPEOF(Pike_sp[-1]) == T_OBJECT &&    (o = Pike_sp[-1].u.object)->prog)    { -  int fun = FIND_LFUN(o->prog->inherits[Pike_sp[-1].subtype].prog, +  int fun = FIND_LFUN(o->prog->inherits[SUBTYPEOF(Pike_sp[-1])].prog,    LFUN__IS_TYPE);    if(fun != -1)    {   /* fprintf(stderr,"******OBJECT OVERLOAD IN TYPEP***** %s\n",get_name_of_type(arg1)); */    push_text(get_name_of_type(arg1));    apply_low(o, fun + -  o->prog->inherits[Pike_sp[-2].subtype].identifier_level, 1); +  o->prog->inherits[SUBTYPEOF(Pike_sp[-2])].identifier_level, 1);    arg1=UNSAFE_IS_ZERO(Pike_sp-1) ? T_FLOAT : T_OBJECT ;    pop_stack();    }    } -  if(Pike_sp[-1].type == arg1) +  if(TYPEOF(Pike_sp[-1]) == arg1)    {    /* write_to_stderr("foreach\n", 8); */    DONT_BRANCH();    }else{    DO_BRANCH();    }    pop_stack();   });      OPCODE1_BRANCH(F_BRANCH_IF_LOCAL, "branch if local", 0, {
pike.git/src/interpret_functions.h:1491:   #else   #define AUTO_BIGNUM_LOOP_TEST(X,Y) 0   #endif       /* FIXME: Does this need bignum tests? /Fixed - Hubbe */    /* LOOP(OPCODE, INCREMENT, OPERATOR, IS_OPERATOR) */   #define LOOP(ID, DESC, INC, OP2, OP4) \    OPCODE0_BRANCH(ID, DESC, 0, { \    union anything *i=get_pointer_if_this_type(Pike_sp-2, T_INT); \    if(i && !AUTO_BIGNUM_LOOP_TEST(i->integer,INC) && \ -  Pike_sp[-3].type == T_INT) \ +  TYPEOF(Pike_sp[-3]) == T_INT) \    { \    i->integer += INC; \    if(i->integer OP2 Pike_sp[-3].u.integer) \    { \    DO_BRANCH(); \    }else{ \    /* write_to_stderr("loop\n", 8); */ \    DONT_BRANCH(); \    } \    }else{ \
pike.git/src/interpret_functions.h:1547:    o_subtract();    DO_BRANCH();    } else {    /* write_to_stderr("foreach\n", 8); */    DONT_BRANCH();    pop_2_elems();    }   });      OPCODE0_BRANCH(F_FOREACH, "foreach", 0, { /* array, lvalue, i */ -  if(Pike_sp[-4].type != PIKE_T_ARRAY) +  if(TYPEOF(Pike_sp[-4]) != PIKE_T_ARRAY)    PIKE_ERROR("foreach", "Bad argument 1.\n", Pike_sp-3, 1);    if(Pike_sp[-1].u.integer < Pike_sp[-4].u.array->size)    {    if(Pike_sp[-1].u.integer < 0)    /* Isn't this an internal compiler error? /mast */    Pike_error("Foreach loop variable is negative!\n");    assign_lvalue(Pike_sp-3, Pike_sp[-4].u.array->item + Pike_sp[-1].u.integer);    DO_BRANCH();    Pike_sp[-1].u.integer++;    DO_IF_DEBUG ( -  if (Pike_sp[-1].subtype) +  if (SUBTYPEOF(Pike_sp[-1]))    Pike_fatal ("Got unexpected subtype in loop variable.\n");    );    }else{    /* write_to_stderr("foreach\n", 8); */    DONT_BRANCH();    }   });      OPCODE0(F_MAKE_ITERATOR, "get_iterator", 0, {    f_get_iterator(1);   });      /* Stack is: iterator, index lvalue, value lvalue. */   OPCODE0_BRANCH (F_FOREACH_START, "foreach start", 0, {    DO_IF_DEBUG ( -  if(Pike_sp[-5].type != PIKE_T_OBJECT) +  if(TYPEOF(Pike_sp[-5]) != PIKE_T_OBJECT)    Pike_fatal ("Iterator gone from stack.\n");    );    /* FIXME: object subtype. */    if (foreach_iterate (Pike_sp[-5].u.object, 0))    DONT_BRANCH();    else {    DO_BRANCH();    }   });      /* Stack is: iterator, index lvalue, value lvalue. */   OPCODE0_BRANCH(F_FOREACH_LOOP, "foreach loop", 0, {    DO_IF_DEBUG ( -  if(Pike_sp[-5].type != PIKE_T_OBJECT) +  if(TYPEOF(Pike_sp[-5]) != PIKE_T_OBJECT)    Pike_fatal ("Iterator gone from stack.\n");    );    /* FIXME: object subtype. */    if(foreach_iterate(Pike_sp[-5].u.object, 1))    {    DO_BRANCH();    }else{    DONT_BRANCH();    }   });
pike.git/src/interpret_functions.h:1645:      OPCODE0_RETURN(F_RETURN, "return", I_UPDATE_FP, {    DO_RETURN;   });      OPCODE0_RETURN(F_DUMB_RETURN,"dumb return", I_UPDATE_FP, {    DO_DUMB_RETURN;   });      OPCODE0(F_NEGATE, "unary minus", 0, { -  if(Pike_sp[-1].type == PIKE_T_INT) +  if(TYPEOF(Pike_sp[-1]) == PIKE_T_INT)    {    DO_IF_BIGNUM(    if(INT_TYPE_NEG_OVERFLOW(Pike_sp[-1].u.integer))    {    convert_stack_top_to_bignum();    o_negate();    }    else    )    {    Pike_sp[-1].u.integer =- Pike_sp[-1].u.integer; -  Pike_sp[-1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    }    } -  else if(Pike_sp[-1].type == PIKE_T_FLOAT) +  else if(TYPEOF(Pike_sp[-1]) == PIKE_T_FLOAT)    {    Pike_sp[-1].u.float_number =- Pike_sp[-1].u.float_number;    }else{    o_negate();    }   });      OPCODE0_ALIAS(F_COMPL, "~", 0, o_compl);      OPCODE0(F_NOT, "!", 0, { -  switch(Pike_sp[-1].type) +  switch(TYPEOF(Pike_sp[-1]))    {    case PIKE_T_INT:    Pike_sp[-1].u.integer =! Pike_sp[-1].u.integer; -  Pike_sp[-1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    break;       case PIKE_T_FUNCTION:    case PIKE_T_OBJECT:    if(UNSAFE_IS_ZERO(Pike_sp-1))    {    pop_stack();    push_int(1);    }else{    pop_stack();    push_int(0);    }    break;       default:    free_svalue(Pike_sp-1); -  Pike_sp[-1].type=PIKE_T_INT; -  Pike_sp[-1].subtype = NUMBER_NUMBER; -  Pike_sp[-1].u.integer=0; +  SET_SVAL(Pike_sp[-1], PIKE_T_INT, NUMBER_NUMBER, integer, 0);    }   });      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE0_ALIAS(F_LSH, "<<", I_UPDATE_SP, o_lsh);   OPCODE0_ALIAS(F_RSH, ">>", I_UPDATE_SP, o_rsh);      #define COMPARISON(ID,DESC,EXPR) \    OPCODE0(ID, DESC, I_UPDATE_SP, { \    INT32 val = EXPR; \
pike.git/src/interpret_functions.h:1723:   COMPARISON(F_LT, "<", is_lt(Pike_sp-2,Pike_sp-1));   COMPARISON(F_LE, "<=", is_le(Pike_sp-2,Pike_sp-1));      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE0(F_ADD, "+", I_UPDATE_SP, {    f_add(2);   });      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE0(F_ADD_INTS, "int+int", I_UPDATE_SP, { -  if(Pike_sp[-1].type == T_INT && Pike_sp[-2].type == T_INT +  if(TYPEOF(Pike_sp[-1]) == T_INT && TYPEOF(Pike_sp[-2]) == T_INT    DO_IF_BIGNUM(    && (!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, Pike_sp[-2].u.integer))    )    )    {    Pike_sp[-2].u.integer+=Pike_sp[-1].u.integer; -  Pike_sp[-2].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_sp[-2], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp--;    }else{    f_add(2);    }   });      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE0(F_ADD_FLOATS, "float+float", I_UPDATE_SP, { -  if(Pike_sp[-1].type == T_FLOAT && Pike_sp[-2].type == T_FLOAT) +  if(TYPEOF(Pike_sp[-1]) == T_FLOAT && TYPEOF(Pike_sp[-2]) == T_FLOAT)    {    Pike_sp[-2].u.float_number+=Pike_sp[-1].u.float_number;    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp--;    }else{    f_add(2);    }   });      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE0_ALIAS(F_SUBTRACT, "-", I_UPDATE_SP, o_subtract);   OPCODE0_ALIAS(F_AND, "&", I_UPDATE_SP, o_and);   OPCODE0_ALIAS(F_OR, "|", I_UPDATE_SP, o_or);   OPCODE0_ALIAS(F_XOR, "^", I_UPDATE_SP, o_xor);   OPCODE0_ALIAS(F_MULTIPLY, "*", I_UPDATE_SP, o_multiply);   OPCODE0_ALIAS(F_DIVIDE, "/", I_UPDATE_SP, o_divide);   OPCODE0_ALIAS(F_MOD, "%", I_UPDATE_SP, o_mod);      OPCODE1(F_ADD_INT, "add integer", 0, { -  if(Pike_sp[-1].type == T_INT +  if(TYPEOF(Pike_sp[-1]) == T_INT    DO_IF_BIGNUM(    && (!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, arg1))    )    )    {    Pike_sp[-1].u.integer+=arg1; -  Pike_sp[-1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    }else{    push_int(arg1);    f_add(2);    }   });      OPCODE1(F_ADD_NEG_INT, "add -integer", 0, { -  if(Pike_sp[-1].type == T_INT +  if(TYPEOF(Pike_sp[-1]) == T_INT    DO_IF_BIGNUM(    && (!INT_TYPE_ADD_OVERFLOW(Pike_sp[-1].u.integer, -arg1))    )    )    {    Pike_sp[-1].u.integer-=arg1; -  Pike_sp[-1].subtype = NUMBER_NUMBER; /* Could have UNDEFINED there before. */ +  SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER); /* Could have UNDEFINED there before. */    }else{    push_int(-arg1);    f_add(2);    }   });      OPCODE0(F_PUSH_ARRAY, "@", I_UPDATE_SP, {    int i;    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    -  switch(Pike_sp[-1].type) +  switch(TYPEOF(Pike_sp[-1]))    {    default:    PIKE_ERROR("@", "Bad argument.\n", Pike_sp, 1);       case PIKE_T_OBJECT:    if(!(p = (o = Pike_sp[-1].u.object)->prog) || -  (i = FIND_LFUN(p->inherits[Pike_sp[-1].subtype].prog, +  (i = FIND_LFUN(p->inherits[SUBTYPEOF(Pike_sp[-1])].prog,    LFUN__VALUES)) == -1)    PIKE_ERROR("@", "Bad argument.\n", Pike_sp, 1);    -  apply_low(o, i + p->inherits[Pike_sp[-1].subtype].identifier_level, 0); -  if(Pike_sp[-1].type != PIKE_T_ARRAY) +  apply_low(o, i + p->inherits[SUBTYPEOF(Pike_sp[-1])].identifier_level, 0); +  if(TYPEOF(Pike_sp[-1]) != PIKE_T_ARRAY)    Pike_error("Bad return type from o->_values() in @\n");    free_svalue(Pike_sp-2);    move_svalue (Pike_sp - 2, Pike_sp - 1);    Pike_sp--;    break;       case PIKE_T_ARRAY: break;    }    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp--;    push_array_items(Pike_sp->u.array);   });      OPCODE0(F_APPEND_ARRAY, "append array", I_UPDATE_SP|I_UPDATE_M_SP, {    o_append_array(Pike_sp - *(--Pike_mark_sp));    });      OPCODE2(F_LOCAL_LOCAL_INDEX, "local[local]", I_UPDATE_SP, {    LOCAL_VAR(struct svalue *s);    s = Pike_fp->locals + arg1; -  if(s->type == PIKE_T_STRING) s->subtype=0; +  if(TYPEOF(*s) == PIKE_T_STRING) SET_SVAL_SUBTYPE(*s, 0);    mark_free_svalue (Pike_sp++);    index_no_free(Pike_sp-1,Pike_fp->locals+arg2,s);   });      OPCODE1(F_LOCAL_INDEX, "local index", 0, {    LOCAL_VAR(struct svalue *s);    LOCAL_VAR(struct svalue tmp);    s = Pike_fp->locals + arg1; -  if(s->type == PIKE_T_STRING) s->subtype=0; +  if(TYPEOF(*s) == PIKE_T_STRING) SET_SVAL_SUBTYPE(*s, 0);    index_no_free(&tmp,Pike_sp-1,s);    free_svalue(Pike_sp-1);    move_svalue (Pike_sp - 1, &tmp);   });      OPCODE2(F_GLOBAL_LOCAL_INDEX, "global[local]", I_UPDATE_SP, {    LOCAL_VAR(struct svalue *s);    LOCAL_VAR(struct svalue tmp);    low_index_current_object_no_free(Pike_sp, arg1);    Pike_sp++;    s=Pike_fp->locals+arg2; -  if(s->type == PIKE_T_STRING) s->subtype=0; +  if(TYPEOF(*s) == PIKE_T_STRING) SET_SVAL_SUBTYPE(*s, 0);    index_no_free(&tmp,Pike_sp-1,s);    free_svalue(Pike_sp-1);    move_svalue (Pike_sp - 1, &tmp);   });      OPCODE2(F_LOCAL_ARROW, "local->x", I_UPDATE_SP, {    LOCAL_VAR(struct svalue tmp); -  tmp.type=PIKE_T_STRING; -  tmp.u.string=Pike_fp->context->prog->strings[arg1]; -  tmp.subtype=1; +  SET_SVAL(tmp, PIKE_T_STRING, 1, string, +  Pike_fp->context->prog->strings[arg1]);    mark_free_svalue (Pike_sp++);    index_no_free(Pike_sp-1,Pike_fp->locals+arg2, &tmp);    print_return_value();   });      OPCODE1(F_ARROW, "->x", 0, {    LOCAL_VAR(struct svalue tmp);    LOCAL_VAR(struct svalue tmp2); -  tmp.type=PIKE_T_STRING; -  tmp.u.string=Pike_fp->context->prog->strings[arg1]; -  tmp.subtype=1; +  SET_SVAL(tmp, PIKE_T_STRING, 1, string, +  Pike_fp->context->prog->strings[arg1]);    index_no_free(&tmp2, Pike_sp-1, &tmp);    free_svalue(Pike_sp-1);    move_svalue (Pike_sp - 1, &tmp2);    print_return_value();   });      OPCODE1(F_STRING_INDEX, "string index", 0, {    LOCAL_VAR(struct svalue tmp);    LOCAL_VAR(struct svalue tmp2); -  tmp.type=PIKE_T_STRING; -  tmp.u.string=Pike_fp->context->prog->strings[arg1]; -  tmp.subtype=0; +  SET_SVAL(tmp, PIKE_T_STRING, 0, string, +  Pike_fp->context->prog->strings[arg1]);    index_no_free(&tmp2, Pike_sp-1, &tmp);    free_svalue(Pike_sp-1);    move_svalue (Pike_sp - 1, &tmp2);    print_return_value();   });      OPCODE1(F_POS_INT_INDEX, "int index", 0, {    push_int((ptrdiff_t)(int)arg1);    print_return_value();    DO_INDEX;
pike.git/src/interpret_functions.h:1927:    push_magic_index(magic_values_program, arg2, arg1);   });      OPCODE0_ALIAS(F_CAST, "cast", I_UPDATE_SP, f_cast);   OPCODE0_ALIAS(F_CAST_TO_INT, "cast_to_int", 0, o_cast_to_int);   OPCODE0_ALIAS(F_CAST_TO_STRING, "cast_to_string", 0, o_cast_to_string);      OPCODE0(F_SOFT_CAST, "soft cast", I_UPDATE_SP, {    /* Stack: type_string, value */    DO_IF_DEBUG({ -  if (Pike_sp[-2].type != T_TYPE) { +  if (TYPEOF(Pike_sp[-2]) != T_TYPE) {    Pike_fatal("Argument 1 to soft_cast isn't a type!\n");    }    });    if (runtime_options & RUNTIME_CHECK_TYPES) {    o_check_soft_cast(Pike_sp-1, Pike_sp[-2].u.type);    DO_IF_DEBUG({    if (d_flag > 2) {    struct pike_string *t = describe_type(Pike_sp[-2].u.type);    fprintf(stderr, "Soft cast to %s\n", t->str);    free_string(t);
pike.git/src/interpret_functions.h:1959:    LOCAL_VAR(struct svalue tmp);    copy_svalues_recursively_no_free(&tmp,Pike_sp-1,1,0);    free_svalue(Pike_sp-1);    move_svalue (Pike_sp - 1, &tmp);    print_return_value();   });      OPCODE0(F_INDIRECT, "indirect", I_UPDATE_SP, {    LOCAL_VAR(struct svalue tmp);    lvalue_to_svalue_no_free(&tmp, Pike_sp-2); -  if(tmp.type != PIKE_T_STRING) +  if(TYPEOF(tmp) != PIKE_T_STRING)    {    pop_2_elems();    move_svalue (Pike_sp, &tmp);    Pike_sp++;    }else{    struct string_assignment_storage *s;    LOCAL_VAR(struct object *o);    o=low_clone(string_assignment_program);    s = (struct string_assignment_storage *)o->storage;    move_svalue (s->lval, Pike_sp - 2);
pike.git/src/interpret_functions.h:2098:   MKAPPLY2(OPCODE1,APPLY,"apply",APPLY_SVALUE_STRICT,    &((Pike_fp->context->prog->constants + arg1)->sval),0);      MKAPPLY(OPCODE0,CALL_FUNCTION,"call function",APPLY_STACK, 0,0);      OPCODE1_JUMP(F_CALL_OTHER,"call other", I_UPDATE_ALL, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));    LOCAL_VAR(struct svalue *s);    s = Pike_sp-args;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); -  if(s->type == T_OBJECT) +  if(TYPEOF(*s) == T_OBJECT)    {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    o = s->u.object;    if((p=o->prog))    { -  p = p->inherits[s->subtype].prog; +  p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    { -  fun += o->prog->inherits[s->subtype].identifier_level; +  fun += o->prog->inherits[SUBTYPEOF(*s)].identifier_level;    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun))    {    Pike_fp->save_sp--;    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(Pike_fp->pc);    }    stack_pop_keep_top();    DO_JUMP_TO_NEXT;    }    }    }    }       {    LOCAL_VAR(struct svalue tmp);    LOCAL_VAR(struct svalue tmp2);    -  tmp.type=PIKE_T_STRING; -  tmp.u.string=Pike_fp->context->prog->strings[arg1]; -  tmp.subtype=1; +  SET_SVAL(tmp, PIKE_T_STRING, 1, string, +  Pike_fp->context->prog->strings[arg1]);       index_no_free(&tmp2, s, &tmp);    free_svalue(s);    move_svalue (s, &tmp2);    print_return_value();       if(low_mega_apply(APPLY_STACK, args, 0, 0))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(Pike_fp->pc);
pike.git/src/interpret_functions.h:2156:    DO_JUMP_TO_NEXT;    }    }   });      OPCODE1_JUMP(F_CALL_OTHER_AND_POP,"call other & pop", I_UPDATE_ALL, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));    LOCAL_VAR(struct svalue *s);    s = Pike_sp-args;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); -  if(s->type == T_OBJECT) +  if(TYPEOF(*s) == T_OBJECT)    {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    o = s->u.object;    if((p=o->prog))    { -  p = p->inherits[s->subtype].prog; +  p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    { -  fun += o->prog->inherits[s->subtype].identifier_level; +  fun += o->prog->inherits[SUBTYPEOF(*s)].identifier_level;    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun))    {    Pike_fp->save_sp--;    Pike_fp->flags |=    PIKE_FRAME_RETURN_INTERNAL |    PIKE_FRAME_RETURN_POP;    DO_JUMP_TO(Pike_fp->pc);    }    pop_2_elems();    DO_JUMP_TO_NEXT;    }    }    }    }       {    LOCAL_VAR(struct svalue tmp);    LOCAL_VAR(struct svalue tmp2);    -  tmp.type=PIKE_T_STRING; -  tmp.u.string=Pike_fp->context->prog->strings[arg1]; -  tmp.subtype=1; +  SET_SVAL(tmp, PIKE_T_STRING, 1, string, +  Pike_fp->context->prog->strings[arg1]);       index_no_free(&tmp2, s, &tmp);    free_svalue(s);    move_svalue (s, &tmp2);    print_return_value();       if(low_mega_apply(APPLY_STACK, args, 0, 0))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP;    DO_JUMP_TO(Pike_fp->pc);
pike.git/src/interpret_functions.h:2216:    pop_stack();    DO_JUMP_TO_NEXT;    }    }   });      OPCODE1_RETURN(F_CALL_OTHER_AND_RETURN,"call other & return", I_UPDATE_ALL, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp));    LOCAL_VAR(struct svalue *s);    s = Pike_sp - args; -  if(s->type == T_OBJECT) +  if(TYPEOF(*s) == T_OBJECT)    {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    o = s->u.object;    if((p=o->prog))    { -  p = p->inherits[s->subtype].prog; +  p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    { -  fun += o->prog->inherits[s->subtype].identifier_level; +  fun += o->prog->inherits[SUBTYPEOF(*s)].identifier_level;    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun))    {    PIKE_OPCODE_T *addr = Pike_fp->pc;    Pike_fp->save_sp--;    DO_IF_DEBUG(Pike_fp->next->pc=0);    unlink_previous_frame();    DO_JUMP_TO(addr);    }    stack_pop_keep_top();    DO_DUMB_RETURN;    }    }    }    }       {    LOCAL_VAR(struct svalue tmp);    LOCAL_VAR(struct svalue tmp2);    -  tmp.type=PIKE_T_STRING; -  tmp.u.string=Pike_fp->context->prog->strings[arg1]; -  tmp.subtype=1; +  SET_SVAL(tmp, PIKE_T_STRING, 1, string, +  Pike_fp->context->prog->strings[arg1]);       index_no_free(&tmp2, s, &tmp);    free_svalue(s);    move_svalue (s, &tmp2);    print_return_value();       if(low_mega_apply(APPLY_STACK, args, 0, 0))    {    PIKE_OPCODE_T *addr = Pike_fp->pc;    DO_IF_DEBUG(Pike_fp->next->pc=0);
pike.git/src/interpret_functions.h:2409:       free_svalue(Pike_sp-args);    mark_free_svalue (Pike_sp - args);    lvalue_to_svalue_no_free(Pike_sp-args, Pike_sp-args-2);    /* This is so that foo = efun(foo,...) (and similar things) will be faster.    * It's done by freeing the old reference to foo after it has been    * pushed on the stack. That way foo can have only 1 reference if we    * are lucky, and then the low array/multiset/mapping manipulation    * routines can be destructive if they like.    */ -  if( (1 << Pike_sp[-args].type) & +  if( (1 << TYPEOF(Pike_sp[-args])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    {    LOCAL_VAR(struct svalue tmp); -  tmp.type = PIKE_T_INT; -  tmp.subtype = NUMBER_NUMBER; -  tmp.u.integer = 0; +  SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-args-2, &tmp);    }    /* NOTE: Pike_sp-args-2 is the lvalue, Pike_sp-args is the original value.    * If an error gets thrown, the original value will thus be restored.    * If the efun succeeds, Pike_sp-args will hold the result.    */    SET_ONERROR(uwp, o_assign_lvalue, Pike_sp-args-2);    DO_CALL_BUILTIN(args);    STACK_LEVEL_CHECK(3);    CALL_AND_UNSET_ONERROR(uwp);
pike.git/src/interpret_functions.h:2457:       free_svalue(Pike_sp-args);    mark_free_svalue (Pike_sp - args);    lvalue_to_svalue_no_free(Pike_sp-args, Pike_sp-args-2);    /* This is so that foo = efun(foo,...) (and similar things) will be faster.    * It's done by freeing the old reference to foo after it has been    * pushed on the stack. That way foo can have only 1 reference if we    * are lucky, and then the low array/multiset/mapping manipulation    * routines can be destructive if they like.    */ -  if( (1 << Pike_sp[-args].type) & +  if( (1 << TYPEOF(Pike_sp[-args])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    {    LOCAL_VAR(struct svalue tmp); -  tmp.type = PIKE_T_INT; -  tmp.subtype = NUMBER_NUMBER; -  tmp.u.integer = 0; +  SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-args-2, &tmp);    }    /* NOTE: Pike_sp-args-2 is the lvalue, Pike_sp-args is the original value.    * If an error gets thrown, the original value will thus be restored.    * If the efun succeeds, Pike_sp-args will hold the result.    */    SET_ONERROR(uwp, o_assign_lvalue, Pike_sp-args-2);    DO_CALL_BUILTIN(args);    STACK_LEVEL_CHECK(3);    CALL_AND_UNSET_ONERROR(uwp);
pike.git/src/interpret_functions.h:2689:    level);    if (!(p->flags & PROGRAM_USES_PARENT))    /* FIXME: Ought to write out the object here. */    Pike_error ("Object %d level(s) up lacks parent reference.\n", level);    o = PARENT_INFO(o)->parent;    }    ref_push_object(o);    });      OPCODE0(F_ZERO_TYPE, "zero_type", 0, { -  if(Pike_sp[-1].type != T_INT) +  if(TYPEOF(Pike_sp[-1]) != T_INT)    { -  if((Pike_sp[-1].type==T_OBJECT || Pike_sp[-1].type==T_FUNCTION) +  if((TYPEOF(Pike_sp[-1]) == T_OBJECT || TYPEOF(Pike_sp[-1]) == T_FUNCTION)    && !Pike_sp[-1].u.object->prog)    {    pop_stack();    push_int(NUMBER_DESTRUCTED);    }else{    pop_stack();    push_int(0);    }    }else{ -  Pike_sp[-1].u.integer=Pike_sp[-1].subtype; -  Pike_sp[-1].subtype=NUMBER_NUMBER; +  SET_SVAL(Pike_sp[-1], T_INT, NUMBER_NUMBER, integer, +  SUBTYPEOF(Pike_sp[-1]));    }   });      OPCODE0(F_SWAP,"swap",0,{    stack_swap();   });      OPCODE0(F_DUP,"dup",I_UPDATE_SP,{    stack_dup();   });