pike.git / src / interpret_functions.h

version» Context lines:

pike.git/src/interpret_functions.h:1:   /*   || This file is part of Pike. For copyright information see COPYRIGHT.   || Pike is distributed under GPL, LGPL and MPL. See the file COPYING   || for more information. - || $Id: interpret_functions.h,v 1.199 2008/01/30 16:52:24 grubba Exp $ + || $Id: interpret_functions.h,v 1.200 2008/02/27 23:59:14 grubba Exp $   */      /*    * Opcode definitions for the interpreter.    */      #include "global.h"      #undef CJUMP   #undef AUTO_BIGNUM_LOOP_TEST
pike.git/src/interpret_functions.h:257:   OPCODE2(F_NUMBER64, "push 64-bit int", I_UPDATE_SP, {    Pike_error("F_NUMBER64: this opcode should never be used in your system\n");   });   #endif      OPCODE1(F_NEG_NUMBER, "push -int", I_UPDATE_SP, {    push_int(-arg1);   });      OPCODE1(F_CONSTANT, "constant", I_UPDATE_SP, { -  push_svalue(& Pike_fp->context.prog->constants[arg1].sval); +  push_svalue(& Pike_fp->context->prog->constants[arg1].sval);    print_return_value();   });         /* Generic swap instruction:    * swaps the arg1 top values with the arg2 values beneath    */   OPCODE2(F_REARRANGE,"rearrange",0,{    check_stack(arg2);    MEMCPY(Pike_sp,Pike_sp-arg1-arg2,sizeof(struct svalue)*arg2);    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]); +  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++;    print_return_value();    });   });         OPCODE1(F_ARROW_STRING, "->string", I_UPDATE_SP, { -  copy_shared_string(Pike_sp->u.string,Pike_fp->context.prog->strings[arg1]); +  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++;    print_return_value();   });      OPCODE1(F_LOOKUP_LFUN, "->lfun", 0, {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct svalue tmp);    LOCAL_VAR(struct program *p);
pike.git/src/interpret_functions.h:330:    tmp2.subtype = 1;    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); +  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);    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;    }    add_ref( ((struct pike_trampoline *)(o->storage))->frame=f ); -  ((struct pike_trampoline *)(o->storage))->func=arg1+Pike_fp->context.identifier_level; +  ((struct pike_trampoline *)(o->storage))->func=arg1+Pike_fp->context->identifier_level;    push_function(o, pike_trampoline_program->lfuns[LFUN_CALL]);    print_return_value();   });      /* The not so basic 'push value' instructions */      OPCODE1_TAIL(F_MARK_AND_GLOBAL, "mark & global", I_UPDATE_SP|I_UPDATE_M_SP, {    *(Pike_mark_sp++)=Pike_sp;       OPCODE1(F_GLOBAL, "global", I_UPDATE_SP, {
pike.git/src/interpret_functions.h:445:    push_svalue( Pike_fp->locals + arg2);    print_return_value();   });      OPCODE2(F_LOCAL_2_LOCAL, "local = local", 0, {    assign_svalue(Pike_fp->locals + arg1, Pike_fp->locals + arg2);   });      OPCODE2(F_LOCAL_2_GLOBAL, "global = local", 0, {    object_low_set_index(Pike_fp->current_object, -  arg1 + Pike_fp->context.identifier_level, +  arg1 + Pike_fp->context->identifier_level,    Pike_fp->locals + arg2);   });      OPCODE2(F_GLOBAL_2_LOCAL, "local = global", 0, {    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.git/src/interpret_functions.h:850:    SET_ONERROR(uwp, o_assign_lvalue, Pike_sp-4);    f_add(2);    CALL_AND_UNSET_ONERROR(uwp); /* assign_lvalue(Pike_sp-3,Pike_sp-1); */    pop_n_elems(3);    add_to_and_pop_done:    ; /* make gcc happy */   });      OPCODE1(F_GLOBAL_LVALUE, "& global", I_UPDATE_SP, {    ref_push_object(Pike_fp->current_object); -  push_obj_index(arg1 + Pike_fp->context.identifier_level); +  push_obj_index(arg1 + Pike_fp->context->identifier_level);   });      OPCODE0(F_INC, "++x", I_UPDATE_SP, {    union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);    if(u    DO_IF_BIGNUM(    && !INT_TYPE_ADD_OVERFLOW(u->integer, 1)    )    )    {
pike.git/src/interpret_functions.h:990:      OPCODE0(F_ASSIGN, "assign", I_UPDATE_SP, {    assign_lvalue(Pike_sp-3,Pike_sp-1);    free_svalue(Pike_sp-3);    free_svalue(Pike_sp-2);    move_svalue (Pike_sp - 3, Pike_sp - 1);    Pike_sp-=2;   });      OPCODE2(F_APPLY_ASSIGN_LOCAL_AND_POP, "apply, assign local and pop", I_UPDATE_SP|I_UPDATE_M_SP, { -  apply_svalue(&((Pike_fp->context.prog->constants + arg1)->sval), +  apply_svalue(&((Pike_fp->context->prog->constants + arg1)->sval),    DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)));    free_svalue(Pike_fp->locals+arg2);    move_svalue (Pike_fp->locals + arg2, Pike_sp - 1);    Pike_sp--;   });      OPCODE2(F_APPLY_ASSIGN_LOCAL, "apply, assign local", I_UPDATE_ALL, { -  apply_svalue(&((Pike_fp->context.prog->constants + arg1)->sval), +  apply_svalue(&((Pike_fp->context->prog->constants + arg1)->sval),    DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)));    assign_svalue(Pike_fp->locals+arg2, Pike_sp-1);   });      OPCODE0(F_ASSIGN_AND_POP, "assign and pop", I_UPDATE_SP, {    assign_lvalue(Pike_sp-3, Pike_sp-1);    pop_n_elems(3);   });      OPCODE1(F_ASSIGN_LOCAL_AND_POP, "assign local and pop", I_UPDATE_SP, {    free_svalue(Pike_fp->locals + arg1);    move_svalue (Pike_fp->locals + arg1, Pike_sp - 1);    Pike_sp--;   });      OPCODE1(F_ASSIGN_GLOBAL, "assign global", 0, {    object_low_set_index(Pike_fp->current_object, -  arg1 + Pike_fp->context.identifier_level, +  arg1 + Pike_fp->context->identifier_level,    Pike_sp-1);   });      OPCODE1(F_ASSIGN_GLOBAL_AND_POP, "assign global and pop", I_UPDATE_SP, {    object_low_set_index(Pike_fp->current_object, -  arg1 + Pike_fp->context.identifier_level, +  arg1 + Pike_fp->context->identifier_level,    Pike_sp-1);    pop_stack();   });         /* Stack machine stuff */      OPCODE0(F_POP_VALUE, "pop", I_UPDATE_SP, {    pop_stack();   });
pike.git/src/interpret_functions.h:1097:   });       /* 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.u.string=Pike_fp->context->prog->strings[arg1];    tmp.subtype=1;    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:1406:      OPCODE0(F_EXIT_CATCH, "exit catch", I_UPDATE_SP, {    push_undefined();    POP_CATCH_CONTEXT;   });      OPCODE1_JUMP(F_SWITCH, "switch", I_UPDATE_ALL, {    INT32 tmp;    PIKE_OPCODE_T *addr;    JUMP_SET_TO_PC_AT_NEXT (addr); -  tmp=switch_lookup(Pike_fp->context.prog-> +  tmp=switch_lookup(Pike_fp->context->prog->    constants[arg1].sval.u.array,Pike_sp-1);    addr = DO_IF_ELSE_COMPUTED_GOTO(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_etc(7);    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);    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-> +  tmp=switch_lookup(Pike_fp->context->prog->    constants[arg1].sval.u.array,Pike_sp-1);    pop_n_elems(3);    addr = DO_IF_ELSE_COMPUTED_GOTO(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_etc(7);    DO_JUMP_TO(addr + *(INT32*)addr);   });      OPCODE2_JUMP(F_SWITCH_ON_LOCAL, "switch on local", 0, {    INT32 tmp;    PIKE_OPCODE_T *addr;    JUMP_SET_TO_PC_AT_NEXT (addr); -  tmp=switch_lookup(Pike_fp->context.prog-> +  tmp=switch_lookup(Pike_fp->context->prog->    constants[arg2].sval.u.array,Pike_fp->locals + arg1);    addr = DO_IF_ELSE_COMPUTED_GOTO(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_etc(7);    DO_JUMP_TO(addr + *(INT32*)addr);   });      
pike.git/src/interpret_functions.h:1824:    s=Pike_fp->locals+arg2;    if(s->type == PIKE_T_STRING) s->subtype=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.u.string=Pike_fp->context->prog->strings[arg1];    tmp.subtype=1;    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.u.string=Pike_fp->context->prog->strings[arg1];    tmp.subtype=1;    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.u.string=Pike_fp->context->prog->strings[arg1];    tmp.subtype=0;    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();
pike.git/src/interpret_functions.h:2052:    unlink_previous_frame(); \    DO_JUMP_TO(addr); \    }else{ \    DO_DUMB_RETURN; \    } \   })         MKAPPLY2(OPCODE1,CALL_LFUN,"call lfun",APPLY_LOW,    Pike_fp->current_object, -  (void *)(ptrdiff_t)(arg1+Pike_fp->context.identifier_level)); +  (void *)(ptrdiff_t)(arg1+Pike_fp->context->identifier_level));      MKAPPLY2(OPCODE1,APPLY,"apply",APPLY_SVALUE_STRICT, -  &((Pike_fp->context.prog->constants + arg1)->sval),0); +  &((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)    {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    o = s->u.object;    if((p=o->prog))    {    p = p->inherits[s->subtype].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun; -  fun=find_shared_string_identifier(Pike_fp->context.prog->strings[arg1], +  fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    {    fun += o->prog->inherits[s->subtype].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);    }
pike.git/src/interpret_functions.h:2098:    }    }    }    }       {    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.u.string=Pike_fp->context->prog->strings[arg1];    tmp.subtype=1;       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.git/src/interpret_functions.h:2133:    {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    o = s->u.object;    if((p=o->prog))    {    p = p->inherits[s->subtype].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun; -  fun=find_shared_string_identifier(Pike_fp->context.prog->strings[arg1], +  fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    {    fun += o->prog->inherits[s->subtype].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;
pike.git/src/interpret_functions.h:2158:    }    }    }    }       {    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.u.string=Pike_fp->context->prog->strings[arg1];    tmp.subtype=1;       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;
pike.git/src/interpret_functions.h:2193:    {    LOCAL_VAR(struct object *o);    LOCAL_VAR(struct program *p);    o = s->u.object;    if((p=o->prog))    {    p = p->inherits[s->subtype].prog;    if(FIND_LFUN(p, LFUN_ARROW) == -1)    {    int fun; -  fun=find_shared_string_identifier(Pike_fp->context.prog->strings[arg1], +  fun=find_shared_string_identifier(Pike_fp->context->prog->strings[arg1],    p);    if(fun >= 0)    {    fun += o->prog->inherits[s->subtype].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();
pike.git/src/interpret_functions.h:2218:    }    }    }    }       {    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.u.string=Pike_fp->context->prog->strings[arg1];    tmp.subtype=1;       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;
pike.git/src/interpret_functions.h:2243:    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); \ -  s = &Pike_fp->context.prog->constants[arg1].sval; \ +  s = &Pike_fp->context->prog->constants[arg1].sval; \    if(Pike_interpreter.trace_level) \    { \    LOCAL_VAR(dynamic_buffer save_buf); \    init_buf(&save_buf); \    if (s->u.efun->name->size_shift) \    my_strcat ("[widestring function name]"); \    else \    my_strcat (s->u.efun->name->str); \    do_trace_call(args_, &save_buf); \    } \
pike.git/src/interpret_functions.h:2286:    if (s->u.efun->name->size_shift) \    my_strcat ("[widestring function name]"); \    else \    my_strcat (s->u.efun->name->str); \    my_strcat ("() "); \    do_trace_return (Pike_sp>expected_stack, &save_buf); \    } \   }while(0)   #else   #define DO_CALL_BUILTIN(ARGS) \ - (*(Pike_fp->context.prog->constants[arg1].sval.u.efun->function))(ARGS) + (*(Pike_fp->context->prog->constants[arg1].sval.u.efun->function))(ARGS)   #endif      OPCODE1(F_CALL_BUILTIN, "call builtin", I_UPDATE_ALL, {    DO_CALL_BUILTIN(DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)));   });      OPCODE1(F_CALL_BUILTIN_AND_POP,"call builtin & pop", I_UPDATE_ALL, {    DO_CALL_BUILTIN(DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)));    pop_stack();   });
pike.git/src/interpret_functions.h:2467:    new_frame->locals, Pike_fp->locals); \    } \    }); \    \    \    SET_PROG_COUNTER(addr); \    new_frame->fun=Pike_fp->fun; \    DO_IF_PROFILING( new_frame->ident=Pike_fp->ident ); \    new_frame->current_storage=Pike_fp->current_storage; \    if(Pike_fp->scope) add_ref(new_frame->scope=Pike_fp->scope); \ -  add_ref(new_frame->current_object=Pike_fp->current_object); \ -  new_frame->context=Pike_fp->context; \ -  add_ref(new_frame->context.prog); \ -  if(new_frame->context.parent) \ -  add_ref(new_frame->context.parent); \ +  add_ref(new_frame->current_object = Pike_fp->current_object); \ +  add_ref(new_frame->current_program = Pike_fp->current_program); \ +  new_frame->context = Pike_fp->context; \    \    DO_IF_PROFILING({ \    new_frame->start_time = \    get_cpu_time() - Pike_interpreter.unlocked_time; \    new_frame->ident = Pike_fp->ident; \    new_frame->children_base = Pike_interpreter.accounted_time; \ -  new_frame->context.prog->identifiers[new_frame->ident].num_calls++; \ +  new_frame->context->prog->identifiers[new_frame->ident].num_calls++; \    DO_IF_PROFILING_DEBUG({ \    fprintf(stderr, "%p{: Push at %" PRINT_CPU_TIME \    " %" PRINT_CPU_TIME "\n", \    Pike_interpreter.thread_state, new_frame->start_time, \    new_frame->children_base); \    }); \    }); \    \    Pike_fp=new_frame; \    new_frame->flags=PIKE_FRAME_RETURN_INTERNAL | XFLAGS; \
pike.git/src/interpret_functions.h:2502:    SET_CURRENT_CREDS(Pike_fp->current_object->prot)); \    \    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); -  p = Pike_fp->current_object->prog; +  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 -  * the since first case is much simpler to test and +  * since the first case is much simpler to test and    * is common, it should offer a speed improvement.    *    * /grubba 2002-11-14    *    * Also test if the function uses scoping. DO_RECUR() doesn't    * adjust fp->expendible which will make eg RETURN_LOCAL fail.    *    * /grubba 2003-03-25    */ -  if(((p != Pike_fp->context.prog) && -  (p->inherits[p->identifier_references[Pike_fp->context.identifier_level + -  arg1].inherit_offset].prog != -  Pike_fp->context.prog)) || -  (ID_FROM_INT(p, arg1+Pike_fp->context.identifier_level)-> +  if(((p != Pike_fp->context->prog) && +  (Pike_fp->context != +  &p->inherits[p->identifier_references[Pike_fp->context->identifier_level + +  arg1].inherit_offset])) || +  (ID_FROM_INT(p, arg1+Pike_fp->context->identifier_level)->    identifier_flags & IDENTIFIER_SCOPE_USED))    {    PIKE_OPCODE_T *faddr;    ptrdiff_t num_locals;    ptrdiff_t args;       JUMP_SET_TO_PC_AT_NEXT (faddr);    faddr += GET_JUMP();    num_locals = READ_INCR_BYTE(faddr); /* ignored */    args = READ_INCR_BYTE(faddr);       if(low_mega_apply(APPLY_LOW,    args,    Pike_fp->current_object,    (void *)(ptrdiff_t)(arg1+ -  Pike_fp->context.identifier_level))) +  Pike_fp->context->identifier_level)))    {    Pike_fp->flags |= PIKE_FRAME_RETURN_INTERNAL;    addr = Pike_fp->pc;    }    DO_JUMP_TO(addr);    }       /* FALL THROUGH */       /* Assume that the number of arguments is correct */