00001
00002
00003
00004 #include <squirrel.h>
00005 #include "sqpcheader.h"
00006 #include <math.h>
00007 #include <stdlib.h>
00008 #include "sqopcodes.h"
00009 #include "sqfuncproto.h"
00010 #include "sqvm.h"
00011 #include "sqclosure.h"
00012 #include "sqstring.h"
00013 #include "sqtable.h"
00014 #include "squserdata.h"
00015 #include "sqarray.h"
00016 #include "sqclass.h"
00017
00018 #define TOP() (_stack._vals[_top-1])
00019
00020 bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
00021 {
00022 SQInteger res;
00023 SQInteger i1 = _integer(o1), i2 = _integer(o2);
00024 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))
00025 {
00026 switch(op) {
00027 case BW_AND: res = i1 & i2; break;
00028 case BW_OR: res = i1 | i2; break;
00029 case BW_XOR: res = i1 ^ i2; break;
00030 case BW_SHIFTL: res = i1 << i2; break;
00031 case BW_SHIFTR: res = i1 >> i2; break;
00032 case BW_USHIFTR:res = (SQInteger)(*((SQUnsignedInteger*)&i1) >> i2); break;
00033 default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; }
00034 }
00035 }
00036 else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),GetTypeName(o1),GetTypeName(o2)); return false;}
00037 trg = res;
00038 return true;
00039 }
00040
00041 bool SQVM::ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
00042 {
00043 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
00044 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER)) {
00045 SQInteger res, i1 = _integer(o1), i2 = _integer(o2);
00046 switch(op) {
00047 case '+': res = i1 + i2; break;
00048 case '-': res = i1 - i2; break;
00049 case '/': if(i2 == 0) { Raise_Error(_SC("division by zero")); return false; }
00050 res = i1 / i2;
00051 break;
00052 case '*': res = i1 * i2; break;
00053 case '%': res = i1 % i2; break;
00054 default: res = 0xDEADBEEF;
00055 }
00056 trg = res;
00057 }else{
00058 SQFloat res, f1 = tofloat(o1), f2 = tofloat(o2);
00059 switch(op) {
00060 case '+': res = f1 + f2; break;
00061 case '-': res = f1 - f2; break;
00062 case '/': res = f1 / f2; break;
00063 case '*': res = f1 * f2; break;
00064 case '%': res = SQFloat(fmod((double)f1,(double)f2)); break;
00065 default: res = 0x0f;
00066 }
00067 trg = res;
00068 }
00069 } else {
00070 if(op == '+' && (type(o1) == OT_STRING || type(o2) == OT_STRING)){
00071 if(!StringCat(o1, o2, trg)) return false;
00072 }
00073 else if(!ArithMetaMethod(op,o1,o2,trg)) {
00074 Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,GetTypeName(o1),GetTypeName(o2)); return false;
00075 }
00076 }
00077 return true;
00078 }
00079
00080 SQVM::SQVM(SQSharedState *ss)
00081 {
00082 _sharedstate=ss;
00083 _suspended = SQFalse;
00084 _suspended_target=-1;
00085 _suspended_root = SQFalse;
00086 _suspended_traps=0;
00087 _foreignptr=NULL;
00088 _nnativecalls=0;
00089 _lasterror = _null_;
00090 _errorhandler = _null_;
00091 _debughook = _null_;
00092 _can_suspend = false;
00093 _ops_till_suspend = 0;
00094 ci = NULL;
00095 INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);
00096 }
00097
00098 void SQVM::Finalize()
00099 {
00100 _roottable = _null_;
00101 _lasterror = _null_;
00102 _errorhandler = _null_;
00103 _debughook = _null_;
00104 temp_reg = _null_;
00105 _callstackdata.resize(0);
00106 SQInteger size=_stack.size();
00107 for(SQInteger i=size - 1;i>=0;i--)
00108 _stack[i]=_null_;
00109 }
00110
00111 SQVM::~SQVM()
00112 {
00113 Finalize();
00114
00115 REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
00116 }
00117
00118 bool SQVM::ArithMetaMethod(SQInteger op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)
00119 {
00120 SQMetaMethod mm;
00121 switch(op){
00122 case _SC('+'): mm=MT_ADD; break;
00123 case _SC('-'): mm=MT_SUB; break;
00124 case _SC('/'): mm=MT_DIV; break;
00125 case _SC('*'): mm=MT_MUL; break;
00126 case _SC('%'): mm=MT_MODULO; break;
00127 default: mm = MT_ADD; assert(0); break;
00128 }
00129 if(is_delegable(o1) && _delegable(o1)->_delegate) {
00130 Push(o1);Push(o2);
00131 return CallMetaMethod(_delegable(o1),mm,2,dest);
00132 }
00133 return false;
00134 }
00135
00136 bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
00137 {
00138
00139 switch(type(o)) {
00140 case OT_INTEGER:
00141 trg = -_integer(o);
00142 return true;
00143 case OT_FLOAT:
00144 trg = -_float(o);
00145 return true;
00146 case OT_TABLE:
00147 case OT_USERDATA:
00148 case OT_INSTANCE:
00149 if(_delegable(o)->_delegate) {
00150 Push(o);
00151 if(CallMetaMethod(_delegable(o), MT_UNM, 1, temp_reg)) {
00152 trg = temp_reg;
00153 return true;
00154 }
00155 }
00156 default:break;
00157 }
00158 Raise_Error(_SC("attempt to negate a %s"), GetTypeName(o));
00159 return false;
00160 }
00161
00162 #define _RET_SUCCEED(exp) { result = (exp); return true; }
00163 bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result)
00164 {
00165 if(type(o1)==type(o2)){
00166 if(_userpointer(o1)==_userpointer(o2))_RET_SUCCEED(0);
00167 SQObjectPtr res;
00168 switch(type(o1)){
00169 case OT_STRING:
00170 _RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2)));
00171 case OT_INTEGER:
00172 _RET_SUCCEED(_integer(o1)-_integer(o2));
00173 case OT_FLOAT:
00174 _RET_SUCCEED((_float(o1)<_float(o2))?-1:1);
00175 case OT_TABLE:
00176 case OT_USERDATA:
00177 case OT_INSTANCE:
00178 if(_delegable(o1)->_delegate) {
00179 Push(o1);Push(o2);
00180 if(CallMetaMethod(_delegable(o1),MT_CMP,2,res)) break;
00181 }
00182
00183 default:
00184 _RET_SUCCEED( _userpointer(o1) < _userpointer(o2)?-1:1 );
00185 }
00186 if(type(res)!=OT_INTEGER) { Raise_CompareError(o1,o2); return false; }
00187 _RET_SUCCEED(_integer(res));
00188
00189 }
00190 else{
00191 if(sq_isnumeric(o1) && sq_isnumeric(o2)){
00192 if((type(o1)==OT_INTEGER) && (type(o2)==OT_FLOAT)) {
00193 if( _integer(o1)==_float(o2) ) { _RET_SUCCEED(0); }
00194 else if( _integer(o1)<_float(o2) ) { _RET_SUCCEED(-1); }
00195 _RET_SUCCEED(1);
00196 }
00197 else{
00198 if( _float(o1)==_integer(o2) ) { _RET_SUCCEED(0); }
00199 else if( _float(o1)<_integer(o2) ) { _RET_SUCCEED(-1); }
00200 _RET_SUCCEED(1);
00201 }
00202 }
00203 else if(type(o1)==OT_NULL) {_RET_SUCCEED(-1);}
00204 else if(type(o2)==OT_NULL) {_RET_SUCCEED(1);}
00205 else { Raise_CompareError(o1,o2); return false; }
00206
00207 }
00208 assert(0);
00209 _RET_SUCCEED(0);
00210 }
00211
00212 bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)
00213 {
00214 SQInteger r;
00215 if(ObjCmp(o1,o2,r)) {
00216 switch(op) {
00217 case CMP_G: res = (r > 0)?_true_:_false_; return true;
00218 case CMP_GE: res = (r >= 0)?_true_:_false_; return true;
00219 case CMP_L: res = (r < 0)?_true_:_false_; return true;
00220 case CMP_LE: res = (r <= 0)?_true_:_false_; return true;
00221
00222 }
00223 assert(0);
00224 }
00225 return false;
00226 }
00227
00228 void SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res)
00229 {
00230 switch(type(o)) {
00231 case OT_STRING:
00232 res = o;
00233 return;
00234 case OT_FLOAT:
00235 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%g"),_float(o));
00236 break;
00237 case OT_INTEGER:
00238 #if defined(_SQ64)
00239 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%ld"),_integer(o));
00240 #else
00241 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%d"),_integer(o));
00242 #endif
00243 break;
00244 case OT_BOOL:
00245 scsprintf(_sp(rsl(6)),_integer(o)?_SC("true"):_SC("false"));
00246 break;
00247 case OT_TABLE:
00248 case OT_USERDATA:
00249 case OT_INSTANCE:
00250 if(_delegable(o)->_delegate) {
00251 Push(o);
00252 if(CallMetaMethod(_delegable(o),MT_TOSTRING,1,res)) {
00253 if(type(res) == OT_STRING)
00254 return;
00255
00256 }
00257 }
00258 default:
00259 scsprintf(_sp(rsl(sizeof(void*)+20)),_SC("(%s : 0x%p)"),GetTypeName(o),(void*)_rawval(o));
00260 }
00261 res = SQString::Create(_ss(this),_spval);
00262 }
00263
00264
00265 bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)
00266 {
00267 SQObjectPtr a, b;
00268 ToString(str, a);
00269 ToString(obj, b);
00270 SQInteger l = _string(a)->_len , ol = _string(b)->_len;
00271 SQChar *s = _sp(rsl(l + ol + 1));
00272 memcpy(s, _stringval(a), rsl(l));
00273 memcpy(s + l, _stringval(b), rsl(ol));
00274 dest = SQString::Create(_ss(this), _spval, l + ol);
00275 return true;
00276 }
00277
00278 void SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
00279 {
00280 if(is_delegable(obj1) && _delegable(obj1)->_delegate) {
00281 Push(obj1);
00282 if(CallMetaMethod(_delegable(obj1),MT_TYPEOF,1,dest))
00283 return;
00284 }
00285 dest = SQString::Create(_ss(this),GetTypeName(obj1));
00286 }
00287
00288 bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)
00289 {
00290 _stack.resize(stacksize);
00291
00292 _alloccallsstacksize = 4;
00293 _callstackdata.resize(_alloccallsstacksize);
00294 _callsstacksize = 0;
00295 _callsstack = &_callstackdata[0];
00296
00297 _stackbase = 0;
00298 _top = 0;
00299 if(!friendvm)
00300 _roottable = SQTable::Create(_ss(this), 0);
00301 else {
00302 _roottable = friendvm->_roottable;
00303 _errorhandler = friendvm->_errorhandler;
00304 _debughook = friendvm->_debughook;
00305 }
00306
00307 sq_base_register(this);
00308 return true;
00309 }
00310
00311 extern SQInstructionDesc g_InstrDesc[];
00312
00313 bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQInteger stackbase,bool tailcall)
00314 {
00315 SQFunctionProto *func = _funcproto(closure->_function);
00316
00317 const SQInteger paramssize = func->_nparameters;
00318 const SQInteger newtop = stackbase + func->_stacksize;
00319 SQInteger nargs = args;
00320 if (paramssize != nargs) {
00321 SQInteger ndef = func->_ndefaultparams;
00322 if(ndef && nargs < paramssize) {
00323 SQInteger diff = paramssize - nargs;
00324 for(SQInteger n = ndef - diff; n < ndef; n++) {
00325 _stack._vals[stackbase + (nargs++)] = closure->_defaultparams[n];
00326 }
00327 }
00328 else if(func->_varparams)
00329 {
00330 if (nargs < paramssize) {
00331 Raise_Error(_SC("wrong number of parameters"));
00332 return false;
00333 }
00334 for(SQInteger n = 0; n < nargs - paramssize; n++) {
00335 _vargsstack.push_back(_stack._vals[stackbase+paramssize+n]);
00336 _stack._vals[stackbase+paramssize+n] = _null_;
00337 }
00338 }
00339 else {
00340 Raise_Error(_SC("wrong number of parameters"));
00341 return false;
00342 }
00343 }
00344
00345 if(type(closure->_env) == OT_WEAKREF) {
00346 _stack._vals[stackbase] = _weakref(closure->_env)->_obj;
00347 }
00348
00349 if (!tailcall) {
00350 CallInfo lc;
00351 memset(&lc, 0, sizeof(lc));
00352 lc._generator = NULL;
00353 lc._etraps = 0;
00354 lc._prevstkbase = (SQInt32) ( stackbase - _stackbase );
00355 lc._target = (SQInt32) target;
00356 lc._prevtop = (SQInt32) (_top - _stackbase);
00357 lc._ncalls = 1;
00358 lc._root = SQFalse;
00359 PUSH_CALLINFO(this, lc);
00360 }
00361 else {
00362 ci->_ncalls++;
00363 }
00364 ci->_vargs.size = (SQInt32)(nargs - paramssize);
00365 ci->_vargs.base = (SQInt32)(_vargsstack.size()-(ci->_vargs.size));
00366 ci->_closure = closure;
00367 ci->_literals = func->_literals;
00368 ci->_ip = func->_instructions;
00369
00370 if (((SQUnsignedInteger)newtop + (func->_stacksize<<1)) > _stack.size()) {
00371 _stack.resize(_stack.size() + (func->_stacksize<<1));
00372 }
00373
00374 _top = newtop;
00375 _stackbase = stackbase;
00376 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
00377 CallDebugHook(_SC('c'));
00378 return true;
00379 }
00380
00381 bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval)
00382 {
00383 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
00384 for(SQInteger i=0;i<ci->_ncalls;i++)
00385 CallDebugHook(_SC('r'));
00386
00387 SQBool broot = ci->_root;
00388 SQInteger last_top = _top;
00389 SQInteger target = ci->_target;
00390 SQInteger oldstackbase = _stackbase;
00391 _stackbase -= ci->_prevstkbase;
00392 _top = _stackbase + ci->_prevtop;
00393 if(ci->_vargs.size) PopVarArgs(ci->_vargs);
00394 POP_CALLINFO(this);
00395 if (broot) {
00396 if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack._vals[oldstackbase+_arg1];
00397 else retval = _null_;
00398 }
00399 else {
00400 if(target != -1) {
00401 if (_arg0 != MAX_FUNC_STACKSIZE)
00402 STK(target) = _stack._vals[oldstackbase+_arg1];
00403 else
00404 STK(target) = _null_;
00405 }
00406 }
00407
00408 while (last_top > oldstackbase) _stack._vals[last_top--].Null();
00409 assert(oldstackbase >= _stackbase);
00410 return broot?true:false;
00411 }
00412
00413 #define _RET_ON_FAIL(exp) { if(!exp) return false; }
00414
00415 bool SQVM::LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
00416 {
00417 _RET_ON_FAIL(ARITH_OP( op , target, a, incr));
00418 a = target;
00419 return true;
00420 }
00421
00422 bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
00423 {
00424 SQObjectPtr trg;
00425 _RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
00426 target = a;
00427 a = trg;
00428 return true;
00429 }
00430
00431 bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)
00432 {
00433 SQObjectPtr tmp, tself = self, tkey = key;
00434 if (!Get(tself, tkey, tmp, false, true)) { Raise_IdxError(tkey); return false; }
00435 _RET_ON_FAIL(ARITH_OP( op , target, tmp, incr))
00436 Set(tself, tkey, target,true);
00437 if (postfix) target = tmp;
00438 return true;
00439 }
00440
00441 #define arg0 (_i_._arg0)
00442 #define arg1 (_i_._arg1)
00443 #define sarg1 (*((SQInt32 *)&_i_._arg1))
00444 #define arg2 (_i_._arg2)
00445 #define arg3 (_i_._arg3)
00446 #define sarg3 ((SQInteger)*((signed char *)&_i_._arg3))
00447
00448 SQRESULT SQVM::Suspend()
00449 {
00450 if (_suspended)
00451 return sq_throwerror(this, _SC("cannot suspend an already suspended vm"));
00452 if (_nnativecalls!=2)
00453 return sq_throwerror(this, _SC("cannot suspend through native calls/metamethods"));
00454 return SQ_SUSPEND_FLAG;
00455 }
00456
00457 void SQVM::PopVarArgs(VarArgs &vargs)
00458 {
00459 for(SQInteger n = 0; n< vargs.size; n++)
00460 _vargsstack.pop_back();
00461 }
00462
00463 #define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; }
00464 bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
00465 &o3,SQObjectPtr &o4,SQInteger arg_2,int exitpos,int &jump)
00466 {
00467 SQInteger nrefidx;
00468 switch(type(o1)) {
00469 case OT_TABLE:
00470 if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(exitpos);
00471 o4 = (SQInteger)nrefidx; _FINISH(1);
00472 case OT_ARRAY:
00473 if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(exitpos);
00474 o4 = (SQInteger) nrefidx; _FINISH(1);
00475 case OT_STRING:
00476 if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
00477 o4 = (SQInteger)nrefidx; _FINISH(1);
00478 case OT_CLASS:
00479 if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
00480 o4 = (SQInteger)nrefidx; _FINISH(1);
00481 case OT_USERDATA:
00482 case OT_INSTANCE:
00483 if(_delegable(o1)->_delegate) {
00484 SQObjectPtr itr;
00485 Push(o1);
00486 Push(o4);
00487 if(CallMetaMethod(_delegable(o1), MT_NEXTI, 2, itr)){
00488 o4 = o2 = itr;
00489 if(type(itr) == OT_NULL) _FINISH(exitpos);
00490 if(!Get(o1, itr, o3, false,false)) {
00491 Raise_Error(_SC("_nexti returned an invalid idx"));
00492 return false;
00493 }
00494 _FINISH(1);
00495 }
00496 Raise_Error(_SC("_nexti failed"));
00497 return false;
00498 }
00499 break;
00500 case OT_GENERATOR:
00501 if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(exitpos);
00502 if(_generator(o1)->_state == SQGenerator::eSuspended) {
00503 SQInteger idx = 0;
00504 if(type(o4) == OT_INTEGER) {
00505 idx = _integer(o4) + 1;
00506 }
00507 o2 = idx;
00508 o4 = idx;
00509 _generator(o1)->Resume(this, arg_2+1);
00510 _FINISH(0);
00511 }
00512 default:
00513 Raise_Error(_SC("cannot iterate %s"), GetTypeName(o1));
00514 }
00515 return false;
00516 }
00517
00518 bool SQVM::DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2)
00519 {
00520 if(type(o1) != OT_TABLE) { Raise_Error(_SC("delegating a '%s'"), GetTypeName(o1)); return false; }
00521 switch(type(o2)) {
00522 case OT_TABLE:
00523 if(!_table(o1)->SetDelegate(_table(o2))){
00524 Raise_Error(_SC("delegate cycle detected"));
00525 return false;
00526 }
00527 break;
00528 case OT_NULL:
00529 _table(o1)->SetDelegate(NULL);
00530 break;
00531 default:
00532 Raise_Error(_SC("using '%s' as delegate"), GetTypeName(o2));
00533 return false;
00534 break;
00535 }
00536 trg = o1;
00537 return true;
00538 }
00539 #define COND_LITERAL (arg3!=0?ci->_literals[arg1]:STK(arg1))
00540
00541 #define _GUARD(exp) { if(!exp) { Raise_Error(_lasterror); SQ_THROW();} }
00542
00543 #define SQ_THROW() { goto exception_trap; }
00544
00545 bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
00546 {
00547 SQInteger nouters;
00548 SQClosure *closure = SQClosure::Create(_ss(this), func);
00549 if((nouters = func->_noutervalues)) {
00550 closure->_outervalues.reserve(nouters);
00551 for(SQInteger i = 0; i<nouters; i++) {
00552 SQOuterVar &v = func->_outervalues[i];
00553 switch(v._type){
00554 case otSYMBOL:
00555 closure->_outervalues.push_back(_null_);
00556 if(!Get(_stack._vals[_stackbase], v._src, closure->_outervalues.top(), false,true))
00557 {Raise_IdxError(v._src); return false; }
00558 break;
00559 case otLOCAL:
00560 closure->_outervalues.push_back(_stack._vals[_stackbase+_integer(v._src)]);
00561 break;
00562 case otOUTER:
00563 closure->_outervalues.push_back(_closure(ci->_closure)->_outervalues[_integer(v._src)]);
00564 break;
00565 }
00566 }
00567 }
00568 SQInteger ndefparams;
00569 if((ndefparams = func->_ndefaultparams)) {
00570 closure->_defaultparams.reserve(ndefparams);
00571 for(SQInteger i = 0; i < ndefparams; i++) {
00572 SQInteger spos = func->_defaultparams[i];
00573 closure->_defaultparams.push_back(_stack._vals[_stackbase + spos]);
00574 }
00575 }
00576 target = closure;
00577 return true;
00578
00579 }
00580
00581 bool SQVM::GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &index,CallInfo *ci)
00582 {
00583 if(ci->_vargs.size == 0) {
00584 Raise_Error(_SC("the function doesn't have var args"));
00585 return false;
00586 }
00587 if(!sq_isnumeric(index)){
00588 Raise_Error(_SC("indexing 'vargv' with %s"),GetTypeName(index));
00589 return false;
00590 }
00591 SQInteger idx = tointeger(index);
00592 if(idx < 0 || idx >= ci->_vargs.size){ Raise_Error(_SC("vargv index out of range")); return false; }
00593 target = _vargsstack[ci->_vargs.base+idx];
00594 return true;
00595 }
00596
00597 bool SQVM::CLASS_OP(SQObjectPtr &target,SQInteger baseclass,SQInteger attributes)
00598 {
00599 SQClass *base = NULL;
00600 SQObjectPtr attrs;
00601 if(baseclass != -1) {
00602 if(type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { Raise_Error(_SC("trying to inherit from a %s"),GetTypeName(_stack._vals[_stackbase+baseclass])); return false; }
00603 base = _class(_stack._vals[_stackbase + baseclass]);
00604 }
00605 if(attributes != MAX_FUNC_STACKSIZE) {
00606 attrs = _stack._vals[_stackbase+attributes];
00607 }
00608 target = SQClass::Create(_ss(this),base);
00609 if(type(_class(target)->_metamethods[MT_INHERITED]) != OT_NULL) {
00610 int nparams = 2;
00611 SQObjectPtr ret;
00612 Push(target); Push(attrs);
00613 Call(_class(target)->_metamethods[MT_INHERITED],nparams,_top - nparams, ret, false, false);
00614 Pop(nparams);
00615 }
00616 _class(target)->_attributes = attrs;
00617 return true;
00618 }
00619
00620
00621
00622 bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)
00623 {
00624 if(type(o1) == type(o2)) {
00625 res = ((_userpointer(o1) == _userpointer(o2)?true:false));
00626 }
00627 else {
00628 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
00629 SQInteger cmpres;
00630 if(!ObjCmp(o1, o2,cmpres)) return false;
00631 res = (cmpres == 0);
00632 }
00633 else {
00634 res = false;
00635 }
00636 }
00637 return true;
00638 }
00639
00640 bool SQVM::IsFalse(SQObjectPtr &o)
00641 {
00642 if(((type(o) & SQOBJECT_CANBEFALSE) && ( (type(o) == OT_FLOAT) && (_float(o) == SQFloat(0.0)) ))
00643 || (_integer(o) == 0) ) {
00644 return true;
00645 }
00646 return false;
00647 }
00648
00649 bool SQVM::GETPARENT_OP(SQObjectPtr &o,SQObjectPtr &target)
00650 {
00651 switch(type(o)) {
00652 case OT_TABLE: target = _table(o)->_delegate?SQObjectPtr(_table(o)->_delegate):_null_;
00653 break;
00654 case OT_CLASS: target = _class(o)->_base?_class(o)->_base:_null_;
00655 break;
00656 default:
00657 Raise_Error(_SC("the %s type doesn't have a parent slot"), GetTypeName(o));
00658 return false;
00659 }
00660 return true;
00661 }
00662
00663 bool SQVM::Execute(SQObjectPtr &closure, SQInteger target, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et)
00664 {
00665 if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
00666 _nnativecalls++;
00667 AutoDec ad(&_nnativecalls);
00668 SQInteger traps = 0;
00669
00670 SQInteger ct_target;
00671 SQInteger ct_stackbase;
00672 bool ct_tailcall;
00673
00674 switch(et) {
00675 case ET_CALL:
00676 if(!StartCall(_closure(closure), _top - nargs, nargs, stackbase, false)) {
00677
00678 if(ci == NULL) CallErrorHandler(_lasterror);
00679 return false;
00680 }
00681 ci->_root = SQTrue;
00682 break;
00683 case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = SQTrue; traps += ci->_etraps; break;
00684 case ET_RESUME_VM:
00685 traps = _suspended_traps;
00686 ci->_root = _suspended_root;
00687 ci->_vargs = _suspend_varargs;
00688 _suspended = SQFalse;
00689 break;
00690 case ET_RESUME_OPENTTD:
00691 traps = _suspended_traps;
00692 _suspended = SQFalse;
00693 break;
00694 }
00695
00696 exception_restore:
00697
00698 {
00699 for(;;)
00700 {
00701 DecreaseOps(1);
00702 if (ShouldSuspend()) { _suspended = SQTrue; _suspended_traps = traps; return true; }
00703
00704 const SQInstruction &_i_ = *ci->_ip++;
00705
00706
00707 switch(_i_.op)
00708 {
00709 case _OP_LINE:
00710 if(type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
00711 CallDebugHook(_SC('l'),arg1);
00712 continue;
00713 case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;
00714 case _OP_LOADINT: TARGET = (SQInteger)arg1; continue;
00715 case _OP_LOADFLOAT: TARGET = *((SQFloat *)&arg1); continue;
00716 case _OP_DLOAD: TARGET = ci->_literals[arg1]; STK(arg2) = ci->_literals[arg3];continue;
00717 case _OP_TAILCALL:
00718 temp_reg = STK(arg1);
00719 if (type(temp_reg) == OT_CLOSURE){
00720 ct_tailcall = true;
00721 if(ci->_vargs.size) PopVarArgs(ci->_vargs);
00722 for (SQInteger i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);
00723 ct_target = ci->_target;
00724 ct_stackbase = _stackbase;
00725 goto common_call;
00726 }
00727 case _OP_CALL: {
00728 ct_tailcall = false;
00729 ct_target = arg0;
00730 temp_reg = STK(arg1);
00731 ct_stackbase = _stackbase+arg2;
00732
00733 common_call:
00734 SQObjectPtr clo = temp_reg;
00735 SQInteger last_top = _top;
00736 switch (type(clo)) {
00737 case OT_CLOSURE:{
00738 _GUARD(StartCall(_closure(clo), ct_target, arg3, ct_stackbase, ct_tailcall));
00739 if (_funcproto(_closure(clo)->_function)->_bgenerator) {
00740 SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(clo));
00741 _GUARD(gen->Yield(this));
00742 Return(1, ct_target, clo);
00743 STK(ct_target) = gen;
00744 while (last_top >= _top) _stack._vals[last_top--].Null();
00745 continue;
00746 }
00747 }
00748 continue;
00749 case OT_NATIVECLOSURE: {
00750 bool suspend;
00751 _suspended_target = ct_target;
00752 try {
00753 _GUARD(CallNative(_nativeclosure(clo), arg3, ct_stackbase, clo,suspend));
00754 } catch (...) {
00755 _suspended = SQTrue;
00756 _suspended_target = ct_target;
00757 _suspended_root = ci->_root;
00758 _suspended_traps = traps;
00759 _suspend_varargs = ci->_vargs;
00760 throw;
00761 }
00762 if(suspend){
00763 _suspended = SQTrue;
00764 _suspended_target = ct_target;
00765 _suspended_root = ci->_root;
00766 _suspended_traps = traps;
00767 _suspend_varargs = ci->_vargs;
00768 outres = clo;
00769 return true;
00770 }
00771 if(ct_target != -1) {
00772 STK(ct_target) = clo;
00773 }
00774 }
00775 continue;
00776 case OT_CLASS:{
00777 SQObjectPtr inst;
00778 _GUARD(CreateClassInstance(_class(clo),inst,temp_reg));
00779 STK(ct_target) = inst;
00780 ct_target = -1;
00781 if(type(temp_reg) != OT_NULL) {
00782 _stack._vals[ct_stackbase] = inst;
00783 goto common_call;
00784 }
00785 }
00786 break;
00787 case OT_TABLE:
00788 case OT_USERDATA:
00789 case OT_INSTANCE:
00790 {
00791 Push(clo);
00792 for (SQInteger i = 0; i < arg3; i++) Push(STK(arg2 + i));
00793 if (_delegable(clo) && CallMetaMethod(_delegable(clo), MT_CALL, arg3+1, clo)){
00794 STK(ct_target) = clo;
00795 break;
00796 }
00797 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo));
00798 SQ_THROW();
00799 }
00800 default:
00801 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo));
00802 SQ_THROW();
00803 }
00804 }
00805 continue;
00806 case _OP_PREPCALL:
00807 case _OP_PREPCALLK:
00808 {
00809 SQObjectPtr &key = _i_.op == _OP_PREPCALLK?(ci->_literals)[arg1]:STK(arg1);
00810 SQObjectPtr &o = STK(arg2);
00811 if (!Get(o, key, temp_reg,false,true)) {
00812 if(type(o) == OT_CLASS) {
00813 if(_class_ddel->Get(key,temp_reg)) {
00814 STK(arg3) = o;
00815 TARGET = temp_reg;
00816 continue;
00817 }
00818 }
00819 { Raise_IdxError(key); SQ_THROW();}
00820 }
00821
00822 STK(arg3) = type(o) == OT_CLASS?STK(0):o;
00823 TARGET = temp_reg;
00824 }
00825 continue;
00826 case _OP_SCOPE_END:
00827 {
00828 SQInteger from = arg0;
00829 SQInteger count = arg1 - arg0 + 2;
00830
00831
00832
00833 if (_stackbase + count + from <= _top) {
00834 while (--count >= 0) _stack._vals[_stackbase + count + from].Null();
00835 }
00836 } continue;
00837 case _OP_GETK:
00838 if (!Get(STK(arg2), ci->_literals[arg1], temp_reg, false,true)) { Raise_IdxError(ci->_literals[arg1]); SQ_THROW();}
00839 TARGET = temp_reg;
00840 continue;
00841 case _OP_MOVE: TARGET = STK(arg1); continue;
00842 case _OP_NEWSLOT:
00843 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),false));
00844 if(arg0 != arg3) TARGET = STK(arg3);
00845 continue;
00846 case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue;
00847 case _OP_SET:
00848 if (!Set(STK(arg1), STK(arg2), STK(arg3),true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
00849 if (arg0 != arg3) TARGET = STK(arg3);
00850 continue;
00851 case _OP_GET:
00852 if (!Get(STK(arg1), STK(arg2), temp_reg, false,true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
00853 TARGET = temp_reg;
00854 continue;
00855 case _OP_EQ:{
00856 bool res;
00857 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
00858 TARGET = res?_true_:_false_;
00859 }continue;
00860 case _OP_NE:{
00861 bool res;
00862 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
00863 TARGET = (!res)?_true_:_false_;
00864 } continue;
00865 case _OP_ARITH: _GUARD(ARITH_OP( arg3 , temp_reg, STK(arg2), STK(arg1))); TARGET = temp_reg; continue;
00866 case _OP_BITW: _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;
00867 case _OP_RETURN:
00868 if(ci->_generator) {
00869 ci->_generator->Kill();
00870 }
00871 if(Return(arg0, arg1, temp_reg)){
00872 assert(traps==0);
00873 outres = temp_reg;
00874 return true;
00875 }
00876 continue;
00877 case _OP_LOADNULLS:{ for(SQInt32 n=0; n < arg1; n++) STK(arg0+n) = _null_; }continue;
00878 case _OP_LOADROOTTABLE: TARGET = _roottable; continue;
00879 case _OP_LOADBOOL: TARGET = arg1?_true_:_false_; continue;
00880 case _OP_DMOVE: STK(arg0) = STK(arg1); STK(arg2) = STK(arg3); continue;
00881 case _OP_JMP: ci->_ip += (sarg1); continue;
00882 case _OP_JNZ: if(!IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
00883 case _OP_JZ: if(IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
00884 case _OP_LOADFREEVAR: TARGET = _closure(ci->_closure)->_outervalues[arg1]; continue;
00885 case _OP_VARGC: TARGET = SQInteger(ci->_vargs.size); continue;
00886 case _OP_GETVARGV:
00887 if(!GETVARGV_OP(TARGET,STK(arg1),ci)) { SQ_THROW(); }
00888 continue;
00889 case _OP_NEWTABLE: TARGET = SQTable::Create(_ss(this), arg1); continue;
00890 case _OP_NEWARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue;
00891 case _OP_APPENDARRAY: _array(STK(arg0))->Append(COND_LITERAL); continue;
00892 case _OP_GETPARENT: _GUARD(GETPARENT_OP(STK(arg1),TARGET)); continue;
00893 case _OP_COMPARITH: _GUARD(DerefInc(arg3, TARGET, STK((((SQUnsignedInteger)arg1&0xFFFF0000)>>16)), STK(arg2), STK(arg1&0x0000FFFF), false)); continue;
00894 case _OP_COMPARITHL: _GUARD(LOCAL_INC(arg3, TARGET, STK(arg1), STK(arg2))); continue;
00895 case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, false));} continue;
00896 case _OP_INCL: {SQObjectPtr o(sarg3); _GUARD(LOCAL_INC('+',TARGET, STK(arg1), o));} continue;
00897 case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, true));} continue;
00898 case _OP_PINCL: {SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o));} continue;
00899 case _OP_CMP: _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET)) continue;
00900 case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, true,false)?_true_:_false_;continue;
00901 case _OP_INSTANCEOF:
00902 if(type(STK(arg1)) != OT_CLASS || type(STK(arg2)) != OT_INSTANCE)
00903 {Raise_Error(_SC("cannot apply instanceof between a %s and a %s"),GetTypeName(STK(arg1)),GetTypeName(STK(arg2))); SQ_THROW();}
00904 TARGET = _instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?_true_:_false_;
00905 continue;
00906 case _OP_AND:
00907 if(IsFalse(STK(arg2))) {
00908 TARGET = STK(arg2);
00909 ci->_ip += (sarg1);
00910 }
00911 continue;
00912 case _OP_OR:
00913 if(!IsFalse(STK(arg2))) {
00914 TARGET = STK(arg2);
00915 ci->_ip += (sarg1);
00916 }
00917 continue;
00918 case _OP_NEG: _GUARD(NEG_OP(TARGET,STK(arg1))); continue;
00919 case _OP_NOT: TARGET = (IsFalse(STK(arg1))?_true_:_false_); continue;
00920 case _OP_BWNOT:
00921 if(type(STK(arg1)) == OT_INTEGER) {
00922 SQInteger t = _integer(STK(arg1));
00923 TARGET = SQInteger(~t);
00924 continue;
00925 }
00926 Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1)));
00927 SQ_THROW();
00928 case _OP_CLOSURE: {
00929 SQClosure *c = ci->_closure._unVal.pClosure;
00930 SQFunctionProto *fp = c->_function._unVal.pFunctionProto;
00931 if(!CLOSURE_OP(TARGET,fp->_functions[arg1]._unVal.pFunctionProto)) { SQ_THROW(); }
00932 continue;
00933 }
00934 case _OP_YIELD:{
00935 if(ci->_generator) {
00936 if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1);
00937 _GUARD(ci->_generator->Yield(this));
00938 traps -= ci->_etraps;
00939 if(sarg1 != MAX_FUNC_STACKSIZE) STK(arg1) = temp_reg;
00940 }
00941 else { Raise_Error(_SC("trying to yield a '%s',only genenerator can be yielded"), GetTypeName(ci->_closure)); SQ_THROW();}
00942 if(Return(arg0, arg1, temp_reg)){
00943 assert(traps == 0);
00944 outres = temp_reg;
00945 return true;
00946 }
00947
00948 }
00949 continue;
00950 case _OP_RESUME:
00951 if(type(STK(arg1)) != OT_GENERATOR){ Raise_Error(_SC("trying to resume a '%s',only genenerator can be resumed"), GetTypeName(STK(arg1))); SQ_THROW();}
00952 _GUARD(_generator(STK(arg1))->Resume(this, arg0));
00953 traps += ci->_etraps;
00954 continue;
00955 case _OP_FOREACH:{ int tojump;
00956 _GUARD(FOREACH_OP(STK(arg0),STK(arg2),STK(arg2+1),STK(arg2+2),arg2,sarg1,tojump));
00957 ci->_ip += tojump; }
00958 continue;
00959 case _OP_POSTFOREACH:
00960 assert(type(STK(arg0)) == OT_GENERATOR);
00961 if(_generator(STK(arg0))->_state == SQGenerator::eDead)
00962 ci->_ip += (sarg1 - 1);
00963 continue;
00964 case _OP_DELEGATE: _GUARD(DELEGATE_OP(TARGET,STK(arg1),STK(arg2))); continue;
00965 case _OP_CLONE:
00966 if(!Clone(STK(arg1), TARGET))
00967 { Raise_Error(_SC("cloning a %s"), GetTypeName(STK(arg1))); SQ_THROW();}
00968 continue;
00969 case _OP_TYPEOF: TypeOf(STK(arg1), TARGET); continue;
00970 case _OP_PUSHTRAP:{
00971 SQInstruction *_iv = _funcproto(_closure(ci->_closure)->_function)->_instructions;
00972 _etraps.push_back(SQExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++;
00973 ci->_etraps++;
00974 }
00975 continue;
00976 case _OP_POPTRAP: {
00977 for(SQInteger i = 0; i < arg0; i++) {
00978 _etraps.pop_back(); traps--;
00979 ci->_etraps--;
00980 }
00981 }
00982 continue;
00983 case _OP_THROW: Raise_Error(TARGET); SQ_THROW(); continue;
00984 case _OP_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;
00985 case _OP_NEWSLOTA:
00986 bool bstatic = (arg0&NEW_SLOT_STATIC_FLAG)?true:false;
00987 if(type(STK(arg1)) == OT_CLASS) {
00988 if(type(_class(STK(arg1))->_metamethods[MT_NEWMEMBER]) != OT_NULL ) {
00989 Push(STK(arg1)); Push(STK(arg2)); Push(STK(arg3));
00990 Push((arg0&NEW_SLOT_ATTRIBUTES_FLAG) ? STK(arg2-1) : _null_);
00991 int nparams = 4;
00992 if(Call(_class(STK(arg1))->_metamethods[MT_NEWMEMBER], nparams, _top - nparams, temp_reg,SQFalse,SQFalse)) {
00993 Pop(nparams);
00994 continue;
00995 }
00996 }
00997 }
00998 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),bstatic));
00999 if((arg0&NEW_SLOT_ATTRIBUTES_FLAG)) {
01000 _class(STK(arg1))->SetAttributes(STK(arg2),STK(arg2-1));
01001 }
01002 continue;
01003 }
01004
01005 }
01006 }
01007 exception_trap:
01008 {
01009 SQObjectPtr currerror = _lasterror;
01010
01011 SQInteger n = 0;
01012 SQInteger last_top = _top;
01013 if(ci) {
01014 if(_ss(this)->_notifyallexceptions) CallErrorHandler(currerror);
01015
01016 if(traps) {
01017 do {
01018 if(ci->_etraps > 0) {
01019 SQExceptionTrap &et = _etraps.top();
01020 ci->_ip = et._ip;
01021 _top = et._stacksize;
01022 _stackbase = et._stackbase;
01023 _stack._vals[_stackbase+et._extarget] = currerror;
01024 _etraps.pop_back(); traps--; ci->_etraps--;
01025 while(last_top >= _top) _stack._vals[last_top--].Null();
01026 goto exception_restore;
01027 }
01028
01029 if(type(ci->_closure) != OT_CLOSURE && n)
01030 break;
01031 if(ci->_generator) ci->_generator->Kill();
01032 PopVarArgs(ci->_vargs);
01033 POP_CALLINFO(this);
01034 n++;
01035 } while(_callsstacksize);
01036 }
01037 else {
01038
01039 if(raiseerror && !_ss(this)->_notifyallexceptions)
01040 CallErrorHandler(currerror);
01041 }
01042
01043 if(ci) do {
01044 SQBool exitafterthisone = ci->_root;
01045 if(ci->_generator) ci->_generator->Kill();
01046 _stackbase -= ci->_prevstkbase;
01047 _top = _stackbase + ci->_prevtop;
01048 PopVarArgs(ci->_vargs);
01049 POP_CALLINFO(this);
01050 if( (ci && type(ci->_closure) != OT_CLOSURE) || exitafterthisone) break;
01051 } while(_callsstacksize);
01052
01053 while(last_top >= _top) _stack._vals[last_top--].Null();
01054 }
01055 _lasterror = currerror;
01056 return false;
01057 }
01058 assert(0);
01059 }
01060
01061 bool SQVM::CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor)
01062 {
01063 inst = theclass->CreateInstance();
01064 if(!theclass->Get(_ss(this)->_constructoridx,constructor)) {
01065
01066
01067 constructor = _null_;
01068 }
01069 return true;
01070 }
01071
01072 void SQVM::CallErrorHandler(SQObjectPtr &error)
01073 {
01074 if(type(_errorhandler) != OT_NULL) {
01075 SQObjectPtr out;
01076 Push(_roottable); Push(error);
01077 Call(_errorhandler, 2, _top-2, out,SQFalse,SQFalse);
01078 Pop(2);
01079 }
01080 }
01081
01082 void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)
01083 {
01084 SQObjectPtr temp_reg;
01085 SQInteger nparams=5;
01086 SQFunctionProto *func=_funcproto(_closure(ci->_closure)->_function);
01087 Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);
01088 Call(_debughook,nparams,_top-nparams,temp_reg,SQFalse,SQFalse);
01089 Pop(nparams);
01090 }
01091
01092 bool SQVM::CallNative(SQNativeClosure *nclosure,SQInteger nargs,SQInteger stackbase,SQObjectPtr &retval,bool &suspend)
01093 {
01094 if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
01095 SQInteger nparamscheck = nclosure->_nparamscheck;
01096 if(((nparamscheck > 0) && (nparamscheck != nargs))
01097 || ((nparamscheck < 0) && (nargs < (-nparamscheck)))) {
01098 Raise_Error(_SC("wrong number of parameters"));
01099 return false;
01100 }
01101
01102 SQInteger tcs;
01103 if((tcs = nclosure->_typecheck.size())) {
01104 for(SQInteger i = 0; i < nargs && i < tcs; i++)
01105 if((nclosure->_typecheck._vals[i] != -1) && !(type(_stack._vals[stackbase+i]) & nclosure->_typecheck[i])) {
01106 Raise_ParamTypeError(i,nclosure->_typecheck._vals[i],type(_stack._vals[stackbase+i]));
01107 return false;
01108 }
01109 }
01110 _nnativecalls++;
01111 if ((_top + MIN_STACK_OVERHEAD) > (SQInteger)_stack.size()) {
01112 _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));
01113 }
01114 SQInteger oldtop = _top;
01115 SQInteger oldstackbase = _stackbase;
01116 _top = stackbase + nargs;
01117 CallInfo lci;
01118 memset(&lci, 0, sizeof(lci));
01119 lci._closure = nclosure;
01120 lci._generator = NULL;
01121 lci._etraps = 0;
01122 lci._prevstkbase = (SQInt32) (stackbase - _stackbase);
01123 lci._ncalls = 1;
01124 lci._prevtop = (SQInt32) (oldtop - oldstackbase);
01125 PUSH_CALLINFO(this, lci);
01126 _stackbase = stackbase;
01127
01128 SQInteger outers = nclosure->_outervalues.size();
01129 for (SQInteger i = 0; i < outers; i++) {
01130 Push(nclosure->_outervalues[i]);
01131 }
01132
01133 if(type(nclosure->_env) == OT_WEAKREF) {
01134 _stack[stackbase] = _weakref(nclosure->_env)->_obj;
01135 }
01136
01137
01138 SQInteger ret;
01139 try {
01140 SQBool can_suspend = this->_can_suspend;
01141 this->_can_suspend = false;
01142 ret = (nclosure->_function)(this);
01143 this->_can_suspend = can_suspend;
01144 } catch (...) {
01145 _nnativecalls--;
01146 suspend = false;
01147
01148 _stackbase = oldstackbase;
01149 _top = oldtop;
01150
01151 POP_CALLINFO(this);
01152
01153 while(oldtop > _stackbase + stackbase) _stack._vals[oldtop--].Null();
01154 throw;
01155 }
01156
01157 _nnativecalls--;
01158 suspend = false;
01159 if( ret == SQ_SUSPEND_FLAG) suspend = true;
01160 else if (ret < 0) {
01161 _stackbase = oldstackbase;
01162 _top = oldtop;
01163 POP_CALLINFO(this);
01164 while(oldtop > _stackbase + stackbase) _stack._vals[oldtop--].Null();
01165 Raise_Error(_lasterror);
01166 return false;
01167 }
01168
01169 if (ret != 0){ retval = TOP(); TOP().Null(); }
01170 else { retval = _null_; }
01171 _stackbase = oldstackbase;
01172 _top = oldtop;
01173 POP_CALLINFO(this);
01174 while(oldtop > _stackbase + stackbase) _stack._vals[oldtop--].Null();
01175 return true;
01176 }
01177
01178 bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, bool fetchroot)
01179 {
01180 switch(type(self)){
01181 case OT_TABLE:
01182 if(_table(self)->Get(key,dest))return true;
01183 break;
01184 case OT_ARRAY:
01185 if(sq_isnumeric(key)){
01186 return _array(self)->Get(tointeger(key),dest);
01187 }
01188 break;
01189 case OT_INSTANCE:
01190 if(_instance(self)->Get(key,dest)) return true;
01191 break;
01192 default:break;
01193 }
01194 if(FallBackGet(self,key,dest,raw)) return true;
01195
01196 if(fetchroot) {
01197 if(_rawval(STK(0)) == _rawval(self) &&
01198 type(STK(0)) == type(self)) {
01199 return _table(_roottable)->Get(key,dest);
01200 }
01201 }
01202 return false;
01203 }
01204
01205 bool SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw)
01206 {
01207 switch(type(self)){
01208 case OT_CLASS:
01209 return _class(self)->Get(key,dest);
01210 break;
01211 case OT_TABLE:
01212 case OT_USERDATA:
01213
01214 if(_delegable(self)->_delegate) {
01215 if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,raw,false))
01216 return true;
01217 if(raw)return false;
01218 Push(self);Push(key);
01219 if(CallMetaMethod(_delegable(self),MT_GET,2,dest))
01220 return true;
01221 }
01222 if(type(self) == OT_TABLE) {
01223 if(raw) return false;
01224 return _table_ddel->Get(key,dest);
01225 }
01226 return false;
01227 break;
01228 case OT_ARRAY:
01229 if(raw)return false;
01230 return _array_ddel->Get(key,dest);
01231 case OT_STRING:
01232 if(sq_isnumeric(key)){
01233 SQInteger n=tointeger(key);
01234 if(abs((int)n)<_string(self)->_len){
01235 if(n<0)n=_string(self)->_len-n;
01236 dest=SQInteger(_stringval(self)[n]);
01237 return true;
01238 }
01239 return false;
01240 }
01241 else {
01242 if(raw)return false;
01243 return _string_ddel->Get(key,dest);
01244 }
01245 break;
01246 case OT_INSTANCE:
01247 if(raw)return false;
01248 Push(self);Push(key);
01249 if(!CallMetaMethod(_delegable(self),MT_GET,2,dest)) {
01250 return _instance_ddel->Get(key,dest);
01251 }
01252 return true;
01253 case OT_INTEGER:case OT_FLOAT:case OT_BOOL:
01254 if(raw)return false;
01255 return _number_ddel->Get(key,dest);
01256 case OT_GENERATOR:
01257 if(raw)return false;
01258 return _generator_ddel->Get(key,dest);
01259 case OT_CLOSURE: case OT_NATIVECLOSURE:
01260 if(raw)return false;
01261 return _closure_ddel->Get(key,dest);
01262 case OT_THREAD:
01263 if(raw)return false;
01264 return _thread_ddel->Get(key,dest);
01265 case OT_WEAKREF:
01266 if(raw)return false;
01267 return _weakref_ddel->Get(key,dest);
01268 default:return false;
01269 }
01270 return false;
01271 }
01272
01273 bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool fetchroot)
01274 {
01275 switch(type(self)){
01276 case OT_TABLE:
01277 if(_table(self)->Set(key,val))
01278 return true;
01279 if(_table(self)->_delegate) {
01280 if(Set(_table(self)->_delegate,key,val,false)) {
01281 return true;
01282 }
01283 }
01284
01285 case OT_USERDATA:
01286 if(_delegable(self)->_delegate) {
01287 SQObjectPtr t;
01288 Push(self);Push(key);Push(val);
01289 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
01290 }
01291 break;
01292 case OT_INSTANCE:{
01293 if(_instance(self)->Set(key,val))
01294 return true;
01295 SQObjectPtr t;
01296 Push(self);Push(key);Push(val);
01297 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
01298 }
01299 break;
01300 case OT_ARRAY:
01301 if(!sq_isnumeric(key)) {Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); return false; }
01302 return _array(self)->Set(tointeger(key),val);
01303 default:
01304 Raise_Error(_SC("trying to set '%s'"),GetTypeName(self));
01305 return false;
01306 }
01307 if(fetchroot) {
01308 if(_rawval(STK(0)) == _rawval(self) &&
01309 type(STK(0)) == type(self)) {
01310 return _table(_roottable)->Set(key,val);
01311 }
01312 }
01313 return false;
01314 }
01315
01316 bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target)
01317 {
01318 SQObjectPtr temp_reg;
01319 SQObjectPtr newobj;
01320 switch(type(self)){
01321 case OT_TABLE:
01322 newobj = _table(self)->Clone();
01323 goto cloned_mt;
01324 case OT_INSTANCE:
01325 newobj = _instance(self)->Clone(_ss(this));
01326 cloned_mt:
01327 if(_delegable(newobj)->_delegate){
01328 Push(newobj);
01329 Push(self);
01330 CallMetaMethod(_delegable(newobj),MT_CLONED,2,temp_reg);
01331 }
01332 target = newobj;
01333 return true;
01334 case OT_ARRAY:
01335 target = _array(self)->Clone();
01336 return true;
01337 default: return false;
01338 }
01339 }
01340
01341 bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic)
01342 {
01343 if(type(key) == OT_NULL) { Raise_Error(_SC("null cannot be used as index")); return false; }
01344 switch(type(self)) {
01345 case OT_TABLE: {
01346 bool rawcall = true;
01347 if(_table(self)->_delegate) {
01348 SQObjectPtr res;
01349 if(!_table(self)->Get(key,res)) {
01350 Push(self);Push(key);Push(val);
01351 rawcall = !CallMetaMethod(_table(self),MT_NEWSLOT,3,res);
01352 }
01353 }
01354 if(rawcall) _table(self)->NewSlot(key,val);
01355
01356 break;}
01357 case OT_INSTANCE: {
01358 SQObjectPtr res;
01359 Push(self);Push(key);Push(val);
01360 if(!CallMetaMethod(_instance(self),MT_NEWSLOT,3,res)) {
01361 Raise_Error(_SC("class instances do not support the new slot operator"));
01362 return false;
01363 }
01364 break;}
01365 case OT_CLASS:
01366 if(!_class(self)->NewSlot(_ss(this),key,val,bstatic)) {
01367 if(_class(self)->_locked) {
01368 Raise_Error(_SC("trying to modify a class that has already been instantiated"));
01369 return false;
01370 }
01371 else {
01372 SQObjectPtr oval = PrintObjVal(key);
01373 Raise_Error(_SC("the property '%s' already exists"),_stringval(oval));
01374 return false;
01375 }
01376 }
01377 break;
01378 default:
01379 Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key));
01380 return false;
01381 break;
01382 }
01383 return true;
01384 }
01385
01386 bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res)
01387 {
01388 switch(type(self)) {
01389 case OT_TABLE:
01390 case OT_INSTANCE:
01391 case OT_USERDATA: {
01392 SQObjectPtr t;
01393 bool handled = false;
01394 if(_delegable(self)->_delegate) {
01395 Push(self);Push(key);
01396 handled = CallMetaMethod(_delegable(self),MT_DELSLOT,2,t);
01397 }
01398
01399 if(!handled) {
01400 if(type(self) == OT_TABLE) {
01401 if(_table(self)->Get(key,t)) {
01402 _table(self)->Remove(key);
01403 }
01404 else {
01405 Raise_IdxError((SQObject &)key);
01406 return false;
01407 }
01408 }
01409 else {
01410 Raise_Error(_SC("cannot delete a slot from %s"),GetTypeName(self));
01411 return false;
01412 }
01413 }
01414 res = t;
01415 }
01416 break;
01417 default:
01418 Raise_Error(_SC("attempt to delete a slot from a %s"),GetTypeName(self));
01419 return false;
01420 }
01421 return true;
01422 }
01423
01424 bool SQVM::Call(SQObjectPtr &closure,SQInteger nparams,SQInteger stackbase,SQObjectPtr &outres,SQBool raiseerror,SQBool can_suspend)
01425 {
01426 #ifdef _DEBUG
01427 SQInteger prevstackbase = _stackbase;
01428 #endif
01429 switch(type(closure)) {
01430 case OT_CLOSURE: {
01431 assert(!can_suspend || this->_can_suspend);
01432 SQBool backup_suspend = this->_can_suspend;
01433 this->_can_suspend = can_suspend;
01434 bool ret = Execute(closure, _top - nparams, nparams, stackbase,outres,raiseerror);
01435 this->_can_suspend = backup_suspend;
01436 return ret;
01437 }
01438 break;
01439 case OT_NATIVECLOSURE:{
01440 bool suspend;
01441 return CallNative(_nativeclosure(closure), nparams, stackbase, outres,suspend);
01442
01443 }
01444 break;
01445 case OT_CLASS: {
01446 SQObjectPtr constr;
01447 SQObjectPtr temp;
01448 CreateClassInstance(_class(closure),outres,constr);
01449 if(type(constr) != OT_NULL) {
01450 _stack[stackbase] = outres;
01451 return Call(constr,nparams,stackbase,temp,raiseerror,false);
01452 }
01453 return true;
01454 }
01455 break;
01456 default:
01457 return false;
01458 }
01459 #ifdef _DEBUG
01460 if(!_suspended) {
01461 assert(_stackbase == prevstackbase);
01462 }
01463 #endif
01464 return true;
01465 }
01466
01467 bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,SQInteger nparams,SQObjectPtr &outres)
01468 {
01469 SQObjectPtr closure;
01470 if(del->GetMetaMethod(this, mm, closure)) {
01471 if(Call(closure, nparams, _top - nparams, outres, SQFalse, SQFalse)) {
01472 Pop(nparams);
01473 return true;
01474 }
01475 }
01476 Pop(nparams);
01477 return false;
01478 }
01479
01480 void SQVM::Remove(SQInteger n) {
01481 n = (n >= 0)?n + _stackbase - 1:_top + n;
01482 for(SQInteger i = n; i < _top; i++){
01483 _stack[i] = _stack[i+1];
01484 }
01485 _stack[_top] = _null_;
01486 _top--;
01487 }
01488
01489 void SQVM::Pop() {
01490 _stack[--_top] = _null_;
01491 }
01492
01493 void SQVM::Pop(SQInteger n) {
01494 for(SQInteger i = 0; i < n; i++){
01495 _stack[--_top] = _null_;
01496 }
01497 }
01498
01499 void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; }
01500 SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }
01501 SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }
01502 SQObjectPtr &SQVM::GetUp(SQInteger n) { return _stack[_top+n]; }
01503 SQObjectPtr &SQVM::GetAt(SQInteger n) { return _stack[n]; }
01504
01505 #ifdef _DEBUG_DUMP
01506 void SQVM::dumpstack(SQInteger stackbase,bool dumpall)
01507 {
01508 SQInteger size=dumpall?_stack.size():_top;
01509 SQInteger n=0;
01510 scprintf(_SC("\n>>>>stack dump<<<<\n"));
01511 CallInfo &ci=_callsstack[_callsstacksize-1];
01512 scprintf(_SC("IP: %p\n"),ci._ip);
01513 scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);
01514 scprintf(_SC("prev top: %d\n"),ci._prevtop);
01515 for(SQInteger i=0;i<size;i++){
01516 SQObjectPtr &obj=_stack[i];
01517 if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));
01518 scprintf(_SC("[%d]:"),n);
01519 switch(type(obj)){
01520 case OT_FLOAT: scprintf(_SC("FLOAT %.3f"),_float(obj));break;
01521 case OT_INTEGER: scprintf(_SC("INTEGER %d"),_integer(obj));break;
01522 case OT_BOOL: scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break;
01523 case OT_STRING: scprintf(_SC("STRING %s"),_stringval(obj));break;
01524 case OT_NULL: scprintf(_SC("NULL")); break;
01525 case OT_TABLE: scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break;
01526 case OT_ARRAY: scprintf(_SC("ARRAY %p"),_array(obj));break;
01527 case OT_CLOSURE: scprintf(_SC("CLOSURE [%p]"),_closure(obj));break;
01528 case OT_NATIVECLOSURE: scprintf(_SC("NATIVECLOSURE"));break;
01529 case OT_USERDATA: scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break;
01530 case OT_GENERATOR: scprintf(_SC("GENERATOR %p"),_generator(obj));break;
01531 case OT_THREAD: scprintf(_SC("THREAD [%p]"),_thread(obj));break;
01532 case OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break;
01533 case OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break;
01534 case OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break;
01535 case OT_WEAKREF: scprintf(_SC("WEAKERF %p"),_weakref(obj));break;
01536 default:
01537 assert(0);
01538 break;
01539 };
01540 scprintf(_SC("\n"));
01541 ++n;
01542 }
01543 }
01544
01545
01546
01547 #endif