\r
#define TOP() (_stack[_top-1])\r
\r
-bool SQVM::BW_OP(unsigned int op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)\r
+bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)\r
{\r
SQInteger res;\r
SQInteger i1 = _integer(o1), i2 = _integer(o2);\r
case BW_XOR: res = i1 ^ i2; break;\r
case BW_SHIFTL: res = i1 << i2; break;\r
case BW_SHIFTR: res = i1 >> i2; break;\r
- case BW_USHIFTR:res = (SQInteger)(*((unsigned int*)&i1) >> i2); break;\r
+ case BW_USHIFTR:res = (SQInteger)(*((SQUnsignedInteger*)&i1) >> i2); break;\r
default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; }\r
}\r
} \r
return true;\r
}\r
\r
-bool SQVM::ARITH_OP(unsigned int op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)\r
+bool SQVM::ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)\r
{\r
if(sq_isnumeric(o1) && sq_isnumeric(o2)) {\r
if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER)) {\r
return true;\r
}\r
\r
-SQObjectPtr &stack_get(HSQUIRRELVM v,int idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));}\r
-\r
SQVM::SQVM(SQSharedState *ss)\r
{\r
_sharedstate=ss;\r
- _suspended=false;\r
+ _suspended = SQFalse;\r
_suspended_target=-1;\r
- _suspended_root=false;\r
+ _suspended_root = SQFalse;\r
_suspended_traps=-1;\r
_foreignptr=NULL;\r
_nnativecalls=0;\r
- _uiRef=0;\r
_lasterror = _null_;\r
_errorhandler = _null_;\r
_debughook = _null_;\r
_errorhandler = _null_;\r
_debughook = _null_;\r
temp_reg = _null_;\r
- int size=_stack.size();\r
- for(int i=0;i<size;i++)\r
+ SQInteger size=_stack.size();\r
+ for(SQInteger i=0;i<size;i++)\r
_stack[i]=_null_;\r
}\r
\r
REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);\r
}\r
\r
-bool SQVM::ArithMetaMethod(int op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)\r
+bool SQVM::ArithMetaMethod(SQInteger op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)\r
{\r
SQMetaMethod mm;\r
switch(op){\r
}\r
\r
#define _RET_SUCCEED(exp) { result = (exp); return true; } \r
-bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,int &result)\r
+bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result)\r
{\r
if(type(o1)==type(o2)){\r
if(_userpointer(o1)==_userpointer(o2))_RET_SUCCEED(0);\r
\r
bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)\r
{\r
- int r;\r
+ SQInteger r;\r
if(ObjCmp(o1,o2,r)) {\r
switch(op) {\r
case CMP_G: res = (r > 0)?_true_:_false_; return true;\r
return false;\r
}\r
\r
+void SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res)\r
+{\r
+ switch(type(o)) {\r
+ case OT_STRING:\r
+ res = o;\r
+ return;\r
+ case OT_FLOAT:\r
+ scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%g"),_float(o));\r
+ break;\r
+ case OT_INTEGER:\r
+ scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%d"),_integer(o));\r
+ break;\r
+ case OT_BOOL:\r
+ scsprintf(_sp(rsl(6)),_integer(o)?_SC("true"):_SC("false"));\r
+ break;\r
+ case OT_TABLE:\r
+ case OT_USERDATA:\r
+ case OT_INSTANCE:\r
+ if(_delegable(o)->_delegate) {\r
+ Push(o);\r
+ if(CallMetaMethod(_delegable(o),MT_TOSTRING,1,res)) {\r
+ if(type(res) == OT_STRING)\r
+ return;\r
+ //else keeps going to the default\r
+ }\r
+ }\r
+ default:\r
+ scsprintf(_sp(rsl(sizeof(void*)+20)),_SC("(%s : 0x%p)"),GetTypeName(o),_rawval(o));\r
+ }\r
+ res = SQString::Create(_ss(this),_spval);\r
+ return;\r
+}\r
+\r
+\r
bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)\r
{\r
switch(type(obj))\r
case OT_STRING:\r
switch(type(str)){\r
case OT_STRING: {\r
- int l=_string(str)->_len,ol=_string(obj)->_len;\r
+ SQInteger l=_string(str)->_len,ol=_string(obj)->_len;\r
SQChar *s=_sp(rsl(l+ol+1));\r
memcpy(s,_stringval(str),rsl(l));memcpy(s+l,_stringval(obj),rsl(ol));s[l+ol]=_SC('\0');\r
break;\r
case _RT_FUNCPROTO: return _SC("function");\r
case _RT_CLASS: return _SC("class");\r
case _RT_INSTANCE: return _SC("instance");\r
+ case _RT_WEAKREF: return _SC("weakref");\r
default:\r
return NULL;\r
}\r
dest = SQString::Create(_ss(this),GetTypeName(obj1));\r
}\r
\r
-bool SQVM::Init(SQVM *friendvm, int stacksize)\r
+bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)\r
{\r
_stack.resize(stacksize);\r
_callsstack.reserve(4);\r
\r
extern SQInstructionDesc g_InstrDesc[];\r
\r
-bool SQVM::StartCall(SQClosure *closure,int target,int nargs,int stackbase,bool tailcall)\r
+bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger nargs,SQInteger stackbase,bool tailcall)\r
{\r
SQFunctionProto *func = _funcproto(closure->_function);\r
- //const int outerssize = func->_outervalues.size();\r
+ //const SQInteger outerssize = func->_outervalues.size();\r
\r
- const int paramssize = func->_parameters.size();\r
- const int oldtop = _top;\r
- const int newtop = stackbase + func->_stacksize;\r
+ const SQInteger paramssize = func->_parameters.size();\r
+ const SQInteger oldtop = _top;\r
+ const SQInteger newtop = stackbase + func->_stacksize;\r
\r
\r
- if(func->_varparams)\r
- {\r
- if (nargs < paramssize) {\r
- Raise_Error(_SC("wrong number of parameters"));\r
- return false;\r
- }\r
- for(int n = 0; n < nargs - paramssize; n++) {\r
- _vargsstack.push_back(_stack[stackbase+paramssize+n]);\r
- _stack[stackbase+paramssize+n] = _null_;\r
+ if (paramssize != nargs) {\r
+ if(func->_varparams)\r
+ {\r
+ if (nargs < paramssize) {\r
+ Raise_Error(_SC("wrong number of parameters"));\r
+ return false;\r
+ }\r
+ for(SQInteger n = 0; n < nargs - paramssize; n++) {\r
+ _vargsstack.push_back(_stack[stackbase+paramssize+n]);\r
+ _stack[stackbase+paramssize+n] = _null_;\r
+ }\r
}\r
- }\r
- else {\r
- if (paramssize != nargs) {\r
+ else {\r
Raise_Error(_SC("wrong number of parameters"));\r
return false;\r
}\r
- \r
}\r
\r
if (!tailcall) {\r
ci->_target = target;\r
ci->_prevtop = _top - _stackbase;\r
ci->_ncalls = 1;\r
- ci->_root = false;\r
+ ci->_root = SQFalse;\r
}\r
else {\r
ci->_ncalls++;\r
ci->_iv = &func->_instructions;\r
ci->_literals = &func->_literals;\r
//grows the stack if needed\r
- if (((unsigned int)newtop + (func->_stacksize<<1)) > _stack.size()) {\r
+ if (((SQUnsignedInteger)newtop + (func->_stacksize<<1)) > _stack.size()) {\r
_stack.resize(_stack.size() + (func->_stacksize<<1));\r
}\r
\r
return true;\r
}\r
\r
-bool SQVM::Return(int _arg0, int _arg1, SQObjectPtr &retval)\r
+bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval)\r
{\r
if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))\r
- for(int i=0;i<ci->_ncalls;i++)\r
+ for(SQInteger i=0;i<ci->_ncalls;i++)\r
CallDebugHook(_SC('r'));\r
\r
- bool broot = ci->_root;\r
- int last_top = _top;\r
- int target = ci->_target;\r
- int oldstackbase = _stackbase;\r
+ SQBool broot = ci->_root;\r
+ SQInteger last_top = _top;\r
+ SQInteger target = ci->_target;\r
+ SQInteger oldstackbase = _stackbase;\r
_stackbase -= ci->_prevstkbase;\r
_top = _stackbase + ci->_prevtop;\r
- PopVarArgs(ci->_vargs);\r
+ if(ci->_vargs.size) PopVarArgs(ci->_vargs);\r
POP_CALLINFO(this);\r
if (broot) {\r
if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack[oldstackbase+_arg1];\r
\r
while (last_top >= _top) _stack[last_top--].Null();\r
assert(oldstackbase >= _stackbase); \r
- return broot;\r
+ return broot?true:false;\r
}\r
\r
#define _RET_ON_FAIL(exp) { if(!exp) return false; }\r
\r
-bool SQVM::LOCAL_INC(int op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)\r
+bool SQVM::LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)\r
{\r
_RET_ON_FAIL(ARITH_OP( op , target, a, incr));\r
a = target;\r
return true;\r
}\r
\r
-bool SQVM::PLOCAL_INC(int op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)\r
+bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)\r
{\r
SQObjectPtr trg;\r
_RET_ON_FAIL(ARITH_OP( op , trg, a, incr));\r
return true;\r
}\r
\r
-bool SQVM::DerefInc(int op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)\r
+bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)\r
{\r
SQObjectPtr tmp, tself = self, tkey = key;\r
if (!Get(tself, tkey, tmp, false, true)) { Raise_IdxError(tkey); return false; }\r
\r
#define arg0 (_i_._arg0)\r
#define arg1 (_i_._arg1)\r
-#define sarg1 (*((int *)&_i_._arg1))\r
+#define sarg1 (*((SQInteger *)&_i_._arg1))\r
#define arg2 (_i_._arg2)\r
#define arg3 (_i_._arg3)\r
#define sarg3 (*((char *)&_i_._arg3))\r
\r
void SQVM::PopVarArgs(VarArgs &vargs)\r
{\r
- for(int n = 0; n< vargs.size; n++)\r
+ for(SQInteger n = 0; n< vargs.size; n++)\r
_vargsstack.pop_back();\r
}\r
\r
#define _FINISH(stoploop) {finished = stoploop; return true; }\r
bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr \r
-&o3,SQObjectPtr &o4,int arg_2,bool &finished)\r
+&o3,SQObjectPtr &o4,SQInteger arg_2,bool &finished)\r
{\r
- int nrefidx;\r
+ SQInteger nrefidx;\r
switch(type(o1)) {\r
case OT_TABLE:\r
- if((nrefidx = _table(o1)->Next(o4, o2, o3)) == -1) _FINISH(true);\r
+ if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(true);\r
o4 = (SQInteger)nrefidx; _FINISH(false);\r
case OT_ARRAY:\r
if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(true);\r
\r
bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)\r
{\r
- int nouters;\r
+ SQInteger nouters;\r
SQClosure *closure = SQClosure::Create(_ss(this), func);\r
if(nouters = func->_outervalues.size()) {\r
closure->_outervalues.reserve(nouters);\r
- for(int i = 0; i<nouters; i++) {\r
+ for(SQInteger i = 0; i<nouters; i++) {\r
SQOuterVar &v = func->_outervalues[i];\r
switch(v._type){\r
case otSYMBOL:\r
Raise_Error(_SC("indexing 'vargv' with %s"),GetTypeName(index));\r
return false;\r
}\r
- int idx = tointeger(index);\r
+ SQInteger idx = tointeger(index);\r
if(idx < 0 || idx >= ci->_vargs.size){ Raise_Error(_SC("vargv index out of range")); return false; }\r
target = _vargsstack[ci->_vargs.base+idx];\r
return true;\r
}\r
\r
-bool SQVM::CLASS_OP(SQObjectPtr &target,int baseclass,int attributes)\r
+bool SQVM::CLASS_OP(SQObjectPtr &target,SQInteger baseclass,SQInteger attributes)\r
{\r
SQClass *base = NULL;\r
SQObjectPtr attrs;\r
return true;\r
}\r
\r
-bool SQVM::IsFalse(SQObjectPtr &o)\r
-{\r
- SQObjectType t = type(o);\r
- if((t & SQOBJECT_CANBEFALSE)\r
- && ((t == OT_NULL) || ((t == OT_INTEGER || t == OT_BOOL) && _integer(o) == 0)\r
- || (t == OT_FLOAT && _float(o) == SQFloat(0.0)))) {\r
- return true;\r
- }\r
- return false;\r
-}\r
+\r
\r
bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)\r
{\r
}\r
else {\r
if(sq_isnumeric(o1) && sq_isnumeric(o2)) {\r
- int cmpres;\r
+ SQInteger cmpres;\r
if(!ObjCmp(o1, o2,cmpres)) return false;\r
res = (cmpres == 0);\r
}\r
return true;\r
}\r
\r
-bool SQVM::Execute(SQObjectPtr &closure, int target, int nargs, int stackbase,SQObjectPtr &outres, ExecutionType et)\r
+bool SQVM::Execute(SQObjectPtr &closure, SQInteger target, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, ExecutionType et)\r
{\r
if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }\r
_nnativecalls++;\r
AutoDec ad(&_nnativecalls);\r
- int traps = 0;\r
+ SQInteger traps = 0;\r
//temp_reg vars for OP_CALL\r
- int ct_target;\r
+ SQInteger ct_target;\r
bool ct_tailcall; \r
\r
switch(et) {\r
if(ci == NULL) CallErrorHandler(_lasterror);\r
return false;\r
}\r
- ci->_root = true;\r
+ ci->_root = SQTrue;\r
break;\r
- case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = true; traps += ci->_etraps; break;\r
+ case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = SQTrue; traps += ci->_etraps; break;\r
case ET_RESUME_VM:\r
traps = _suspended_traps;\r
ci->_root = _suspended_root;\r
- _suspended = false;\r
+ _suspended = SQFalse;\r
break;\r
}\r
\r
exception_restore:\r
- //SQ_TRY \r
+ //\r
{\r
for(;;)\r
{\r
CallDebugHook(_SC('l'),arg1);\r
continue;\r
case _OP_LOAD: TARGET = (*ci->_literals)[arg1]; continue;\r
+ case _OP_DLOAD: TARGET = (*ci->_literals)[arg1]; STK(arg2) = (*ci->_literals)[arg3];continue;\r
case _OP_TAILCALL:\r
temp_reg = STK(arg1);\r
if (type(temp_reg) == OT_CLOSURE){ \r
ct_tailcall = true;\r
- PopVarArgs(ci->_vargs);\r
- for (int i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);\r
+ if(ci->_vargs.size) PopVarArgs(ci->_vargs);\r
+ for (SQInteger i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);\r
ct_target = ci->_target;\r
goto common_call;\r
}\r
ct_target = arg0;\r
temp_reg = STK(arg1);\r
common_call:\r
- int last_top = _top;\r
+ SQInteger last_top = _top;\r
switch (type(temp_reg)) {\r
case OT_CLOSURE:{\r
- StartCall(_closure(temp_reg), ct_target, arg3, ct_tailcall?_stackbase:_stackbase+arg2, ct_tailcall);\r
+ _GUARD(StartCall(_closure(temp_reg), ct_target, arg3, ct_tailcall?_stackbase:_stackbase+arg2, ct_tailcall));\r
if (_funcproto(_closure(temp_reg)->_function)->_bgenerator) {\r
SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(temp_reg));\r
_GUARD(gen->Yield(this));\r
bool suspend;\r
_GUARD(CallNative(_nativeclosure(temp_reg), arg3, _stackbase+arg2, ct_tailcall, temp_reg,suspend));\r
if(suspend){\r
- _suspended = true;\r
+ _suspended = SQTrue;\r
_suspended_target = ct_target;\r
_suspended_root = ci->_root;\r
_suspended_traps = traps;\r
case OT_INSTANCE:\r
{\r
Push(temp_reg);\r
- for (int i = 0; i < arg3; i++) Push(STK(arg2 + i));\r
+ for (SQInteger i = 0; i < arg3; i++) Push(STK(arg2 + i));\r
if (_delegable(temp_reg) && CallMetaMethod(_delegable(temp_reg), MT_CALL, arg3+1, temp_reg)){\r
STK(ct_target) = temp_reg;\r
break;\r
return true;\r
}\r
continue;\r
- case _OP_LOADNULLS:{ for(unsigned int n=0;n<arg1;n++) STK(arg0+n) = _null_; }continue;\r
+ case _OP_LOADNULLS:{ for(SQInt32 n=0; n < arg1; n++) STK(arg0+n) = _null_; }continue;\r
case _OP_LOADROOTTABLE: TARGET = _roottable; continue;\r
case _OP_LOADBOOL: TARGET = arg1?_true_:_false_; continue;\r
case _OP_DMOVE: STK(arg0) = STK(arg1); STK(arg2) = STK(arg3); continue;\r
Raise_Error(_SC("the %s type doesn't have a parent slot"), GetTypeName(STK(arg1)));\r
SQ_THROW();\r
continue;\r
- case _OP_COMPARITH: _GUARD(DerefInc(arg3, TARGET, STK((((unsigned int)arg1&0xFFFF0000)>>16)), STK(arg2), STK(arg1&0x0000FFFF), false)); continue;\r
+ case _OP_COMPARITH: _GUARD(DerefInc(arg3, TARGET, STK((((SQUnsignedInteger)arg1&0xFFFF0000)>>16)), STK(arg2), STK(arg1&0x0000FFFF), false)); continue;\r
case _OP_COMPARITHL: _GUARD(LOCAL_INC(arg3, TARGET, STK(arg1), STK(arg2))); continue;\r
case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, false));} continue;\r
case _OP_INCL: {SQObjectPtr o(sarg3); _GUARD(LOCAL_INC('+',TARGET, STK(arg1), o));} continue;\r
ci->_etraps++;\r
continue;\r
case _OP_POPTRAP:{\r
- for(
int i=0; i<arg0; i++) {
\r+ for(
SQInteger i=0; i<arg0; i++) {
\r _etraps.pop_back(); traps--;\r
ci->_etraps--;\r
}}\r
{\r
SQObjectPtr currerror = _lasterror;\r
// dumpstack(_stackbase);\r
- int n = 0;\r
- int last_top = _top;\r
+ SQInteger n = 0;\r
+ SQInteger last_top = _top;\r
if(ci) {\r
if(traps) {\r
do {\r
CallErrorHandler(currerror);\r
//remove call stack until a C function is found or the cstack is empty\r
if(ci) do{\r
- bool exitafterthisone = ci->_root;\r
+ SQBool exitafterthisone = ci->_root;\r
if(type(ci->_generator) == OT_GENERATOR) _generator(ci->_generator)->Kill();\r
_stackbase -= ci->_prevstkbase;\r
_top = _stackbase + ci->_prevtop;\r
assert(0);\r
}\r
\r
-bool SQVM::CreateClassInstance(SQClass *theclass, int nargs, int stackbase, SQObjectPtr &retval)\r
+bool SQVM::CreateClassInstance(SQClass *theclass, SQInteger nargs, SQInteger stackbase, SQObjectPtr &retval)\r
{\r
SQObjectPtr constr;\r
SQObjectPtr inst = theclass->CreateInstance();\r
}\r
}\r
\r
-void SQVM::CallDebugHook(int type,int forcedline)\r
+void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)\r
{\r
SQObjectPtr temp_reg;\r
- int nparams=5;\r
+ SQInteger nparams=5;\r
SQFunctionProto *func=_funcproto(_closure(ci->_closure)->_function);\r
Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);\r
Call(_debughook,nparams,_top-nparams,temp_reg);\r
Pop(nparams);\r
}\r
\r
-bool SQVM::CallNative(SQNativeClosure *nclosure,int nargs,int stackbase,bool tailcall,SQObjectPtr &retval,bool &suspend)\r
+bool SQVM::CallNative(SQNativeClosure *nclosure,SQInteger nargs,SQInteger stackbase,bool tailcall,SQObjectPtr &retval,bool &suspend)\r
{\r
if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }\r
- int nparamscheck = nclosure->_nparamscheck;\r
+ SQInteger nparamscheck = nclosure->_nparamscheck;\r
if(((nparamscheck > 0) && (nparamscheck != nargs))\r
|| ((nparamscheck < 0) && (nargs < (-nparamscheck)))) {\r
Raise_Error(_SC("wrong number of parameters"));\r
return false;\r
}\r
\r
- int tcs;\r
+ SQInteger tcs;\r
if(tcs = nclosure->_typecheck.size()) {\r
- for(int i = 0; i < nargs && i < tcs; i++)\r
+ for(SQInteger i = 0; i < nargs && i < tcs; i++)\r
if((nclosure->_typecheck[i] != -1) && !(type(_stack[stackbase+i]) & nclosure->_typecheck[i])) {\r
Raise_ParamTypeError(i,nclosure->_typecheck[i],type(_stack[stackbase+i]));\r
return false;\r
}\r
}\r
_nnativecalls++;\r
- if ((_top + MIN_STACK_OVERHEAD) > (int)_stack.size()) {\r
+ if ((_top + MIN_STACK_OVERHEAD) > (SQInteger)_stack.size()) {\r
_stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));\r
}\r
- int oldtop = _top;\r
- int oldstackbase = _stackbase;\r
+ SQInteger oldtop = _top;\r
+ SQInteger oldstackbase = _stackbase;\r
_top = stackbase + nargs;\r
PUSH_CALLINFO(this, CallInfo());\r
ci->_etraps = 0;\r
ci->_ncalls = 1;\r
_stackbase = stackbase;\r
//push free variables\r
- int outers = nclosure->_outervalues.size();\r
- for (int i = 0; i < outers; i++) {\r
+ SQInteger outers = nclosure->_outervalues.size();\r
+ for (SQInteger i = 0; i < outers; i++) {\r
Push(nclosure->_outervalues[i]);\r
}\r
ci->_prevtop = (oldtop - oldstackbase);\r
- int ret = (nclosure->_function)(this);\r
+ SQInteger ret = (nclosure->_function)(this);\r
_nnativecalls--;\r
suspend = false;\r
if( ret == SQ_SUSPEND_FLAG) suspend = true;\r
case OT_THREAD:\r
if(raw)return false;\r
return _thread_ddel->Get(key,dest);\r
+ case OT_WEAKREF:\r
+ if(raw)return false;\r
+ return _weakref_ddel->Get(key,dest);\r
default:return false;\r
}\r
return false;\r
return true;\r
}\r
\r
-bool SQVM::Call(SQObjectPtr &closure,int nparams,int stackbase,SQObjectPtr &outres)\r
+bool SQVM::Call(SQObjectPtr &closure,SQInteger nparams,SQInteger stackbase,SQObjectPtr &outres)\r
{\r
#ifdef _DEBUG\r
-int prevstackbase = _stackbase;\r
+SQInteger prevstackbase = _stackbase;\r
#endif\r
switch(type(closure)) {\r
case OT_CLOSURE:\r
return true;\r
}\r
\r
-bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,int nparams,SQObjectPtr &outres)\r
+bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,SQInteger nparams,SQObjectPtr &outres)\r
{\r
SQObjectPtr closure;\r
if(del->GetMetaMethod(mm, closure)) {\r
return false;\r
}\r
\r
-void SQVM::Pop() {\r
- _stack[--_top] = _null_;\r
-}\r
-void SQVM::Pop(int n) {\r
- for(int i = 0; i < n; i++){\r
- _stack[--_top] = _null_;\r
- }\r
-}\r
-\r
-void SQVM::Remove(int n) {\r
+void SQVM::Remove(SQInteger n) {\r
n = (n >= 0)?n + _stackbase - 1:_top + n;\r
- for(int i = n; i < _top; i++){\r
+ for(SQInteger i = n; i < _top; i++){\r
_stack[i] = _stack[i+1];\r
}\r
_stack[_top] = _null_;\r
_top--;\r
}\r
\r
-void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; }\r
-SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }\r
-SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }\r
-SQObjectPtr &SQVM::GetUp(int n) { return _stack[_top+n]; }\r
-SQObjectPtr &SQVM::GetAt(int n) { return _stack[n]; }\r
\r
#ifdef _DEBUG_DUMP\r
-void SQVM::dumpstack(int stackbase,bool dumpall)\r
+void SQVM::dumpstack(SQInteger stackbase,bool dumpall)\r
{\r
- int size=dumpall?_stack.size():_top;\r
- int n=0;\r
+ SQInteger size=dumpall?_stack.size():_top;\r
+ SQInteger n=0;\r
scprintf(_SC("\n>>>>stack dump<<<<\n"));\r
CallInfo &ci=_callsstack.back();\r
scprintf(_SC("IP: %d\n"),ci._ip);\r
scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);\r
scprintf(_SC("prev top: %d\n"),ci._prevtop);\r
- for(int i=0;i<size;i++){\r
+ for(SQInteger i=0;i<size;i++){\r
SQObjectPtr &obj=_stack[i]; \r
if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));\r
scprintf(_SC("[%d]:"),n);\r
case OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break;\r
case OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break;\r
case OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break;\r
+ case OT_WEAKREF: scprintf(_SC("WEAKERF %p"),_weakref(obj));break;\r
default:\r
assert(0);\r
break;\r
projects / supertux.git / blobdiff