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.169 2004/08/26 16:12:12 grubba Exp $ + || $Id: interpret_functions.h,v 1.170 2004/09/22 17:55:29 grubba Exp $   */      /*    * Opcode definitions for the interpreter.    */      #include "global.h"      #undef CJUMP   #undef AUTO_BIGNUM_LOOP_TEST
pike.git/src/interpret_functions.h:97:   /* 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 OVERRIDE_JUMPS      #undef GET_JUMP   #undef SKIPJUMP   #undef DOJUMP      #ifdef PIKE_DEBUG      #define GET_JUMP() (backlog[backlogp].arg=( \    (Pike_interpreter.trace_level>3 ? \
pike.git/src/interpret_functions.h:194:    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 { \ -  struct svalue s; \ -  index_no_free(&s,Pike_sp-2,Pike_sp-1); \ +  LOCAL_VAR(struct svalue tmp); \ +  index_no_free(&tmp,Pike_sp-2,Pike_sp-1); \    pop_2_elems(); \ -  *Pike_sp=s; \ +  *Pike_sp=tmp; \    Pike_sp++; \    dmalloc_touch_svalue(Pike_sp-1); \ -  print_return_value(); \ +  print_return_value(); \   }while(0)         OPCODE0(F_UNDEFINED, "push UNDEFINED", I_UPDATE_SP, {    push_int(0);    Pike_sp[-1].subtype=NUMBER_UNDEFINED;   });      OPCODE0(F_CONST0, "push 0", I_UPDATE_SP, {    push_int(0);
pike.git/src/interpret_functions.h:297:      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++;    print_return_value();   });      OPCODE1(F_LOOKUP_LFUN, "->lfun", 0, { -  struct svalue tmp; -  struct object *o; +  LOCAL_VAR(struct object *o); +  LOCAL_VAR(struct svalue tmp);       if ((Pike_sp[-1].type == T_OBJECT) && ((o = Pike_sp[-1].u.object)->prog) &&    (FIND_LFUN(o->prog, LFUN_ARROW) == -1)) {    int id = FIND_LFUN(o->prog, arg1);    if ((id != -1) &&    (!(o->prog->identifier_references[id].id_flags &    (ID_STATIC|ID_PRIVATE|ID_HIDDEN)))) {    low_object_index_no_free(&tmp, o, id);    } else {    /* Not found. */    tmp.type = T_INT;    tmp.subtype = 1;    tmp.u.integer = 0;    }    } else { -  struct svalue tmp2; +  LOCAL_VAR(struct svalue tmp2);    tmp2.type = PIKE_T_STRING;    tmp2.u.string = lfun_strings[arg1];    tmp2.subtype = 1;    index_no_free(&tmp, Pike_sp-1, &tmp2);    }    free_svalue(Pike_sp-1);    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 object *o=low_clone(pike_trampoline_program); +     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;    }
pike.git/src/interpret_functions.h:369:    arg1 + Pike_fp->context.identifier_level);    Pike_sp++;    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, { -  struct external_variable_context loc; +  LOCAL_VAR(struct external_variable_context loc);       loc.o=Pike_fp->current_object;    loc.parent_identifier=Pike_fp->fun;    if (loc.o->prog)    loc.inherit=INHERIT_FROM_INT(loc.o->prog, loc.parent_identifier);    find_external_context(&loc, arg2);       DO_IF_DEBUG({    TRACE((5,"- Identifier=%d Offset=%d\n",    arg1,
pike.git/src/interpret_functions.h:399:    loc.o,    arg1 + loc.inherit->identifier_level);    Pike_sp++;    }    print_return_value();    });   });         OPCODE2(F_EXTERNAL_LVALUE, "& external", I_UPDATE_SP, { -  struct external_variable_context loc; +  LOCAL_VAR(struct external_variable_context loc);       loc.o=Pike_fp->current_object;    loc.parent_identifier=Pike_fp->fun;    if (loc.o->prog)    loc.inherit=INHERIT_FROM_INT(loc.o->prog, loc.parent_identifier);    find_external_context(&loc, arg2);       if (!loc.o->prog)    Pike_error ("Cannot access variable in destructed parent object.\n");   
pike.git/src/interpret_functions.h:655:       /* this is so that foo+=bar (and similar things) will be faster, this    * is 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) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  struct svalue s; -  s.type = PIKE_T_INT; -  s.subtype = 0; -  s.u.integer = 0; -  assign_lvalue(Pike_sp-4, &s); +  LOCAL_VAR(struct svalue tmp); +  tmp.type = PIKE_T_INT; +  tmp.subtype = 0; +  tmp.u.integer = 0; +  assign_lvalue(Pike_sp-4, &tmp);    }   });      OPCODE0(F_LTOSVAL3, "ltosval3", I_UPDATE_SP, {    Pike_sp[0] = Pike_sp[-1];    Pike_sp[-1] = Pike_sp[-2];    Pike_sp[-2].type = PIKE_T_INT;    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, this    * is 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) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  struct svalue s; -  s.type = PIKE_T_INT; -  s.subtype = 0; -  s.u.integer = 0; -  assign_lvalue(Pike_sp-5, &s); +  LOCAL_VAR(struct svalue tmp); +  tmp.type = PIKE_T_INT; +  tmp.subtype = 0; +  tmp.u.integer = 0; +  assign_lvalue(Pike_sp-5, &tmp);    }   });      OPCODE0(F_ADD_TO, "+=", I_UPDATE_SP, {    Pike_sp[0]=Pike_sp[-1];    Pike_sp[-1].type=PIKE_T_INT;    Pike_sp++;    lvalue_to_svalue_no_free(Pike_sp-2,Pike_sp-4);       if( Pike_sp[-1].type == PIKE_T_INT &&
pike.git/src/interpret_functions.h:718:    }    /* this is so that foo+=bar (and similar things) will be faster, this    * is 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) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  struct svalue s; -  s.type=PIKE_T_INT; -  s.subtype=0; -  s.u.integer=0; -  assign_lvalue(Pike_sp-4,&s); +  LOCAL_VAR(struct svalue tmp); +  tmp.type=PIKE_T_INT; +  tmp.subtype=0; +  tmp.u.integer=0; +  assign_lvalue(Pike_sp-4, &tmp);    } else if (Pike_sp[-2].type == T_OBJECT) {    /* One ref in the lvalue, and one on the stack. */    int i;    if(Pike_sp[-2].u.object->refs <= 2 &&    (i = FIND_LFUN(Pike_sp[-2].u.object->prog, LFUN_ADD_EQ)) != -1)    {    apply_low(Pike_sp[-2].u.object, i, 1);    /* NB: The lvalue already contains the object, so    * no need to reassign it.    */
pike.git/src/interpret_functions.h:775:    }    /* this is so that foo+=bar (and similar things) will be faster, this    * is 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) &    (BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING) )    { -  struct svalue s; -  s.type=PIKE_T_INT; -  s.subtype=0; -  s.u.integer=0; -  assign_lvalue(Pike_sp-4,&s); +  LOCAL_VAR(struct svalue tmp); +  tmp.type=PIKE_T_INT; +  tmp.subtype=0; +  tmp.u.integer=0; +  assign_lvalue(Pike_sp-4, &tmp);    } else if (Pike_sp[-2].type == PIKE_T_OBJECT) {    /* One ref in the lvalue, and one on the stack. */    int i;    if(Pike_sp[-2].u.object->refs <= 2 &&    (i = FIND_LFUN(Pike_sp[-2].u.object->prog, LFUN_ADD_EQ)) != -1)    {    apply_low(Pike_sp[-2].u.object, i, 1);    /* NB: The lvalue already contains the object, so    * no need to reassign it.    */
pike.git/src/interpret_functions.h:1053:   OPCODE0(F_CLEAR_STRING_SUBTYPE, "clear string subtype", 0, {    if(Pike_sp[-1].type==PIKE_T_STRING) Pike_sp[-1].subtype=0;   });       /* Jumps */   OPCODE0_BRANCH(F_BRANCH, "branch", 0, {    DO_BRANCH();   });      OPCODE2_BRANCH(F_BRANCH_IF_NOT_LOCAL_ARROW, "branch if !local->x", 0, { -  struct svalue tmp; +  LOCAL_VAR(struct svalue tmp);    tmp.type=PIKE_T_STRING;    tmp.u.string=Pike_fp->context.prog->strings[arg1];    tmp.subtype=1;    Pike_sp->type=PIKE_T_INT;    Pike_sp++;    index_no_free(Pike_sp-1,Pike_fp->locals+arg2, &tmp);    print_return_value();       /* Fall through */   
pike.git/src/interpret_functions.h:1273:    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; -  struct svalue s; +     PIKE_OPCODE_T *addr; -  +  LOCAL_VAR(struct svalue tmp2);    JUMP_SET_TO_PC_AT_NEXT (addr); -  index_no_free(&s,Pike_sp-2,Pike_sp-1); -  Pike_sp++[0]=s; +  index_no_free(&tmp2, Pike_sp-2, Pike_sp-1); +  Pike_sp++[0] = tmp2;       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);
pike.git/src/interpret_functions.h:1623:    break;       case PIKE_T_ARRAY: break;    }    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp--;    push_array_items(Pike_sp->u.array);   });      OPCODE2(F_LOCAL_LOCAL_INDEX, "local[local]", I_UPDATE_SP, { -  struct svalue *s=Pike_fp->locals+arg1; +  LOCAL_VAR(struct svalue *s); +  s = Pike_fp->locals + arg1;    if(s->type == PIKE_T_STRING) s->subtype=0;    Pike_sp++->type=PIKE_T_INT;    index_no_free(Pike_sp-1,Pike_fp->locals+arg2,s);   });      OPCODE1(F_LOCAL_INDEX, "local index", 0, { -  struct svalue tmp; -  struct svalue *s = Pike_fp->locals+arg1; +  LOCAL_VAR(struct svalue *s); +  LOCAL_VAR(struct svalue tmp); +  s = Pike_fp->locals + arg1;    if(s->type == PIKE_T_STRING) s->subtype=0;    index_no_free(&tmp,Pike_sp-1,s);    free_svalue(Pike_sp-1);    Pike_sp[-1]=tmp;   });      OPCODE2(F_GLOBAL_LOCAL_INDEX, "global[local]", I_UPDATE_SP, { -  struct svalue tmp; -  struct svalue *s; +  LOCAL_VAR(struct svalue *s); +  LOCAL_VAR(struct svalue tmp);    low_object_index_no_free(Pike_sp,    Pike_fp->current_object,    arg1 + Pike_fp->context.identifier_level);    Pike_sp++;    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);    Pike_sp[-1]=tmp;   });      OPCODE2(F_LOCAL_ARROW, "local->x", I_UPDATE_SP, { -  struct svalue tmp; +  LOCAL_VAR(struct svalue tmp);    tmp.type=PIKE_T_STRING;    tmp.u.string=Pike_fp->context.prog->strings[arg1];    tmp.subtype=1;    Pike_sp->type=PIKE_T_INT;    Pike_sp++;    index_no_free(Pike_sp-1,Pike_fp->locals+arg2, &tmp);    print_return_value();   });      OPCODE1(F_ARROW, "->x", 0, { -  struct svalue tmp; -  struct svalue tmp2; +  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;    index_no_free(&tmp2, Pike_sp-1, &tmp);    free_svalue(Pike_sp-1);    Pike_sp[-1]=tmp2;    print_return_value();   });      OPCODE1(F_STRING_INDEX, "string index", 0, { -  struct svalue tmp; -  struct svalue tmp2; +  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;    index_no_free(&tmp2, Pike_sp-1, &tmp);    free_svalue(Pike_sp-1);    Pike_sp[-1]=tmp2;    print_return_value();   });      OPCODE1(F_POS_INT_INDEX, "int index", 0, {
pike.git/src/interpret_functions.h:1789:    }    });    }    stack_swap();    pop_stack();   });      OPCODE0_ALIAS(F_RANGE, "range", I_UPDATE_SP, o_range);      OPCODE0(F_COPY_VALUE, "copy_value", 0, { -  struct svalue tmp; +  LOCAL_VAR(struct svalue tmp);    copy_svalues_recursively_no_free(&tmp,Pike_sp-1,1,0);    free_svalue(Pike_sp-1);    Pike_sp[-1]=tmp;    print_return_value();   });      OPCODE0(F_INDIRECT, "indirect", I_UPDATE_SP, { -  struct svalue s; -  lvalue_to_svalue_no_free(&s,Pike_sp-2); -  if(s.type != PIKE_T_STRING) +  LOCAL_VAR(struct svalue tmp); +  lvalue_to_svalue_no_free(&tmp, Pike_sp-2); +  if(tmp.type != PIKE_T_STRING)    {    pop_2_elems(); -  *Pike_sp=s; +  *Pike_sp = tmp;    Pike_sp++;    }else{ -  struct object *o; +  LOCAL_VAR(struct object *o);    o=low_clone(string_assignment_program);    ((struct string_assignment_storage *)o->storage)->lval[0]=Pike_sp[-2];    ((struct string_assignment_storage *)o->storage)->lval[1]=Pike_sp[-1]; -  ((struct string_assignment_storage *)o->storage)->s=s.u.string; +  ((struct string_assignment_storage *)o->storage)->s=tmp.u.string;    Pike_sp-=2;    push_object(o);    }    print_return_value();   });      OPCODE0(F_SIZEOF, "sizeof", 0, {    INT_TYPE val = pike_sizeof(Pike_sp-1);    pop_stack();    push_int(val);
pike.git/src/interpret_functions.h:1933:    Pike_fp->current_object,    (void *)(ptrdiff_t)(arg1+Pike_fp->context.identifier_level));      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)); -  struct svalue *s=Pike_sp-args; +  LOCAL_VAR(struct svalue *s); +  s = Pike_sp-args;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if(s->type == T_OBJECT)    { -  struct object *o=s->u.object; -  struct program *p; +  LOCAL_VAR(struct object *o); +  LOCAL_VAR(struct program *p); +  o = s->u.object;    if((p=o->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)    {    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun))
pike.git/src/interpret_functions.h:1962:    DO_JUMP_TO(Pike_fp->pc);    }    stack_pop_keep_top();    DO_JUMP_TO_NEXT;    }    }    }    }       { -  struct svalue tmp; -  struct svalue tmp2; +  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;       index_no_free(&tmp2, s, &tmp);    free_svalue(s);    *s=tmp2;    print_return_value();   
pike.git/src/interpret_functions.h:1987:    DO_JUMP_TO(Pike_fp->pc);    }    else {    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)); -  struct svalue *s=Pike_sp-args; +  LOCAL_VAR(struct svalue *s); +  s = Pike_sp-args;    JUMP_SET_TO_PC_AT_NEXT (Pike_fp->return_addr);    if(s->type == T_OBJECT)    { -  struct object *o=s->u.object; -  struct program *p; +  LOCAL_VAR(struct object *o); +  LOCAL_VAR(struct program *p); +  o = s->u.object;    if((p=o->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)    {    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun))
pike.git/src/interpret_functions.h:2018:    DO_JUMP_TO(Pike_fp->pc);    }    pop_2_elems();    DO_JUMP_TO_NEXT;    }    }    }    }       { -  struct svalue tmp; -  struct svalue tmp2; +  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;       index_no_free(&tmp2, s, &tmp);    free_svalue(s);    *s=tmp2;    print_return_value();   
pike.git/src/interpret_functions.h:2044:    }    else {    pop_stack();    DO_JUMP_TO_NEXT;    }    }   });      OPCODE1_JUMP(F_CALL_OTHER_AND_RETURN,"call other & return", I_UPDATE_ALL, {    INT32 args=DO_NOT_WARN((INT32)(Pike_sp - *--Pike_mark_sp)); -  struct svalue *s=Pike_sp-args; +  LOCAL_VAR(struct svalue *s); +  s = Pike_sp - args;    if(s->type == T_OBJECT)    { -  struct object *o=s->u.object; -  struct program *p; +  LOCAL_VAR(struct object *o); +  LOCAL_VAR(struct program *p); +  o = s->u.object;    if((p=o->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)    {    if(low_mega_apply(APPLY_LOW, args-1, o, (void *)(ptrdiff_t)fun))
pike.git/src/interpret_functions.h:2074:    DO_JUMP_TO(addr);    }    stack_pop_keep_top();    DO_DUMB_RETURN;    }    }    }    }       { -  struct svalue tmp; -  struct svalue tmp2; +  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;       index_no_free(&tmp2, s, &tmp);    free_svalue(s);    *s=tmp2;    print_return_value();   
pike.git/src/interpret_functions.h:2102:    }    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; \ -  struct svalue *s=&Pike_fp->context.prog->constants[arg1].sval; \ +  LOCAL_VAR(struct svalue *s); \ +  s = &Pike_fp->context.prog->constants[arg1].sval; \    if(Pike_interpreter.trace_level) \    { \ -  dynamic_buffer save_buf; \ +  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); \    } \    (*(s->u.efun->function))(args); \    s->u.efun->runs++; \    if(Pike_sp != expected_stack + !s->u.efun->may_return_void) \
pike.git/src/interpret_functions.h:2133:    s->u.efun->name->str); \    if(Pike_sp == expected_stack && !s->u.efun->may_return_void) \    Pike_fatal("Non-void function returned without return value " \    "on stack: %s %d\n", \    s->u.efun->name->str,s->u.efun->may_return_void); \    if(Pike_sp==expected_stack+1 && s->u.efun->may_return_void) \    Pike_fatal("Void function returned with a value on the stack: %s %d\n", \    s->u.efun->name->str, s->u.efun->may_return_void); \    } \    if(Pike_interpreter.trace_level>1) { \ -  dynamic_buffer save_buf; \ +  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); \    my_strcat ("() "); \    do_trace_return (Pike_sp>expected_stack, &save_buf); \    } \   }while(0)   #else
pike.git/src/interpret_functions.h:2271:    DO_IF_SECURITY(if(!CHECK_DATA_SECURITY(Pike_fp->current_object, \    SECURITY_BIT_NOT_SETUID)) \    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, { -  struct program *p = Pike_fp->current_object->prog; +     PIKE_OPCODE_T *addr; -  +  LOCAL_VAR(struct program *p); +  p = Pike_fp->current_object->prog;    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    * is common, it should offer a speed improvement.    *    * /grubba 2002-11-14
pike.git/src/interpret_functions.h:2380: Inside #if 0
  #if 0   /* This opcode needs mending if it is to work with machine code. */   OPCODE0_JUMP(F_BREAKPOINT, "breakpoint", 0, {    extern void o_breakpoint(void);    o_breakpoint();    DO_JUMP_TO(PROG_COUNTER-1);   });   #endif      OPCODE1(F_THIS_OBJECT, "this_object", I_UPDATE_SP, { -  struct object *o = Pike_fp->current_object; +     int level; -  +  LOCAL_VAR(struct object *o); +  o = Pike_fp->current_object;    for (level = 0; level < arg1; level++) { -  struct program *p = o->prog; +  LOCAL_VAR(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);    });