diff --git a/src/builtin_functions.h b/src/builtin_functions.h
index 80aa5ecab2843178df60a4dc3a12e899da2b55ea..043a4aea2e1bd6d3664e58b79642a955405e4960 100644
--- a/src/builtin_functions.h
+++ b/src/builtin_functions.h
@@ -5,7 +5,7 @@
\*/
/*
- * $Id: builtin_functions.h,v 1.11 2000/01/20 23:10:59 noring Exp $
+ * $Id: builtin_functions.h,v 1.12 2000/02/17 00:31:07 hubbe Exp $
*/
#ifndef BUILTIN_EFUNS_H
#define BUILTIN_EFUNS_H
@@ -17,7 +17,7 @@
/* Prototypes begin here */
#ifdef DEBUG_MALLOC
void _f_aggregate(INT32 args);
-#define f_aggregate(X) do { _f_aggregate(X); debug_malloc_touch(sp[-1].u.refs); } while (0)
+#define f_aggregate(X) do { _f_aggregate(X); debug_malloc_touch(Pike_sp[-1].u.refs); } while (0)
#else
void f_aggregate(INT32 args);
#endif
diff --git a/src/error.h b/src/error.h
index cbcbba11fa63389a416c78b09b595ea2a67cd3a5..f27781e0767ff8e54164f5a79cad4bd0db7dafcf 100644
--- a/src/error.h
+++ b/src/error.h
@@ -5,7 +5,7 @@
\*/
/*
- * $Id: error.h,v 1.39 2000/02/07 09:15:54 hubbe Exp $
+ * $Id: error.h,v 1.40 2000/02/17 00:31:08 hubbe Exp $
*/
#ifndef ERROR_H
#define ERROR_H
@@ -58,9 +58,9 @@ typedef struct JMP_BUF
{
struct JMP_BUF *previous;
jmp_buf recovery;
- struct pike_frame *fp;
- INT32 sp;
- INT32 mark_sp;
+ struct pike_frame *Pike_fp;
+ INT32 Pike_sp;
+ INT32 Pike_mark_sp;
INT32 severity;
ONERROR *onerror;
#ifdef PIKE_DEBUG
@@ -234,19 +234,19 @@ void cleanup_error(void);
/* Some useful error macros. */
#define SIMPLE_BAD_ARG_ERROR(FUNC, ARG, EXPECT) \
- bad_arg_error(FUNC, sp-args, args, ARG, EXPECT, sp+ARG-1-args,\
+ bad_arg_error(FUNC, Pike_sp-args, args, ARG, EXPECT, Pike_sp+ARG-1-args,\
"Bad argument %d to %s(). Expected %s\n", \
ARG, FUNC, EXPECT)
#define SIMPLE_TOO_FEW_ARGS_ERROR(FUNC, ARG) \
- bad_arg_error(FUNC, sp-args, args, ARG, "void", 0,\
+ bad_arg_error(FUNC, Pike_sp-args, args, ARG, "void", 0,\
"Too few arguments to %s().\n",FUNC)
#define SIMPLE_OUT_OF_MEMORY_ERROR(FUNC, AMOUNT) \
- resource_error(FUNC, sp-args, args, "memory", AMOUNT, "Out of memory.\n")
+ resource_error(FUNC, Pike_sp-args, args, "memory", AMOUNT, "Out of memory.\n")
#define SIMPLE_DIVISION_BY_ZERO_ERROR(FUNC) \
- math_error(FUNC, sp-args, args, 0, "Division by zero.\n")
+ math_error(FUNC, Pike_sp-args, args, 0, "Division by zero.\n")
#endif
diff --git a/src/errors.h b/src/errors.h
index 0d20e8c5105678f3bdfec5a26053010f850febc4..6da9d52d2714a91490c9896d615b09beb5b2f359 100644
--- a/src/errors.h
+++ b/src/errors.h
@@ -68,7 +68,7 @@ DECLARE_ERROR(generic, EMPTY ,
ERR_FUNC("backtrace",f_error_backtrace,tFunc(tVoid,tArr(tMixed)),0)
)
-#define GENERIC_ERROR_THIS ((struct generic_error_struct *)fp->current_storage)
+#define GENERIC_ERROR_THIS ((struct generic_error_struct *)Pike_fp->current_storage)
DECLARE_ERROR(index,
ERR_INHERIT(generic),
diff --git a/src/interpret.h b/src/interpret.h
index ef4dfdb28bbc615e24d4749810c82d5b57e77b27..9005a78cb7fa20c1ce0f544dd41116297e001694 100644
--- a/src/interpret.h
+++ b/src/interpret.h
@@ -5,7 +5,7 @@
\*/
/*
- * $Id: interpret.h,v 1.35 1999/11/18 04:14:46 hubbe Exp $
+ * $Id: interpret.h,v 1.36 2000/02/17 00:31:10 hubbe Exp $
*/
#ifndef INTERPRET_H
#define INTERPRET_H
@@ -35,7 +35,7 @@ struct pike_frame
};
#ifdef PIKE_DEBUG
-#define debug_check_stack() do{if(sp<evaluator_stack)fatal("Stack error.\n");}while(0)
+#define debug_check_stack() do{if(Pike_sp<Pike_evaluator_stack)fatal("Stack error.\n");}while(0)
#define check__positive(X,Y) if((X)<0) fatal(Y)
#include "error.h"
#else
@@ -44,90 +44,90 @@ struct pike_frame
#endif
#define check_stack(X) do { \
- if(sp - evaluator_stack + (X) >= stack_size) \
+ if(Pike_sp - Pike_evaluator_stack + (X) >= Pike_stack_size) \
error("Svalue stack overflow. " \
"(%d of %d entries on stack, needed %d more entries)\n", \
- sp-evaluator_stack,stack_size,(X)); \
+ Pike_sp-Pike_evaluator_stack,Pike_stack_size,(X)); \
}while(0)
#define check_mark_stack(X) do { \
- if(mark_sp - mark_stack + (X) >= stack_size) \
+ if(Pike_mark_sp - Pike_mark_stack + (X) >= Pike_stack_size) \
error("Mark stack overflow.\n"); \
}while(0)
#define check_c_stack(X) do { \
- long x_= ((char *)&x_) + STACK_DIRECTION * (X) - stack_top ; \
+ long x_= ((char *)&x_) + STACK_DIRECTION * (X) - Pike_stack_top ; \
x_*=STACK_DIRECTION; \
if(x_>0) \
low_error("C stack overflow.\n"); \
}while(0)
-#define pop_stack() do{ free_svalue(--sp); debug_check_stack(); }while(0)
+#define pop_stack() do{ free_svalue(--Pike_sp); debug_check_stack(); }while(0)
#define pop_n_elems(X) \
do { int x_=(X); if(x_) { \
check__positive(x_,"Popping negative number of args....\n"); \
- sp-=x_; debug_check_stack(); \
- free_svalues(sp,x_,BIT_MIXED); \
+ Pike_sp-=x_; debug_check_stack(); \
+ free_svalues(Pike_sp,x_,BIT_MIXED); \
} } while (0)
#define stack_pop_n_elems_keep_top(X) \
- do { struct svalue s=sp[-1]; sp[-1]=sp[-1-(X)]; sp[-1-(X)]=s; \
+ do { struct svalue s=Pike_sp[-1]; Pike_sp[-1]=Pike_sp[-1-(X)]; Pike_sp[-1-(X)]=s; \
pop_n_elems(X); } while (0)
-#define push_program(P) do{ struct program *_=(P); debug_malloc_touch(_); sp->u.program=_; sp++->type=PIKE_T_PROGRAM; }while(0)
-#define push_int(I) do{ INT32 _=(I); sp->u.integer=_;sp->type=PIKE_T_INT;sp++->subtype=NUMBER_NUMBER; }while(0)
-#define push_mapping(M) do{ struct mapping *_=(M); debug_malloc_touch(_); sp->u.mapping=_; sp++->type=PIKE_T_MAPPING; }while(0)
-#define push_array(A) do{ struct array *_=(A); debug_malloc_touch(_); sp->u.array=_ ;sp++->type=PIKE_T_ARRAY; }while(0)
-#define push_multiset(L) do{ struct multiset *_=(L); debug_malloc_touch(_); sp->u.multiset=_; sp++->type=PIKE_T_MULTISET; }while(0)
-#define push_string(S) do{ struct pike_string *_=(S); debug_malloc_touch(_); sp->subtype=0; sp->u.string=_; sp++->type=PIKE_T_STRING; }while(0)
-#define push_object(O) do{ struct object *_=(O); debug_malloc_touch(_); sp->u.object=_; sp++->type=PIKE_T_OBJECT; }while(0)
-#define push_float(F) do{ float _=(F); sp->u.float_number=_; sp++->type=PIKE_T_FLOAT; }while(0)
+#define push_program(P) do{ struct program *_=(P); debug_malloc_touch(_); Pike_sp->u.program=_; Pike_sp++->type=PIKE_T_PROGRAM; }while(0)
+#define push_int(I) do{ INT32 _=(I); Pike_sp->u.integer=_;Pike_sp->type=PIKE_T_INT;Pike_sp++->subtype=NUMBER_NUMBER; }while(0)
+#define push_mapping(M) do{ struct mapping *_=(M); debug_malloc_touch(_); Pike_sp->u.mapping=_; Pike_sp++->type=PIKE_T_MAPPING; }while(0)
+#define push_array(A) do{ struct array *_=(A); debug_malloc_touch(_); Pike_sp->u.array=_ ;Pike_sp++->type=PIKE_T_ARRAY; }while(0)
+#define push_multiset(L) do{ struct multiset *_=(L); debug_malloc_touch(_); Pike_sp->u.multiset=_; Pike_sp++->type=PIKE_T_MULTISET; }while(0)
+#define push_string(S) do{ struct pike_string *_=(S); debug_malloc_touch(_); Pike_sp->subtype=0; Pike_sp->u.string=_; Pike_sp++->type=PIKE_T_STRING; }while(0)
+#define push_object(O) do{ struct object *_=(O); debug_malloc_touch(_); Pike_sp->u.object=_; Pike_sp++->type=PIKE_T_OBJECT; }while(0)
+#define push_float(F) do{ float _=(F); Pike_sp->u.float_number=_; Pike_sp++->type=PIKE_T_FLOAT; }while(0)
#define push_text(T) push_string(make_shared_string((T)))
-#define push_constant_text(T) do{ sp->subtype=0; MAKE_CONSTANT_SHARED_STRING(sp->u.string,T); sp++->type=PIKE_T_STRING; }while(0)
+#define push_constant_text(T) do{ Pike_sp->subtype=0; MAKE_CONSTANT_SHARED_STRING(Pike_sp->u.string,T); Pike_sp++->type=PIKE_T_STRING; }while(0)
-#define ref_push_program(P) do{ struct program *_=(P); debug_malloc_touch(_); _->refs++; sp->u.program=_; sp++->type=PIKE_T_PROGRAM; }while(0)
-#define ref_push_mapping(M) do{ struct mapping *_=(M); debug_malloc_touch(_); _->refs++; sp->u.mapping=_; sp++->type=PIKE_T_MAPPING; }while(0)
-#define ref_push_array(A) do{ struct array *_=(A); debug_malloc_touch(_); _->refs++; sp->u.array=_ ;sp++->type=PIKE_T_ARRAY; }while(0)
-#define ref_push_multiset(L) do{ struct multiset *_=(L); debug_malloc_touch(_); _->refs++; sp->u.multiset=_; sp++->type=PIKE_T_MULTISET; }while(0)
-#define ref_push_string(S) do{ struct pike_string *_=(S); debug_malloc_touch(_); _->refs++; sp->subtype=0; sp->u.string=_; sp++->type=PIKE_T_STRING; }while(0)
-#define ref_push_object(O) do{ struct object *_=(O); debug_malloc_touch(_); _->refs++; sp->u.object=_; sp++->type=PIKE_T_OBJECT; }while(0)
+#define ref_push_program(P) do{ struct program *_=(P); debug_malloc_touch(_); _->refs++; Pike_sp->u.program=_; Pike_sp++->type=PIKE_T_PROGRAM; }while(0)
+#define ref_push_mapping(M) do{ struct mapping *_=(M); debug_malloc_touch(_); _->refs++; Pike_sp->u.mapping=_; Pike_sp++->type=PIKE_T_MAPPING; }while(0)
+#define ref_push_array(A) do{ struct array *_=(A); debug_malloc_touch(_); _->refs++; Pike_sp->u.array=_ ;Pike_sp++->type=PIKE_T_ARRAY; }while(0)
+#define ref_push_multiset(L) do{ struct multiset *_=(L); debug_malloc_touch(_); _->refs++; Pike_sp->u.multiset=_; Pike_sp++->type=PIKE_T_MULTISET; }while(0)
+#define ref_push_string(S) do{ struct pike_string *_=(S); debug_malloc_touch(_); _->refs++; Pike_sp->subtype=0; Pike_sp->u.string=_; Pike_sp++->type=PIKE_T_STRING; }while(0)
+#define ref_push_object(O) do{ struct object *_=(O); debug_malloc_touch(_); _->refs++; Pike_sp->u.object=_; Pike_sp++->type=PIKE_T_OBJECT; }while(0)
-#define push_svalue(S) do { struct svalue *_=(S); assign_svalue_no_free(sp,_); sp++; }while(0)
+#define push_svalue(S) do { struct svalue *_=(S); assign_svalue_no_free(Pike_sp,_); Pike_sp++; }while(0)
-#define stack_dup() push_svalue(sp-1)
-#define stack_swap() do { struct svalue _=sp[-1]; sp[-1]=sp[-2]; sp[-2]=_; } while(0)
+#define stack_dup() push_svalue(Pike_sp-1)
+#define stack_swap() do { struct svalue _=Pike_sp[-1]; Pike_sp[-1]=Pike_sp[-2]; Pike_sp[-2]=_; } while(0)
/* This pops a number of arguments from the stack but keeps the top
* element on top. Used for popping the arguments while keeping the
* return value.
*/
-#define stack_unlink(X) do { if(X) { free_svalue(sp-(X)-1); sp[-(X)-1]=sp[-1]; sp--; pop_n_elems(X-1); } }while(0)
+#define stack_unlink(X) do { if(X) { free_svalue(Pike_sp-(X)-1); Pike_sp[-(X)-1]=Pike_sp[-1]; Pike_sp--; pop_n_elems(X-1); } }while(0)
#define free_pike_frame(F) do{ struct pike_frame *f_=(F); debug_malloc_touch(f_); if(!--f_->refs) really_free_pike_frame(f_); }while(0)
#define POP_PIKE_FRAME() do { \
- struct pike_frame *tmp_=fp->next; \
- if(!--fp->refs) \
+ struct pike_frame *tmp_=Pike_fp->next; \
+ if(!--Pike_fp->refs) \
{ \
- really_free_pike_frame(fp); \
+ really_free_pike_frame(Pike_fp); \
}else{ \
- DO_IF_DEBUG(if( fp->locals+fp->num_locals>sp) fatal("Stack failure in POP_PIKE_FRAME!\n")); \
- debug_malloc_touch(fp); \
- if(fp->num_locals) \
+ DO_IF_DEBUG(if( Pike_fp->locals+Pike_fp->num_locals>Pike_sp) fatal("Stack failure in POP_PIKE_FRAME!\n")); \
+ debug_malloc_touch(Pike_fp); \
+ if(Pike_fp->num_locals) \
{ \
struct svalue *s=(struct svalue *)xalloc(sizeof(struct svalue)* \
- fp->num_locals); \
- assign_svalues_no_free(s,fp->locals,fp->num_locals,BIT_MIXED); \
- fp->locals=s; \
- fp->malloced_locals=1; \
+ Pike_fp->num_locals); \
+ assign_svalues_no_free(s,Pike_fp->locals,Pike_fp->num_locals,BIT_MIXED); \
+ Pike_fp->locals=s; \
+ Pike_fp->malloced_locals=1; \
}else{ \
- fp->locals=0; \
+ Pike_fp->locals=0; \
} \
- fp->next=0; \
+ Pike_fp->next=0; \
} \
- fp=tmp_; \
+ Pike_fp=tmp_; \
}while(0)
@@ -211,13 +211,13 @@ void cleanup_interpret(void);
void really_clean_up_interpret(void);
/* Prototypes end here */
-extern struct svalue *sp;
-extern struct svalue **mark_sp;
-extern struct svalue *evaluator_stack;
-extern struct svalue **mark_stack;
-extern struct pike_frame *fp; /* pike_frame pointer */
-extern char *stack_top;
-extern int stack_size;
+extern struct svalue *Pike_sp;
+extern struct svalue **Pike_mark_sp;
+extern struct svalue *Pike_evaluator_stack;
+extern struct svalue **Pike_mark_stack;
+extern struct pike_frame *Pike_fp; /* pike_frame pointer */
+extern char *Pike_stack_top;
+extern int Pike_stack_size;
extern int evaluator_stack_malloced, mark_stack_malloced;
struct callback;
extern struct callback_list evaluator_callbacks;
@@ -230,5 +230,17 @@ extern long long time_base;
#endif
#endif
+#ifndef NO_PIKE_SHORTHAND
+
+#define sp Pike_sp
+#define fp Pike_fp
+#define evaluator_stack Pike_evaluator_stack
+#define stack_top Pike_stack_top
+#define mark_sp Pike_mark_sp
+#define mark_stack Pike_mark_stack
+#define stack_size Pike_stack_size
+
+#endif /* !NO_PIKE_SHORTHAND */
+
#endif
diff --git a/src/interpreter.h b/src/interpreter.h
index 85295baf1c617633d31f8b50427aaa546a21cefa..5fb0203b494fad245b6db25d88c3a57e8e7196b8 100644
--- a/src/interpreter.h
+++ b/src/interpreter.h
@@ -22,10 +22,10 @@
static int eval_instruction(unsigned char *pc)
{
unsigned INT32 accumulator=0,instr, prefix=0;
- debug_malloc_touch(fp);
+ debug_malloc_touch(Pike_fp);
while(1)
{
- fp->pc = pc;
+ Pike_fp->pc = pc;
instr=EXTRACT_UCHAR(pc++);
#ifdef PIKE_DEBUG
@@ -40,25 +40,25 @@ static int eval_instruction(unsigned char *pc)
fatal("thread_for_id() (or thread_id) failed in interpreter.h! %p != %p\n",thread_for_id(th_self()),thread_id);
#endif
- sp[0].type=99; /* an invalid type */
- sp[1].type=99;
- sp[2].type=99;
- sp[3].type=99;
+ Pike_sp[0].type=99; /* an invalid type */
+ Pike_sp[1].type=99;
+ Pike_sp[2].type=99;
+ Pike_sp[3].type=99;
- if(sp<evaluator_stack || mark_sp < mark_stack || fp->locals>sp)
+ if(Pike_sp<Pike_evaluator_stack || Pike_mark_sp < Pike_mark_stack || Pike_fp->locals>Pike_sp)
fatal("Stack error (generic).\n");
- if(sp > evaluator_stack+stack_size)
+ if(Pike_sp > Pike_evaluator_stack+Pike_stack_size)
fatal("Stack error (overflow).\n");
- if(fp->fun>=0 && fp->current_object->prog &&
- fp->locals+fp->num_locals > sp)
+ if(Pike_fp->fun>=0 && Pike_fp->current_object->prog &&
+ Pike_fp->locals+Pike_fp->num_locals > Pike_sp)
fatal("Stack error (stupid!).\n");
- if(recoveries && sp-evaluator_stack < recoveries->sp)
+ if(recoveries && Pike_sp-Pike_evaluator_stack < recoveries->Pike_sp)
fatal("Stack error (underflow).\n");
- if(mark_sp > mark_stack && mark_sp[-1] > sp)
+ if(Pike_mark_sp > Pike_mark_stack && Pike_mark_sp[-1] > Pike_sp)
fatal("Stack error (underflow?)\n");
if(d_flag > 9) do_debug();
@@ -69,24 +69,24 @@ static int eval_instruction(unsigned char *pc)
if(backlog[backlogp].program)
free_program(backlog[backlogp].program);
- backlog[backlogp].program=fp->context.prog;
- add_ref(fp->context.prog);
+ backlog[backlogp].program=Pike_fp->context.prog;
+ add_ref(Pike_fp->context.prog);
backlog[backlogp].instruction=instr;
backlog[backlogp].arg=0;
backlog[backlogp].pc=pc;
- debug_malloc_touch(fp->current_object);
+ debug_malloc_touch(Pike_fp->current_object);
switch(d_flag)
{
default:
case 3:
- check_object(fp->current_object);
+ check_object(Pike_fp->current_object);
/* break; */
case 2:
- check_object_context(fp->current_object,
- fp->context.prog,
- fp->current_storage);
+ check_object_context(Pike_fp->current_object,
+ Pike_fp->context.prog,
+ Pike_fp->current_storage);
case 1:
case 0:
break;
@@ -98,14 +98,14 @@ static int eval_instruction(unsigned char *pc)
char *file, *f;
INT32 linep;
- file=get_line(pc-1,fp->context.prog,&linep);
+ file=get_line(pc-1,Pike_fp->context.prog,&linep);
while((f=STRCHR(file,'/'))) file=f+1;
fprintf(stderr,"- %s:%4ld:(%lx): %-25s %4ld %4ld\n",
file,(long)linep,
- (long)(pc-fp->context.prog->program-1),
+ (long)(pc-Pike_fp->context.prog->program-1),
get_f_name(instr + F_OFFSET),
- (long)(sp-evaluator_stack),
- (long)(mark_sp-mark_stack));
+ (long)(Pike_sp-Pike_evaluator_stack),
+ (long)(Pike_mark_sp-Pike_mark_stack));
}
if(instr + F_OFFSET < F_MAX_OPCODE)
@@ -130,7 +130,7 @@ static int eval_instruction(unsigned char *pc)
CASE(F_LDA); accumulator=GET_ARG(); break;
/* Push number */
- CASE(F_UNDEFINED); push_int(0); sp[-1].subtype=NUMBER_UNDEFINED; break;
+ CASE(F_UNDEFINED); push_int(0); Pike_sp[-1].subtype=NUMBER_UNDEFINED; break;
CASE(F_CONST0); push_int(0); break;
CASE(F_CONST1); push_int(1); break;
CASE(F_CONST_1); push_int(-1); break;
@@ -140,53 +140,53 @@ static int eval_instruction(unsigned char *pc)
/* The rest of the basic 'push value' instructions */
- CASE(F_MARK_AND_STRING); *(mark_sp++)=sp;
+ CASE(F_MARK_AND_STRING); *(Pike_mark_sp++)=Pike_sp;
CASE(F_STRING);
- copy_shared_string(sp->u.string,fp->context.prog->strings[GET_ARG()]);
- sp->type=PIKE_T_STRING;
- sp->subtype=0;
- sp++;
+ copy_shared_string(Pike_sp->u.string,Pike_fp->context.prog->strings[GET_ARG()]);
+ Pike_sp->type=PIKE_T_STRING;
+ Pike_sp->subtype=0;
+ Pike_sp++;
print_return_value();
break;
CASE(F_ARROW_STRING);
- copy_shared_string(sp->u.string,fp->context.prog->strings[GET_ARG()]);
- sp->type=PIKE_T_STRING;
- sp->subtype=1; /* Magic */
- sp++;
+ copy_shared_string(Pike_sp->u.string,Pike_fp->context.prog->strings[GET_ARG()]);
+ Pike_sp->type=PIKE_T_STRING;
+ Pike_sp->subtype=1; /* Magic */
+ Pike_sp++;
print_return_value();
break;
CASE(F_CONSTANT);
- assign_svalue_no_free(sp++,& fp->context.prog->constants[GET_ARG()].sval);
+ assign_svalue_no_free(Pike_sp++,& Pike_fp->context.prog->constants[GET_ARG()].sval);
print_return_value();
break;
CASE(F_FLOAT);
- sp->type=PIKE_T_FLOAT;
- MEMCPY((void *)&sp->u.float_number, pc, sizeof(FLOAT_TYPE));
+ Pike_sp->type=PIKE_T_FLOAT;
+ MEMCPY((void *)&Pike_sp->u.float_number, pc, sizeof(FLOAT_TYPE));
pc+=sizeof(FLOAT_TYPE);
- sp++;
+ Pike_sp++;
break;
CASE(F_LFUN);
- sp->u.object=fp->current_object;
- add_ref(fp->current_object);
- sp->subtype=GET_ARG()+fp->context.identifier_level;
- sp->type=PIKE_T_FUNCTION;
- sp++;
+ Pike_sp->u.object=Pike_fp->current_object;
+ add_ref(Pike_fp->current_object);
+ Pike_sp->subtype=GET_ARG()+Pike_fp->context.identifier_level;
+ Pike_sp->type=PIKE_T_FUNCTION;
+ Pike_sp++;
print_return_value();
break;
CASE(F_TRAMPOLINE);
{
struct object *o=low_clone(pike_trampoline_program);
- add_ref( ((struct pike_trampoline *)(o->storage))->frame=fp );
- ((struct pike_trampoline *)(o->storage))->func=GET_ARG()+fp->context.identifier_level;
+ add_ref( ((struct pike_trampoline *)(o->storage))->frame=Pike_fp );
+ ((struct pike_trampoline *)(o->storage))->func=GET_ARG()+Pike_fp->context.identifier_level;
push_object(o);
/* Make it look like a function. */
- sp[-1].subtype = pike_trampoline_program->lfuns[LFUN_CALL];
- sp[-1].type = T_FUNCTION;
+ Pike_sp[-1].subtype = pike_trampoline_program->lfuns[LFUN_CALL];
+ Pike_sp[-1].type = T_FUNCTION;
print_return_value();
break;
}
@@ -195,10 +195,10 @@ static int eval_instruction(unsigned char *pc)
/* The not so basic 'push value' instructions */
CASE(F_GLOBAL);
{
- low_object_index_no_free(sp,
- fp->current_object,
- GET_ARG() + fp->context.identifier_level);
- sp++;
+ low_object_index_no_free(Pike_sp,
+ Pike_fp->current_object,
+ GET_ARG() + Pike_fp->context.identifier_level);
+ Pike_sp++;
print_return_value();
}
break;
@@ -210,9 +210,9 @@ static int eval_instruction(unsigned char *pc)
struct object *o;
INT32 i,id=GET_ARG();
- inherit=&fp->context;
+ inherit=&Pike_fp->context;
- o=fp->current_object;
+ o=Pike_fp->current_object;
if(!o)
error("Current object is destructed\n");
@@ -289,10 +289,10 @@ static int eval_instruction(unsigned char *pc)
--accumulator;
}
- low_object_index_no_free(sp,
+ low_object_index_no_free(Pike_sp,
o,
id + inherit->identifier_level);
- sp++;
+ Pike_sp++;
print_return_value();
break;
}
@@ -304,8 +304,8 @@ static int eval_instruction(unsigned char *pc)
struct object *o;
INT32 i,id=GET_ARG();
- inherit=&fp->context;
- o=fp->current_object;
+ inherit=&Pike_fp->context;
+ o=Pike_fp->current_object;
if(!o)
error("Current object is destructed\n");
@@ -335,76 +335,76 @@ static int eval_instruction(unsigned char *pc)
}
ref_push_object(o);
- sp->type=T_LVALUE;
- sp->u.integer=id + inherit->identifier_level;
- sp++;
+ Pike_sp->type=T_LVALUE;
+ Pike_sp->u.integer=id + inherit->identifier_level;
+ Pike_sp++;
break;
}
- CASE(F_MARK_AND_LOCAL); *(mark_sp++)=sp;
+ CASE(F_MARK_AND_LOCAL); *(Pike_mark_sp++)=Pike_sp;
CASE(F_LOCAL);
- assign_svalue_no_free(sp++,fp->locals+GET_ARG());
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+GET_ARG());
print_return_value();
break;
CASE(F_2_LOCALS);
- assign_svalue_no_free(sp++,fp->locals+GET_ARG());
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+GET_ARG());
print_return_value();
- assign_svalue_no_free(sp++,fp->locals+GET_ARG2());
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+GET_ARG2());
print_return_value();
break;
CASE(F_LOCAL_2_LOCAL);
{
int tmp=GET_ARG();
- assign_svalue(fp->locals+tmp, fp->locals+GET_ARG2());
+ assign_svalue(Pike_fp->locals+tmp, Pike_fp->locals+GET_ARG2());
break;
}
CASE(F_LOCAL_2_GLOBAL);
{
- INT32 tmp=GET_ARG() + fp->context.identifier_level;
+ INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
struct identifier *i;
- if(!fp->current_object->prog)
+ if(!Pike_fp->current_object->prog)
error("Cannot access global variables in destructed object.\n");
- i=ID_FROM_INT(fp->current_object->prog, tmp);
+ i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags))
error("Cannot assign functions or constants.\n");
if(i->run_time_type == T_MIXED)
{
- assign_svalue((struct svalue *)GLOBAL_FROM_INT(tmp), fp->locals + GET_ARG2());
+ assign_svalue((struct svalue *)GLOBAL_FROM_INT(tmp), Pike_fp->locals + GET_ARG2());
}else{
assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp),
i->run_time_type,
- fp->locals + GET_ARG2());
+ Pike_fp->locals + GET_ARG2());
}
break;
}
CASE(F_GLOBAL_2_LOCAL);
{
- INT32 tmp=GET_ARG() + fp->context.identifier_level;
+ INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
INT32 tmp2=GET_ARG2();
- free_svalue(fp->locals + tmp2);
- low_object_index_no_free(fp->locals + tmp2,
- fp->current_object,
+ free_svalue(Pike_fp->locals + tmp2);
+ low_object_index_no_free(Pike_fp->locals + tmp2,
+ Pike_fp->current_object,
tmp);
break;
}
CASE(F_LOCAL_LVALUE);
- sp[0].type=T_LVALUE;
- sp[0].u.lval=fp->locals+GET_ARG();
- sp[1].type=T_VOID;
- sp+=2;
+ Pike_sp[0].type=T_LVALUE;
+ Pike_sp[0].u.lval=Pike_fp->locals+GET_ARG();
+ Pike_sp[1].type=T_VOID;
+ Pike_sp+=2;
break;
CASE(F_LEXICAL_LOCAL);
{
- struct pike_frame *f=fp;
+ struct pike_frame *f=Pike_fp;
while(accumulator--)
{
f=f->scope;
@@ -417,103 +417,103 @@ static int eval_instruction(unsigned char *pc)
CASE(F_LEXICAL_LOCAL_LVALUE);
{
- struct pike_frame *f=fp;
+ struct pike_frame *f=Pike_fp;
while(accumulator--)
{
f=f->scope;
if(!f) error("Lexical scope error.\n");
}
- sp[0].type=T_LVALUE;
- sp[0].u.lval=f->locals+GET_ARG();
- sp[1].type=T_VOID;
- sp+=2;
+ Pike_sp[0].type=T_LVALUE;
+ Pike_sp[0].u.lval=f->locals+GET_ARG();
+ Pike_sp[1].type=T_VOID;
+ Pike_sp+=2;
break;
}
CASE(F_ARRAY_LVALUE);
f_aggregate(GET_ARG()*2);
- sp[-1].u.array->flags |= ARRAY_LVALUE;
- sp[-1].u.array->type_field |= BIT_UNFINISHED | BIT_MIXED;
- sp[0]=sp[-1];
- sp[-1].type=T_ARRAY_LVALUE;
- sp++;
+ Pike_sp[-1].u.array->flags |= ARRAY_LVALUE;
+ Pike_sp[-1].u.array->type_field |= BIT_UNFINISHED | BIT_MIXED;
+ Pike_sp[0]=Pike_sp[-1];
+ Pike_sp[-1].type=T_ARRAY_LVALUE;
+ Pike_sp++;
break;
CASE(F_CLEAR_2_LOCAL);
instr=GET_ARG();
- free_svalues(fp->locals + instr, 2, -1);
- fp->locals[instr].type=PIKE_T_INT;
- fp->locals[instr].subtype=0;
- fp->locals[instr].u.integer=0;
- fp->locals[instr+1].type=PIKE_T_INT;
- fp->locals[instr+1].subtype=0;
- fp->locals[instr+1].u.integer=0;
+ free_svalues(Pike_fp->locals + instr, 2, -1);
+ Pike_fp->locals[instr].type=PIKE_T_INT;
+ Pike_fp->locals[instr].subtype=0;
+ Pike_fp->locals[instr].u.integer=0;
+ Pike_fp->locals[instr+1].type=PIKE_T_INT;
+ Pike_fp->locals[instr+1].subtype=0;
+ Pike_fp->locals[instr+1].u.integer=0;
break;
CASE(F_CLEAR_4_LOCAL);
{
int e;
instr=GET_ARG();
- free_svalues(fp->locals + instr, 4, -1);
+ free_svalues(Pike_fp->locals + instr, 4, -1);
for(e=0;e<4;e++)
{
- fp->locals[instr+e].type=PIKE_T_INT;
- fp->locals[instr+e].subtype=0;
- fp->locals[instr+e].u.integer=0;
+ Pike_fp->locals[instr+e].type=PIKE_T_INT;
+ Pike_fp->locals[instr+e].subtype=0;
+ Pike_fp->locals[instr+e].u.integer=0;
}
break;
}
CASE(F_CLEAR_LOCAL);
instr=GET_ARG();
- free_svalue(fp->locals + instr);
- fp->locals[instr].type=PIKE_T_INT;
- fp->locals[instr].subtype=0;
- fp->locals[instr].u.integer=0;
+ free_svalue(Pike_fp->locals + instr);
+ Pike_fp->locals[instr].type=PIKE_T_INT;
+ Pike_fp->locals[instr].subtype=0;
+ Pike_fp->locals[instr].u.integer=0;
break;
CASE(F_INC_LOCAL);
instr=GET_ARG();
#ifdef AUTO_BIGNUM
- if(fp->locals[instr].type == PIKE_T_INT &&
- !INT_TYPE_ADD_OVERFLOW(fp->locals[instr].u.integer, 1))
+ if(Pike_fp->locals[instr].type == PIKE_T_INT &&
+ !INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
#else
- if(fp->locals[instr].type == PIKE_T_INT)
+ if(Pike_fp->locals[instr].type == PIKE_T_INT)
#endif /* AUTO_BIGNUM */
{
- fp->locals[instr].u.integer++;
- assign_svalue_no_free(sp++,fp->locals+instr);
+ Pike_fp->locals[instr].u.integer++;
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
}
else
{
- assign_svalue_no_free(sp++,fp->locals+instr);
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
push_int(1);
f_add(2);
- assign_svalue(fp->locals+instr,sp-1);
+ assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
}
break;
CASE(F_POST_INC_LOCAL);
instr=GET_ARG();
- assign_svalue_no_free(sp++,fp->locals+instr);
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
goto inc_local_and_pop;
CASE(F_INC_LOCAL_AND_POP);
instr=GET_ARG();
inc_local_and_pop:
#ifdef AUTO_BIGNUM
- if(fp->locals[instr].type == PIKE_T_INT &&
- !INT_TYPE_ADD_OVERFLOW(fp->locals[instr].u.integer, 1))
+ if(Pike_fp->locals[instr].type == PIKE_T_INT &&
+ !INT_TYPE_ADD_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
#else
- if(fp->locals[instr].type == PIKE_T_INT)
+ if(Pike_fp->locals[instr].type == PIKE_T_INT)
#endif /* AUTO_BIGNUM */
{
- fp->locals[instr].u.integer++;
+ Pike_fp->locals[instr].u.integer++;
}else{
- assign_svalue_no_free(sp++,fp->locals+instr);
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
push_int(1);
f_add(2);
- assign_svalue(fp->locals+instr,sp-1);
+ assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
pop_stack();
}
break;
@@ -521,59 +521,59 @@ static int eval_instruction(unsigned char *pc)
CASE(F_DEC_LOCAL);
instr=GET_ARG();
#ifdef AUTO_BIGNUM
- if(fp->locals[instr].type == PIKE_T_INT &&
- !INT_TYPE_SUB_OVERFLOW(fp->locals[instr].u.integer, 1))
+ if(Pike_fp->locals[instr].type == PIKE_T_INT &&
+ !INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
#else
- if(fp->locals[instr].type == PIKE_T_INT)
+ if(Pike_fp->locals[instr].type == PIKE_T_INT)
#endif /* AUTO_BIGNUM */
{
- fp->locals[instr].u.integer--;
- assign_svalue_no_free(sp++,fp->locals+instr);
+ Pike_fp->locals[instr].u.integer--;
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
}else{
- assign_svalue_no_free(sp++,fp->locals+instr);
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
push_int(1);
o_subtract();
- assign_svalue(fp->locals+instr,sp-1);
+ assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
}
break;
CASE(F_POST_DEC_LOCAL);
instr=GET_ARG();
- assign_svalue_no_free(sp++,fp->locals+instr);
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
goto dec_local_and_pop;
- /* fp->locals[instr].u.integer--; */
+ /* Pike_fp->locals[instr].u.integer--; */
break;
CASE(F_DEC_LOCAL_AND_POP);
instr=GET_ARG();
dec_local_and_pop:
#ifdef AUTO_BIGNUM
- if(fp->locals[instr].type == PIKE_T_INT &&
- !INT_TYPE_SUB_OVERFLOW(fp->locals[instr].u.integer, 1))
+ if(Pike_fp->locals[instr].type == PIKE_T_INT &&
+ !INT_TYPE_SUB_OVERFLOW(Pike_fp->locals[instr].u.integer, 1))
#else
- if(fp->locals[instr].type == PIKE_T_INT)
+ if(Pike_fp->locals[instr].type == PIKE_T_INT)
#endif /* AUTO_BIGNUM */
{
- fp->locals[instr].u.integer--;
+ Pike_fp->locals[instr].u.integer--;
}else{
- assign_svalue_no_free(sp++,fp->locals+instr);
+ assign_svalue_no_free(Pike_sp++,Pike_fp->locals+instr);
push_int(1);
o_subtract();
- assign_svalue(fp->locals+instr,sp-1);
+ assign_svalue(Pike_fp->locals+instr,Pike_sp-1);
pop_stack();
}
break;
CASE(F_LTOSVAL);
- lvalue_to_svalue_no_free(sp,sp-2);
- sp++;
+ lvalue_to_svalue_no_free(Pike_sp,Pike_sp-2);
+ Pike_sp++;
break;
CASE(F_LTOSVAL2);
- sp[0]=sp[-1];
- sp[-1].type=PIKE_T_INT;
- sp++;
- lvalue_to_svalue_no_free(sp-2,sp-4);
+ 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);
/* 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
@@ -581,22 +581,22 @@ static int eval_instruction(unsigned char *pc)
* and then the low array/multiset/mapping manipulation routines can be
* destructive if they like
*/
- if( (1 << sp[-2].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING ))
+ 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(sp-4,&s);
+ assign_lvalue(Pike_sp-4,&s);
}
break;
CASE(F_ADD_TO_AND_POP);
- sp[0]=sp[-1];
- sp[-1].type=PIKE_T_INT;
- sp++;
- lvalue_to_svalue_no_free(sp-2,sp-4);
+ 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);
/* 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
@@ -604,49 +604,49 @@ static int eval_instruction(unsigned char *pc)
* and then the low array/multiset/mapping manipulation routines can be
* destructive if they like
*/
- if( (1 << sp[-2].type) & ( BIT_ARRAY | BIT_MULTISET | BIT_MAPPING | BIT_STRING ))
+ 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(sp-4,&s);
+ assign_lvalue(Pike_sp-4,&s);
}
f_add(2);
- assign_lvalue(sp-3,sp-1);
+ assign_lvalue(Pike_sp-3,Pike_sp-1);
pop_n_elems(3);
break;
CASE(F_GLOBAL_LVALUE);
{
struct identifier *i;
- INT32 tmp=GET_ARG() + fp->context.identifier_level;
+ INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
- if(!fp->current_object->prog)
+ if(!Pike_fp->current_object->prog)
error("Cannot access global variables in destructed object.\n");
- i=ID_FROM_INT(fp->current_object->prog, tmp);
+ i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags))
error("Cannot re-assign functions or constants.\n");
if(i->run_time_type == T_MIXED)
{
- sp[0].type=T_LVALUE;
- sp[0].u.lval=(struct svalue *)GLOBAL_FROM_INT(tmp);
+ Pike_sp[0].type=T_LVALUE;
+ Pike_sp[0].u.lval=(struct svalue *)GLOBAL_FROM_INT(tmp);
}else{
- sp[0].type=T_SHORT_LVALUE;
- sp[0].u.short_lval= (union anything *)GLOBAL_FROM_INT(tmp);
- sp[0].subtype=i->run_time_type;
+ Pike_sp[0].type=T_SHORT_LVALUE;
+ Pike_sp[0].u.short_lval= (union anything *)GLOBAL_FROM_INT(tmp);
+ Pike_sp[0].subtype=i->run_time_type;
}
- sp[1].type=T_VOID;
- sp+=2;
+ Pike_sp[1].type=T_VOID;
+ Pike_sp+=2;
break;
}
CASE(F_INC);
{
- union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);
+ union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
if(u
#ifdef AUTO_BIGNUM
&& !INT_TYPE_ADD_OVERFLOW(u->integer, 1)
@@ -658,18 +658,18 @@ static int eval_instruction(unsigned char *pc)
push_int(u->integer);
break;
}
- lvalue_to_svalue_no_free(sp, sp-2); sp++;
+ lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
push_int(1);
f_add(2);
- assign_lvalue(sp-3, sp-1);
- assign_svalue(sp-3, sp-1);
+ assign_lvalue(Pike_sp-3, Pike_sp-1);
+ assign_svalue(Pike_sp-3, Pike_sp-1);
pop_n_elems(2);
break;
}
CASE(F_DEC);
{
- union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);
+ union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
if(u
#ifdef AUTO_BIGNUM
&& !INT_TYPE_SUB_OVERFLOW(u->integer, 1)
@@ -681,18 +681,18 @@ static int eval_instruction(unsigned char *pc)
push_int(u->integer);
break;
}
- lvalue_to_svalue_no_free(sp, sp-2); sp++;
+ lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
push_int(1);
o_subtract();
- assign_lvalue(sp-3, sp-1);
- assign_svalue(sp-3, sp-1);
+ assign_lvalue(Pike_sp-3, Pike_sp-1);
+ assign_svalue(Pike_sp-3, Pike_sp-1);
pop_n_elems(2);
break;
}
CASE(F_DEC_AND_POP);
{
- union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);
+ union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
if(u
#ifdef AUTO_BIGNUM
&& !INT_TYPE_SUB_OVERFLOW(u->integer, 1)
@@ -702,10 +702,10 @@ static int eval_instruction(unsigned char *pc)
instr=-- u->integer;
pop_n_elems(2);
}else{
- lvalue_to_svalue_no_free(sp, sp-2); sp++;
+ lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
push_int(1);
o_subtract();
- assign_lvalue(sp-3, sp-1);
+ assign_lvalue(Pike_sp-3, Pike_sp-1);
pop_n_elems(3);
}
break;
@@ -713,7 +713,7 @@ static int eval_instruction(unsigned char *pc)
CASE(F_INC_AND_POP);
{
- union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);
+ union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
if(u
#ifdef AUTO_BIGNUM
&& !INT_TYPE_ADD_OVERFLOW(u->integer, 1)
@@ -724,17 +724,17 @@ static int eval_instruction(unsigned char *pc)
pop_n_elems(2);
break;
}
- lvalue_to_svalue_no_free(sp, sp-2); sp++;
+ lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
push_int(1);
f_add(2);
- assign_lvalue(sp-3, sp-1);
+ assign_lvalue(Pike_sp-3, Pike_sp-1);
pop_n_elems(3);
break;
}
CASE(F_POST_INC);
{
- union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);
+ union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
if(u
#ifdef AUTO_BIGNUM
&& !INT_TYPE_ADD_OVERFLOW(u->integer, 1)
@@ -746,19 +746,19 @@ static int eval_instruction(unsigned char *pc)
push_int(instr);
break;
}
- lvalue_to_svalue_no_free(sp, sp-2); sp++;
- assign_svalue_no_free(sp,sp-1); sp++;
+ lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
+ assign_svalue_no_free(Pike_sp,Pike_sp-1); Pike_sp++;
push_int(1);
f_add(2);
- assign_lvalue(sp-4, sp-1);
- assign_svalue(sp-4, sp-2);
+ assign_lvalue(Pike_sp-4, Pike_sp-1);
+ assign_svalue(Pike_sp-4, Pike_sp-2);
pop_n_elems(3);
break;
}
CASE(F_POST_DEC);
{
- union anything *u=get_pointer_if_this_type(sp-2, PIKE_T_INT);
+ union anything *u=get_pointer_if_this_type(Pike_sp-2, PIKE_T_INT);
if(u
#ifdef AUTO_BIGNUM
&& !INT_TYPE_SUB_OVERFLOW(u->integer, 1)
@@ -770,65 +770,65 @@ static int eval_instruction(unsigned char *pc)
push_int(instr);
break;
}
- lvalue_to_svalue_no_free(sp, sp-2); sp++;
- assign_svalue_no_free(sp,sp-1); sp++;
+ lvalue_to_svalue_no_free(Pike_sp, Pike_sp-2); Pike_sp++;
+ assign_svalue_no_free(Pike_sp,Pike_sp-1); Pike_sp++;
push_int(1);
o_subtract();
- assign_lvalue(sp-4, sp-1);
- assign_svalue(sp-4, sp-2);
+ assign_lvalue(Pike_sp-4, Pike_sp-1);
+ assign_svalue(Pike_sp-4, Pike_sp-2);
pop_n_elems(3);
break;
}
CASE(F_ASSIGN);
- assign_lvalue(sp-3,sp-1);
- free_svalue(sp-3);
- free_svalue(sp-2);
- sp[-3]=sp[-1];
- sp-=2;
+ assign_lvalue(Pike_sp-3,Pike_sp-1);
+ free_svalue(Pike_sp-3);
+ free_svalue(Pike_sp-2);
+ Pike_sp[-3]=Pike_sp[-1];
+ Pike_sp-=2;
break;
CASE(F_ASSIGN_AND_POP);
- assign_lvalue(sp-3,sp-1);
+ assign_lvalue(Pike_sp-3,Pike_sp-1);
pop_n_elems(3);
break;
CASE(F_APPLY_ASSIGN_LOCAL);
- strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp );
+ strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
/* Fall through */
CASE(F_ASSIGN_LOCAL);
- assign_svalue(fp->locals+GET_ARG(),sp-1);
+ assign_svalue(Pike_fp->locals+GET_ARG(),Pike_sp-1);
break;
CASE(F_APPLY_ASSIGN_LOCAL_AND_POP);
- strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp );
+ strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
/* Fall through */
CASE(F_ASSIGN_LOCAL_AND_POP);
instr=GET_ARG();
- free_svalue(fp->locals+instr);
- fp->locals[instr]=sp[-1];
- sp--;
+ free_svalue(Pike_fp->locals+instr);
+ Pike_fp->locals[instr]=Pike_sp[-1];
+ Pike_sp--;
break;
CASE(F_ASSIGN_GLOBAL)
{
struct identifier *i;
- INT32 tmp=GET_ARG() + fp->context.identifier_level;
- if(!fp->current_object->prog)
+ INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
+ if(!Pike_fp->current_object->prog)
error("Cannot access global variables in destructed object.\n");
- i=ID_FROM_INT(fp->current_object->prog, tmp);
+ i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags))
error("Cannot assign functions or constants.\n");
if(i->run_time_type == T_MIXED)
{
- assign_svalue((struct svalue *)GLOBAL_FROM_INT(tmp), sp-1);
+ assign_svalue((struct svalue *)GLOBAL_FROM_INT(tmp), Pike_sp-1);
}else{
assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp),
i->run_time_type,
- sp-1);
+ Pike_sp-1);
}
}
break;
@@ -836,11 +836,11 @@ static int eval_instruction(unsigned char *pc)
CASE(F_ASSIGN_GLOBAL_AND_POP)
{
struct identifier *i;
- INT32 tmp=GET_ARG() + fp->context.identifier_level;
- if(!fp->current_object->prog)
+ INT32 tmp=GET_ARG() + Pike_fp->context.identifier_level;
+ if(!Pike_fp->current_object->prog)
error("Cannot access global variables in destructed object.\n");
- i=ID_FROM_INT(fp->current_object->prog, tmp);
+ i=ID_FROM_INT(Pike_fp->current_object->prog, tmp);
if(!IDENTIFIER_IS_VARIABLE(i->identifier_flags))
error("Cannot assign functions or constants.\n");
@@ -848,12 +848,12 @@ static int eval_instruction(unsigned char *pc)
{
struct svalue *s=(struct svalue *)GLOBAL_FROM_INT(tmp);
free_svalue(s);
- sp--;
- *s=*sp;
+ Pike_sp--;
+ *s=*Pike_sp;
}else{
assign_to_short_svalue((union anything *)GLOBAL_FROM_INT(tmp),
i->run_time_type,
- sp-1);
+ Pike_sp-1);
pop_stack();
}
}
@@ -862,13 +862,13 @@ static int eval_instruction(unsigned char *pc)
/* Stack machine stuff */
CASE(F_POP_VALUE); pop_stack(); break;
CASE(F_POP_N_ELEMS); pop_n_elems(GET_ARG()); break;
- CASE(F_MARK2); *(mark_sp++)=sp;
- CASE(F_MARK); *(mark_sp++)=sp; break;
- CASE(F_MARK_X); *(mark_sp++)=sp-GET_ARG(); break;
- CASE(F_POP_MARK); --mark_sp; break;
+ CASE(F_MARK2); *(Pike_mark_sp++)=Pike_sp;
+ CASE(F_MARK); *(Pike_mark_sp++)=Pike_sp; break;
+ CASE(F_MARK_X); *(Pike_mark_sp++)=Pike_sp-GET_ARG(); break;
+ CASE(F_POP_MARK); --Pike_mark_sp; break;
CASE(F_CLEAR_STRING_SUBTYPE);
- if(sp[-1].type==PIKE_T_STRING) sp[-1].subtype=0;
+ if(Pike_sp[-1].type==PIKE_T_STRING) Pike_sp[-1].subtype=0;
break;
/* Jumps */
@@ -880,18 +880,18 @@ static int eval_instruction(unsigned char *pc)
{
struct svalue tmp;
tmp.type=PIKE_T_STRING;
- tmp.u.string=fp->context.prog->strings[GET_ARG()];
+ tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
tmp.subtype=1;
- sp->type=PIKE_T_INT;
- sp++;
- index_no_free(sp-1,fp->locals+GET_ARG2() , &tmp);
+ Pike_sp->type=PIKE_T_INT;
+ Pike_sp++;
+ index_no_free(Pike_sp-1,Pike_fp->locals+GET_ARG2() , &tmp);
print_return_value();
}
/* Fall through */
CASE(F_BRANCH_WHEN_ZERO);
- if(!IS_ZERO(sp-1))
+ if(!IS_ZERO(Pike_sp-1))
{
pc+=sizeof(INT32);
}else{
@@ -902,7 +902,7 @@ static int eval_instruction(unsigned char *pc)
CASE(F_BRANCH_WHEN_NON_ZERO);
- if(IS_ZERO(sp-1))
+ if(IS_ZERO(Pike_sp-1))
{
pc+=sizeof(INT32);
}else{
@@ -913,7 +913,7 @@ static int eval_instruction(unsigned char *pc)
CASE(F_BRANCH_IF_LOCAL);
instr=GET_ARG();
- if(IS_ZERO(fp->locals + instr))
+ if(IS_ZERO(Pike_fp->locals + instr))
{
pc+=sizeof(INT32);
}else{
@@ -923,7 +923,7 @@ static int eval_instruction(unsigned char *pc)
CASE(F_BRANCH_IF_NOT_LOCAL);
instr=GET_ARG();
- if(!IS_ZERO(fp->locals + instr))
+ if(!IS_ZERO(Pike_fp->locals + instr))
{
pc+=sizeof(INT32);
}else{
@@ -939,7 +939,7 @@ static int eval_instruction(unsigned char *pc)
CJUMP(F_BRANCH_WHEN_GE,!is_lt);
CASE(F_BRANCH_AND_POP_WHEN_ZERO);
- if(!IS_ZERO(sp-1))
+ if(!IS_ZERO(Pike_sp-1))
{
pc+=sizeof(INT32);
}else{
@@ -949,7 +949,7 @@ static int eval_instruction(unsigned char *pc)
break;
CASE(F_BRANCH_AND_POP_WHEN_NON_ZERO);
- if(IS_ZERO(sp-1))
+ if(IS_ZERO(Pike_sp-1))
{
pc+=sizeof(INT32);
}else{
@@ -959,7 +959,7 @@ static int eval_instruction(unsigned char *pc)
break;
CASE(F_LAND);
- if(!IS_ZERO(sp-1))
+ if(!IS_ZERO(Pike_sp-1))
{
pc+=sizeof(INT32);
pop_stack();
@@ -969,7 +969,7 @@ static int eval_instruction(unsigned char *pc)
break;
CASE(F_LOR);
- if(IS_ZERO(sp-1))
+ if(IS_ZERO(Pike_sp-1))
{
pc+=sizeof(INT32);
pop_stack();
@@ -979,7 +979,7 @@ static int eval_instruction(unsigned char *pc)
break;
CASE(F_EQ_OR);
- if(!is_eq(sp-2,sp-1))
+ if(!is_eq(Pike_sp-2,Pike_sp-1))
{
pop_n_elems(2);
pc+=sizeof(INT32);
@@ -991,7 +991,7 @@ static int eval_instruction(unsigned char *pc)
break;
CASE(F_EQ_AND);
- if(is_eq(sp-2,sp-1))
+ if(is_eq(Pike_sp-2,Pike_sp-1))
{
pop_n_elems(2);
pc+=sizeof(INT32);
@@ -1017,8 +1017,8 @@ static int eval_instruction(unsigned char *pc)
CASE(F_SWITCH)
{
INT32 tmp;
- tmp=switch_lookup(fp->context.prog->
- constants[GET_ARG()].sval.u.array,sp-1);
+ tmp=switch_lookup(Pike_fp->context.prog->
+ constants[GET_ARG()].sval.u.array,Pike_sp-1);
pc=(unsigned char *)DO_ALIGN(pc,sizeof(INT32));
pc+=(tmp>=0 ? 1+tmp*2 : 2*~tmp) * sizeof(INT32);
if(*(INT32*)pc < 0) fast_check_threads_etc(7);
@@ -1035,18 +1035,18 @@ static int eval_instruction(unsigned char *pc)
CASE(F_FOREACH) /* array, lvalue, X, i */
{
- if(sp[-4].type != PIKE_T_ARRAY)
- PIKE_ERROR("foreach", "Bad argument 1.\n", sp-3, 1);
- if(sp[-1].u.integer < sp[-4].u.array->size)
+ if(Pike_sp[-4].type != 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)
{
fast_check_threads_etc(10);
- index_no_free(sp,sp-4,sp-1);
- sp++;
- assign_lvalue(sp-4, sp-1);
- free_svalue(sp-1);
- sp--;
+ index_no_free(Pike_sp,Pike_sp-4,Pike_sp-1);
+ Pike_sp++;
+ assign_lvalue(Pike_sp-4, Pike_sp-1);
+ free_svalue(Pike_sp-1);
+ Pike_sp--;
pc+=EXTRACT_INT(pc);
- sp[-1].u.integer++;
+ Pike_sp[-1].u.integer++;
}else{
pc+=sizeof(INT32);
}
@@ -1055,57 +1055,57 @@ static int eval_instruction(unsigned char *pc)
CASE(F_APPLY_AND_RETURN);
{
- INT32 args=sp - *--mark_sp;
-/* fprintf(stderr,"%p >= %p\n",fp->expendible,sp-args); */
- if(fp->expendible >= sp-args)
+ INT32 args=Pike_sp - *--Pike_mark_sp;
+/* fprintf(stderr,"%p >= %p\n",Pike_fp->expendible,Pike_sp-args); */
+ if(Pike_fp->expendible >= Pike_sp-args)
{
/* fprintf(stderr,"NOT EXPENDIBLE!\n"); */
- MEMMOVE(sp-args+1,sp-args,args*sizeof(struct svalue));
- sp++;
- sp[-args-1].type=PIKE_T_INT;
+ MEMMOVE(Pike_sp-args+1,Pike_sp-args,args*sizeof(struct svalue));
+ Pike_sp++;
+ Pike_sp[-args-1].type=PIKE_T_INT;
}
/* We sabotage the stack here */
- assign_svalue(sp-args-1,&fp->context.prog->constants[GET_ARG()].sval);
+ assign_svalue(Pike_sp-args-1,&Pike_fp->context.prog->constants[GET_ARG()].sval);
return args+1;
}
CASE(F_CALL_LFUN_AND_RETURN);
{
- INT32 args=sp - *--mark_sp;
- if(fp->expendible >= sp-args)
+ INT32 args=Pike_sp - *--Pike_mark_sp;
+ if(Pike_fp->expendible >= Pike_sp-args)
{
- MEMMOVE(sp-args+1,sp-args,args*sizeof(struct svalue));
- sp++;
- sp[-args-1].type=PIKE_T_INT;
+ MEMMOVE(Pike_sp-args+1,Pike_sp-args,args*sizeof(struct svalue));
+ Pike_sp++;
+ Pike_sp[-args-1].type=PIKE_T_INT;
}else{
- free_svalue(sp-args-1);
+ free_svalue(Pike_sp-args-1);
}
/* More stack sabotage */
- sp[-args-1].u.object=fp->current_object;
- sp[-args-1].subtype=GET_ARG()+fp->context.identifier_level;
+ Pike_sp[-args-1].u.object=Pike_fp->current_object;
+ Pike_sp[-args-1].subtype=GET_ARG()+Pike_fp->context.identifier_level;
#ifdef PIKE_DEBUG
if(t_flag > 9)
- fprintf(stderr,"- IDENTIFIER_LEVEL: %d\n",fp->context.identifier_level);
+ fprintf(stderr,"- IDENTIFIER_LEVEL: %d\n",Pike_fp->context.identifier_level);
#endif
- sp[-args-1].type=PIKE_T_FUNCTION;
- add_ref(fp->current_object);
+ Pike_sp[-args-1].type=PIKE_T_FUNCTION;
+ add_ref(Pike_fp->current_object);
return args+1;
}
CASE(F_RETURN_LOCAL);
instr=GET_ARG();
- if(fp->expendible <= fp->locals+instr)
+ if(Pike_fp->expendible <= Pike_fp->locals+instr)
{
- pop_n_elems(sp-1 - (fp->locals+instr));
+ pop_n_elems(Pike_sp-1 - (Pike_fp->locals+instr));
}else{
- push_svalue(fp->locals+instr);
+ push_svalue(Pike_fp->locals+instr);
}
print_return_value();
goto do_return;
CASE(F_RETURN_IF_TRUE);
- if(!IS_ZERO(sp-1))
+ if(!IS_ZERO(Pike_sp-1))
goto do_return;
pop_stack();
break;
@@ -1132,21 +1132,21 @@ static int eval_instruction(unsigned char *pc)
return -1;
CASE(F_NEGATE);
- if(sp[-1].type == PIKE_T_INT)
+ if(Pike_sp[-1].type == PIKE_T_INT)
{
#ifdef AUTO_BIGNUM
- if(INT_TYPE_NEG_OVERFLOW(sp[-1].u.integer))
+ if(INT_TYPE_NEG_OVERFLOW(Pike_sp[-1].u.integer))
{
convert_stack_top_to_bignum();
o_negate();
}
else
#endif /* AUTO_BIGNUM */
- sp[-1].u.integer =- sp[-1].u.integer;
+ Pike_sp[-1].u.integer =- Pike_sp[-1].u.integer;
}
- else if(sp[-1].type == PIKE_T_FLOAT)
+ else if(Pike_sp[-1].type == PIKE_T_FLOAT)
{
- sp[-1].u.float_number =- sp[-1].u.float_number;
+ Pike_sp[-1].u.float_number =- Pike_sp[-1].u.float_number;
}else{
o_negate();
}
@@ -1155,15 +1155,15 @@ static int eval_instruction(unsigned char *pc)
CASE(F_COMPL); o_compl(); break;
CASE(F_NOT);
- switch(sp[-1].type)
+ switch(Pike_sp[-1].type)
{
case PIKE_T_INT:
- sp[-1].u.integer =! sp[-1].u.integer;
+ Pike_sp[-1].u.integer =! Pike_sp[-1].u.integer;
break;
case PIKE_T_FUNCTION:
case PIKE_T_OBJECT:
- if(IS_ZERO(sp-1))
+ if(IS_ZERO(Pike_sp-1))
{
pop_stack();
push_int(1);
@@ -1174,21 +1174,21 @@ static int eval_instruction(unsigned char *pc)
break;
default:
- free_svalue(sp-1);
- sp[-1].type=PIKE_T_INT;
- sp[-1].u.integer=0;
+ free_svalue(Pike_sp-1);
+ Pike_sp[-1].type=PIKE_T_INT;
+ Pike_sp[-1].u.integer=0;
}
break;
CASE(F_LSH); o_lsh(); break;
CASE(F_RSH); o_rsh(); break;
- COMPARISMENT(F_EQ, is_eq(sp-2,sp-1));
- COMPARISMENT(F_NE,!is_eq(sp-2,sp-1));
- COMPARISMENT(F_GT, is_gt(sp-2,sp-1));
- COMPARISMENT(F_GE,!is_lt(sp-2,sp-1));
- COMPARISMENT(F_LT, is_lt(sp-2,sp-1));
- COMPARISMENT(F_LE,!is_gt(sp-2,sp-1));
+ COMPARISMENT(F_EQ, is_eq(Pike_sp-2,Pike_sp-1));
+ COMPARISMENT(F_NE,!is_eq(Pike_sp-2,Pike_sp-1));
+ COMPARISMENT(F_GT, is_gt(Pike_sp-2,Pike_sp-1));
+ COMPARISMENT(F_GE,!is_lt(Pike_sp-2,Pike_sp-1));
+ COMPARISMENT(F_LT, is_lt(Pike_sp-2,Pike_sp-1));
+ COMPARISMENT(F_LE,!is_gt(Pike_sp-2,Pike_sp-1));
CASE(F_ADD); f_add(2); break;
CASE(F_SUBTRACT); o_subtract(); break;
@@ -1203,60 +1203,60 @@ static int eval_instruction(unsigned char *pc)
CASE(F_ADD_NEG_INT); push_int(-GET_ARG()); f_add(2); break;
CASE(F_PUSH_ARRAY);
- switch(sp[-1].type)
+ switch(Pike_sp[-1].type)
{
default:
- PIKE_ERROR("@", "Bad argument.\n", sp, 1);
+ PIKE_ERROR("@", "Bad argument.\n", Pike_sp, 1);
case PIKE_T_OBJECT:
- if(!sp[-1].u.object->prog || FIND_LFUN(sp[-1].u.object->prog,LFUN__VALUES) == -1)
- PIKE_ERROR("@", "Bad argument.\n", sp, 1);
+ if(!Pike_sp[-1].u.object->prog || FIND_LFUN(Pike_sp[-1].u.object->prog,LFUN__VALUES) == -1)
+ PIKE_ERROR("@", "Bad argument.\n", Pike_sp, 1);
- apply_lfun(sp[-1].u.object, LFUN__VALUES, 0);
- if(sp[-1].type != PIKE_T_ARRAY)
+ apply_lfun(Pike_sp[-1].u.object, LFUN__VALUES, 0);
+ if(Pike_sp[-1].type != PIKE_T_ARRAY)
error("Bad return type from o->_values() in @\n");
- free_svalue(sp-2);
- sp[-2]=sp[-1];
- sp--;
+ free_svalue(Pike_sp-2);
+ Pike_sp[-2]=Pike_sp[-1];
+ Pike_sp--;
break;
case PIKE_T_ARRAY: break;
}
- sp--;
- push_array_items(sp->u.array);
+ Pike_sp--;
+ push_array_items(Pike_sp->u.array);
break;
CASE(F_LOCAL_LOCAL_INDEX);
{
- struct svalue *s=fp->locals+GET_ARG();
+ struct svalue *s=Pike_fp->locals+GET_ARG();
if(s->type == PIKE_T_STRING) s->subtype=0;
- sp++->type=PIKE_T_INT;
- index_no_free(sp-1,fp->locals+GET_ARG2(),s);
+ Pike_sp++->type=PIKE_T_INT;
+ index_no_free(Pike_sp-1,Pike_fp->locals+GET_ARG2(),s);
break;
}
CASE(F_LOCAL_INDEX);
{
- struct svalue tmp,*s=fp->locals+GET_ARG();
+ struct svalue tmp,*s=Pike_fp->locals+GET_ARG();
if(s->type == PIKE_T_STRING) s->subtype=0;
- index_no_free(&tmp,sp-1,s);
- free_svalue(sp-1);
- sp[-1]=tmp;
+ index_no_free(&tmp,Pike_sp-1,s);
+ free_svalue(Pike_sp-1);
+ Pike_sp[-1]=tmp;
break;
}
CASE(F_GLOBAL_LOCAL_INDEX);
{
struct svalue tmp,*s;
- low_object_index_no_free(sp,
- fp->current_object,
- GET_ARG() + fp->context.identifier_level);
- sp++;
- s=fp->locals+GET_ARG2();
+ low_object_index_no_free(Pike_sp,
+ Pike_fp->current_object,
+ GET_ARG() + Pike_fp->context.identifier_level);
+ Pike_sp++;
+ s=Pike_fp->locals+GET_ARG2();
if(s->type == PIKE_T_STRING) s->subtype=0;
- index_no_free(&tmp,sp-1,s);
- free_svalue(sp-1);
- sp[-1]=tmp;
+ index_no_free(&tmp,Pike_sp-1,s);
+ free_svalue(Pike_sp-1);
+ Pike_sp[-1]=tmp;
break;
}
@@ -1264,11 +1264,11 @@ static int eval_instruction(unsigned char *pc)
{
struct svalue tmp;
tmp.type=PIKE_T_STRING;
- tmp.u.string=fp->context.prog->strings[GET_ARG()];
+ tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
tmp.subtype=1;
- sp->type=PIKE_T_INT;
- sp++;
- index_no_free(sp-1,fp->locals+GET_ARG2() , &tmp);
+ Pike_sp->type=PIKE_T_INT;
+ Pike_sp++;
+ index_no_free(Pike_sp-1,Pike_fp->locals+GET_ARG2() , &tmp);
print_return_value();
break;
}
@@ -1277,11 +1277,11 @@ static int eval_instruction(unsigned char *pc)
{
struct svalue tmp,tmp2;
tmp.type=PIKE_T_STRING;
- tmp.u.string=fp->context.prog->strings[GET_ARG()];
+ tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
tmp.subtype=1;
- index_no_free(&tmp2, sp-1, &tmp);
- free_svalue(sp-1);
- sp[-1]=tmp2;
+ index_no_free(&tmp2, Pike_sp-1, &tmp);
+ free_svalue(Pike_sp-1);
+ Pike_sp[-1]=tmp2;
print_return_value();
break;
}
@@ -1290,11 +1290,11 @@ static int eval_instruction(unsigned char *pc)
{
struct svalue tmp,tmp2;
tmp.type=PIKE_T_STRING;
- tmp.u.string=fp->context.prog->strings[GET_ARG()];
+ tmp.u.string=Pike_fp->context.prog->strings[GET_ARG()];
tmp.subtype=0;
- index_no_free(&tmp2, sp-1, &tmp);
- free_svalue(sp-1);
- sp[-1]=tmp2;
+ index_no_free(&tmp2, Pike_sp-1, &tmp);
+ free_svalue(Pike_sp-1);
+ Pike_sp[-1]=tmp2;
print_return_value();
break;
}
@@ -1312,10 +1312,10 @@ static int eval_instruction(unsigned char *pc)
do_index:
{
struct svalue s;
- index_no_free(&s,sp-2,sp-1);
+ index_no_free(&s,Pike_sp-2,Pike_sp-1);
pop_n_elems(2);
- *sp=s;
- sp++;
+ *Pike_sp=s;
+ Pike_sp++;
}
print_return_value();
break;
@@ -1333,36 +1333,36 @@ static int eval_instruction(unsigned char *pc)
CASE(F_SOFT_CAST);
/* Stack: type_string, value */
#ifdef PIKE_DEBUG
- if (sp[-2].type != T_STRING) {
+ if (Pike_sp[-2].type != T_STRING) {
/* FIXME: The type should really be T_TYPE... */
fatal("Argument 1 to soft_cast isn't a string!\n");
}
#endif /* PIKE_DEBUG */
if (runtime_options & RUNTIME_CHECK_TYPES) {
- struct pike_string *sval_type = get_type_of_svalue(sp-1);
- if (!pike_types_le(sval_type, sp[-2].u.string)) {
+ struct pike_string *sval_type = get_type_of_svalue(Pike_sp-1);
+ if (!pike_types_le(sval_type, Pike_sp[-2].u.string)) {
/* get_type_from_svalue() doesn't return a fully specified type
* for array, mapping and multiset, so we perform a more lenient
* check for them.
*/
if (!pike_types_le(sval_type, weak_type_string) ||
- !match_types(sval_type, sp[-2].u.string)) {
+ !match_types(sval_type, Pike_sp[-2].u.string)) {
struct pike_string *t1;
struct pike_string *t2;
char *fname = "__soft-cast";
ONERROR tmp1;
ONERROR tmp2;
- if (fp->current_object && fp->context.prog &&
- fp->current_object->prog) {
+ if (Pike_fp->current_object && Pike_fp->context.prog &&
+ Pike_fp->current_object->prog) {
/* Look up the function-name */
struct pike_string *name =
- ID_FROM_INT(fp->current_object->prog, fp->fun)->name;
+ ID_FROM_INT(Pike_fp->current_object->prog, Pike_fp->fun)->name;
if ((!name->size_shift) && (name->len < 100))
fname = name->str;
}
- t1 = describe_type(sp[-2].u.string);
+ t1 = describe_type(Pike_sp[-2].u.string);
SET_ONERROR(tmp1, do_free_string, t1);
t2 = describe_type(sval_type);
@@ -1370,7 +1370,7 @@ static int eval_instruction(unsigned char *pc)
free_string(sval_type);
- bad_arg_error(NULL, sp-1, 1, 1, t1->str, sp-1,
+ bad_arg_error(NULL, Pike_sp-1, 1, 1, t1->str, Pike_sp-1,
"%s(): Soft cast failed. Expected %s, got %s\n",
fname, t1->str, t2->str);
/* NOT_REACHED */
@@ -1383,7 +1383,7 @@ static int eval_instruction(unsigned char *pc)
free_string(sval_type);
#ifdef PIKE_DEBUG
if (d_flag > 2) {
- struct pike_string *t = describe_type(sp[-2].u.string);
+ struct pike_string *t = describe_type(Pike_sp[-2].u.string);
fprintf(stderr, "Soft cast to %s\n", t->str);
free_string(t);
}
@@ -1397,28 +1397,28 @@ static int eval_instruction(unsigned char *pc)
CASE(F_COPY_VALUE);
{
struct svalue tmp;
- copy_svalues_recursively_no_free(&tmp,sp-1,1,0);
- free_svalue(sp-1);
- sp[-1]=tmp;
+ copy_svalues_recursively_no_free(&tmp,Pike_sp-1,1,0);
+ free_svalue(Pike_sp-1);
+ Pike_sp[-1]=tmp;
}
break;
CASE(F_INDIRECT);
{
struct svalue s;
- lvalue_to_svalue_no_free(&s,sp-2);
+ lvalue_to_svalue_no_free(&s,Pike_sp-2);
if(s.type != PIKE_T_STRING)
{
pop_n_elems(2);
- *sp=s;
- sp++;
+ *Pike_sp=s;
+ Pike_sp++;
}else{
struct object *o;
o=low_clone(string_assignment_program);
- ((struct string_assignment_storage *)o->storage)->lval[0]=sp[-2];
- ((struct string_assignment_storage *)o->storage)->lval[1]=sp[-1];
+ ((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;
- sp-=2;
+ Pike_sp-=2;
push_object(o);
}
}
@@ -1427,68 +1427,68 @@ static int eval_instruction(unsigned char *pc)
CASE(F_SIZEOF);
- instr=pike_sizeof(sp-1);
+ instr=pike_sizeof(Pike_sp-1);
pop_stack();
push_int(instr);
break;
CASE(F_SIZEOF_LOCAL);
- push_int(pike_sizeof(fp->locals+GET_ARG()));
+ push_int(pike_sizeof(Pike_fp->locals+GET_ARG()));
break;
CASE(F_SSCANF); o_sscanf(GET_ARG()); break;
CASE(F_CALL_LFUN);
- apply_low(fp->current_object,
- GET_ARG()+fp->context.identifier_level,
- sp - *--mark_sp);
+ apply_low(Pike_fp->current_object,
+ GET_ARG()+Pike_fp->context.identifier_level,
+ Pike_sp - *--Pike_mark_sp);
break;
CASE(F_CALL_LFUN_AND_POP);
- apply_low(fp->current_object,
- GET_ARG()+fp->context.identifier_level,
- sp - *--mark_sp);
+ apply_low(Pike_fp->current_object,
+ GET_ARG()+Pike_fp->context.identifier_level,
+ Pike_sp - *--Pike_mark_sp);
pop_stack();
break;
CASE(F_MARK_APPLY);
- strict_apply_svalue(fp->context.prog->constants + GET_ARG(), 0);
+ strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), 0);
break;
CASE(F_MARK_APPLY_POP);
- strict_apply_svalue(fp->context.prog->constants + GET_ARG(), 0);
+ strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), 0);
pop_stack();
break;
CASE(F_APPLY);
- strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp );
+ strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
break;
CASE(F_APPLY_AND_POP);
- strict_apply_svalue(fp->context.prog->constants + GET_ARG(), sp - *--mark_sp );
+ strict_apply_svalue(Pike_fp->context.prog->constants + GET_ARG(), Pike_sp - *--Pike_mark_sp );
pop_stack();
break;
CASE(F_CALL_FUNCTION);
- mega_apply(APPLY_STACK,sp - *--mark_sp,0,0);
+ mega_apply(APPLY_STACK,Pike_sp - *--Pike_mark_sp,0,0);
break;
CASE(F_CALL_FUNCTION_AND_RETURN);
{
- INT32 args=sp - *--mark_sp;
+ INT32 args=Pike_sp - *--Pike_mark_sp;
if(!args)
- PIKE_ERROR("`()", "Too few arguments.\n", sp, 0);
- switch(sp[-args].type)
+ PIKE_ERROR("`()", "Too few arguments.\n", Pike_sp, 0);
+ switch(Pike_sp[-args].type)
{
case PIKE_T_INT:
- if (!sp[-args].u.integer) {
- PIKE_ERROR("`()", "Attempt to call the NULL-value\n", sp, args);
+ if (!Pike_sp[-args].u.integer) {
+ PIKE_ERROR("`()", "Attempt to call the NULL-value\n", Pike_sp, args);
}
case PIKE_T_STRING:
case PIKE_T_FLOAT:
case PIKE_T_MAPPING:
case PIKE_T_MULTISET:
- PIKE_ERROR("`()", "Attempt to call a non-function value.\n", sp, args);
+ PIKE_ERROR("`()", "Attempt to call a non-function value.\n", Pike_sp, args);
}
return args;
}
diff --git a/src/object.h b/src/object.h
index 29cedf1e1141c5d6d43d7a0f9f89e2a71285eec0..523afae3437d8c86de1597f58b0312b6534b9f1e 100644
--- a/src/object.h
+++ b/src/object.h
@@ -5,7 +5,7 @@
\*/
/*
- * $Id: object.h,v 1.36 2000/01/29 08:44:42 hubbe Exp $
+ * $Id: object.h,v 1.37 2000/02/17 00:31:13 hubbe Exp $
*/
#ifndef OBJECT_H
#define OBJECT_H
@@ -42,9 +42,9 @@ extern struct program *magic_set_index_program;
#define LOW_GET_GLOBAL(O,I,ID) ((O)->storage+INHERIT_FROM_INT((O)->prog, (I))->storage_offset+(ID)->func.offset)
#define GET_GLOBAL(O,I) LOW_GET_GLOBAL(O,I,ID_FROM_INT((O)->prog,I))
-#define GLOBAL_FROM_INT(I) GET_GLOBAL(fp->current_object, I)
+#define GLOBAL_FROM_INT(I) GET_GLOBAL(Pike_fp->current_object, I)
-#define this_object() (add_ref(fp->current_object), fp->current_object)
+#define this_object() (add_ref(Pike_fp->current_object), Pike_fp->current_object)
#include "block_alloc_h.h"
/* Prototypes begin here */
diff --git a/src/preprocessor.h b/src/preprocessor.h
index 8b8c16b8766215d869f61ce0e94ea39516e124d6..19276f993b54a6df2edb764890ae38ce45431750 100644
--- a/src/preprocessor.h
+++ b/src/preprocessor.h
@@ -1,5 +1,5 @@
/*
- * $Id: preprocessor.h,v 1.18 2000/02/11 00:04:00 grubba Exp $
+ * $Id: preprocessor.h,v 1.19 2000/02/17 00:31:14 hubbe Exp $
*
* Preprocessor template.
* Based on cpp.c 1.45
@@ -662,8 +662,8 @@ static INT32 calc3(struct cpp *this,WCHAR *data,INT32 len,INT32 pos)
{
/* DUMPPOS("inside calc3"); */
- check_destructed(sp-1);
- if(IS_ZERO(sp-1))
+ check_destructed(Pike_sp-1);
+ if(IS_ZERO(Pike_sp-1))
{
pos=calc4(this,data,len,pos);
pop_stack();
@@ -688,8 +688,8 @@ static INT32 calc2(struct cpp *this,WCHAR *data,INT32 len,INT32 pos)
{
/* DUMPPOS("inside calc2"); */
- check_destructed(sp-1);
- if(!IS_ZERO(sp-1))
+ check_destructed(Pike_sp-1);
+ if(!IS_ZERO(Pike_sp-1))
{
pos=calc3(this,data,len,pos);
pop_stack();
@@ -716,8 +716,8 @@ static INT32 calc1(struct cpp *this, WCHAR *data, INT32 len, INT32 pos)
cpp_error(this, "Colon expected.");
pos=calc1(this,data,len,pos);
- check_destructed(sp-3);
- assign_svalue(sp-3,IS_ZERO(sp-3)?sp-1:sp-2);
+ check_destructed(Pike_sp-3);
+ assign_svalue(Pike_sp-3,IS_ZERO(Pike_sp-3)?Pike_sp-1:Pike_sp-2);
pop_n_elems(2);
}
return pos;
@@ -750,7 +750,7 @@ static int calc(struct cpp *this, WCHAR *data, INT32 len, INT32 tmp)
push_int(0);
}else{
pos=calc1(this,data,len,tmp);
- check_destructed(sp-1);
+ check_destructed(Pike_sp-1);
}
UNSETJMP(recovery);
@@ -1196,7 +1196,7 @@ static INT32 lower_cpp(struct cpp *this,
tmp2=0;
do_include:
{
- struct svalue *save_sp=sp;
+ struct svalue *save_sp=Pike_sp;
SKIPSPACE();
check_stack(3);
@@ -1249,7 +1249,7 @@ static INT32 lower_cpp(struct cpp *this,
break;
}
- if(sp==save_sp) break;
+ if(Pike_sp==save_sp) break;
if(OUTP())
{
@@ -1257,25 +1257,25 @@ static INT32 lower_cpp(struct cpp *this,
SAFE_APPLY_MASTER("handle_include",3);
- if(sp[-1].type != PIKE_T_STRING)
+ if(Pike_sp[-1].type != PIKE_T_STRING)
{
cpp_error(this, "Couldn't include file.");
- pop_n_elems(sp-save_sp);
+ pop_n_elems(Pike_sp-save_sp);
break;
}
- new_file=sp[-1].u.string;
+ new_file=Pike_sp[-1].u.string;
/* Why not just use ref_push_string(new_file)? */
- assign_svalue_no_free(sp,sp-1);
- sp++;
+ assign_svalue_no_free(Pike_sp,Pike_sp-1);
+ Pike_sp++;
SAFE_APPLY_MASTER("read_include",1);
- if(sp[-1].type != PIKE_T_STRING)
+ if(Pike_sp[-1].type != PIKE_T_STRING)
{
cpp_error(this, "Couldn't read include file.");
- pop_n_elems(sp-save_sp);
+ pop_n_elems(Pike_sp-save_sp);
break;
}
@@ -1296,35 +1296,35 @@ static INT32 lower_cpp(struct cpp *this,
if(tmp2)
{
/* #string */
- struct pike_string *str = sp[-1].u.string;
+ struct pike_string *str = Pike_sp[-1].u.string;
PUSH_STRING_SHIFT(str->str, str->len, str->size_shift,
&this->buf);
}else{
/* #include */
if (auto_convert) {
- struct pike_string *new_str = recode_string(sp[-1].u.string);
- free_string(sp[-1].u.string);
- sp[-1].u.string = new_str;
+ struct pike_string *new_str = recode_string(Pike_sp[-1].u.string);
+ free_string(Pike_sp[-1].u.string);
+ Pike_sp[-1].u.string = new_str;
} else if (charset) {
ref_push_string(charset);
SAFE_APPLY_MASTER("decode_charset", 2);
- if (sp[-1].type != PIKE_T_STRING) {
+ if (Pike_sp[-1].type != PIKE_T_STRING) {
cpp_error(this,
"Charset decoding failed for included file.");
- pop_n_elems(sp - save_sp);
+ pop_n_elems(Pike_sp - save_sp);
break;
}
}
- if (sp[-1].u.string->size_shift) {
+ if (Pike_sp[-1].u.string->size_shift) {
/* Get rid of any byte order marks (0xfeff) */
- struct pike_string *new_str = filter_bom(sp[-1].u.string);
- free_string(sp[-1].u.string);
- sp[-1].u.string = new_str;
+ struct pike_string *new_str = filter_bom(Pike_sp[-1].u.string);
+ free_string(Pike_sp[-1].u.string);
+ Pike_sp[-1].u.string = new_str;
}
low_cpp(this,
- sp[-1].u.string->str,
- sp[-1].u.string->len,
- sp[-1].u.string->size_shift,
+ Pike_sp[-1].u.string->str,
+ Pike_sp[-1].u.string->len,
+ Pike_sp[-1].u.string->size_shift,
flags&~(CPP_EXPECT_ENDIF | CPP_EXPECT_ELSE),
auto_convert, charset);
}
@@ -1343,7 +1343,7 @@ static INT32 lower_cpp(struct cpp *this,
}
}
- pop_n_elems(sp-save_sp);
+ pop_n_elems(Pike_sp-save_sp);
break;
}
@@ -1403,7 +1403,7 @@ static INT32 lower_cpp(struct cpp *this,
break;
}
free_string_builder(&tmp);
- if(IS_ZERO(sp-1)) nflags|=CPP_NO_OUTPUT;
+ if(IS_ZERO(Pike_sp-1)) nflags|=CPP_NO_OUTPUT;
pop_stack();
pos += lower_cpp(this, data+pos, len-pos, nflags,
auto_convert, charset);
@@ -1530,7 +1530,7 @@ static INT32 lower_cpp(struct cpp *this,
break;
}
free_string_builder(&tmp);
- if(!IS_ZERO(sp-1)) flags&=~CPP_NO_OUTPUT;
+ if(!IS_ZERO(Pike_sp-1)) flags&=~CPP_NO_OUTPUT;
pop_stack();
}else{
FIND_EOL();
@@ -1556,7 +1556,7 @@ static INT32 lower_cpp(struct cpp *this,
push_string(make_shared_binary_string2(data+foo, pos-foo));
#endif /* SHIFT == 1 */
#endif /* SHIFT == 0 */
- cpp_error(this, sp[-1].u.string->str);
+ cpp_error(this, Pike_sp[-1].u.string->str);
}
break;
}
@@ -1572,7 +1572,7 @@ static INT32 lower_cpp(struct cpp *this,
struct string_builder str;
INT32 namestart, tmp3, nameend, argno=-1;
struct define *def;
- struct svalue *partbase,*argbase=sp;
+ struct svalue *partbase,*argbase=Pike_sp;
SKIPSPACE();
@@ -1642,7 +1642,7 @@ static INT32 lower_cpp(struct cpp *this,
SKIPSPACE();
- partbase=sp;
+ partbase=Pike_sp;
init_string_builder(&str, 0);
while(1)
@@ -1686,13 +1686,13 @@ static INT32 lower_cpp(struct cpp *this,
/* FIXME: Wide strings? */
while(str.s->len && isspace(((unsigned char *)str.s->str)[str.s->len-1]))
str.s->len--;
- if(!str.s->len && sp-partbase>1)
+ if(!str.s->len && Pike_sp-partbase>1)
{
#ifdef PIKE_DEBUG
- if(sp[-1].type != PIKE_T_INT)
+ if(Pike_sp[-1].type != PIKE_T_INT)
fatal("Internal error in CPP\n");
#endif
- sp[-1].u.integer|=DEF_ARG_NOPOSTSPACE;
+ Pike_sp[-1].u.integer|=DEF_ARG_NOPOSTSPACE;
}
}else{
extra=DEF_ARG_STRINGIFY;
@@ -1770,18 +1770,18 @@ static INT32 lower_cpp(struct cpp *this,
def=alloc_empty_define(
make_shared_binary_string((char *)data+namestart,
nameend-namestart),
- (sp-partbase)/2);
+ (Pike_sp-partbase)/2);
#else /* SHIFT != 0 */
#if (SHIFT == 1)
def=alloc_empty_define(
make_shared_binary_string1(data+namestart,
nameend-namestart),
- (sp-partbase)/2);
+ (Pike_sp-partbase)/2);
#else /* SHIFT != 1 */
def=alloc_empty_define(
make_shared_binary_string2(data+namestart,
nameend-namestart),
- (sp-partbase)/2);
+ (Pike_sp-partbase)/2);
#endif /* SHIFT == 1 */
#endif /* SHIFT == 0 */
copy_shared_string(def->first, partbase->u.string);
@@ -1810,7 +1810,7 @@ static INT32 lower_cpp(struct cpp *this,
this->defines=hash_insert(this->defines, & def->link);
}
- pop_n_elems(sp-argbase);
+ pop_n_elems(Pike_sp-argbase);
break;
}
@@ -1892,12 +1892,12 @@ static INT32 lower_cpp(struct cpp *this,
SAFE_APPLY_MASTER("decode_charset", 2);
- if (sp[-1].type != PIKE_T_STRING) {
+ if (Pike_sp[-1].type != PIKE_T_STRING) {
pop_stack();
cpp_error(this, "Unknown charset.");
} else {
- low_cpp(this, sp[-1].u.string->str, sp[-1].u.string->len,
- sp[-1].u.string->size_shift, flags,
+ low_cpp(this, Pike_sp[-1].u.string->str, Pike_sp[-1].u.string->len,
+ Pike_sp[-1].u.string->size_shift, flags,
auto_convert, charset);
pop_stack();
}
diff --git a/src/security.h b/src/security.h
index 35e999a706c9466dcced26717f379651ee817ee1..8f1fa66617049f6be880a0d7407216a0651c8766 100644
--- a/src/security.h
+++ b/src/security.h
@@ -63,7 +63,7 @@ struct pike_creds
if(!CHECK_SECURITY(SECURITY_BIT_SECURITY)) \
{ \
int e; \
- struct svalue *base_sp=sp-args; \
+ struct svalue *base_sp=Pike_sp-args; \
\
if(!CHECK_SECURITY(SECURITY_BIT_CONDITIONAL_IO)) \
error(name ": Permission denied.\n"); \
@@ -75,17 +75,17 @@ struct pike_creds
\
safe_apply(OBJ2CREDS(current_creds)->user,"valid_io",args+2); \
\
- switch(sp[-1].type) \
+ switch(Pike_sp[-1].type) \
{ \
case PIKE_T_ARRAY: \
case PIKE_T_OBJECT: \
case PIKE_T_MAPPING: \
- assign_svalue(sp-args-1,sp-1); \
+ assign_svalue(Pike_sp-args-1,Pike_sp-1); \
pop_n_elems(args); \
return; \
\
case PIKE_T_INT: \
- switch(sp[-1].u.integer) \
+ switch(Pike_sp[-1].u.integer) \
{ \
case 0: /* return 0 */ \
errno=EPERM; \
@@ -114,7 +114,7 @@ struct pike_creds
error("Error in user->valid_io, wrong return type.\n"); \
\
case PIKE_T_STRING: \
- assign_svalue(sp-args-1,sp-1); \
+ assign_svalue(Pike_sp-args-1,Pike_sp-1); \
pop_stack(); \
} \
}
diff --git a/src/threads.h b/src/threads.h
index 15d158fc5077f7f863f90347e16be81c4874b310..384496b5eb62fc3ba2c5ea9995e213dcab379dc7 100644
--- a/src/threads.h
+++ b/src/threads.h
@@ -1,5 +1,5 @@
/*
- * $Id: threads.h,v 1.72 2000/02/04 21:46:15 grubba Exp $
+ * $Id: threads.h,v 1.73 2000/02/17 00:31:16 hubbe Exp $
*/
#ifndef THREADS_H
#define THREADS_H
@@ -315,14 +315,14 @@ struct thread_state {
struct mapping *thread_local;
/* Swapped variables */
- struct svalue *sp,*evaluator_stack;
- struct svalue **mark_sp,**mark_stack;
- struct pike_frame *fp;
+ struct svalue *Pike_sp,*Pike_evaluator_stack;
+ struct svalue **Pike_mark_sp,**Pike_mark_stack;
+ struct pike_frame *Pike_fp;
int evaluator_stack_malloced;
int mark_stack_malloced;
JMP_BUF *recoveries;
struct object * thread_id;
- char *stack_top;
+ char *Pike_stack_top;
DO_IF_SECURITY(struct object *current_creds;)
#ifdef PROFILING
@@ -389,15 +389,15 @@ struct thread_state {
#define SWAP_OUT_THREAD(_tmp) do { \
(_tmp)->swapped=1; \
- (_tmp)->evaluator_stack=evaluator_stack;\
+ (_tmp)->Pike_evaluator_stack=Pike_evaluator_stack;\
(_tmp)->evaluator_stack_malloced=evaluator_stack_malloced;\
- (_tmp)->fp=fp;\
- (_tmp)->mark_sp=mark_sp;\
- (_tmp)->mark_stack=mark_stack;\
+ (_tmp)->Pike_fp=Pike_fp;\
+ (_tmp)->Pike_mark_sp=Pike_mark_sp;\
+ (_tmp)->Pike_mark_stack=Pike_mark_stack;\
(_tmp)->mark_stack_malloced=mark_stack_malloced;\
(_tmp)->recoveries=recoveries;\
- (_tmp)->sp=sp; \
- (_tmp)->stack_top=stack_top; \
+ (_tmp)->Pike_sp=Pike_sp; \
+ (_tmp)->Pike_stack_top=Pike_stack_top; \
(_tmp)->thread_id=thread_id;\
DO_IF_PROFILING( (_tmp)->accounted_time=accounted_time; ) \
DO_IF_PROFILING( (_tmp)->time_base = gethrtime() - time_base; ) \
@@ -407,15 +407,15 @@ struct thread_state {
#define SWAP_IN_THREAD(_tmp) do {\
(_tmp)->swapped=0; \
- evaluator_stack=(_tmp)->evaluator_stack;\
+ Pike_evaluator_stack=(_tmp)->Pike_evaluator_stack;\
evaluator_stack_malloced=(_tmp)->evaluator_stack_malloced;\
- fp=(_tmp)->fp;\
- mark_sp=(_tmp)->mark_sp;\
- mark_stack=(_tmp)->mark_stack;\
+ Pike_fp=(_tmp)->Pike_fp;\
+ Pike_mark_sp=(_tmp)->Pike_mark_sp;\
+ Pike_mark_stack=(_tmp)->Pike_mark_stack;\
mark_stack_malloced=(_tmp)->mark_stack_malloced;\
recoveries=(_tmp)->recoveries;\
- sp=(_tmp)->sp;\
- stack_top=(_tmp)->stack_top;\
+ Pike_sp=(_tmp)->Pike_sp;\
+ Pike_stack_top=(_tmp)->Pike_stack_top;\
thread_id=(_tmp)->thread_id;\
DO_IF_PROFILING( accounted_time=(_tmp)->accounted_time; ) \
DO_IF_PROFILING( time_base = gethrtime() - (_tmp)->time_base; ) \
@@ -443,7 +443,7 @@ struct thread_state {
* environment.
*/
#define HIDE_GLOBAL_VARIABLES() do { \
- int sp = 0, evaluator_stack = 0, mark_sp = 0, mark_stack = 0, fp = 0; \
+ int Pike_sp = 0, Pike_evaluator_stack = 0, Pike_mark_sp = 0, Pike_mark_stack = 0, Pike_fp = 0; \
void *evaluator_stack_malloced = NULL, *mark_stack_malloced = NULL; \
int recoveries = 0, thread_id = 0; \
int error = 0, xalloc = 0, low_my_putchar = 0, low_my_binary_strcat = 0; \
@@ -541,7 +541,7 @@ struct thread_state {
#endif
/* Prototypes begin here */
-int low_nt_create_thread(unsigned stack_size,
+int low_nt_create_thread(unsigned Pike_stack_size,
unsigned (TH_STDCALL *func)(void *),
void *arg,
unsigned *id);