pike.git / src / interpret_functions.h

version» Context lines:

pike.git/src/interpret_functions.h:77:   /* BRANCH opcodes use these two to indicate whether the    * branch should be taken or not.    */   #ifndef DO_BRANCH   #define DO_BRANCH DOJUMP   #endif   #ifndef DONT_BRANCH   #define DONT_BRANCH SKIPJUMP   #endif    - #ifndef LOCAL_VAR - #define LOCAL_VAR(X) X - #endif -  +    #ifndef MACHINE_CODE_FORCE_FP   #define MACHINE_CODE_FORCE_FP() 0   #endif      #ifndef OVERRIDE_JUMPS      #undef GET_JUMP   #undef SKIPJUMP   #undef DOJUMP   
pike.git/src/interpret_functions.h:182:    FETCH; \    JUMP_DONE; \    } while (0)   #else /* !OPCODE_RETURN_JUMPADDR */   #define JUMP_SET_TO_PC_AT_NEXT(PC) ((PC) = PROG_COUNTER)   #define DO_JUMP_TO_NEXT JUMP_DONE   #endif /* !OPCODE_RETURN_JUMPADDR */      #undef DO_INDEX   #define DO_INDEX do { \ -  LOCAL_VAR(struct svalue tmp); \ +  struct svalue tmp; \    index_no_free(&tmp,Pike_sp-2,Pike_sp-1); \    pop_2_elems(); \    move_svalue (Pike_sp, &tmp); \    Pike_sp++; \    print_return_value(); \    }while(0)         OPCODE0(F_UNDEFINED, "push UNDEFINED", I_UPDATE_SP, {    push_undefined();
pike.git/src/interpret_functions.h:283:   });         OPCODE1(F_ARROW_STRING, "->string", I_UPDATE_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); +  struct object *o; +  struct svalue tmp; +  struct program *p;       if ((TYPEOF(Pike_sp[-1]) == T_OBJECT) &&    (p = (o = Pike_sp[-1].u.object)->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[SUBTYPEOF(Pike_sp[-1])].identifier_level;    low_object_index_no_free(&tmp, o, id);    } else {    /* Not found. */    SET_SVAL(tmp, T_INT, NUMBER_UNDEFINED, integer, 0);    }    } else { -  LOCAL_VAR(struct svalue tmp2); +  struct svalue tmp2;    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);    print_return_value();   });      OPCODE2(F_TRAMPOLINE, "trampoline", I_UPDATE_SP, {    struct pike_frame *f=Pike_fp;    DO_IF_DEBUG(INT32 arg2_ = arg2;) -  LOCAL_VAR(struct object *o); +  struct object *o;    o = low_clone(pike_trampoline_program);       while(arg2--) {    DO_IF_DEBUG({    if (!f->scope) {    Pike_fatal("F_TRAMPOLINE %d, %d: Missing %d levels of scope!\n",    arg1, arg2_, arg2+1);    }    });    f=f->scope;
pike.git/src/interpret_functions.h:402:    {    struct svalue *tmp;    tmp = (struct svalue *)(Pike_fp->current_storage + arg1);    assign_svalue(tmp,Pike_sp-1);    }    });      OPCODE2(F_ASSIGN_PRIVATE_TYPED_GLOBAL_AND_POP, "assign global <private,typed> and pop", I_UPDATE_SP, {    /* lazy mode. */    union anything *tmp_s; -  LOCAL_VAR(struct object *o); +  struct object *o;    o = Pike_fp->current_object;    if(!o->prog) /* note: generate an error. */    object_low_set_index(o,0,0);    tmp_s = (union anything *)(Pike_fp->current_storage + arg1);    assign_to_short_svalue( tmp_s, arg2, Pike_sp-1 );    pop_stack();   });      OPCODE2(F_ASSIGN_PRIVATE_TYPED_GLOBAL, "assign global <private,typed>", 0, {    union anything *tmp; -  LOCAL_VAR(struct object *o); +  struct object *o;    o = Pike_fp->current_object;    if(!o->prog) /* note: generate an error. */    object_low_set_index(o,0,0);    tmp = (union anything *)(Pike_fp->current_storage + arg1);    assign_to_short_svalue( tmp, arg2, Pike_sp-1);   });         #if SIZEOF_FLOAT_TYPE != SIZEOF_INT_TYPE   #define DO_IF_ELSE_SIZEOF_FLOAT_INT(EQ, NEQ) do { NEQ; } while(0)   #else   #define DO_IF_ELSE_SIZEOF_FLOAT_INT(EQ, NEQ) do { EQ; } while(0)   #endif      OPCODE2(F_PRIVATE_TYPED_GLOBAL, "global <private,typed>", I_UPDATE_SP, {    void *ptr; -  LOCAL_VAR(struct object *o); +  struct object *o;       o = Pike_fp->current_object;    ptr = (void *)(Pike_fp->current_storage + arg1);    if( arg2 < MIN_REF_TYPE )    {    DO_IF_ELSE_SIZEOF_FLOAT_INT(    SET_SVAL_TYPE_SUBTYPE(Pike_sp[0], arg2, 0);    Pike_sp[0].u.integer = *(INT_TYPE*)ptr;    Pike_sp++;    ,
pike.git/src/interpret_functions.h:468:    }    }       print_return_value();   });      OPCODE2_TAIL(F_MARK_AND_EXTERNAL, "mark & external", I_UPDATE_SP|I_UPDATE_M_SP, {    *(Pike_mark_sp++)=Pike_sp;       OPCODE2(F_EXTERNAL,"external", I_UPDATE_SP, { -  LOCAL_VAR(struct external_variable_context loc); +  struct external_variable_context loc;       loc.o=Pike_fp->current_object;    loc.parent_identifier=Pike_fp->fun;    loc.inherit=Pike_fp->context;    find_external_context(&loc, arg2);       DO_IF_DEBUG({    TRACE((5,"- Identifier=%d Offset=%d\n",    arg1,    loc.inherit->identifier_level));
pike.git/src/interpret_functions.h:496:    low_object_index_no_free(Pike_sp,    loc.o,    arg1 + loc.inherit->identifier_level);    Pike_sp++;    }    print_return_value();    });   });      OPCODE2(F_EXTERNAL_LVALUE, "& external", I_UPDATE_SP, { -  LOCAL_VAR(struct external_variable_context loc); +  struct external_variable_context loc;       loc.o=Pike_fp->current_object;    loc.parent_identifier=Pike_fp->fun;    loc.inherit=Pike_fp->context;    find_external_context(&loc, arg2);       if (!loc.o->prog)    Pike_error ("Cannot access variable in destructed parent object.\n");       DO_IF_DEBUG({
pike.git/src/interpret_functions.h:831:    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 << TYPEOF(Pike_sp[-2])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    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, {
pike.git/src/interpret_functions.h:862:       /* 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 << TYPEOF(Pike_sp[-3])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    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, {
pike.git/src/interpret_functions.h:884:    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 << TYPEOF(Pike_sp[-1])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    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++;
pike.git/src/interpret_functions.h:921:    }    /* 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 << TYPEOF(Pike_sp[-2])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-4, &tmp);    } 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); +  struct object *o; +  struct program *p;    if((o = Pike_sp[-2].u.object)->refs <= 2 &&    (p = o->prog) &&    (i = FIND_LFUN(p->inherits[SUBTYPEOF(Pike_sp[-2])].prog,    LFUN_ADD_EQ)) != -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();
pike.git/src/interpret_functions.h:985:    }    /* 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 << TYPEOF(Pike_sp[-2])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    SET_SVAL(tmp, PIKE_T_INT, NUMBER_NUMBER, integer, 0);    assign_lvalue(Pike_sp-4, &tmp);    } 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); +  struct object *o; +  struct program *p;    if((o = Pike_sp[-2].u.object)->refs <= 2 &&    (p = o->prog) &&    (i = FIND_LFUN(p->inherits[SUBTYPEOF(Pike_sp[-2])].prog,    LFUN_ADD_EQ)) != -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);
pike.git/src/interpret_functions.h:1230:    struct svalue *tmp;    struct object *co;    co = Pike_fp->current_object;    if(!co->prog) /* note: generate an error. */    object_low_set_index(co,0,0);    tmp = (struct svalue *)(Pike_fp->current_storage + arg1);    assign_svalue( tmp, Pike_sp-1 );   });      OPCODE2(F_ASSIGN_GLOBAL_NUMBER_AND_POP, "assign global number and pop", 0, { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    SET_SVAL(tmp,PIKE_T_INT,0,integer,arg2);    object_low_set_index(Pike_fp->current_object,    arg1 + Pike_fp->context->identifier_level,    &tmp);   });         /* Stack machine stuff */      OPCODE0(F_POP_VALUE, "pop", I_UPDATE_SP, {
pike.git/src/interpret_functions.h:1307:    if(TYPEOF(Pike_sp[-1]) == PIKE_T_STRING) SET_SVAL_SUBTYPE(Pike_sp[-1], 0);   });       /* Jumps */   OPCODE0_BRANCH(F_BRANCH, "branch", 0, {    MACHINE_CODE_FORCE_FP();    DO_BRANCH();   });      OPCODE2_BRANCH(F_BRANCH_IF_NOT_LOCAL_ARROW, "branch if !local->x", 0, { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    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, {
pike.git/src/interpret_functions.h:1361:    {    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); +  struct object *o;    if(TYPEOF(Pike_sp[-1]) == T_OBJECT &&    (o = Pike_sp[-1].u.object)->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 +
pike.git/src/interpret_functions.h:1634:    addr = (PIKE_OPCODE_T *) DO_ALIGN(PTR_TO_INT(addr), ((ptrdiff_t)sizeof(INT32)));    addr = (PIKE_OPCODE_T *)(((INT32 *)addr) + (tmp>=0 ? 1+tmp*2 : 2*~tmp));    if(*(INT32*)addr < 0) FAST_CHECK_THREADS_ON_BRANCH();    pop_stack();    DO_JUMP_TO(addr + *(INT32*)addr);   });      OPCODE1_JUMP(F_SWITCH_ON_INDEX, "switch on index", I_UPDATE_ALL, {    INT32 tmp;    PIKE_OPCODE_T *addr; -  LOCAL_VAR(struct svalue tmp2); +  struct svalue tmp2;    JUMP_SET_TO_PC_AT_NEXT (addr);    index_no_free(&tmp2, Pike_sp-2, Pike_sp-1);    move_svalue (Pike_sp++, &tmp2);       tmp=switch_lookup(Pike_fp->context->prog->    constants[arg1].sval.u.array,Pike_sp-1);    pop_n_elems(3);    addr = (PIKE_OPCODE_T *) DO_ALIGN(PTR_TO_INT(addr), ((ptrdiff_t)sizeof(INT32)));    addr = (PIKE_OPCODE_T *)(((INT32 *)addr) + (tmp>=0 ? 1+tmp*2 : 2*~tmp));    if(*(INT32*)addr < 0) FAST_CHECK_THREADS_ON_BRANCH();
pike.git/src/interpret_functions.h:1994:    {    Pike_sp[-1].u.integer-=arg1;    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, { -  LOCAL_VAR(struct object *o); -  LOCAL_VAR(struct program *p); +  struct object *o; +  struct program *p;       switch(TYPEOF(Pike_sp[-1]))    {    default:    PIKE_ERROR("@", "Bad argument.\n", Pike_sp, 1);       case PIKE_T_OBJECT:    {    int i;    if(!(p = (o = Pike_sp[-1].u.object)->prog) ||
pike.git/src/interpret_functions.h:2035:      OPCODE0(F_APPEND_ARRAY, "append array", I_UPDATE_SP|I_UPDATE_M_SP, {    o_append_array(Pike_sp - *(--Pike_mark_sp));    });      OPCODE0(F_APPEND_MAPPING, "append mapping", I_UPDATE_SP|I_UPDATE_M_SP, {    o_append_mapping(Pike_sp - *(--Pike_mark_sp));    });      OPCODE2(F_LOCAL_LOCAL_INDEX, "local[local]", I_UPDATE_SP, { -  LOCAL_VAR(struct svalue *s); +  struct svalue *s;    s = Pike_fp->locals + arg1;    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); +  struct svalue *s; +  struct svalue tmp;    s = Pike_fp->locals + arg1;    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); +  struct svalue *s; +  struct svalue tmp;    low_index_current_object_no_free(Pike_sp, arg1);    Pike_sp++;    s=Pike_fp->locals+arg2;    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, {    struct pike_frame *fp = Pike_fp; -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    SET_SVAL(tmp, PIKE_T_STRING, 1, string,    fp->context->prog->strings[arg1]);    mark_free_svalue (Pike_sp++);    index_no_free(Pike_sp-1,fp->locals+arg2, &tmp);    print_return_value();   });      OPCODE1(F_ARROW, "->x", 0, { -  LOCAL_VAR(struct svalue tmp); -  LOCAL_VAR(struct svalue tmp2); +  struct svalue tmp; +  struct svalue tmp2;    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); +  struct svalue tmp; +  struct svalue tmp2;    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);
pike.git/src/interpret_functions.h:2157:    });    }    stack_swap();    pop_stack();   });      /* Used with F_LTOSVAL*_AND_FREE - must not release interpreter lock. */   OPCODE1_ALIAS(F_RANGE, "range", I_UPDATE_SP, o_range2);      OPCODE0(F_COPY_VALUE, "copy_value", 0, { -  LOCAL_VAR(struct svalue tmp); +  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); +  struct svalue tmp;    lvalue_to_svalue_no_free(&tmp, Pike_sp-2);    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); +  struct object *o;    o=low_clone(string_assignment_program);    s = (struct string_assignment_storage *)o->storage;    move_svalue (s->lval, Pike_sp - 2);    move_svalue (s->lval + 1, Pike_sp - 1);    s->s=tmp.u.string;    Pike_sp-=2;    push_object(o);    }    print_return_value();   });
pike.git/src/interpret_functions.h:2211:      OPCODE1(F_SIZEOF_LOCAL_STRING, "sizeof local string", I_UPDATE_SP, {    push_int(pike_sizeof(Pike_fp->locals+arg1));   });      OPCODE1_ALIAS(F_SSCANF, "sscanf", I_UPDATE_SP, o_sscanf);      #define MKAPPLY(OP,OPCODE,NAME,TYPE, ARG2, ARG3) \   PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT(F_,OPCODE),NAME,I_UPDATE_ALL, \   { \ -  LOCAL_VAR(PIKE_OPCODE_T *addr); \ +  PIKE_OPCODE_T *addr; \    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); \    if((addr=low_mega_apply(TYPE,(INT32)(Pike_sp - *--Pike_mark_sp), \    ARG2, ARG3))) \    { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL; \    DO_JUMP_TO(addr); \    } \    else { \    DO_JUMP_TO_NEXT; \    } \    }); \    \   PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT3(F_,OPCODE,_AND_POP),NAME " & pop", \    I_UPDATE_ALL, \   { \ -  LOCAL_VAR(PIKE_OPCODE_T *addr); \ +  PIKE_OPCODE_T *addr; \    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); \    if((addr=low_mega_apply(TYPE, (INT32)(Pike_sp - *--Pike_mark_sp), \    ARG2, ARG3))) \    { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP; \    DO_JUMP_TO(addr); \    } \    else { \    pop_stack(); \    DO_JUMP_TO_NEXT; \    } \   }); \    \   PIKE_CONCAT(OP,_RETURN)(PIKE_CONCAT3(F_,OPCODE,_AND_RETURN), \    NAME " & return",I_UPDATE_ALL, \   { \ -  LOCAL_VAR(PIKE_OPCODE_T *addr); \ +  PIKE_OPCODE_T *addr; \    if((addr = low_mega_apply(TYPE, (INT32)(Pike_sp - *--Pike_mark_sp), \    ARG2,ARG3))) \    { \    DO_IF_DEBUG(Pike_fp->next->pc=0); \    unlink_previous_frame(); \    DO_JUMP_TO(addr); \    } \    else { \    DO_DUMB_RETURN; \    } \   })         #define MKAPPLY2(OP,OPCODE,NAME,TYPE, ARG2, ARG3) \    \   MKAPPLY(OP,OPCODE,NAME,TYPE, ARG2, ARG3); \    \   PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT(F_MARK_,OPCODE),"mark, " NAME, \    I_UPDATE_ALL, \   { \ -  LOCAL_VAR(PIKE_OPCODE_T *addr); \ +  PIKE_OPCODE_T *addr; \    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); \    if((addr=low_mega_apply(TYPE, 0, ARG2, ARG3))) \    { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL; \    DO_JUMP_TO(addr); \    } \    else { \    DO_JUMP_TO_NEXT; \    } \   }); \    \   PIKE_CONCAT(OP,_JUMP)(PIKE_CONCAT3(F_MARK_,OPCODE,_AND_POP), \    "mark, " NAME " & pop",I_UPDATE_ALL, \   { \ -  LOCAL_VAR(PIKE_OPCODE_T *addr); \ +  PIKE_OPCODE_T *addr; \    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr); \    if((addr=low_mega_apply(TYPE, 0, ARG2, ARG3))) \    { \    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP; \    DO_JUMP_TO(addr); \    } \    else { \    pop_stack(); \    DO_JUMP_TO_NEXT; \    } \   }); \    \   PIKE_CONCAT(OP,_RETURN)(PIKE_CONCAT3(F_MARK_,OPCODE,_AND_RETURN), \    "mark, " NAME " & return",I_UPDATE_ALL, \   { \ -  LOCAL_VAR(PIKE_OPCODE_T *pc); \ +  PIKE_OPCODE_T *pc; \    if((pc=low_mega_apply(TYPE, 0, ARG2, ARG3))) \    { \    DO_IF_DEBUG(Pike_fp->next->pc=0); \    unlink_previous_frame(); \    DO_JUMP_TO(pc); \    } \    else { \    DO_DUMB_RETURN; \    } \   })         OPCODE1_JUMP(F_CALL_LFUN , "call lfun", I_UPDATE_ALL, { -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  PIKE_OPCODE_T *addr;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if((addr = lower_mega_apply((INT32)(Pike_sp - *--Pike_mark_sp),    Pike_fp->current_object,    (arg1+Pike_fp->context->identifier_level) )))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(addr);    }    else    {    DO_JUMP_TO_NEXT;    }    });      OPCODE2_JUMP(F_CALL_LFUN_N , "call lfun <n>", I_UPDATE_ALL, { -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  PIKE_OPCODE_T *addr;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if((addr = lower_mega_apply(arg2,    Pike_fp->current_object,    (arg1+Pike_fp->context->identifier_level) )))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(addr);    }    else    {    DO_JUMP_TO_NEXT;    }    });      OPCODE1_JUMP(F_CALL_LFUN_AND_POP, "call lfun & pop", I_UPDATE_ALL, { -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  PIKE_OPCODE_T *addr;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if((addr = lower_mega_apply((INT32)(Pike_sp - *--Pike_mark_sp),    Pike_fp->current_object,    (arg1+Pike_fp->context->identifier_level))))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP;    DO_JUMP_TO(addr);    }    else    {    pop_stack();    DO_JUMP_TO_NEXT;    }    });      OPCODE1_RETURN(F_CALL_LFUN_AND_RETURN , "call lfun & return", I_UPDATE_ALL, { -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  PIKE_OPCODE_T *addr;    if((addr = lower_mega_apply((INT32)(Pike_sp - *--Pike_mark_sp),    Pike_fp->current_object,    (arg1+Pike_fp->context->identifier_level))))    {    DO_IF_DEBUG(Pike_fp->next->pc=0);    unlink_previous_frame();    DO_JUMP_TO(addr);    }else{    DO_DUMB_RETURN;    }    });      OPCODE1_JUMP(F_MARK_CALL_LFUN, "mark, call lfun" , I_UPDATE_ALL, { -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  PIKE_OPCODE_T *addr;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if((addr = lower_mega_apply(0, Pike_fp->current_object,    (arg1+Pike_fp->context->identifier_level)))) {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    DO_JUMP_TO(addr);    } else {    DO_JUMP_TO_NEXT;    }    });      OPCODE1_JUMP( F_MARK_CALL_LFUN_AND_POP , "mark, call lfun & pop", I_UPDATE_ALL, { -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  PIKE_OPCODE_T *addr;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if((addr = lower_mega_apply(0, Pike_fp->current_object,    (arg1+Pike_fp->context->identifier_level) )))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL | PIKE_FRAME_RETURN_POP;    DO_JUMP_TO(addr);    }    else    {    pop_stack();    DO_JUMP_TO_NEXT;    }    });      OPCODE1_RETURN(F_MARK_CALL_LFUN_AND_RETURN , "mark, call lfun & return", I_UPDATE_ALL, { -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  PIKE_OPCODE_T *addr;    if((addr = lower_mega_apply(0, Pike_fp->current_object,    (arg1+Pike_fp->context->identifier_level))))    {    DO_IF_DEBUG(Pike_fp->next->pc=0);    unlink_previous_frame();    DO_JUMP_TO(addr);    }    else    {    DO_DUMB_RETURN;    }    });      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=(INT32)(Pike_sp - *--Pike_mark_sp); -  LOCAL_VAR(struct svalue *s); +  struct svalue *s;    s = Pike_sp-args;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if(TYPEOF(*s) == T_OBJECT)    { -  LOCAL_VAR(struct object *o); -  LOCAL_VAR(struct program *p); +  struct object *o; +  struct program *p;    o = s->u.object;    if((p=o->prog))    {    p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    PIKE_OPCODE_T *addr;    int fun;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);
pike.git/src/interpret_functions.h:2456:    DO_JUMP_TO(addr);    }    stack_pop_keep_top();    DO_JUMP_TO_NEXT;    }    }    }    }       { -  LOCAL_VAR(struct svalue tmp); -  LOCAL_VAR(struct svalue tmp2); -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  struct svalue tmp; +  struct svalue tmp2; +  PIKE_OPCODE_T *addr;    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((addr = low_mega_apply(APPLY_STACK, args, 0, 0)))    {
pike.git/src/interpret_functions.h:2480:    DO_JUMP_TO(addr);    }    else {    DO_JUMP_TO_NEXT;    }    }   });      OPCODE1_JUMP(F_CALL_OTHER_AND_POP,"call other & pop", I_UPDATE_ALL, {    INT32 args=(INT32)(Pike_sp - *--Pike_mark_sp); -  LOCAL_VAR(struct svalue *s); +  struct svalue *s;    s = Pike_sp-args;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if(TYPEOF(*s) == T_OBJECT)    { -  LOCAL_VAR(struct object *o); -  LOCAL_VAR(struct program *p); +  struct object *o; +  struct program *p;    o = s->u.object;    if((p=o->prog))    {    p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    PIKE_OPCODE_T *addr;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);
pike.git/src/interpret_functions.h:2516:    DO_JUMP_TO(addr);    }    pop_2_elems();    DO_JUMP_TO_NEXT;    }    }    }    }       { -  LOCAL_VAR(struct svalue tmp); -  LOCAL_VAR(struct svalue tmp2); -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  struct svalue tmp; +  struct svalue tmp2; +  PIKE_OPCODE_T *addr;       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((addr = low_mega_apply(APPLY_STACK, args, 0, 0)))
pike.git/src/interpret_functions.h:2542:    }    else {    pop_stack();    DO_JUMP_TO_NEXT;    }    }   });      OPCODE1_RETURN(F_CALL_OTHER_AND_RETURN,"call other & return", I_UPDATE_ALL, {    INT32 args=(INT32)(Pike_sp - *--Pike_mark_sp); -  LOCAL_VAR(struct svalue *s); +  struct svalue *s;    s = Pike_sp - args;    if(TYPEOF(*s) == T_OBJECT)    { -  LOCAL_VAR(struct object *o); -  LOCAL_VAR(struct program *p); +  struct object *o; +  struct program *p;    o = s->u.object;    if((p=o->prog))    {    p = p->inherits[SUBTYPEOF(*s)].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun;    PIKE_OPCODE_T *addr;    fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);
pike.git/src/interpret_functions.h:2576:    DO_JUMP_TO(addr);    }    stack_pop_keep_top();    DO_DUMB_RETURN;    }    }    }    }       { -  LOCAL_VAR(struct svalue tmp); -  LOCAL_VAR(struct svalue tmp2); -  LOCAL_VAR(PIKE_OPCODE_T *addr); +  struct svalue tmp; +  struct svalue tmp2; +  PIKE_OPCODE_T *addr;    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((addr = low_mega_apply(APPLY_STACK, args, 0, 0)))    {
pike.git/src/interpret_functions.h:2602:    }    DO_DUMB_RETURN;    }   });      #undef DO_CALL_BUILTIN   #ifdef PIKE_DEBUG   #define DO_CALL_BUILTIN(ARGS) do { \    int args_=(ARGS); \    struct svalue *expected_stack=Pike_sp-args_; \ -  LOCAL_VAR(struct svalue *s); \ +  struct svalue *s; \    s = &Pike_fp->context->prog->constants[arg1].sval; \    if(Pike_interpreter.trace_level) \    { \    do_trace_efun_call(s, args_); \    } \    if (PIKE_FN_START_ENABLED()) { \    /* DTrace enter probe \    arg0: function name \    arg1: object \    */ \
pike.git/src/interpret_functions.h:2734:    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 << TYPEOF(Pike_sp[-args])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    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);
pike.git/src/interpret_functions.h:2780:    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 << TYPEOF(Pike_sp[-args])) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  LOCAL_VAR(struct svalue tmp); +  struct svalue tmp;    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);
pike.git/src/interpret_functions.h:2863:    fprintf(stderr, "- Addr = 0x%lx\n", (unsigned long) addr); \    } \    \    FETCH; \    JUMP_DONE; \   }while(0)      /* Assume that the number of arguments is correct */   OPCODE1_PTRJUMP(F_COND_RECUR, "recur if not overloaded", I_UPDATE_ALL, {    PIKE_OPCODE_T *addr; -  LOCAL_VAR(struct program *p); +  struct program *p;    p = Pike_fp->current_program;    JUMP_SET_TO_PC_AT_NEXT (addr);    Pike_fp->return_addr = (PIKE_OPCODE_T *)(((INT32 *)addr) + 1);       /* Test if the function is overloaded.    *    * Note: The second part of the test is sufficient, but    * since the first case is much simpler to test and    * is common, it should offer a speed improvement.    *
pike.git/src/interpret_functions.h:2950:    assign_svalues(Pike_fp->locals, Pike_sp-args, args, BIT_MIXED);    pop_n_elems(Pike_sp - (Pike_fp->locals + args));    }       FETCH;    JUMP_DONE;   });      OPCODE1(F_THIS_OBJECT, "this_object", I_UPDATE_SP, {    int level; -  LOCAL_VAR(struct object *o); +  struct object *o;    o = Pike_fp->current_object;    for (level = 0; level < arg1; level++) { -  LOCAL_VAR(struct program *p); +  struct program *p;    p = o->prog;    if (!p)    Pike_error ("Object %d level(s) up is destructed - cannot get the parent.\n",    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);
pike.git/src/interpret_functions.h:3024:      OPCODE0(F_SWAP,"swap",0,{    stack_swap();   });      OPCODE0(F_DUP,"dup",I_UPDATE_SP,{    stack_dup();   });      OPCODE2(F_THIS, "this", I_UPDATE_SP, { -  LOCAL_VAR(struct external_variable_context loc); +  struct external_variable_context loc;       loc.o = Pike_fp->current_object;    loc.parent_identifier = Pike_fp->fun;    loc.inherit = Pike_fp->context;    find_external_context(&loc, arg1);       DO_IF_DEBUG({    TRACE((5,"- Identifier=%d Offset=%d\n",    arg1,    loc.inherit->identifier_level));