#include <math.h>\r
#include <stdlib.h>\r
#include "sqopcodes.h"\r
-#include "sqfuncproto.h"\r
#include "sqvm.h"\r
+#include "sqfuncproto.h"\r
#include "sqclosure.h"\r
#include "sqstring.h"\r
#include "sqtable.h"\r
\r
#define TOP() (_stack._vals[_top-1])\r
\r
-#define CLEARSTACK(_last_top) { if((_last_top) >= _top) ClearStack(_last_top); }\r
-void SQVM::ClearStack(SQInteger last_top)\r
-{\r
- SQObjectType tOldType;\r
- SQObjectValue unOldVal;\r
- while (last_top >= _top) {\r
- SQObjectPtr &o = _stack._vals[last_top--];\r
- tOldType = o._type;\r
- unOldVal = o._unVal;\r
- o._type = OT_NULL;\r
- o._unVal.pUserPointer = NULL;\r
- __Release(tOldType,unOldVal);\r
- }\r
-}\r
-\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
- if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))\r
+ if((type(o1)|type(o2)) == OT_INTEGER)\r
{\r
+ SQInteger i1 = _integer(o1), i2 = _integer(o2);\r
switch(op) {\r
case BW_AND: res = i1 & i2; break;\r
case BW_OR: res = i1 | i2; break;\r
return true;\r
}\r
\r
+#define _ARITH_(op,trg,o1,o2) \\r
+{ \\r
+ SQInteger tmask = type(o1)|type(o2); \\r
+ switch(tmask) { \\r
+ case OT_INTEGER: trg = _integer(o1) op _integer(o2);break; \\r
+ case (OT_FLOAT|OT_INTEGER): \\r
+ case (OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\\r
+ default: _GUARD(ARITH_OP((#op)[0],trg,o1,o2)); break;\\r
+ } \\r
+}\r
+\r
+#define _ARITH_NOZERO(op,trg,o1,o2,err) \\r
+{ \\r
+ SQInteger tmask = type(o1)|type(o2); \\r
+ switch(tmask) { \\r
+ case OT_INTEGER: { SQInteger i2 = _integer(o2); if(i2 == 0) { Raise_Error(err); SQ_THROW(); } trg = _integer(o1) op i2; } break;\\r
+ case (OT_FLOAT|OT_INTEGER): \\r
+ case (OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\\r
+ default: _GUARD(ARITH_OP((#op)[0],trg,o1,o2)); break;\\r
+ } \\r
+}\r
+\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
- SQInteger res, i1 = _integer(o1), i2 = _integer(o2);\r
- switch(op) {\r
- case '+': res = i1 + i2; break;\r
- case '-': res = i1 - i2; break;\r
- case '/': if(i2 == 0) { Raise_Error(_SC("division by zero")); return false; }\r
+ SQInteger tmask = type(o1)|type(o2);\r
+ switch(tmask) {\r
+ case OT_INTEGER:{\r
+ SQInteger res, i1 = _integer(o1), i2 = _integer(o2);\r
+ switch(op) {\r
+ case '+': res = i1 + i2; break;\r
+ case '-': res = i1 - i2; break;\r
+ case '/': if(i2 == 0) { Raise_Error(_SC("division by zero")); return false; }\r
res = i1 / i2; \r
break;\r
- case '*': res = i1 * i2; break;\r
- case '%': if(i2 == 0) { Raise_Error(_SC("modulo by zero")); return false; }\r
+ case '*': res = i1 * i2; break;\r
+ case '%': if(i2 == 0) { Raise_Error(_SC("modulo by zero")); return false; }\r
res = i1 % i2; \r
break;\r
- default: res = 0xDEADBEEF;\r
- }\r
- trg = res;\r
- }else{\r
- SQFloat res, f1 = tofloat(o1), f2 = tofloat(o2);\r
- switch(op) {\r
- case '+': res = f1 + f2; break;\r
- case '-': res = f1 - f2; break;\r
- case '/': res = f1 / f2; break;\r
- case '*': res = f1 * f2; break;\r
- case '%': res = SQFloat(fmod((double)f1,(double)f2)); break;\r
- default: res = 0x0f;\r
- }\r
- trg = res;\r
- } \r
- } else {\r
- if(op == '+' && (type(o1) == OT_STRING || type(o2) == OT_STRING)){\r
- if(!StringCat(o1, o2, trg)) return false;\r
+ default: res = 0xDEADBEEF;\r
+ }\r
+ trg = res; }\r
+ break;\r
+ case (OT_FLOAT|OT_INTEGER):\r
+ case (OT_FLOAT):{\r
+ SQFloat res, f1 = tofloat(o1), f2 = tofloat(o2);\r
+ switch(op) {\r
+ case '+': res = f1 + f2; break;\r
+ case '-': res = f1 - f2; break;\r
+ case '/': res = f1 / f2; break;\r
+ case '*': res = f1 * f2; break;\r
+ case '%': res = SQFloat(fmod((double)f1,(double)f2)); break;\r
+ default: res = 0x0f;\r
+ }\r
+ trg = res; }\r
+ break;\r
+ default:\r
+ if(op == '+' && (tmask & _RT_STRING)){\r
+ if(!StringCat(o1, o2, trg)) return false;\r
}\r
else if(!ArithMetaMethod(op,o1,o2,trg)) { \r
- Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,GetTypeName(o1),GetTypeName(o2)); return false; \r
+ return false; \r
}\r
- }\r
- return true;\r
+ }\r
+ return true;\r
}\r
\r
SQVM::SQVM(SQSharedState *ss)\r
{\r
_sharedstate=ss;\r
_suspended = SQFalse;\r
- _suspended_target=-1;\r
+ _suspended_target = -1;\r
_suspended_root = SQFalse;\r
- _suspended_traps=-1;\r
- _foreignptr=NULL;\r
- _nnativecalls=0;\r
- _lasterror = _null_;\r
- _errorhandler = _null_;\r
- _debughook = _null_;\r
+ _suspended_traps = -1;\r
+ _foreignptr = NULL;\r
+ _nnativecalls = 0;\r
+ _nmetamethodscall = 0;\r
+ _lasterror.Null();\r
+ _errorhandler.Null();\r
+ _debughook = false;\r
+ _debughook_native = NULL;\r
+ _debughook_closure.Null();\r
+ _openouters = NULL;\r
ci = NULL;\r
INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);\r
}\r
\r
void SQVM::Finalize()\r
{\r
- _roottable = _null_;\r
- _lasterror = _null_;\r
- _errorhandler = _null_;\r
- _debughook = _null_;\r
- temp_reg = _null_;\r
+ if(_openouters) CloseOuters(&_stack._vals[0]);\r
+ _roottable.Null();\r
+ _lasterror.Null();\r
+ _errorhandler.Null();\r
+ _debughook = false;\r
+ _debughook_native = NULL;\r
+ _debughook_closure.Null();\r
+ temp_reg.Null();\r
_callstackdata.resize(0);\r
SQInteger size=_stack.size();\r
for(SQInteger i=0;i<size;i++)\r
- _stack[i]=_null_;\r
+ _stack[i].Null();\r
}\r
\r
SQVM::~SQVM()\r
{\r
Finalize();\r
- //sq_free(_callsstack,_alloccallsstacksize*sizeof(CallInfo));\r
REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);\r
}\r
\r
default: mm = MT_ADD; assert(0); break; //shutup compiler\r
}\r
if(is_delegable(o1) && _delegable(o1)->_delegate) {\r
- Push(o1);Push(o2);\r
- return CallMetaMethod(_delegable(o1),mm,2,dest);\r
+ \r
+ SQObjectPtr closure;\r
+ if(_delegable(o1)->GetMetaMethod(this, mm, closure)) {\r
+ Push(o1);Push(o2);\r
+ return CallMetaMethod(closure,mm,2,dest);\r
+ }\r
}\r
+ Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,GetTypeName(o1),GetTypeName(o2)); \r
return false;\r
}\r
\r
case OT_USERDATA:\r
case OT_INSTANCE:\r
if(_delegable(o)->_delegate) {\r
- Push(o);\r
- if(CallMetaMethod(_delegable(o), MT_UNM, 1, temp_reg)) {\r
- trg = temp_reg;\r
+ SQObjectPtr closure;\r
+ if(_delegable(o)->GetMetaMethod(this, MT_UNM, closure)) {\r
+ Push(o);\r
+ if(!CallMetaMethod(closure, MT_UNM, 1, temp_reg)) return false;\r
+ _Swap(trg,temp_reg);\r
return true;\r
+\r
}\r
}\r
default:break; //shutup compiler\r
#define _RET_SUCCEED(exp) { result = (exp); return true; } \r
bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result)\r
{\r
- if(type(o1)==type(o2)){\r
- if(_rawval(o1)==_rawval(o2))_RET_SUCCEED(0);\r
+ SQObjectType t1 = type(o1), t2 = type(o2);\r
+ if(t1 == t2) {\r
+ if(_rawval(o1) == _rawval(o2))_RET_SUCCEED(0);\r
SQObjectPtr res;\r
- switch(type(o1)){\r
+ switch(t1){\r
case OT_STRING:\r
_RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2)));\r
case OT_INTEGER:\r
- _RET_SUCCEED(_integer(o1)-_integer(o2));\r
+ _RET_SUCCEED((_integer(o1)<_integer(o2))?-1:1);\r
case OT_FLOAT:\r
_RET_SUCCEED((_float(o1)<_float(o2))?-1:1);\r
case OT_TABLE:\r
case OT_USERDATA:\r
case OT_INSTANCE:\r
if(_delegable(o1)->_delegate) {\r
- Push(o1);Push(o2);\r
- if(CallMetaMethod(_delegable(o1),MT_CMP,2,res)) break;\r
+ SQObjectPtr closure;\r
+ if(_delegable(o1)->GetMetaMethod(this, MT_CMP, closure)) {\r
+ Push(o1);Push(o2);\r
+ if(CallMetaMethod(closure,MT_CMP,2,res)) {\r
+ if(type(res) != OT_INTEGER) {\r
+ Raise_Error(_SC("_cmp must return an integer"));\r
+ return false;\r
+ }\r
+ _RET_SUCCEED(_integer(res))\r
+ }\r
+ return false;\r
+ }\r
}\r
//continues through (no break needed)\r
default: \r
_RET_SUCCEED( _userpointer(o1) < _userpointer(o2)?-1:1 );\r
}\r
- if(type(res)!=OT_INTEGER) { Raise_CompareError(o1,o2); return false; }\r
- _RET_SUCCEED(_integer(res));\r
+ assert(0);\r
+ //if(type(res)!=OT_INTEGER) { Raise_CompareError(o1,o2); return false; }\r
+ // _RET_SUCCEED(_integer(res));\r
\r
}\r
else{\r
if(sq_isnumeric(o1) && sq_isnumeric(o2)){\r
- if((type(o1)==OT_INTEGER) && (type(o2)==OT_FLOAT)) { \r
+ if((t1==OT_INTEGER) && (t2==OT_FLOAT)) { \r
if( _integer(o1)==_float(o2) ) { _RET_SUCCEED(0); }\r
else if( _integer(o1)<_float(o2) ) { _RET_SUCCEED(-1); }\r
_RET_SUCCEED(1);\r
_RET_SUCCEED(1);\r
}\r
}\r
- else if(type(o1)==OT_NULL) {_RET_SUCCEED(-1);}\r
- else if(type(o2)==OT_NULL) {_RET_SUCCEED(1);}\r
+ else if(t1==OT_NULL) {_RET_SUCCEED(-1);}\r
+ else if(t2==OT_NULL) {_RET_SUCCEED(1);}\r
else { Raise_CompareError(o1,o2); return false; }\r
\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
- case CMP_GE: res = (r >= 0)?_true_:_false_; return true;\r
- case CMP_L: res = (r < 0)?_true_:_false_; return true;\r
- case CMP_LE: res = (r <= 0)?_true_:_false_; return true;\r
- \r
+ case CMP_G: res = (r > 0); return true;\r
+ case CMP_GE: res = (r >= 0); return true;\r
+ case CMP_L: res = (r < 0); return true;\r
+ case CMP_LE: res = (r <= 0); return true;\r
+ case CMP_3W: res = r; return true;\r
}\r
assert(0);\r
}\r
return false;\r
}\r
\r
-void SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res)\r
+bool SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res)\r
{\r
switch(type(o)) {\r
case OT_STRING:\r
res = o;\r
- return;\r
+ return true;\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
+ scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_PRINT_INT_FMT,_integer(o));\r
break;\r
case OT_BOOL:\r
scsprintf(_sp(rsl(6)),_integer(o)?_SC("true"):_SC("false"));\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
+ SQObjectPtr closure;\r
+ if(_delegable(o)->GetMetaMethod(this, MT_TOSTRING, closure)) {\r
+ Push(o);\r
+ if(CallMetaMethod(closure,MT_TOSTRING,1,res)) {;\r
+ if(type(res) == OT_STRING)\r
+ return true;\r
+ } \r
+ else {\r
+ return false;\r
+ }\r
}\r
}\r
default:\r
scsprintf(_sp(rsl(sizeof(void*)+20)),_SC("(%s : 0x%p)"),GetTypeName(o),(void*)_rawval(o));\r
}\r
res = SQString::Create(_ss(this),_spval);\r
+ return true;\r
}\r
\r
\r
bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)\r
{\r
SQObjectPtr a, b;\r
- ToString(str, a);\r
- ToString(obj, b);\r
+ if(!ToString(str, a)) return false;\r
+ if(!ToString(obj, b)) return false;\r
SQInteger l = _string(a)->_len , ol = _string(b)->_len;\r
SQChar *s = _sp(rsl(l + ol + 1));\r
memcpy(s, _stringval(a), rsl(l)); \r
return true;\r
}\r
\r
-void SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)\r
+bool SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)\r
{\r
if(is_delegable(obj1) && _delegable(obj1)->_delegate) {\r
- Push(obj1);\r
- if(CallMetaMethod(_delegable(obj1),MT_TYPEOF,1,dest))\r
- return;\r
+ SQObjectPtr closure;\r
+ if(_delegable(obj1)->GetMetaMethod(this, MT_TYPEOF, closure)) {\r
+ Push(obj1);\r
+ return CallMetaMethod(closure,MT_TYPEOF,1,dest);\r
+ }\r
}\r
dest = SQString::Create(_ss(this),GetTypeName(obj1));\r
+ return true;\r
}\r
\r
bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)\r
_roottable = friendvm->_roottable;\r
_errorhandler = friendvm->_errorhandler;\r
_debughook = friendvm->_debughook;\r
+ _debughook_native = friendvm->_debughook_native;\r
+ _debughook_closure = friendvm->_debughook_closure;\r
}\r
\r
sq_base_register(this);\r
return true;\r
}\r
\r
-extern SQInstructionDesc g_InstrDesc[];\r
\r
bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQInteger stackbase,bool tailcall)\r
{\r
- SQFunctionProto *func = _funcproto(closure->_function);\r
- \r
- const SQInteger paramssize = func->_nparameters;\r
+ SQFunctionProto *func = closure->_function;\r
+\r
+ SQInteger paramssize = func->_nparameters;\r
const SQInteger newtop = stackbase + func->_stacksize;\r
SQInteger nargs = args;\r
- if (paramssize != nargs) {\r
+ if(func->_varparams)\r
+ {\r
+ paramssize--;\r
+ if (nargs < paramssize) {\r
+ Raise_Error(_SC("wrong number of parameters"));\r
+ return false;\r
+ }\r
+\r
+ //dumpstack(stackbase);\r
+ SQInteger nvargs = nargs - paramssize;\r
+ SQArray *arr = SQArray::Create(_ss(this),nvargs);\r
+ SQInteger pbase = stackbase+paramssize;\r
+ for(SQInteger n = 0; n < nvargs; n++) {\r
+ arr->_values[n] = _stack._vals[pbase];\r
+ _stack._vals[pbase].Null();\r
+ pbase++;\r
+\r
+ }\r
+ _stack._vals[stackbase+paramssize] = arr;\r
+ //dumpstack(stackbase);\r
+ }\r
+ else if (paramssize != nargs) {\r
SQInteger ndef = func->_ndefaultparams;\r
SQInteger diff;\r
if(ndef && nargs < paramssize && (diff = paramssize - nargs) <= ndef) {\r
_stack._vals[stackbase + (nargs++)] = closure->_defaultparams[n];\r
}\r
}\r
- else 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._vals[stackbase+paramssize+n]);\r
- _stack._vals[stackbase+paramssize+n] = _null_;\r
- }\r
- }\r
else {\r
Raise_Error(_SC("wrong number of parameters"));\r
return false;\r
}\r
}\r
\r
- if(type(closure->_env) == OT_WEAKREF) {\r
- _stack._vals[stackbase] = _weakref(closure->_env)->_obj;\r
+ if(closure->_env) {\r
+ _stack._vals[stackbase] = closure->_env->_obj;\r
}\r
\r
- if (!tailcall) {\r
- CallInfo lc;\r
- lc._generator = NULL;\r
- lc._etraps = 0;\r
- lc._prevstkbase = (SQInt32) ( stackbase - _stackbase );\r
- lc._target = (SQInt32) target;\r
- lc._prevtop = (SQInt32) (_top - _stackbase);\r
- lc._ncalls = 1;\r
- lc._root = SQFalse;\r
- PUSH_CALLINFO(this, lc);\r
- }\r
- else {\r
- ci->_ncalls++;\r
- }\r
- ci->_vargs.size = (SQInt32)(nargs - paramssize);\r
- ci->_vargs.base = (SQInt32)(_vargsstack.size()-(ci->_vargs.size));\r
- ci->_closure = closure;\r
+ if(!EnterFrame(stackbase, newtop, tailcall)) return false;\r
+\r
+ ci->_closure = closure;\r
ci->_literals = func->_literals;\r
- ci->_ip = func->_instructions;\r
- //grows the stack if needed\r
- if (((SQUnsignedInteger)newtop + (func->_stacksize<<1)) > _stack.size()) {\r
- _stack.resize(_stack.size() + (func->_stacksize<<1));\r
- }\r
- \r
- _top = newtop;\r
- _stackbase = stackbase;\r
- if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))\r
+ ci->_ip = func->_instructions;\r
+ ci->_target = (SQInt32)target;\r
+\r
+ if (_debughook) {\r
CallDebugHook(_SC('c'));\r
+ }\r
+\r
+ if (closure->_function->_bgenerator) {\r
+ SQFunctionProto *f = closure->_function;\r
+ SQGenerator *gen = SQGenerator::Create(_ss(this), closure);\r
+ if(!gen->Yield(this,f->_stacksize))\r
+ return false;\r
+ SQObjectPtr temp;\r
+ Return(1, target, temp);\r
+ STK(target) = gen;\r
+ }\r
+\r
+\r
return true;\r
}\r
\r
bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval)\r
{\r
- if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))\r
- for(SQInteger i=0;i<ci->_ncalls;i++)\r
+ SQBool _isroot = ci->_root;\r
+ SQInteger callerbase = _stackbase - ci->_prevstkbase;\r
+\r
+ if (_debughook) {\r
+ for(SQInteger i=0; i<ci->_ncalls; i++) {\r
CallDebugHook(_SC('r'));\r
- \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
- if(ci->_vargs.size) PopVarArgs(ci->_vargs);\r
- POP_CALLINFO(this);\r
- if (broot) {\r
- if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack._vals[oldstackbase+_arg1];\r
- else retval = _null_;\r
- }\r
- else {\r
- if(target != -1) { //-1 is when a class contructor ret value has to be ignored\r
- if (_arg0 != MAX_FUNC_STACKSIZE)\r
- STK(target) = _stack._vals[oldstackbase+_arg1];\r
- else\r
- STK(target) = _null_;\r
}\r
}\r
\r
- CLEARSTACK(last_top);\r
- assert(oldstackbase >= _stackbase); \r
- return broot?true:false;\r
+ SQObjectPtr *dest;\r
+ if (_isroot) {\r
+ dest = &(retval);\r
+ } else if (ci->_target == -1) {\r
+ dest = NULL;\r
+ } else {\r
+ dest = &_stack._vals[callerbase + ci->_target];\r
+ }\r
+ if (dest) {\r
+ if(_arg0 != 0xFF) {\r
+ *dest = _stack._vals[_stackbase+_arg1];\r
+ }\r
+ else {\r
+ dest->Null();\r
+ }\r
+ //*dest = (_arg0 != 0xFF) ? _stack._vals[_stackbase+_arg1] : _null_;\r
+ }\r
+ LeaveFrame();\r
+ return _isroot ? true : false;\r
}\r
\r
#define _RET_ON_FAIL(exp) { if(!exp) return false; }\r
\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(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)\r
{\r
SQObjectPtr trg;\r
return true;\r
}\r
\r
-bool SQVM::DerefInc(SQInteger 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,SQInteger selfidx)\r
{\r
SQObjectPtr tmp, tself = self, tkey = key;\r
- if (!Get(tself, tkey, tmp, false, true)) { Raise_IdxError(tkey); return false; }\r
+ if (!Get(tself, tkey, tmp, false, selfidx)) { return false; }\r
_RET_ON_FAIL(ARITH_OP( op , target, tmp, incr))\r
- Set(tself, tkey, target,true);\r
+ if (!Set(tself, tkey, target,selfidx)) { return false; }\r
if (postfix) target = tmp;\r
return true;\r
}\r
\r
#define arg0 (_i_._arg0)\r
+#define sarg0 ((SQInteger)*((signed char *)&_i_._arg0))\r
#define arg1 (_i_._arg1)\r
#define sarg1 (*((SQInt32 *)&_i_._arg1))\r
#define arg2 (_i_._arg2)\r
return SQ_SUSPEND_FLAG;\r
}\r
\r
-void SQVM::PopVarArgs(VarArgs &vargs)\r
-{\r
- for(SQInteger n = 0; n< vargs.size; n++)\r
- _vargsstack.pop_back();\r
-}\r
\r
#define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; }\r
bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr \r
case OT_INSTANCE:\r
if(_delegable(o1)->_delegate) {\r
SQObjectPtr itr;\r
- Push(o1);\r
- Push(o4);\r
- if(CallMetaMethod(_delegable(o1), MT_NEXTI, 2, itr)){\r
- o4 = o2 = itr;\r
- if(type(itr) == OT_NULL) _FINISH(exitpos);\r
- if(!Get(o1, itr, o3, false,false)) {\r
- Raise_Error(_SC("_nexti returned an invalid idx"));\r
+ SQObjectPtr closure;\r
+ if(_delegable(o1)->GetMetaMethod(this, MT_NEXTI, closure)) {\r
+ Push(o1);\r
+ Push(o4);\r
+ if(CallMetaMethod(closure, MT_NEXTI, 2, itr)) {\r
+ o4 = o2 = itr;\r
+ if(type(itr) == OT_NULL) _FINISH(exitpos);\r
+ if(!Get(o1, itr, o3, false, DONT_FALL_BACK)) {\r
+ Raise_Error(_SC("_nexti returned an invalid idx")); // cloud be changed\r
+ return false;\r
+ }\r
+ _FINISH(1);\r
+ }\r
+ else {\r
return false;\r
}\r
- _FINISH(1);\r
}\r
Raise_Error(_SC("_nexti failed"));\r
return false;\r
}\r
o2 = idx;\r
o4 = idx;\r
- _generator(o1)->Resume(this, arg_2+1);\r
+ _generator(o1)->Resume(this, o3);\r
_FINISH(0);\r
}\r
default: \r
return false; //cannot be hit(just to avoid warnings)\r
}\r
\r
-bool SQVM::DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2)\r
-{\r
- if(type(o1) != OT_TABLE) { Raise_Error(_SC("delegating a '%s'"), GetTypeName(o1)); return false; }\r
- switch(type(o2)) {\r
- case OT_TABLE:\r
- if(!_table(o1)->SetDelegate(_table(o2))){\r
- Raise_Error(_SC("delegate cycle detected"));\r
- return false;\r
- }\r
- break;\r
- case OT_NULL:\r
- _table(o1)->SetDelegate(NULL);\r
- break;\r
- default:\r
- Raise_Error(_SC("using '%s' as delegate"), GetTypeName(o2));\r
- return false;\r
- break;\r
- }\r
- trg = o1;\r
- return true;\r
-}\r
#define COND_LITERAL (arg3!=0?ci->_literals[arg1]:STK(arg1))\r
\r
-#define _GUARD(exp) { if(!exp) { Raise_Error(_lasterror); SQ_THROW();} }\r
-\r
#define SQ_THROW() { goto exception_trap; }\r
\r
+#define _GUARD(exp) { if(!exp) { SQ_THROW();} }\r
+\r
bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)\r
{\r
SQInteger nouters;\r
SQClosure *closure = SQClosure::Create(_ss(this), func);\r
if((nouters = func->_noutervalues)) {\r
- closure->_outervalues.reserve(nouters);\r
for(SQInteger i = 0; i<nouters; i++) {\r
SQOuterVar &v = func->_outervalues[i];\r
switch(v._type){\r
- case otSYMBOL:\r
- closure->_outervalues.push_back(_null_);\r
- if(!Get(_stack._vals[_stackbase]/*STK(0)*/, v._src, closure->_outervalues.top(), false,true))\r
- {Raise_IdxError(v._src); return false; }\r
- break;\r
case otLOCAL:\r
- closure->_outervalues.push_back(_stack._vals[_stackbase+_integer(v._src)]);\r
+ FindOuter(closure->_outervalues[i], &STK(_integer(v._src)));\r
break;\r
case otOUTER:\r
- closure->_outervalues.push_back(_closure(ci->_closure)->_outervalues[_integer(v._src)]);\r
+ closure->_outervalues[i] = _closure(ci->_closure)->_outervalues[_integer(v._src)];\r
break;\r
}\r
}\r
}\r
SQInteger ndefparams;\r
if((ndefparams = func->_ndefaultparams)) {\r
- closure->_defaultparams.reserve(ndefparams);\r
for(SQInteger i = 0; i < ndefparams; i++) {\r
SQInteger spos = func->_defaultparams[i];\r
- closure->_defaultparams.push_back(_stack._vals[_stackbase + spos]);\r
+ closure->_defaultparams[i] = _stack._vals[_stackbase + spos];\r
}\r
}\r
target = closure;\r
\r
}\r
\r
-bool SQVM::GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &index,CallInfo *ci)\r
-{\r
- if(ci->_vargs.size == 0) {\r
- Raise_Error(_SC("the function doesn't have var args"));\r
- return false;\r
- }\r
- if(!sq_isnumeric(index)){\r
- Raise_Error(_SC("indexing 'vargv' with %s"),GetTypeName(index));\r
- return false;\r
- }\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,SQInteger baseclass,SQInteger attributes)\r
{\r
return true;\r
}\r
\r
-\r
-\r
-bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)\r
+bool SQVM::IsEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res)\r
{\r
if(type(o1) == type(o2)) {\r
- res = ((_rawval(o1) == _rawval(o2)?true:false));\r
+ res = (_rawval(o1) == _rawval(o2));\r
}\r
else {\r
if(sq_isnumeric(o1) && sq_isnumeric(o2)) {\r
- SQInteger cmpres;\r
- if(!ObjCmp(o1, o2,cmpres)) return false;\r
- res = (cmpres == 0);\r
+ res = (tofloat(o1) == tofloat(o2));\r
}\r
else {\r
res = false;\r
\r
bool SQVM::IsFalse(SQObjectPtr &o)\r
{\r
- if((type(o) & SQOBJECT_CANBEFALSE) && ( (type(o) == OT_FLOAT) && (_float(o) == SQFloat(0.0)) )\r
- || (_integer(o) == 0) ) { //OT_NULL|OT_INTEGER|OT_BOOL\r
+ if(((type(o) & SQOBJECT_CANBEFALSE) \r
+ && ( ((type(o) == OT_FLOAT) && (_float(o) == SQFloat(0.0))) ))\r
+#if !defined(SQUSEDOUBLE) || (defined(SQUSEDOUBLE) && defined(_SQ64))\r
+ || (_integer(o) == 0) ) //OT_NULL|OT_INTEGER|OT_BOOL\r
+#else\r
+ || (((type(o) != OT_FLOAT) && (_integer(o) == 0))) ) //OT_NULL|OT_INTEGER|OT_BOOL\r
+#endif\r
+ {\r
return true;\r
}\r
return false;\r
}\r
\r
-bool SQVM::GETPARENT_OP(SQObjectPtr &o,SQObjectPtr &target)\r
-{\r
- switch(type(o)) {\r
- case OT_TABLE: target = _table(o)->_delegate?SQObjectPtr(_table(o)->_delegate):_null_;\r
- break;\r
- case OT_CLASS: target = _class(o)->_base?_class(o)->_base:_null_;\r
- break;\r
- default:\r
- Raise_Error(_SC("the %s type doesn't have a parent slot"), GetTypeName(o));\r
- return false;\r
- }\r
- return true;\r
-}\r
-\r
-bool SQVM::Execute(SQObjectPtr &closure, SQInteger target, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et)\r
+bool SQVM::Execute(SQObjectPtr &closure, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, SQBool raiseerror,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
SQInteger traps = 0;\r
- //temp_reg vars for OP_CALL\r
- SQInteger ct_target;\r
- SQInteger ct_stackbase;\r
- bool ct_tailcall; \r
-\r
+ CallInfo *prevci = ci;\r
+ \r
switch(et) {\r
case ET_CALL: {\r
- SQInteger last_top = _top;\r
temp_reg = closure;\r
if(!StartCall(_closure(temp_reg), _top - nargs, nargs, stackbase, false)) { \r
//call the handler if there are no calls in the stack, if not relies on the previous node\r
if(ci == NULL) CallErrorHandler(_lasterror);\r
return false;\r
}\r
- if (_funcproto(_closure(temp_reg)->_function)->_bgenerator) {\r
- SQFunctionProto *f = _funcproto(_closure(temp_reg)->_function);\r
- SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(temp_reg));\r
- _GUARD(gen->Yield(this));\r
- Return(1, ci->_target, temp_reg);\r
- outres = gen;\r
- CLEARSTACK(last_top);\r
+ if(ci == prevci) {\r
+ outres = STK(_top-nargs);\r
return true;\r
}\r
ci->_root = SQTrue;\r
}\r
break;\r
- case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = SQTrue; traps += ci->_etraps; break;\r
+ case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, outres); ci->_root = SQTrue; traps += ci->_etraps; break;\r
case ET_RESUME_VM:\r
case ET_RESUME_THROW_VM:\r
traps = _suspended_traps;\r
ci->_root = _suspended_root;\r
- ci->_vargs = _suspend_varargs;\r
_suspended = SQFalse;\r
if(et == ET_RESUME_THROW_VM) { SQ_THROW(); }\r
break;\r
//scprintf("\n[%d] %s %d %d %d %d\n",ci->_ip-ci->_iv->_vals,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3);\r
switch(_i_.op)\r
{\r
- case _OP_LINE:\r
- if(type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))\r
- CallDebugHook(_SC('l'),arg1);\r
- continue;\r
+ case _OP_LINE: if (_debughook) CallDebugHook(_SC('l'),arg1); continue;\r
case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;\r
- case _OP_LOADINT: TARGET = (SQInteger)arg1; continue;\r
+ case _OP_LOADINT: \r
+#ifndef _SQ64\r
+ TARGET = (SQInteger)arg1; continue;\r
+#else\r
+ TARGET = (SQInteger)((SQUnsignedInteger32)arg1); continue;\r
+#endif\r
case _OP_LOADFLOAT: TARGET = *((SQFloat *)&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 && !_funcproto(_closure(temp_reg)->_function)->_bgenerator){ \r
- ct_tailcall = true;\r
- if(ci->_vargs.size) PopVarArgs(ci->_vargs);\r
+ case _OP_TAILCALL:{\r
+ SQObjectPtr &t = STK(arg1);\r
+ if (type(t) == OT_CLOSURE \r
+ && (!_closure(t)->_function->_bgenerator)){\r
+ SQObjectPtr clo = t;\r
+ if(_openouters) CloseOuters(&(_stack._vals[_stackbase]));\r
for (SQInteger i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);\r
- ct_target = ci->_target;\r
- ct_stackbase = _stackbase;\r
- goto common_call;\r
+ _GUARD(StartCall(_closure(clo), ci->_target, arg3, _stackbase, true));\r
+ continue;\r
}\r
+ }\r
case _OP_CALL: {\r
- ct_tailcall = false;\r
- ct_target = arg0;\r
- temp_reg = STK(arg1);\r
- ct_stackbase = _stackbase+arg2;\r
-\r
-common_call:\r
- SQObjectPtr clo = temp_reg;\r
- SQInteger last_top = _top;\r
+ SQObjectPtr clo = STK(arg1);\r
switch (type(clo)) {\r
- case OT_CLOSURE:{\r
- _GUARD(StartCall(_closure(clo), ct_target, arg3, ct_stackbase, ct_tailcall));\r
- if (_funcproto(_closure(clo)->_function)->_bgenerator) {\r
- SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(clo));\r
- _GUARD(gen->Yield(this));\r
- Return(1, ct_target, clo);\r
- STK(ct_target) = gen;\r
- CLEARSTACK(last_top);\r
- continue;\r
- }\r
- }\r
+ case OT_CLOSURE:\r
+ _GUARD(StartCall(_closure(clo), sarg0, arg3, _stackbase+arg2, false));\r
continue;\r
case OT_NATIVECLOSURE: {\r
bool suspend;\r
- _GUARD(CallNative(_nativeclosure(clo), arg3, ct_stackbase, clo,suspend));\r
+ _GUARD(CallNative(_nativeclosure(clo), arg3, _stackbase+arg2, clo,suspend));\r
if(suspend){\r
_suspended = SQTrue;\r
- _suspended_target = ct_target;\r
+ _suspended_target = sarg0;\r
_suspended_root = ci->_root;\r
_suspended_traps = traps;\r
- _suspend_varargs = ci->_vargs;\r
outres = clo;\r
return true;\r
}\r
- if(ct_target != -1) { //skip return value for constructors\r
- STK(ct_target) = clo;\r
+ if(sarg0 != -1) {\r
+ STK(arg0) = clo;\r
}\r
}\r
continue;\r
case OT_CLASS:{\r
SQObjectPtr inst;\r
- _GUARD(CreateClassInstance(_class(clo),inst,temp_reg));\r
- STK(ct_target) = inst;\r
- ct_target = -1; //fakes return value target so that is not overwritten by the constructor\r
- if(type(temp_reg) != OT_NULL) {\r
- _stack._vals[ct_stackbase] = inst;\r
- goto common_call; //hard core spaghetti code(reissues the OP_CALL to invoke the constructor)\r
+ _GUARD(CreateClassInstance(_class(clo),inst,clo));\r
+ if(sarg0 != -1) {\r
+ STK(arg0) = inst;\r
+ }\r
+ SQInteger stkbase;\r
+ switch(type(clo)) {\r
+ case OT_CLOSURE:\r
+ stkbase = _stackbase+arg2;\r
+ _stack._vals[stkbase] = inst;\r
+ _GUARD(StartCall(_closure(clo), -1, arg3, stkbase, false));\r
+ break;\r
+ case OT_NATIVECLOSURE:\r
+ bool suspend;\r
+ stkbase = _stackbase+arg2;\r
+ _stack._vals[stkbase] = inst;\r
+ _GUARD(CallNative(_nativeclosure(clo), arg3, stkbase, clo,suspend));\r
+ break;\r
+ default: break; //shutup GCC 4.x\r
}\r
}\r
break;\r
case OT_TABLE:\r
case OT_USERDATA:\r
- case OT_INSTANCE:\r
- {\r
- Push(clo);\r
- for (SQInteger i = 0; i < arg3; i++) Push(STK(arg2 + i));\r
- if (_delegable(clo) && CallMetaMethod(_delegable(clo), MT_CALL, arg3+1, clo)){\r
- STK(ct_target) = clo;\r
+ case OT_INSTANCE:{\r
+ SQObjectPtr closure;\r
+ if(_delegable(clo)->_delegate && _delegable(clo)->GetMetaMethod(this,MT_CALL,closure)) {\r
+ Push(clo);\r
+ for (SQInteger i = 0; i < arg3; i++) Push(STK(arg2 + i));\r
+ if(!CallMetaMethod(closure, MT_CALL, arg3+1, clo)) SQ_THROW();\r
+ if(sarg0 != -1) {\r
+ STK(arg0) = clo;\r
+ }\r
break;\r
}\r
- Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo));\r
- SQ_THROW();\r
+ \r
+ //Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo));\r
+ //SQ_THROW();\r
}\r
default:\r
Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo));\r
}\r
continue;\r
case _OP_PREPCALL:\r
- case _OP_PREPCALLK:\r
- {\r
+ case _OP_PREPCALLK: {\r
SQObjectPtr &key = _i_.op == _OP_PREPCALLK?(ci->_literals)[arg1]:STK(arg1);\r
SQObjectPtr &o = STK(arg2);\r
- if (!Get(o, key, temp_reg,false,true)) {\r
- if(type(o) == OT_CLASS) { //hack?\r
- if(_class_ddel->Get(key,temp_reg)) {\r
- STK(arg3) = o;\r
- TARGET = temp_reg;\r
- continue;\r
- }\r
- }\r
- { Raise_IdxError(key); SQ_THROW();}\r
+ if (!Get(o, key, temp_reg,false,arg2)) {\r
+ SQ_THROW();\r
}\r
-\r
- STK(arg3) = type(o) == OT_CLASS?STK(0):o;\r
- TARGET = temp_reg;\r
+ STK(arg3) = o;\r
+ _Swap(TARGET,temp_reg);//TARGET = temp_reg;\r
}\r
continue;\r
case _OP_GETK:\r
- if (!Get(STK(arg2), ci->_literals[arg1], temp_reg, false,true)) { Raise_IdxError(ci->_literals[arg1]); SQ_THROW();}\r
- TARGET = temp_reg;\r
+ if (!Get(STK(arg2), ci->_literals[arg1], temp_reg, false,arg2)) { SQ_THROW();}\r
+ _Swap(TARGET,temp_reg);//TARGET = temp_reg;\r
continue;\r
case _OP_MOVE: TARGET = STK(arg1); continue;\r
case _OP_NEWSLOT:\r
_GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),false));\r
- if(arg0 != arg3) TARGET = STK(arg3);\r
+ if(arg0 != 0xFF) TARGET = STK(arg3);\r
continue;\r
case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue;\r
case _OP_SET:\r
- if (!Set(STK(arg1), STK(arg2), STK(arg3),true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }\r
- if (arg0 != arg3) TARGET = STK(arg3);\r
+ if (!Set(STK(arg1), STK(arg2), STK(arg3),arg1)) { SQ_THROW(); }\r
+ if (arg0 != 0xFF) TARGET = STK(arg3);\r
continue;\r
case _OP_GET:\r
- if (!Get(STK(arg1), STK(arg2), temp_reg, false,true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }\r
- TARGET = temp_reg;\r
+ if (!Get(STK(arg1), STK(arg2), temp_reg, false,arg1)) { SQ_THROW(); }\r
+ _Swap(TARGET,temp_reg);//TARGET = temp_reg;\r
continue;\r
case _OP_EQ:{\r
bool res;\r
if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }\r
- TARGET = res?_true_:_false_;\r
+ TARGET = res?true:false;\r
}continue;\r
case _OP_NE:{ \r
bool res;\r
if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }\r
- TARGET = (!res)?_true_:_false_;\r
+ TARGET = (!res)?true:false;\r
} continue;\r
- case _OP_ARITH: _GUARD(ARITH_OP( arg3 , temp_reg, STK(arg2), STK(arg1))); TARGET = temp_reg; continue;\r
+ case _OP_ADD: _ARITH_(+,TARGET,STK(arg2),STK(arg1)); continue;\r
+ case _OP_SUB: _ARITH_(-,TARGET,STK(arg2),STK(arg1)); continue;\r
+ case _OP_MUL: _ARITH_(*,TARGET,STK(arg2),STK(arg1)); continue;\r
+ case _OP_DIV: _ARITH_NOZERO(/,TARGET,STK(arg2),STK(arg1),_SC("division by zero")); continue;\r
+ case _OP_MOD: ARITH_OP('%',TARGET,STK(arg2),STK(arg1)); continue;\r
case _OP_BITW: _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;\r
case _OP_RETURN:\r
- if(ci->_generator) {\r
- ci->_generator->Kill();\r
+ if((ci)->_generator) {\r
+ (ci)->_generator->Kill();\r
}\r
if(Return(arg0, arg1, temp_reg)){\r
assert(traps==0);\r
- outres = temp_reg;\r
+ //outres = temp_reg;\r
+ _Swap(outres,temp_reg);\r
return true;\r
}\r
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_LOADNULLS:{ for(SQInt32 n=0; n < arg1; n++) STK(arg0+n).Null(); }continue;\r
+ case _OP_LOADROOT: 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
case _OP_JMP: ci->_ip += (sarg1); continue;\r
- case _OP_JNZ: if(!IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;\r
+ //case _OP_JNZ: if(!IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;\r
+ case _OP_JCMP: \r
+ _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg0),temp_reg));\r
+ if(IsFalse(temp_reg)) ci->_ip+=(sarg1);\r
+ continue;\r
case _OP_JZ: if(IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;\r
- case _OP_LOADFREEVAR: TARGET = _closure(ci->_closure)->_outervalues[arg1]; continue;\r
- case _OP_VARGC: TARGET = SQInteger(ci->_vargs.size); continue;\r
- case _OP_GETVARGV: \r
- if(!GETVARGV_OP(TARGET,STK(arg1),ci)) { SQ_THROW(); } \r
+ case _OP_GETOUTER: {\r
+ SQClosure *cur_cls = _closure(ci->_closure);\r
+ SQOuter *otr = _outer(cur_cls->_outervalues[arg1]);\r
+ TARGET = *(otr->_valptr);\r
+ }\r
+ continue;\r
+ case _OP_SETOUTER: {\r
+ SQClosure *cur_cls = _closure(ci->_closure);\r
+ SQOuter *otr = _outer(cur_cls->_outervalues[arg1]);\r
+ *(otr->_valptr) = STK(arg2);\r
+ if(arg0 != 0xFF) {\r
+ TARGET = STK(arg2);\r
+ }\r
+ }\r
+ continue;\r
+ case _OP_NEWOBJ: \r
+ switch(arg3) {\r
+ case NOT_TABLE: TARGET = SQTable::Create(_ss(this), arg1); continue;\r
+ case NOT_ARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue;\r
+ case NOT_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;\r
+ default: assert(0); continue;\r
+ }\r
+ case _OP_APPENDARRAY: \r
+ {\r
+ SQObject val;\r
+ val._unVal.raw = 0;\r
+ switch(arg2) {\r
+ case AAT_STACK:\r
+ val = STK(arg1); break;\r
+ case AAT_LITERAL:\r
+ val = ci->_literals[arg1]; break;\r
+ case AAT_INT:\r
+ val._type = OT_INTEGER;\r
+#ifndef _SQ64\r
+ val._unVal.nInteger = (SQInteger)arg1; \r
+#else\r
+ val._unVal.nInteger = (SQInteger)((SQUnsignedInteger32)arg1);\r
+#endif\r
+ break;\r
+ case AAT_FLOAT:\r
+ val._type = OT_FLOAT;\r
+ val._unVal.fFloat = *((SQFloat *)&arg1);\r
+ break;\r
+ case AAT_BOOL:\r
+ val._type = OT_BOOL;\r
+ val._unVal.nInteger = arg1;\r
+ break;\r
+ default: assert(0); break;\r
+\r
+ }\r
+ _array(STK(arg0))->Append(val); continue;\r
+ }\r
+ case _OP_COMPARITH: {\r
+ SQInteger selfidx = (((SQUnsignedInteger)arg1&0xFFFF0000)>>16);\r
+ _GUARD(DerefInc(arg3, TARGET, STK(selfidx), STK(arg2), STK(arg1&0x0000FFFF), false, selfidx)); \r
+ }\r
continue;\r
- case _OP_NEWTABLE: TARGET = SQTable::Create(_ss(this), arg1); continue;\r
- case _OP_NEWARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue;\r
- case _OP_APPENDARRAY: _array(STK(arg0))->Append(COND_LITERAL); continue;\r
- case _OP_GETPARENT: _GUARD(GETPARENT_OP(STK(arg1),TARGET)); 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
- case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, true));} continue;\r
- case _OP_PINCL: {SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o));} continue;\r
+ case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, false, arg1));} continue;\r
+ case _OP_INCL: {\r
+ SQObjectPtr &a = STK(arg1);\r
+ if(type(a) == OT_INTEGER) {\r
+ a._unVal.nInteger = _integer(a) + sarg3;\r
+ }\r
+ else {\r
+ SQObjectPtr o(sarg3); //_GUARD(LOCAL_INC('+',TARGET, STK(arg1), o));\r
+ _ARITH_(+,a,a,o);\r
+ }\r
+ } continue;\r
+ case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, true, arg1));} continue;\r
+ case _OP_PINCL: {\r
+ SQObjectPtr &a = STK(arg1);\r
+ if(type(a) == OT_INTEGER) {\r
+ TARGET = a;\r
+ a._unVal.nInteger = _integer(a) + sarg3;\r
+ }\r
+ else {\r
+ SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o));\r
+ }\r
+ \r
+ } continue;\r
case _OP_CMP: _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET)) continue;\r
- case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, true,false)?_true_:_false_;continue;\r
+ case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, true,DONT_FALL_BACK)?true:false;continue;\r
case _OP_INSTANCEOF: \r
- if(type(STK(arg1)) != OT_CLASS || type(STK(arg2)) != OT_INSTANCE)\r
+ if(type(STK(arg1)) != OT_CLASS)\r
{Raise_Error(_SC("cannot apply instanceof between a %s and a %s"),GetTypeName(STK(arg1)),GetTypeName(STK(arg2))); SQ_THROW();}\r
- TARGET = _instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?_true_:_false_;\r
+ TARGET = (type(STK(arg2)) == OT_INSTANCE) ? (_instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?true:false) : false;\r
continue;\r
case _OP_AND: \r
if(IsFalse(STK(arg2))) {\r
}\r
continue;\r
case _OP_NEG: _GUARD(NEG_OP(TARGET,STK(arg1))); continue;\r
- case _OP_NOT: TARGET = (IsFalse(STK(arg1))?_true_:_false_); continue;\r
+ case _OP_NOT: TARGET = IsFalse(STK(arg1)); continue;\r
case _OP_BWNOT:\r
if(type(STK(arg1)) == OT_INTEGER) {\r
SQInteger t = _integer(STK(arg1));\r
SQ_THROW();\r
case _OP_CLOSURE: {\r
SQClosure *c = ci->_closure._unVal.pClosure;\r
- SQFunctionProto *fp = c->_function._unVal.pFunctionProto;\r
+ SQFunctionProto *fp = c->_function;\r
if(!CLOSURE_OP(TARGET,fp->_functions[arg1]._unVal.pFunctionProto)) { SQ_THROW(); }\r
continue;\r
}\r
case _OP_YIELD:{\r
if(ci->_generator) {\r
if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1);\r
- _GUARD(ci->_generator->Yield(this));\r
+ _GUARD(ci->_generator->Yield(this,arg2));\r
traps -= ci->_etraps;\r
- if(sarg1 != MAX_FUNC_STACKSIZE) STK(arg1) = temp_reg;\r
+ if(sarg1 != MAX_FUNC_STACKSIZE) _Swap(STK(arg1),temp_reg);//STK(arg1) = temp_reg;\r
}\r
else { Raise_Error(_SC("trying to yield a '%s',only genenerator can be yielded"), GetTypeName(ci->_generator)); SQ_THROW();}\r
if(Return(arg0, arg1, temp_reg)){\r
continue;\r
case _OP_RESUME:\r
if(type(STK(arg1)) != OT_GENERATOR){ Raise_Error(_SC("trying to resume a '%s',only genenerator can be resumed"), GetTypeName(STK(arg1))); SQ_THROW();}\r
- _GUARD(_generator(STK(arg1))->Resume(this, arg0));\r
+ _GUARD(_generator(STK(arg1))->Resume(this, TARGET));\r
traps += ci->_etraps;\r
continue;\r
case _OP_FOREACH:{ int tojump;\r
if(_generator(STK(arg0))->_state == SQGenerator::eDead) \r
ci->_ip += (sarg1 - 1);\r
continue;\r
- case _OP_DELEGATE: _GUARD(DELEGATE_OP(TARGET,STK(arg1),STK(arg2))); continue;\r
- case _OP_CLONE:\r
- if(!Clone(STK(arg1), TARGET))\r
- { Raise_Error(_SC("cloning a %s"), GetTypeName(STK(arg1))); SQ_THROW();}\r
- continue;\r
- case _OP_TYPEOF: TypeOf(STK(arg1), TARGET); continue;\r
+ case _OP_CLONE: _GUARD(Clone(STK(arg1), TARGET)); continue;\r
+ case _OP_TYPEOF: _GUARD(TypeOf(STK(arg1), TARGET)) continue;\r
case _OP_PUSHTRAP:{\r
- SQInstruction *_iv = _funcproto(_closure(ci->_closure)->_function)->_instructions;\r
+ SQInstruction *_iv = _closure(ci->_closure)->_function->_instructions;\r
_etraps.push_back(SQExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++;\r
ci->_etraps++;\r
}\r
}\r
continue;\r
case _OP_THROW: Raise_Error(TARGET); SQ_THROW(); continue;\r
- case _OP_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;\r
case _OP_NEWSLOTA:\r
- bool bstatic = (arg0&NEW_SLOT_STATIC_FLAG)?true:false;\r
- if(type(STK(arg1)) == OT_CLASS) {\r
- if(type(_class(STK(arg1))->_metamethods[MT_NEWMEMBER]) != OT_NULL ) {\r
- Push(STK(arg1)); Push(STK(arg2)); Push(STK(arg3));\r
- Push((arg0&NEW_SLOT_ATTRIBUTES_FLAG) ? STK(arg2-1) : _null_);\r
- Push(bstatic);\r
- int nparams = 5;\r
- if(Call(_class(STK(arg1))->_metamethods[MT_NEWMEMBER], nparams, _top - nparams, temp_reg,SQFalse)) {\r
- Pop(nparams);\r
- continue;\r
- }\r
- }\r
+ _GUARD(NewSlotA(STK(arg1),STK(arg2),STK(arg3),(arg0&NEW_SLOT_ATTRIBUTES_FLAG) ? STK(arg2-1) : SQObjectPtr(),(arg0&NEW_SLOT_STATIC_FLAG)?true:false,false));\r
+ continue;\r
+ case _OP_GETBASE:{\r
+ SQClosure *clo = _closure(ci->_closure);\r
+ if(clo->_base) {\r
+ TARGET = clo->_base;\r
}\r
- _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),bstatic));\r
- if((arg0&NEW_SLOT_ATTRIBUTES_FLAG)) {\r
- _class(STK(arg1))->SetAttributes(STK(arg2),STK(arg2-1));\r
+ else {\r
+ TARGET.Null();\r
}\r
continue;\r
}\r
+ case _OP_CLOSE:\r
+ if(_openouters) CloseOuters(&(STK(arg1)));\r
+ continue;\r
+ }\r
\r
}\r
}\r
{\r
SQObjectPtr currerror = _lasterror;\r
// dumpstack(_stackbase);\r
- SQInteger n = 0;\r
+// SQInteger n = 0;\r
SQInteger last_top = _top;\r
- if(ci) {\r
- if(_ss(this)->_notifyallexceptions) CallErrorHandler(currerror);\r
-\r
- if(traps) {\r
- do {\r
- if(ci->_etraps > 0) {\r
- SQExceptionTrap &et = _etraps.top();\r
- ci->_ip = et._ip;\r
- _top = et._stacksize;\r
- _stackbase = et._stackbase;\r
- _stack._vals[_stackbase+et._extarget] = currerror;\r
- _etraps.pop_back(); traps--; ci->_etraps--;\r
- CLEARSTACK(last_top);\r
- goto exception_restore;\r
- }\r
- //if is a native closure\r
- if(type(ci->_closure) != OT_CLOSURE && n)\r
- break;\r
- if(ci->_generator) ci->_generator->Kill();\r
- PopVarArgs(ci->_vargs);\r
- POP_CALLINFO(this);\r
- n++;\r
- } while(_callsstacksize);\r
+ \r
+ if(_ss(this)->_notifyallexceptions || (!traps && raiseerror)) CallErrorHandler(currerror);\r
+\r
+ while( ci ) {\r
+ if(ci->_etraps > 0) {\r
+ SQExceptionTrap &et = _etraps.top();\r
+ ci->_ip = et._ip;\r
+ _top = et._stacksize;\r
+ _stackbase = et._stackbase;\r
+ _stack._vals[_stackbase + et._extarget] = currerror;\r
+ _etraps.pop_back(); traps--; ci->_etraps--;\r
+ while(last_top >= _top) _stack._vals[last_top--].Null();\r
+ goto exception_restore;\r
}\r
- else {\r
- //call the hook\r
- if(raiseerror && !_ss(this)->_notifyallexceptions)\r
- CallErrorHandler(currerror);\r
+ else if (_debughook) { \r
+ //notify debugger of a "return"\r
+ //even if it really an exception unwinding the stack\r
+ for(SQInteger i = 0; i < ci->_ncalls; i++) {\r
+ CallDebugHook(_SC('r'));\r
+ }\r
}\r
- //remove call stack until a C function is found or the cstack is empty\r
- if(ci) do {\r
- SQBool exitafterthisone = ci->_root;\r
- if(ci->_generator) ci->_generator->Kill();\r
- _stackbase -= ci->_prevstkbase;\r
- _top = _stackbase + ci->_prevtop;\r
- PopVarArgs(ci->_vargs);\r
- POP_CALLINFO(this);\r
- if( (ci && type(ci->_closure) != OT_CLOSURE) || exitafterthisone) break;\r
- } while(_callsstacksize);\r
-\r
- CLEARSTACK(last_top);\r
+ if(ci->_generator) ci->_generator->Kill();\r
+ bool mustbreak = ci && ci->_root;\r
+ LeaveFrame();\r
+ if(mustbreak) break;\r
}\r
+ \r
_lasterror = currerror;\r
return false;\r
}\r
bool SQVM::CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor)\r
{\r
inst = theclass->CreateInstance();\r
- if(!theclass->Get(_ss(this)->_constructoridx,constructor)) {\r
- constructor = _null_;\r
+ if(!theclass->GetConstructor(constructor)) {\r
+ constructor.Null();\r
}\r
return true;\r
}\r
}\r
}\r
\r
+\r
void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)\r
{\r
- SQObjectPtr temp_reg;\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,SQFalse);\r
- Pop(nparams);\r
+ _debughook = false;\r
+ SQFunctionProto *func=_closure(ci->_closure)->_function;\r
+ if(_debughook_native) {\r
+ const SQChar *src = type(func->_sourcename) == OT_STRING?_stringval(func->_sourcename):NULL;\r
+ const SQChar *fname = type(func->_name) == OT_STRING?_stringval(func->_name):NULL;\r
+ SQInteger line = forcedline?forcedline:func->GetLine(ci->_ip);\r
+ _debughook_native(this,type,src,line,fname);\r
+ }\r
+ else {\r
+ SQObjectPtr temp_reg;\r
+ SQInteger nparams=5;\r
+ Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);\r
+ Call(_debughook_closure,nparams,_top-nparams,temp_reg,SQFalse);\r
+ Pop(nparams);\r
+ }\r
+ _debughook = true;\r
}\r
\r
-bool SQVM::CallNative(SQNativeClosure *nclosure,SQInteger nargs,SQInteger stackbase,SQObjectPtr &retval,bool &suspend)\r
+bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newbase, SQObjectPtr &retval, bool &suspend)\r
{\r
- if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }\r
SQInteger nparamscheck = nclosure->_nparamscheck;\r
- if(((nparamscheck > 0) && (nparamscheck != nargs))\r
- || ((nparamscheck < 0) && (nargs < (-nparamscheck)))) {\r
+ SQInteger newtop = newbase + nargs + nclosure->_noutervalues;\r
+ \r
+ if (_nnativecalls + 1 > MAX_NATIVE_CALLS) {\r
+ Raise_Error(_SC("Native stack overflow"));\r
+ return false;\r
+ }\r
+\r
+ if(nparamscheck && (((nparamscheck > 0) && (nparamscheck != nargs)) ||\r
+ ((nparamscheck < 0) && (nargs < (-nparamscheck)))))\r
+ {\r
Raise_Error(_SC("wrong number of parameters"));\r
return false;\r
- }\r
+ }\r
\r
SQInteger tcs;\r
- if((tcs = nclosure->_typecheck.size())) {\r
- for(SQInteger i = 0; i < nargs && i < tcs; i++)\r
- if((nclosure->_typecheck._vals[i] != -1) && !(type(_stack._vals[stackbase+i]) & nclosure->_typecheck[i])) {\r
- Raise_ParamTypeError(i,nclosure->_typecheck._vals[i],type(_stack._vals[stackbase+i]));\r
+ SQIntVec &tc = nclosure->_typecheck;\r
+ if((tcs = tc.size())) {\r
+ for(SQInteger i = 0; i < nargs && i < tcs; i++) {\r
+ if((tc._vals[i] != -1) && !(type(_stack._vals[newbase+i]) & tc._vals[i])) {\r
+ Raise_ParamTypeError(i,tc._vals[i],type(_stack._vals[newbase+i]));\r
return false;\r
}\r
+ }\r
}\r
- _nnativecalls++;\r
- if ((_top + MIN_STACK_OVERHEAD) > (SQInteger)_stack.size()) {\r
- _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));\r
- }\r
- SQInteger oldtop = _top;\r
- SQInteger oldstackbase = _stackbase;\r
- _top = stackbase + nargs;\r
- CallInfo lci;\r
- lci._closure = nclosure;\r
- lci._generator = NULL;\r
- lci._etraps = 0;\r
- lci._prevstkbase = (SQInt32) (stackbase - _stackbase);\r
- lci._ncalls = 1;\r
- lci._prevtop = (SQInt32) (oldtop - oldstackbase);\r
- PUSH_CALLINFO(this, lci);\r
- _stackbase = stackbase;\r
- //push free variables\r
- SQInteger outers = nclosure->_outervalues.size();\r
+\r
+ if(!EnterFrame(newbase, newtop, false)) return false;\r
+ ci->_closure = nclosure;\r
+\r
+ SQInteger outers = nclosure->_noutervalues;\r
for (SQInteger i = 0; i < outers; i++) {\r
- Push(nclosure->_outervalues[i]);\r
+ _stack._vals[newbase+nargs+i] = nclosure->_outervalues[i];\r
}\r
-\r
- if(type(nclosure->_env) == OT_WEAKREF) {\r
- _stack[stackbase] = _weakref(nclosure->_env)->_obj;\r
+ if(nclosure->_env) {\r
+ _stack._vals[newbase] = nclosure->_env->_obj;\r
}\r
\r
- \r
+ _nnativecalls++;\r
SQInteger ret = (nclosure->_function)(this);\r
_nnativecalls--;\r
+\r
suspend = false;\r
- if( ret == SQ_SUSPEND_FLAG) suspend = true;\r
- else if (ret < 0) { \r
- _stackbase = oldstackbase;\r
- _top = oldtop;\r
- POP_CALLINFO(this);\r
+ if (ret == SQ_SUSPEND_FLAG) {\r
+ suspend = true;\r
+ }\r
+ else if (ret < 0) {\r
+ LeaveFrame();\r
Raise_Error(_lasterror);\r
return false;\r
}\r
- \r
- if (ret != 0){ retval = TOP(); TOP().Null(); }\r
- else { retval = _null_; }\r
- _stackbase = oldstackbase;\r
- _top = oldtop;\r
- POP_CALLINFO(this);\r
+ if(ret) {\r
+ retval = _stack._vals[_top-1];\r
+ }\r
+ else {\r
+ retval.Null();\r
+ }\r
+ //retval = ret ? _stack._vals[_top-1] : _null_;\r
+ LeaveFrame();\r
return true;\r
}\r
\r
-bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, bool fetchroot)\r
+#define FALLBACK_OK 0\r
+#define FALLBACK_NO_MATCH 1\r
+#define FALLBACK_ERROR 2\r
+\r
+bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, SQInteger selfidx)\r
{\r
switch(type(self)){\r
case OT_TABLE:\r
if(_table(self)->Get(key,dest))return true;\r
break;\r
case OT_ARRAY:\r
- if(sq_isnumeric(key)){\r
- return _array(self)->Get(tointeger(key),dest);\r
- }\r
+ if(sq_isnumeric(key)) { if(_array(self)->Get(tointeger(key),dest)) { return true; } Raise_IdxError(key); return false; }\r
break;\r
case OT_INSTANCE:\r
if(_instance(self)->Get(key,dest)) return true;\r
break;\r
+ case OT_CLASS: \r
+ if(_class(self)->Get(key,dest)) return true;\r
+ break;\r
+ case OT_STRING:\r
+ if(sq_isnumeric(key)){\r
+ SQInteger n = tointeger(key);\r
+ if(abs((int)n) < _string(self)->_len) {\r
+ if(n < 0) n = _string(self)->_len - n;\r
+ dest = SQInteger(_stringval(self)[n]);\r
+ return true;\r
+ }\r
+ Raise_IdxError(key);\r
+ return false;\r
+ }\r
+ break;\r
default:break; //shut up compiler\r
}\r
- if(FallBackGet(self,key,dest,raw)) return true;\r
-\r
- if(fetchroot) {\r
- if(_rawval(STK(0)) == _rawval(self) &&\r
- type(STK(0)) == type(self)) {\r
- return _table(_roottable)->Get(key,dest);\r
+ if(!raw) {\r
+ switch(FallBackGet(self,key,dest)) {\r
+ case FALLBACK_OK: return true; //okie\r
+ case FALLBACK_NO_MATCH: break; //keep falling back\r
+ case FALLBACK_ERROR: return false; // the metamethod failed\r
+ }\r
+ if(InvokeDefaultDelegate(self,key,dest)) {\r
+ return true;\r
}\r
}\r
+//#ifdef ROOT_FALLBACK\r
+ if(selfidx == 0) {\r
+ if(_table(_roottable)->Get(key,dest)) return true;\r
+ }\r
+//#endif\r
+ Raise_IdxError(key);\r
return false;\r
}\r
\r
-bool SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw)\r
+bool SQVM::InvokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest)\r
+{\r
+ SQTable *ddel = NULL;\r
+ switch(type(self)) {\r
+ case OT_CLASS: ddel = _class_ddel; break;\r
+ case OT_TABLE: ddel = _table_ddel; break;\r
+ case OT_ARRAY: ddel = _array_ddel; break;\r
+ case OT_STRING: ddel = _string_ddel; break;\r
+ case OT_INSTANCE: ddel = _instance_ddel; break;\r
+ case OT_INTEGER:case OT_FLOAT:case OT_BOOL: ddel = _number_ddel; break;\r
+ case OT_GENERATOR: ddel = _generator_ddel; break;\r
+ case OT_CLOSURE: case OT_NATIVECLOSURE: ddel = _closure_ddel; break;\r
+ case OT_THREAD: ddel = _thread_ddel; break;\r
+ case OT_WEAKREF: ddel = _weakref_ddel; break;\r
+ default: return false;\r
+ }\r
+ return ddel->Get(key,dest);\r
+}\r
+\r
+\r
+SQInteger SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest)\r
{\r
switch(type(self)){\r
- case OT_CLASS: \r
- return _class(self)->Get(key,dest);\r
- break;\r
case OT_TABLE:\r
case OT_USERDATA:\r
//delegation\r
if(_delegable(self)->_delegate) {\r
- if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,raw,false))\r
- return true; \r
- if(raw)return false;\r
- Push(self);Push(key);\r
- if(CallMetaMethod(_delegable(self),MT_GET,2,dest))\r
- return true;\r
+ if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,false,DONT_FALL_BACK)) return FALLBACK_OK; \r
}\r
- if(type(self) == OT_TABLE) {\r
- if(raw) return false;\r
- return _table_ddel->Get(key,dest);\r
+ else {\r
+ return FALLBACK_NO_MATCH;\r
}\r
- return false;\r
- break;\r
- case OT_ARRAY:\r
- if(raw)return false;\r
- return _array_ddel->Get(key,dest);\r
- case OT_STRING:\r
- if(sq_isnumeric(key)){\r
- SQInteger n=tointeger(key);\r
- if(abs((int)n)<_string(self)->_len){\r
- if(n<0)n=_string(self)->_len-n;\r
- dest=SQInteger(_stringval(self)[n]);\r
- return true;\r
+ //go through\r
+ case OT_INSTANCE: {\r
+ SQObjectPtr closure;\r
+ if(_delegable(self)->GetMetaMethod(this, MT_GET, closure)) {\r
+ Push(self);Push(key);\r
+ _nmetamethodscall++;\r
+ AutoDec ad(&_nmetamethodscall);\r
+ if(Call(closure, 2, _top - 2, dest, SQFalse)) {\r
+ Pop(2);\r
+ return FALLBACK_OK;\r
+ }\r
+ else {\r
+ Pop(2);\r
+ if(type(_lasterror) != OT_NULL) { //NULL means "clean failure" (not found)\r
+ return FALLBACK_ERROR;\r
+ }\r
}\r
- return false;\r
- }\r
- else {\r
- if(raw)return false;\r
- return _string_ddel->Get(key,dest);\r
}\r
+ }\r
break;\r
- case OT_INSTANCE:\r
- if(raw)return false;\r
- Push(self);Push(key);\r
- if(!CallMetaMethod(_delegable(self),MT_GET,2,dest)) {\r
- return _instance_ddel->Get(key,dest);\r
- }\r
- return true;\r
- case OT_INTEGER:case OT_FLOAT:case OT_BOOL: \r
- if(raw)return false;\r
- return _number_ddel->Get(key,dest);\r
- case OT_GENERATOR: \r
- if(raw)return false;\r
- return _generator_ddel->Get(key,dest);\r
- case OT_CLOSURE: case OT_NATIVECLOSURE: \r
- if(raw)return false;\r
- return _closure_ddel->Get(key,dest);\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
+ default: break;//shutup GCC 4.x\r
}\r
- return false;\r
+ // no metamethod or no fallback type\r
+ return FALLBACK_NO_MATCH;\r
}\r
\r
-bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool fetchroot)\r
+bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,SQInteger selfidx)\r
{\r
switch(type(self)){\r
case OT_TABLE:\r
- if(_table(self)->Set(key,val))\r
- return true;\r
- if(_table(self)->_delegate) {\r
- if(Set(_table(self)->_delegate,key,val,false)) {\r
- return true;\r
- }\r
- }\r
- //keeps going\r
- case OT_USERDATA:\r
- if(_delegable(self)->_delegate) {\r
- SQObjectPtr t;\r
- Push(self);Push(key);Push(val);\r
- if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;\r
- }\r
+ if(_table(self)->Set(key,val)) return true;\r
break;\r
- case OT_INSTANCE:{\r
- if(_instance(self)->Set(key,val))\r
- return true;\r
- SQObjectPtr t;\r
- Push(self);Push(key);Push(val);\r
- if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;\r
- }\r
+ case OT_INSTANCE:\r
+ if(_instance(self)->Set(key,val)) return true;\r
break;\r
case OT_ARRAY:\r
- if(!sq_isnumeric(key)) {Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); return false; }\r
- return _array(self)->Set(tointeger(key),val);\r
+ if(!sq_isnumeric(key)) { Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); return false; }\r
+ if(!_array(self)->Set(tointeger(key),val)) {\r
+ Raise_IdxError(key);\r
+ return false;\r
+ }\r
+ return true;\r
default:\r
Raise_Error(_SC("trying to set '%s'"),GetTypeName(self));\r
return false;\r
}\r
- if(fetchroot) {\r
- if(_rawval(STK(0)) == _rawval(self) &&\r
- type(STK(0)) == type(self)) {\r
- return _table(_roottable)->Set(key,val);\r
- }\r
+\r
+ switch(FallBackSet(self,key,val)) {\r
+ case FALLBACK_OK: return true; //okie\r
+ case FALLBACK_NO_MATCH: break; //keep falling back\r
+ case FALLBACK_ERROR: return false; // the metamethod failed\r
+ }\r
+ if(selfidx == 0) {\r
+ if(_table(_roottable)->Set(key,val))\r
+ return true;\r
}\r
+ Raise_IdxError(key);\r
return false;\r
}\r
\r
+SQInteger SQVM::FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val)\r
+{\r
+ switch(type(self)) {\r
+ case OT_TABLE:\r
+ if(_table(self)->_delegate) {\r
+ if(Set(_table(self)->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK;\r
+ }\r
+ //keps on going\r
+ case OT_INSTANCE:\r
+ case OT_USERDATA:{\r
+ SQObjectPtr closure;\r
+ SQObjectPtr t;\r
+ if(_delegable(self)->GetMetaMethod(this, MT_SET, closure)) {\r
+ Push(self);Push(key);Push(val);\r
+ _nmetamethodscall++;\r
+ AutoDec ad(&_nmetamethodscall);\r
+ if(Call(closure, 3, _top - 3, t, SQFalse)) {\r
+ Pop(3);\r
+ return FALLBACK_OK;\r
+ }\r
+ else {\r
+ if(type(_lasterror) != OT_NULL) { //NULL means "clean failure" (not found)\r
+ //error\r
+ Pop(3);\r
+ return FALLBACK_ERROR;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ default: break;//shutup GCC 4.x\r
+ }\r
+ // no metamethod or no fallback type\r
+ return FALLBACK_NO_MATCH;\r
+}\r
+\r
bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target)\r
{\r
SQObjectPtr temp_reg;\r
case OT_TABLE:\r
newobj = _table(self)->Clone();\r
goto cloned_mt;\r
- case OT_INSTANCE:\r
+ case OT_INSTANCE: {\r
newobj = _instance(self)->Clone(_ss(this));\r
cloned_mt:\r
- if(_delegable(newobj)->_delegate){\r
+ SQObjectPtr closure;\r
+ if(_delegable(newobj)->_delegate && _delegable(newobj)->GetMetaMethod(this,MT_CLONED,closure)) {\r
Push(newobj);\r
Push(self);\r
- CallMetaMethod(_delegable(newobj),MT_CLONED,2,temp_reg);\r
+ if(!CallMetaMethod(closure,MT_CLONED,2,temp_reg))\r
+ return false;\r
+ }\r
}\r
target = newobj;\r
return true;\r
case OT_ARRAY: \r
target = _array(self)->Clone();\r
return true;\r
- default: return false;\r
+ default: \r
+ Raise_Error(_SC("cloning a %s"), GetTypeName(self));\r
+ return false;\r
+ }\r
+}\r
+\r
+bool SQVM::NewSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,const SQObjectPtr &attrs,bool bstatic,bool raw)\r
+{\r
+ if(type(self) != OT_CLASS) {\r
+ Raise_Error(_SC("object must be a class"));\r
+ return false;\r
}\r
+ SQClass *c = _class(self);\r
+ if(!raw) {\r
+ SQObjectPtr &mm = c->_metamethods[MT_NEWMEMBER];\r
+ if(type(mm) != OT_NULL ) {\r
+ Push(self); Push(key); Push(val);\r
+ Push(attrs);\r
+ Push(bstatic);\r
+ return CallMetaMethod(mm,MT_NEWMEMBER,5,temp_reg);\r
+ }\r
+ }\r
+ if(!NewSlot(self, key, val,bstatic))\r
+ return false;\r
+ if(type(attrs) != OT_NULL) {\r
+ c->SetAttributes(key,attrs);\r
+ }\r
+ return true;\r
}\r
\r
bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic)\r
if(_table(self)->_delegate) {\r
SQObjectPtr res;\r
if(!_table(self)->Get(key,res)) {\r
- Push(self);Push(key);Push(val);\r
- rawcall = !CallMetaMethod(_table(self),MT_NEWSLOT,3,res);\r
+ SQObjectPtr closure;\r
+ if(_delegable(self)->_delegate && _delegable(self)->GetMetaMethod(this,MT_NEWSLOT,closure)) {\r
+ Push(self);Push(key);Push(val);\r
+ if(!CallMetaMethod(closure,MT_NEWSLOT,3,res)) {\r
+ return false;\r
+ }\r
+ rawcall = false;\r
+ }\r
+ else {\r
+ rawcall = true;\r
+ }\r
}\r
}\r
if(rawcall) _table(self)->NewSlot(key,val); //cannot fail\r
break;}\r
case OT_INSTANCE: {\r
SQObjectPtr res;\r
- Push(self);Push(key);Push(val);\r
- if(!CallMetaMethod(_instance(self),MT_NEWSLOT,3,res)) {\r
- Raise_Error(_SC("class instances do not support the new slot operator"));\r
- return false;\r
+ SQObjectPtr closure;\r
+ if(_delegable(self)->_delegate && _delegable(self)->GetMetaMethod(this,MT_NEWSLOT,closure)) {\r
+ Push(self);Push(key);Push(val);\r
+ if(!CallMetaMethod(closure,MT_NEWSLOT,3,res)) {\r
+ return false;\r
+ }\r
+ break;\r
}\r
+ Raise_Error(_SC("class instances do not support the new slot operator"));\r
+ return false;\r
break;}\r
case OT_CLASS: \r
if(!_class(self)->NewSlot(_ss(this),key,val,bstatic)) {\r
return true;\r
}\r
\r
+\r
+\r
bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res)\r
{\r
switch(type(self)) {\r
case OT_INSTANCE:\r
case OT_USERDATA: {\r
SQObjectPtr t;\r
- bool handled = false;\r
- if(_delegable(self)->_delegate) {\r
+ //bool handled = false;\r
+ SQObjectPtr closure;\r
+ if(_delegable(self)->_delegate && _delegable(self)->GetMetaMethod(this,MT_DELSLOT,closure)) {\r
Push(self);Push(key);\r
- handled = CallMetaMethod(_delegable(self),MT_DELSLOT,2,t);\r
+ return CallMetaMethod(closure,MT_DELSLOT,2,res);\r
}\r
-\r
- if(!handled) {\r
+ else {\r
if(type(self) == OT_TABLE) {\r
if(_table(self)->Get(key,t)) {\r
_table(self)->Remove(key);\r
#endif\r
switch(type(closure)) {\r
case OT_CLOSURE:\r
- return Execute(closure, _top - nparams, nparams, stackbase,outres,raiseerror);\r
+ return Execute(closure, nparams, stackbase, outres, raiseerror);\r
break;\r
case OT_NATIVECLOSURE:{\r
bool suspend;\r
return true;\r
}\r
\r
-bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,SQInteger nparams,SQObjectPtr &outres)\r
+bool SQVM::CallMetaMethod(SQObjectPtr &closure,SQMetaMethod mm,SQInteger nparams,SQObjectPtr &outres)\r
{\r
- SQObjectPtr closure;\r
- if(del->GetMetaMethod(this, mm, closure)) {\r
- if(Call(closure, nparams, _top - nparams, outres, SQFalse)) {\r
- Pop(nparams);\r
- return true;\r
- }\r
+ //SQObjectPtr closure;\r
+ \r
+ _nmetamethodscall++;\r
+ if(Call(closure, nparams, _top - nparams, outres, SQFalse)) {\r
+ _nmetamethodscall--;\r
+ Pop(nparams);\r
+ return true;\r
}\r
+ _nmetamethodscall--;\r
+ //}\r
Pop(nparams);\r
return false;\r
}\r
\r
+void SQVM::FindOuter(SQObjectPtr &target, SQObjectPtr *stackindex)\r
+{\r
+ SQOuter **pp = &_openouters;\r
+ SQOuter *p;\r
+ SQOuter *otr;\r
+\r
+ while ((p = *pp) != NULL && p->_valptr >= stackindex) {\r
+ if (p->_valptr == stackindex) {\r
+ target = SQObjectPtr(p);\r
+ return;\r
+ }\r
+ pp = &p->_next;\r
+ }\r
+ otr = SQOuter::Create(_ss(this), stackindex);\r
+ otr->_next = *pp;\r
+ otr->_idx = (stackindex - _stack._vals);\r
+ __ObjAddRef(otr);\r
+ *pp = otr;\r
+ target = SQObjectPtr(otr);\r
+}\r
+\r
+bool SQVM::EnterFrame(SQInteger newbase, SQInteger newtop, bool tailcall)\r
+{\r
+ if( !tailcall ) {\r
+ if( _callsstacksize == _alloccallsstacksize ) {\r
+ GrowCallStack();\r
+ }\r
+ ci = &_callsstack[_callsstacksize++];\r
+ ci->_prevstkbase = (SQInt32)(newbase - _stackbase);\r
+ ci->_prevtop = (SQInt32)(_top - _stackbase);\r
+ ci->_etraps = 0;\r
+ ci->_ncalls = 1;\r
+ ci->_generator = NULL;\r
+ ci->_root = SQFalse;\r
+ }\r
+ else {\r
+ ci->_ncalls++;\r
+ }\r
+\r
+ _stackbase = newbase;\r
+ _top = newtop;\r
+ if(newtop + MIN_STACK_OVERHEAD > (SQInteger)_stack.size()) {\r
+ if(_nmetamethodscall) {\r
+ Raise_Error(_SC("stack overflow, cannot resize stack while in a metamethod"));\r
+ return false;\r
+ }\r
+ _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD << 2));\r
+ RelocateOuters();\r
+ }\r
+ return true;\r
+}\r
+\r
+void SQVM::LeaveFrame() {\r
+ SQInteger last_top = _top;\r
+ SQInteger last_stackbase = _stackbase;\r
+ SQInteger css = --_callsstacksize;\r
+\r
+ /* First clean out the call stack frame */\r
+ ci->_closure.Null();\r
+ _stackbase -= ci->_prevstkbase;\r
+ _top = _stackbase + ci->_prevtop;\r
+ ci = (css) ? &_callsstack[css-1] : NULL;\r
+\r
+ if(_openouters) CloseOuters(&(_stack._vals[last_stackbase]));\r
+ while (last_top >= _top) {\r
+ _stack._vals[last_top--].Null();\r
+ }\r
+}\r
+\r
+void SQVM::RelocateOuters()\r
+{\r
+ SQOuter *p = _openouters;\r
+ while (p) {\r
+ p->_valptr = _stack._vals + p->_idx;\r
+ p = p->_next;\r
+ }\r
+}\r
+\r
+void SQVM::CloseOuters(SQObjectPtr *stackindex) {\r
+ SQOuter *p;\r
+ while ((p = _openouters) != NULL && p->_valptr >= stackindex) {\r
+ p->_value = *(p->_valptr);\r
+ p->_valptr = &p->_value;\r
+ _openouters = p->_next;\r
+ __ObjRelease(p);\r
+ }\r
+}\r
+\r
void SQVM::Remove(SQInteger n) {\r
n = (n >= 0)?n + _stackbase - 1:_top + n;\r
for(SQInteger i = n; i < _top; i++){\r
_stack[i] = _stack[i+1];\r
}\r
- _stack[_top] = _null_;\r
+ _stack[_top].Null();\r
_top--;\r
}\r
\r
void SQVM::Pop() {\r
- _stack[--_top] = _null_;\r
+ _stack[--_top].Null();\r
}\r
\r
void SQVM::Pop(SQInteger n) {\r
for(SQInteger i = 0; i < n; i++){\r
- _stack[--_top] = _null_;\r
+ _stack[--_top].Null();\r
}\r
}\r
\r
+void SQVM::PushNull() { _stack[_top++].Null(); }\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
projects / supertux.git / blobdiff