src/squirrel/squirrel/sqvm.cpp

   1 /*
   2         see copyright notice in squirrel.h
   3 */
   4 #include "sqpcheader.h"
   5 #include <math.h>
   6 #include <stdlib.h>
   7 #include <assert.h>
   8 #include "sqopcodes.h"
   9 #include "sqfuncproto.h"
  10 #include "sqvm.h"
  11 #include "sqclosure.h"
  12 #include "sqstring.h"
  13 #include "sqtable.h"
  14 #include "squserdata.h"
  15 #include "sqarray.h"
  16 #include "sqclass.h"
  17
  18 #define TOP() (_stack[_top-1])
  19
  20 bool SQVM::BW_OP(unsigned int op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
  21 {
  22         SQInteger res;
  23         SQInteger i1 = _integer(o1), i2 = _integer(o2);
  24         if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))
  25         {
  26                 switch(op) {
  27                         case BW_AND:    res = i1 & i2; break;
  28                         case BW_OR:             res = i1 | i2; break;
  29                         case BW_XOR:    res = i1 ^ i2; break;
  30                         case BW_SHIFTL: res = i1 << i2; break;
  31                         case BW_SHIFTR: res = i1 >> i2; break;
  32                         case BW_USHIFTR:res = (SQInteger)(*((unsigned int*)&i1) >> i2); break;
  33                         default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; }
  34                 }
  35         }
  36         else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),GetTypeName(o1),GetTypeName(o2)); return false;}
  37         trg = res;
  38         return true;
  39 }
  40
  41 bool SQVM::ARITH_OP(unsigned int op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
  42 {
  43         if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
  44                         if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER)) {
  45                                 switch(op) {
  46                                 case '+': trg = _integer(o1) + _integer(o2); break;
  47                                 case '-': trg = _integer(o1) - _integer(o2); break;
  48                                 case '/': if(_integer(o2) == 0) { Raise_Error(_SC("division by zero")); return false; }
  49                                         trg = _integer(o1) / _integer(o2);
  50                                         break;
  51                                 case '*': trg = _integer(o1) * _integer(o2); break;
  52                                 case '%': trg = _integer(o1) % _integer(o2); break;
  53                                 }
  54                         }else{
  55                                 switch(op) {
  56                                 case '+': trg = tofloat(o1) + tofloat(o2); break;
  57                                 case '-': trg = tofloat(o1) - tofloat(o2); break;
  58                                 case '/': trg = tofloat(o1) / tofloat(o2); break;
  59                                 case '*': trg = tofloat(o1) * tofloat(o2); break;
  60                                 case '%': trg = SQFloat(fmod((double)tofloat(o1),(double)tofloat(o2))); break;
  61                                 }
  62                         }
  63                 } else {
  64                         if(op == '+' && (type(o1) == OT_STRING || type(o2) == OT_STRING)){
  65                                         if(!StringCat(o1, o2, trg)) return false;
  66                         }
  67                         else if(!ArithMetaMethod(op,o1,o2,trg)) {
  68                                 Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,GetTypeName(o1),GetTypeName(o2)); return false;
  69                         }
  70                 }
  71                 return true;
  72 }
  73
  74 SQObjectPtr &stack_get(HSQUIRRELVM v,int idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));}
  75
  76 SQVM::SQVM(SQSharedState *ss)
  77 {
  78         _sharedstate=ss;
  79         _suspended=false;
  80         _suspended_target=-1;
  81         _suspended_root=false;
  82         _suspended_traps=-1;
  83         _foreignptr=NULL;
  84         _nnativecalls=0;
  85         _uiRef=0;
  86         _lasterror = _null_;
  87         _errorhandler = _null_;
  88         _debughook = _null_;
  89         INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);
  90 }
  91
  92 void SQVM::Finalize()
  93 {
  94         _roottable = _null_;
  95         _lasterror = _null_;
  96         _errorhandler = _null_;
  97         _debughook = _null_;
  98         temp_reg = _null_;
  99         int size=_stack.size();
 100         for(int i=0;i<size;i++)
 101                 _stack[i]=_null_;
 102 }
 103
 104 SQVM::~SQVM()
 105 {
 106         Finalize();
 107         REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
 108 }
 109
 110 bool SQVM::ArithMetaMethod(int op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)
 111 {
 112         SQMetaMethod mm;
 113         switch(op){
 114                 case _SC('+'): mm=MT_ADD; break;
 115                 case _SC('-'): mm=MT_SUB; break;
 116                 case _SC('/'): mm=MT_DIV; break;
 117                 case _SC('*'): mm=MT_MUL; break;
 118                 case _SC('%'): mm=MT_MODULO; break;
 119                 default: mm=MT_ADD; assert(0); break;
 120         }
 121         if(is_delegable(o1) && _delegable(o1)->_delegate) {
 122                 Push(o1);Push(o2);
 123                 return CallMetaMethod(_delegable(o1),mm,2,dest);
 124         }
 125         return false;
 126 }
 127
 128 bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
 129 {
 130
 131         switch(type(o)) {
 132         case OT_INTEGER:
 133                 trg = -_integer(o);
 134                 return true;
 135         case OT_FLOAT:
 136                 trg = -_float(o);
 137                 return true;
 138         case OT_TABLE:
 139         case OT_USERDATA:
 140         case OT_INSTANCE:
 141                 if(_delegable(o)->_delegate) {
 142                         Push(o);
 143                         if(CallMetaMethod(_delegable(o), MT_UNM, 1, temp_reg)) {
 144                                 trg = temp_reg;
 145                                 return true;
 146                         }
 147                 }
 148                 return true;
 149         default:
 150                 break;
 151         }
 152         Raise_Error(_SC("attempt to negate a %s"), GetTypeName(o));
 153         return false;
 154 }
 155
 156 #define _RET_SUCCEED(exp) { result = (exp); return true; }
 157 bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,int &result)
 158 {
 159         if(type(o1)==type(o2)){
 160                 if(_userpointer(o1)==_userpointer(o2))_RET_SUCCEED(0);
 161                 SQObjectPtr res;
 162                 switch(type(o1)){
 163                 case OT_STRING:
 164                         _RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2)));
 165                 case OT_INTEGER:
 166                         _RET_SUCCEED(_integer(o1)-_integer(o2));
 167                 case OT_FLOAT:
 168                         _RET_SUCCEED((_float(o1)<_float(o2))?-1:1);
 169                 case OT_TABLE:
 170                 case OT_USERDATA:
 171                 case OT_INSTANCE:
 172                         Push(o1);Push(o2);
 173                         if(_delegable(o1)->_delegate)CallMetaMethod(_delegable(o1),MT_CMP,2,res);
 174                         break;
 175                 default:
 176                         break;
 177                 }
 178                 if(type(res)!=OT_INTEGER) { Raise_CompareError(o1,o2); return false; }
 179                 _RET_SUCCEED(_integer(res));
 180         }
 181         else{
 182                 if(sq_isnumeric(o1) && sq_isnumeric(o2)){
 183                         if((type(o1)==OT_INTEGER) && (type(o2)==OT_FLOAT)) {
 184                                 if( _integer(o1)==_float(o2) ) { _RET_SUCCEED(0); }
 185                                 else if( _integer(o1)<_float(o2) ) { _RET_SUCCEED(-1); }
 186                                 _RET_SUCCEED(1);
 187                         }
 188                         else{
 189                                 if( _float(o1)==_integer(o2) ) { _RET_SUCCEED(0); }
 190                                 else if( _float(o1)<_integer(o2) ) { _RET_SUCCEED(-1); }
 191                                 _RET_SUCCEED(1);
 192                         }
 193                 }
 194                 else if(type(o1)==OT_NULL) {_RET_SUCCEED(-1);}
 195                 else if(type(o2)==OT_NULL) {_RET_SUCCEED(1);}
 196                 else { Raise_CompareError(o1,o2); return false; }
 197
 198         }
 199         assert(0);
 200         _RET_SUCCEED(0); //cannot happen
 201 }
 202
 203 bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)
 204 {
 205         int r;
 206         if(ObjCmp(o1,o2,r)) {
 207                 switch(op) {
 208                         case CMP_G: res = (r > 0)?_true_:_false_; return true;
 209                         case CMP_GE: res = (r >= 0)?_true_:_false_; return true;
 210                         case CMP_L: res = (r < 0)?_true_:_false_; return true;
 211                         case CMP_LE: res = (r <= 0)?_true_:_false_; return true;
 212
 213                 }
 214                 assert(0);
 215         }
 216         return false;
 217 }
 218
 219 bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)
 220 {
 221         switch(type(obj))
 222         {
 223         case OT_STRING:
 224                 switch(type(str)){
 225                 case OT_STRING: {
 226                         int l=_string(str)->_len,ol=_string(obj)->_len;
 227                         SQChar *s=_sp(rsl(l+ol+1));
 228                         memcpy(s,_stringval(str),rsl(l));memcpy(s+l,_stringval(obj),rsl(ol));s[l+ol]=_SC('\0');
 229                         break;
 230                 }
 231                 case OT_FLOAT:
 232                         scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(obj)->_len+1)),_SC("%g%s"),_float(str),_stringval(obj));
 233                         break;
 234                 case OT_INTEGER:
 235                         scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(obj)->_len+1)),_SC("%d%s"),_integer(str),_stringval(obj));
 236                         break;
 237                 default:
 238                         Raise_Error(_SC("string concatenation between '%s' and '%s'"),GetTypeName(str),GetTypeName(obj));
 239                         return false;
 240                 }
 241                 dest=SQString::Create(_ss(this),_spval);
 242                 break;
 243         case OT_FLOAT:
 244                 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(str)->_len+1)),_SC("%s%g"),_stringval(str),_float(obj));
 245                 dest=SQString::Create(_ss(this),_spval);
 246                 break;
 247         case OT_INTEGER:
 248                 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(str)->_len+1)),_SC("%s%d"),_stringval(str),_integer(obj));
 249                 dest=SQString::Create(_ss(this),_spval);
 250                 break;
 251         default:
 252                 Raise_Error(_SC("string concatenation between '%s' and '%s'"),GetTypeName(str),GetTypeName(obj));
 253                 return false;
 254         }
 255         return true;
 256 }
 257
 258 const SQChar *IdType2Name(SQObjectType type)
 259 {
 260         switch(_RAW_TYPE(type))
 261         {
 262         case _RT_NULL:return _SC("null");
 263         case _RT_INTEGER:return _SC("integer");
 264         case _RT_FLOAT:return _SC("float");
 265         case _RT_BOOL:return _SC("bool");
 266         case _RT_STRING:return _SC("string");
 267         case _RT_TABLE:return _SC("table");
 268         case _RT_ARRAY:return _SC("array");
 269         case _RT_GENERATOR:return _SC("generator");
 270         case _RT_CLOSURE:
 271         case _RT_NATIVECLOSURE:
 272                 return _SC("function");
 273         case _RT_USERDATA:
 274         case _RT_USERPOINTER:
 275                 return _SC("userdata");
 276         case _RT_THREAD: return _SC("thread");
 277         case _RT_FUNCPROTO: return _SC("function");
 278         case _RT_CLASS: return _SC("class");
 279         case _RT_INSTANCE: return _SC("instance");
 280         default:
 281                 return NULL;
 282         }
 283 }
 284
 285 const SQChar *GetTypeName(const SQObjectPtr &obj1)
 286 {
 287         return IdType2Name(type(obj1));
 288 }
 289
 290 void SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
 291 {
 292         if(is_delegable(obj1) && _delegable(obj1)->_delegate) {
 293                 Push(obj1);
 294                 if(CallMetaMethod(_delegable(obj1),MT_TYPEOF,1,dest))
 295                         return;
 296         }
 297         dest = SQString::Create(_ss(this),GetTypeName(obj1));
 298 }
 299
 300 bool SQVM::Init(SQVM *friendvm, int stacksize)
 301 {
 302         _stack.resize(stacksize);
 303         _callsstack.reserve(4);
 304         _stackbase = 0;
 305         _top = 0;
 306         if(!friendvm)
 307                 _roottable = SQTable::Create(_ss(this), 0);
 308         else {
 309                 _roottable = friendvm->_roottable;
 310                 _errorhandler = friendvm->_errorhandler;
 311                 _debughook = friendvm->_debughook;
 312         }
 313
 314         sq_base_register(this);
 315         return true;
 316 }
 317
 318 extern SQInstructionDesc g_InstrDesc[];
 319
 320 bool SQVM::StartCall(SQClosure *closure,int target,int nargs,int stackbase,bool tailcall)
 321 {
 322         SQFunctionProto *func = _funcproto(closure->_function);
 323         //const int outerssize = func->_outervalues.size();
 324
 325         const int paramssize = func->_parameters.size();
 326         // const int oldtop = _top;
 327         const int newtop = stackbase + func->_stacksize;
 328
 329
 330         if(func->_varparams)
 331         {
 332                 if (nargs < paramssize) {
 333                         Raise_Error(_SC("wrong number of parameters"));
 334                         return false;
 335                 }
 336                 for(int n = 0; n < nargs - paramssize; n++) {
 337                         _vargsstack.push_back(_stack[stackbase+paramssize+n]);
 338                         _stack[stackbase+paramssize+n] = _null_;
 339                 }
 340         }
 341         else {
 342                 if (paramssize != nargs) {
 343                         Raise_Error(_SC("wrong number of parameters"));
 344                         return false;
 345                 }
 346
 347         }
 348
 349         if (!tailcall) {
 350                 PUSH_CALLINFO(this, CallInfo());
 351                 ci->_etraps = 0;
 352                 ci->_prevstkbase = stackbase - _stackbase;
 353                 ci->_target = target;
 354                 ci->_prevtop = _top - _stackbase;
 355                 ci->_ncalls = 1;
 356                 ci->_root = false;
 357         }
 358         else {
 359                 ci->_ncalls++;
 360         }
 361         ci->_vargs.size = (nargs - paramssize);
 362         ci->_vargs.base = _vargsstack.size()-(nargs - paramssize);
 363         ci->_closure._unVal.pClosure = closure;
 364         ci->_closure._type = OT_CLOSURE;
 365         ci->_iv = &func->_instructions;
 366         ci->_literals = &func->_literals;
 367         //grows the stack if needed
 368         if (((unsigned int)newtop + (func->_stacksize<<1)) > _stack.size()) {
 369                 _stack.resize(_stack.size() + (func->_stacksize<<1));
 370         }
 371
 372         _top = newtop;
 373         _stackbase = stackbase;
 374         ci->_ip = ci->_iv->_vals;
 375         return true;
 376 }
 377
 378 bool SQVM::Return(int _arg0, int _arg1, SQObjectPtr &retval)
 379 {
 380         if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
 381                 for(int i=0;i<ci->_ncalls;i++)
 382                         CallDebugHook(_SC('r'));
 383
 384         bool broot = ci->_root;
 385         int last_top = _top;
 386         int target = ci->_target;
 387         int oldstackbase = _stackbase;
 388         _stackbase -= ci->_prevstkbase;
 389         _top = _stackbase + ci->_prevtop;
 390         PopVarArgs(ci->_vargs);
 391         POP_CALLINFO(this);
 392         if (broot) {
 393                 if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack[oldstackbase+_arg1];
 394                 else retval = _null_;
 395         }
 396         else {
 397                 if (_arg0 != MAX_FUNC_STACKSIZE)
 398                         STK(target) = _stack[oldstackbase+_arg1];
 399                 else
 400                         STK(target) = _null_;
 401         }
 402
 403         while (last_top >= _top) _stack[last_top--].Null();
 404         assert(oldstackbase >= _stackbase);
 405         return broot;
 406 }
 407
 408 #define _RET_ON_FAIL(exp) { if(!exp) return false; }
 409
 410 bool SQVM::LOCAL_INC(int op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
 411 {
 412         _RET_ON_FAIL(ARITH_OP( op , target, a, incr));
 413         a = target;
 414         return true;
 415 }
 416
 417 bool SQVM::PLOCAL_INC(int op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
 418 {
 419         SQObjectPtr trg;
 420         _RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
 421         target = a;
 422         a = trg;
 423         return true;
 424 }
 425
 426 bool SQVM::DerefInc(int op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)
 427 {
 428         SQObjectPtr tmp, tself = self, tkey = key;
 429         if (!Get(tself, tkey, tmp, false, true)) { Raise_IdxError(tkey); return false; }
 430         _RET_ON_FAIL(ARITH_OP( op , target, tmp, incr))
 431         Set(tself, tkey, target,true);
 432         if (postfix) target = tmp;
 433         return true;
 434 }
 435
 436 #define arg0 (_i_._arg0)
 437 #define arg1 (_i_._arg1)
 438 #define sarg1 (*((int *)&_i_._arg1))
 439 #define arg2 (_i_._arg2)
 440 #define arg3 (_i_._arg3)
 441 #define sarg3 (*((char *)&_i_._arg3))
 442
 443 SQRESULT SQVM::Suspend()
 444 {
 445         if (_suspended)
 446                 return sq_throwerror(this, _SC("cannot suspend an already suspended vm"));
 447         if (_nnativecalls!=2)
 448                 return sq_throwerror(this, _SC("cannot suspend through native calls/metamethods"));
 449         return SQ_SUSPEND_FLAG;
 450 }
 451
 452 void SQVM::PopVarArgs(VarArgs &vargs)
 453 {
 454         for(int n = 0; n< vargs.size; n++)
 455                 _vargsstack.pop_back();
 456 }
 457
 458 #define _FINISH(stoploop) {finished = stoploop; return true; }
 459 bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
 460 &o3,SQObjectPtr &o4,int arg_2,bool &finished)
 461 {
 462         int nrefidx;
 463         switch(type(o1)) {
 464         case OT_TABLE:
 465                 if((nrefidx = _table(o1)->Next(o4, o2, o3)) == -1) _FINISH(true);
 466                 o4 = (SQInteger)nrefidx; _FINISH(false);
 467         case OT_ARRAY:
 468                 if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(true);
 469                 o4 = (SQInteger) nrefidx; _FINISH(false);
 470         case OT_STRING:
 471                 if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(true);
 472                 o4 = (SQInteger)nrefidx; _FINISH(false);
 473         case OT_CLASS:
 474                 if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(true);
 475                 o4 = (SQInteger)nrefidx; _FINISH(false);
 476         case OT_USERDATA:
 477         case OT_INSTANCE:
 478                 if(_delegable(o1)->_delegate) {
 479                         SQObjectPtr itr;
 480                         Push(o1);
 481                         Push(o4);
 482                         if(CallMetaMethod(_delegable(o1), MT_NEXTI, 2, itr)){
 483                                 o4 = o2 = itr;
 484                                 if(type(itr) == OT_NULL) _FINISH(true);
 485                                 if(!Get(o1, itr, o3, false,false)) {
 486                                         Raise_Error(_SC("_nexti returned an invalid idx"));
 487                                         return false;
 488                                 }
 489                                 _FINISH(false);
 490                         }
 491                         Raise_Error(_SC("_nexti failed"));
 492                         return false;
 493                 }
 494                 break;
 495         case OT_GENERATOR:
 496                 if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(true);
 497                 if(_generator(o1)->_state == SQGenerator::eSuspended) {
 498                         SQInteger idx = 0;
 499                         if(type(o4) == OT_INTEGER) {
 500                                 idx = _integer(o4) + 1;
 501                         }
 502                         o2 = idx;
 503                         o4 = idx;
 504                         _generator(o1)->Resume(this, arg_2+1);
 505                         _FINISH(false);
 506                 }
 507         default:
 508                 break;
 509         }
 510         Raise_Error(_SC("cannot iterate %s"), GetTypeName(o1));
 511         return false; //cannot be hit(just to avoid warnings)
 512 }
 513
 514 bool SQVM::DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2)
 515 {
 516         if(type(o1) != OT_TABLE) { Raise_Error(_SC("delegating a '%s'"), GetTypeName(o1)); return false; }
 517         switch(type(o2)) {
 518         case OT_TABLE:
 519                 if(!_table(o1)->SetDelegate(_table(o2))){
 520                         Raise_Error(_SC("delegate cycle detected"));
 521                         return false;
 522                 }
 523                 break;
 524         case OT_NULL:
 525                 _table(o1)->SetDelegate(NULL);
 526                 break;
 527         default:
 528                 Raise_Error(_SC("using '%s' as delegate"), GetTypeName(o2));
 529                 return false;
 530                 break;
 531         }
 532         trg = o1;
 533         return true;
 534 }
 535 #define COND_LITERAL (arg3!=0?(*ci->_literals)[arg1]:STK(arg1))
 536
 537 #define _GUARD(exp) { if(!exp) { Raise_Error(_lasterror); SQ_THROW();} }
 538
 539 #define SQ_THROW() { goto exception_trap; }
 540
 541 bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
 542 {
 543         int nouters;
 544         SQClosure *closure = SQClosure::Create(_ss(this), func);
 545         if( (nouters = func->_outervalues.size()) ) {
 546                 closure->_outervalues.reserve(nouters);
 547                 for(int i = 0; i<nouters; i++) {
 548                         SQOuterVar &v = func->_outervalues[i];
 549                         switch(v._type){
 550                         case otSYMBOL:
 551                                 closure->_outervalues.push_back(_null_);
 552                                 if(!Get(_stack._vals[_stackbase]/*STK(0)*/, v._src, closure->_outervalues.top(), false,true))
 553                                 {Raise_IdxError(v._src); return false; }
 554                                 break;
 555                         case otLOCAL:
 556                                 closure->_outervalues.push_back(_stack._vals[_stackbase+_integer(v._src)]);
 557                                 break;
 558                         case otOUTER:
 559                                 closure->_outervalues.push_back(_closure(ci->_closure)->_outervalues[_integer(v._src)]);
 560                                 break;
 561                         }
 562                 }
 563         }
 564         target = closure;
 565         return true;
 566
 567 }
 568
 569 bool SQVM::GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &index,CallInfo *ci)
 570 {
 571         if(ci->_vargs.size == 0) {
 572                 Raise_Error(_SC("the function doesn't have var args"));
 573                 return false;
 574         }
 575         if(!sq_isnumeric(index)){
 576                 Raise_Error(_SC("indexing 'vargv' with %s"),GetTypeName(index));
 577                 return false;
 578         }
 579         int idx = tointeger(index);
 580         if(idx < 0 || idx >= ci->_vargs.size){ Raise_Error(_SC("vargv index out of range")); return false; }
 581         target = _vargsstack[ci->_vargs.base+idx];
 582         return true;
 583 }
 584
 585 bool SQVM::CLASS_OP(SQObjectPtr &target,int baseclass,int attributes)
 586 {
 587         SQClass *base = NULL;
 588         SQObjectPtr attrs;
 589         if(baseclass != MAX_LITERALS) {
 590                 if(type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { Raise_Error(_SC("trying to inherit from a %s"),GetTypeName(_stack._vals[_stackbase+baseclass])); return false; }
 591                 base = _class(_stack._vals[_stackbase + baseclass]);
 592         }
 593         if(attributes != MAX_FUNC_STACKSIZE) {
 594                 attrs = _stack._vals[_stackbase+attributes];
 595         }
 596         target = SQClass::Create(_ss(this),base);
 597         _class(target)->_attributes = attrs;
 598         return true;
 599 }
 600
 601 bool SQVM::IsFalse(SQObjectPtr &o)
 602 {
 603         SQObjectType t = type(o);
 604         if((t & SQOBJECT_CANBEFALSE)
 605                 && ((t == OT_NULL) || ((t == OT_INTEGER || t == OT_BOOL) && _integer(o) == 0)
 606                 || (t == OT_FLOAT && _float(o) == SQFloat(0.0)))) {
 607                         return true;
 608                 }
 609         return false;
 610 }
 611
 612 bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)
 613 {
 614         if(type(o1) == type(o2)) {
 615                 res = ((_userpointer(o1) == _userpointer(o2)?true:false));
 616         }
 617         else {
 618                 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
 619                         int cmpres;
 620                         if(!ObjCmp(o1, o2,cmpres)) return false;
 621                         res = (cmpres == 0);
 622                 }
 623                 else {
 624                         res = false;
 625                 }
 626         }
 627         return true;
 628 }
 629
 630 bool SQVM::Execute(SQObjectPtr &closure, int target, int nargs, int stackbase,SQObjectPtr &outres, ExecutionType et)
 631 {
 632         if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
 633         _nnativecalls++;
 634         AutoDec ad(&_nnativecalls);
 635         int traps = 0;
 636         //temp_reg vars for OP_CALL
 637         int ct_target;
 638         bool ct_tailcall;
 639
 640         switch(et) {
 641                 case ET_CALL:
 642                         if(!StartCall(_closure(closure), _top - nargs, nargs, stackbase, false)) {
 643                                 //call the handler if there are no calls in the stack, if not relies on the previous node
 644                                 if(ci == NULL) CallErrorHandler(_lasterror);
 645                                 return false;
 646                         }
 647                         ci->_root = true;
 648                         break;
 649                 case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = true; traps += ci->_etraps; break;
 650                 case ET_RESUME_VM:
 651                         traps = _suspended_traps;
 652                         ci->_root = _suspended_root;
 653                         _suspended = false;
 654                         break;
 655         }
 656
 657 exception_restore:
 658         //SQ_TRY
 659         {
 660                 for(;;)
 661                 {
 662                         const SQInstruction &_i_ = *ci->_ip++;
 663                         //dumpstack(_stackbase);
 664                         //scprintf("\n[%d] %s %d %d %d %d\n",ci->_ip-ci->_iv->_vals,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3);
 665                         switch(_i_.op)
 666                         {
 667                         case _OP_LINE:
 668                                 if(type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
 669                                         CallDebugHook(_SC('l'),arg1);
 670                                 continue;
 671                         case _OP_LOAD: TARGET = (*ci->_literals)[arg1]; continue;
 672                         case _OP_TAILCALL:
 673                                 temp_reg = STK(arg1);
 674                                 if (type(temp_reg) == OT_CLOSURE){
 675                                         ct_tailcall = true;
 676                                         PopVarArgs(ci->_vargs);
 677                                         for (int i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);
 678                                         ct_target = ci->_target;
 679                                         goto common_call;
 680                                 }
 681                         case _OP_CALL: {
 682                                         ct_tailcall = false;
 683                                         ct_target = arg0;
 684                                         temp_reg = STK(arg1);
 685 common_call:
 686                                         int last_top = _top;
 687                                         switch (type(temp_reg)) {
 688                                         case OT_CLOSURE:{
 689                                                 StartCall(_closure(temp_reg), ct_target, arg3, ct_tailcall?_stackbase:_stackbase+arg2, ct_tailcall);
 690                                                 if (_funcproto(_closure(temp_reg)->_function)->_bgenerator) {
 691                                                         SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(temp_reg));
 692                                                         _GUARD(gen->Yield(this));
 693                                                         Return(1, ct_target, temp_reg);
 694                                                         STK(ct_target) = gen;
 695                                                         while (last_top >= _top) _stack[last_top--].Null();
 696                                                         continue;
 697                                                 }
 698                                                 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
 699                                                         CallDebugHook(_SC('c'));
 700                                                 }
 701                                                 break;
 702                                         case OT_NATIVECLOSURE: {
 703                                                 bool suspend;
 704                                                 _GUARD(CallNative(_nativeclosure(temp_reg), arg3, _stackbase+arg2, ct_tailcall, temp_reg,suspend));
 705                                                 if(suspend){
 706                                                         _suspended = true;
 707                                                         _suspended_target = ct_target;
 708                                                         _suspended_root = ci->_root;
 709                                                         _suspended_traps = traps;
 710                                                         outres = temp_reg;
 711                                                         return true;
 712                                                 }
 713                                                 STK(ct_target) = temp_reg;
 714                                                                                    }
 715                                                 break;
 716                                         case OT_CLASS:{
 717                                                 _GUARD(CreateClassInstance(_class(temp_reg),arg3,_stackbase+arg2,STK(ct_target)));
 718                                                 }
 719                                                 break;
 720                                         case OT_TABLE:
 721                                         case OT_USERDATA:
 722                                         case OT_INSTANCE:
 723                                                 {
 724                                                 Push(temp_reg);
 725                                                 for (int i = 0; i < arg3; i++) Push(STK(arg2 + i));
 726                                                 if (_delegable(temp_reg) && CallMetaMethod(_delegable(temp_reg), MT_CALL, arg3+1, temp_reg)){
 727                                                         STK(ct_target) = temp_reg;
 728                                                         break;
 729                                                 }
 730                                                 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(temp_reg));
 731                                                 SQ_THROW();
 732                                           }
 733                                         default:
 734                                                 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(temp_reg));
 735                                                 SQ_THROW();
 736                                         }
 737                                 }
 738                                   continue;
 739                         case _OP_PREPCALL:
 740                                         if (!Get(STK(arg2), STK(arg1), temp_reg, false,true))
 741                                         { Raise_IdxError(STK(arg1)); SQ_THROW(); }
 742                                         goto common_prepcall;
 743                         case _OP_PREPCALLK:
 744                                         if (!Get(STK(arg2), (*ci->_literals)[arg1], temp_reg,false,true)) {
 745                                                 if(type(STK(arg2)) == OT_CLASS) { //hack?
 746                                                         if(_class_ddel->Get((*ci->_literals)[arg1],temp_reg)) {
 747                                                                 STK(arg3) = STK(arg2);
 748                                                                 TARGET = temp_reg;
 749                                                                 continue;
 750                                                         }
 751                                                 }
 752                                                 { Raise_IdxError((*ci->_literals)[arg1]); SQ_THROW();}
 753                                         }
 754 common_prepcall:
 755                                         if(type(STK(arg2)) == OT_CLASS) {
 756                                                 STK(arg3) = STK(0); // this
 757                                         }
 758                                         else {
 759                                                 STK(arg3) = STK(arg2);
 760                                         }
 761                                         TARGET = temp_reg;
 762                                 continue;
 763                         case _OP_GETK:
 764                                 if (!Get(STK(arg2), (*ci->_literals)[arg1], temp_reg, false,true)) { Raise_IdxError((*ci->_literals)[arg1]); SQ_THROW();}
 765                                 TARGET = temp_reg;
 766                                 continue;
 767                         case _OP_MOVE: TARGET = STK(arg1); continue;
 768                         case _OP_NEWSLOT:
 769                                 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3)));
 770                                 if(arg0 != arg3) TARGET = STK(arg3);
 771                                 continue;
 772                         case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue;
 773                         case _OP_SET:
 774                                 if (!Set(STK(arg1), STK(arg2), STK(arg3),true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
 775                                 if (arg0 != arg3) TARGET = STK(arg3);
 776                                 continue;
 777                         case _OP_GET:
 778                                 if (!Get(STK(arg1), STK(arg2), temp_reg, false,true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
 779                                 TARGET = temp_reg;
 780                                 continue;
 781                         case _OP_EQ:{
 782                                 bool res;
 783                                 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
 784                                 TARGET = res?_true_:_false_;
 785                                 }continue;
 786                         case _OP_NE:{
 787                                 bool res;
 788                                 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
 789                                 TARGET = (!res)?_true_:_false_;
 790                                 } continue;
 791                         case _OP_ARITH: _GUARD(ARITH_OP( arg3 , temp_reg, STK(arg2), STK(arg1))); TARGET = temp_reg; continue;
 792                         case _OP_BITW:  _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;
 793                         case _OP_RETURN:
 794                                 if(type((ci)->_generator) == OT_GENERATOR) {
 795                                         _generator((ci)->_generator)->Kill();
 796                                 }
 797                                 if(Return(arg0, arg1, temp_reg)){
 798                                         assert(traps==0);
 799                                         outres = temp_reg;
 800                                         return true;
 801                                 }
 802                                 continue;
 803                         case _OP_LOADNULLS:{ for(unsigned int n=0;n<arg1;n++) STK(arg0+n) = _null_; }continue;
 804                         case _OP_LOADROOTTABLE: TARGET = _roottable; continue;
 805                         case _OP_LOADBOOL: TARGET = arg1?_true_:_false_; continue;
 806                         case _OP_DMOVE: STK(arg0) = STK(arg1); STK(arg2) = STK(arg3); continue;
 807                         case _OP_JMP: ci->_ip += (sarg1); continue;
 808                         case _OP_JNZ: if(!IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
 809                         case _OP_JZ: if(IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
 810                         case _OP_LOADFREEVAR: TARGET = _closure(ci->_closure)->_outervalues[arg1]; continue;
 811                         case _OP_VARGC: TARGET = SQInteger(ci->_vargs.size); continue;
 812                         case _OP_GETVARGV:
 813                                 if(!GETVARGV_OP(TARGET,STK(arg1),ci)) { SQ_THROW(); }
 814                                 continue;
 815                         case _OP_NEWTABLE: TARGET = SQTable::Create(_ss(this), arg1); continue;
 816                         case _OP_NEWARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue;
 817                         case _OP_APPENDARRAY: _array(STK(arg0))->Append(COND_LITERAL);  continue;
 818                         case _OP_GETPARENT:
 819                                 switch(type(STK(arg1))) {
 820                                 case OT_TABLE:
 821                         TARGET = _table(STK(arg1))->_delegate?SQObjectPtr(_table(STK(arg1))->_delegate):_null_;
 822                                         continue;
 823                                 case OT_CLASS: TARGET = _class(STK(arg1))->_base?_class(STK(arg1))->_base:_null_;
 824                                         continue;
 825                                 default:
 826                                         break;
 827                                 }
 828                                 Raise_Error(_SC("the %s type doesn't have a parent slot"), GetTypeName(STK(arg1)));
 829                                 SQ_THROW();
 830                                 continue;
 831                         case _OP_COMPARITH: _GUARD(DerefInc(arg3, TARGET, STK((((unsigned int)arg1&0xFFFF0000)>>16)), STK(arg2), STK(arg1&0x0000FFFF), false)); continue;
 832                         case _OP_COMPARITHL: _GUARD(LOCAL_INC(arg3, TARGET, STK(arg1), STK(arg2))); continue;
 833                         case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, false));} continue;
 834                         case _OP_INCL: {SQObjectPtr o(sarg3); _GUARD(LOCAL_INC('+',TARGET, STK(arg1), o));} continue;
 835                         case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, true));} continue;
 836                         case _OP_PINCL: {SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o));} continue;
 837                         case _OP_CMP:   _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET))  continue;
 838                         case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, true,false)?_true_:_false_;continue;
 839                         case _OP_INSTANCEOF:
 840                                 if(type(STK(arg1)) != OT_CLASS || type(STK(arg2)) != OT_INSTANCE)
 841                                 {Raise_Error(_SC("cannot apply instanceof between a %s and a %s"),GetTypeName(STK(arg1)),GetTypeName(STK(arg2))); SQ_THROW();}
 842                                 TARGET = _instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?_true_:_false_;
 843                                 continue;
 844                         case _OP_AND:
 845                                 if(IsFalse(STK(arg2))) {
 846                                         TARGET = STK(arg2);
 847                                         ci->_ip += (sarg1);
 848                                 }
 849                                 continue;
 850                         case _OP_OR:
 851                                 if(!IsFalse(STK(arg2))) {
 852                                         TARGET = STK(arg2);
 853                                         ci->_ip += (sarg1);
 854                                 }
 855                                 continue;
 856                         case _OP_NEG: _GUARD(NEG_OP(TARGET,STK(arg1))); continue;
 857                         case _OP_NOT: TARGET = (IsFalse(STK(arg1))?_true_:_false_); continue;
 858                         case _OP_BWNOT:
 859                                 if(type(STK(arg1)) == OT_INTEGER) {
 860                                         TARGET = SQInteger(~_integer(STK(arg1)));
 861                                         continue;
 862                                 }
 863                                 Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1)));
 864                                 SQ_THROW();
 865                         case _OP_CLOSURE: {
 866                                 SQClosure *c = ci->_closure._unVal.pClosure;
 867                                 SQFunctionProto *fp = c->_function._unVal.pFunctionProto;
 868                                 if(!CLOSURE_OP(TARGET,fp->_functions[arg1]._unVal.pFunctionProto)) { SQ_THROW(); }
 869                                 continue;
 870                         }
 871                         case _OP_YIELD:{
 872                                 if(type(ci->_generator) == OT_GENERATOR) {
 873                                         if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1);
 874                                         _GUARD(_generator(ci->_generator)->Yield(this));
 875                                         traps -= ci->_etraps;
 876                                         if(sarg1 != MAX_FUNC_STACKSIZE) STK(arg1) = temp_reg;
 877                                 }
 878                                 else { Raise_Error(_SC("trying to yield a '%s',only genenerator can be yielded"), GetTypeName(ci->_generator)); SQ_THROW();}
 879                                 if(Return(arg0, arg1, temp_reg)){
 880                                         assert(traps==0);
 881                                         outres = temp_reg;
 882                                         return true;
 883                                 }
 884
 885                                 }
 886                                 continue;
 887                         case _OP_RESUME:
 888                                 if(type(STK(arg1)) != OT_GENERATOR){ Raise_Error(_SC("trying to resume a '%s',only genenerator can be resumed"), GetTypeName(STK(arg1))); SQ_THROW();}
 889                                 _GUARD(_generator(STK(arg1))->Resume(this, arg0));
 890                                 traps += ci->_etraps;
 891                 continue;
 892                         case _OP_FOREACH:{ bool finished;
 893                                 _GUARD(FOREACH_OP(STK(arg0),STK(arg2),STK(arg2+1),STK(arg2+2),arg2,finished));
 894                                 if(finished) ci->_ip += sarg1; }
 895                                 continue;
 896                         case _OP_DELEGATE: _GUARD(DELEGATE_OP(TARGET,STK(arg1),STK(arg2))); continue;
 897                         case _OP_CLONE:
 898                                 if(!Clone(STK(arg1), TARGET))
 899                                 { Raise_Error(_SC("cloning a %s"), GetTypeName(STK(arg1))); SQ_THROW();}
 900                                 continue;
 901                         case _OP_TYPEOF: TypeOf(STK(arg1), TARGET); continue;
 902                         case _OP_PUSHTRAP:
 903                                 _etraps.push_back(SQExceptionTrap(_top,_stackbase, &ci->_iv->_vals[(ci->_ip-ci->_iv->_vals)+arg1], arg0)); traps++;
 904                                 ci->_etraps++;
 905                                 continue;
 906                         case _OP_POPTRAP:{
 907                                 for(int i=0; i<arg0; i++) {
 908                                         _etraps.pop_back(); traps--;
 909                                         ci->_etraps--;
 910                                 }}
 911                                 continue;
 912                         case _OP_THROW: Raise_Error(TARGET); SQ_THROW(); continue;
 913                         case _OP_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;
 914                         case _OP_NEWSLOTA:
 915                                 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3)));
 916                                 _class(STK(arg1))->SetAttributes(STK(arg2),STK(arg2-1));
 917                                 if(arg0 != arg3) TARGET = STK(arg3);
 918                                 continue;
 919                         }
 920
 921                 }
 922         }
 923 exception_trap:
 924         {
 925                 SQObjectPtr currerror = _lasterror;
 926 //              dumpstack(_stackbase);
 927                 int n = 0;
 928                 int last_top = _top;
 929                 if(ci) {
 930                         if(traps) {
 931                                 do {
 932                                         if(ci->_etraps > 0) {
 933                                                 SQExceptionTrap &et = _etraps.top();
 934                                                 ci->_ip = et._ip;
 935                                                 _top = et._stacksize;
 936                                                 _stackbase = et._stackbase;
 937                                                 _stack[_stackbase+et._extarget] = currerror;
 938                                                 _etraps.pop_back(); traps--; ci->_etraps--;
 939                                                 while(last_top >= _top) _stack[last_top--].Null();
 940                                                 goto exception_restore;
 941                                         }
 942                                         //if is a native closure
 943                                         if(type(ci->_closure) != OT_CLOSURE && n)
 944                                                 break;
 945                                         if(type(ci->_generator) == OT_GENERATOR) _generator(ci->_generator)->Kill();
 946                                         PopVarArgs(ci->_vargs);
 947                                         POP_CALLINFO(this);
 948                                         n++;
 949                                 }while(_callsstack.size());
 950                         }
 951                         //call the hook
 952                         CallErrorHandler(currerror);
 953                         //remove call stack until a C function is found or the cstack is empty
 954                         if(ci) do{
 955                                 bool exitafterthisone = ci->_root;
 956                                 if(type(ci->_generator) == OT_GENERATOR) _generator(ci->_generator)->Kill();
 957                                 _stackbase -= ci->_prevstkbase;
 958                                 _top = _stackbase + ci->_prevtop;
 959                                 PopVarArgs(ci->_vargs);
 960                                 POP_CALLINFO(this);
 961                                 if( (ci && type(ci->_closure) != OT_CLOSURE) || exitafterthisone) break;
 962                         }while(_callsstack.size());
 963
 964                         while(last_top >= _top) _stack[last_top--].Null();
 965                 }
 966                 _lasterror = currerror;
 967                 return false;
 968         }
 969         assert(0);
 970 }
 971
 972 bool SQVM::CreateClassInstance(SQClass *theclass, int nargs, int stackbase, SQObjectPtr &retval)
 973 {
 974         SQObjectPtr constr;
 975         SQObjectPtr inst = theclass->CreateInstance();
 976         _stack[stackbase] = inst;
 977         if(theclass->Get(_ss(this)->_constructoridx,constr)) {
 978                 if(!Call(constr,nargs,stackbase,constr))
 979                         return false;
 980         }
 981         retval = inst;
 982         return true;
 983 }
 984
 985 void SQVM::CallErrorHandler(SQObjectPtr &error)
 986 {
 987         if(type(_errorhandler) != OT_NULL) {
 988                 SQObjectPtr out;
 989                 Push(_roottable); Push(error);
 990                 Call(_errorhandler, 2, _top-2, out);
 991                 Pop(2);
 992         }
 993 }
 994
 995 void SQVM::CallDebugHook(int type,int forcedline)
 996 {
 997         SQObjectPtr temp_reg;
 998         int nparams=5;
 999         SQFunctionProto *func=_funcproto(_closure(ci->_closure)->_function);
1000         Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);
1001         Call(_debughook,nparams,_top-nparams,temp_reg);
1002         Pop(nparams);
1003 }
1004
1005 bool SQVM::CallNative(SQNativeClosure *nclosure,int nargs,int stackbase,bool tailcall,SQObjectPtr &retval,bool &suspend)
1006 {
1007         (void) tailcall;
1008         if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
1009         int nparamscheck = nclosure->_nparamscheck;
1010         if(((nparamscheck > 0) && (nparamscheck != nargs))
1011                 || ((nparamscheck < 0) && (nargs < (-nparamscheck)))) {
1012                 Raise_Error(_SC("wrong number of parameters"));
1013                 return false;
1014                 }
1015
1016         int tcs;
1017         if( (tcs = nclosure->_typecheck.size()) ) {
1018                 for(int i = 0; i < nargs && i < tcs; i++)
1019                         if((nclosure->_typecheck[i] != -1) && !(type(_stack[stackbase+i]) & nclosure->_typecheck[i])) {
1020                 Raise_ParamTypeError(i,nclosure->_typecheck[i],type(_stack[stackbase+i]));
1021                                 return false;
1022                         }
1023         }
1024         _nnativecalls++;
1025         if ((_top + MIN_STACK_OVERHEAD) > (int)_stack.size()) {
1026                 _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));
1027         }
1028         int oldtop = _top;
1029         int oldstackbase = _stackbase;
1030         _top = stackbase + nargs;
1031         PUSH_CALLINFO(this, CallInfo());
1032         ci->_etraps = 0;
1033         ci->_closure._unVal.pNativeClosure = nclosure;
1034         ci->_closure._type = OT_NATIVECLOSURE;
1035         ci->_prevstkbase = stackbase - _stackbase;
1036         ci->_ncalls = 1;
1037         _stackbase = stackbase;
1038         //push free variables
1039         int outers = nclosure->_outervalues.size();
1040         for (int i = 0; i < outers; i++) {
1041                 Push(nclosure->_outervalues[i]);
1042         }
1043         ci->_prevtop = (oldtop - oldstackbase);
1044         int ret = (nclosure->_function)(this);
1045         _nnativecalls--;
1046         suspend = false;
1047         if( ret == SQ_SUSPEND_FLAG) suspend = true;
1048         else if (ret < 0) {
1049                 _stackbase = oldstackbase;
1050                 _top = oldtop;
1051                 POP_CALLINFO(this);
1052                 Raise_Error(_lasterror);
1053                 return false;
1054         }
1055
1056         if (ret != 0){ retval = TOP(); }
1057         else { retval = _null_; }
1058         _stackbase = oldstackbase;
1059         _top = oldtop;
1060         POP_CALLINFO(this);
1061         return true;
1062 }
1063
1064 bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, bool fetchroot)
1065 {
1066         switch(type(self)){
1067         case OT_TABLE:
1068                 if(_table(self)->Get(key,dest))return true;
1069                 break;
1070         case OT_ARRAY:
1071                 if(sq_isnumeric(key)){
1072                         return _array(self)->Get(tointeger(key),dest);
1073                 }
1074                 break;
1075         case OT_INSTANCE:
1076                 if(_instance(self)->Get(key,dest)) return true;
1077                 break;
1078         default:
1079                 break;
1080         }
1081         if(FallBackGet(self,key,dest,raw)) return true;
1082
1083         if(fetchroot) {
1084                 if(_rawval(STK(0)) == _rawval(self) &&
1085                         type(STK(0)) == type(self)) {
1086                                 return _table(_roottable)->Get(key,dest);
1087                 }
1088         }
1089         return false;
1090 }
1091
1092 bool SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw)
1093 {
1094         switch(type(self)){
1095         case OT_CLASS:
1096                 return _class(self)->Get(key,dest);
1097                 break;
1098         case OT_TABLE:
1099         case OT_USERDATA:
1100         //delegation
1101                 if(_delegable(self)->_delegate) {
1102                         if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,raw,false))
1103                                 return true;
1104                         if(raw)return false;
1105                         Push(self);Push(key);
1106                         if(CallMetaMethod(_delegable(self),MT_GET,2,dest))
1107                                 return true;
1108                 }
1109                 if(type(self) == OT_TABLE) {
1110                         if(raw) return false;
1111                         return _table_ddel->Get(key,dest);
1112                 }
1113                 return false;
1114                 break;
1115         case OT_ARRAY:
1116                 if(raw)return false;
1117                 return _array_ddel->Get(key,dest);
1118         case OT_STRING:
1119                 if(sq_isnumeric(key)){
1120                         SQInteger n=tointeger(key);
1121                         if(abs(n)<_string(self)->_len){
1122                                 if(n<0)n=_string(self)->_len-n;
1123                                 dest=SQInteger(_stringval(self)[n]);
1124                                 return true;
1125                         }
1126                         return false;
1127                 }
1128                 else {
1129                         if(raw)return false;
1130                         return _string_ddel->Get(key,dest);
1131                 }
1132                 break;
1133         case OT_INSTANCE:
1134                 if(raw)return false;
1135                 Push(self);Push(key);
1136                 if(!CallMetaMethod(_delegable(self),MT_GET,2,dest)) {
1137                         return _instance_ddel->Get(key,dest);
1138                 }
1139                 return true;
1140         case OT_INTEGER:case OT_FLOAT:case OT_BOOL:
1141                 if(raw)return false;
1142                 return _number_ddel->Get(key,dest);
1143         case OT_GENERATOR:
1144                 if(raw)return false;
1145                 return _generator_ddel->Get(key,dest);
1146         case OT_CLOSURE: case OT_NATIVECLOSURE:
1147                 if(raw)return false;
1148                 return _closure_ddel->Get(key,dest);
1149         case OT_THREAD:
1150                 if(raw)return false;
1151                 return  _thread_ddel->Get(key,dest);
1152         default:return false;
1153         }
1154         return false;
1155 }
1156
1157 bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool fetchroot)
1158 {
1159         switch(type(self)){
1160         case OT_TABLE:
1161                 if(_table(self)->Set(key,val))
1162                         return true;
1163                 if(_table(self)->_delegate) {
1164                         if(Set(_table(self)->_delegate,key,val,false)) {
1165                                 return true;
1166                         }
1167                 }
1168                 //keeps going
1169         case OT_USERDATA:
1170                 if(_delegable(self)->_delegate) {
1171                         SQObjectPtr t;
1172                         Push(self);Push(key);Push(val);
1173                         if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1174                 }
1175                 break;
1176         case OT_INSTANCE:{
1177                 if(_instance(self)->Set(key,val))
1178                         return true;
1179                 SQObjectPtr t;
1180                 Push(self);Push(key);Push(val);
1181                 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1182                 }
1183                 break;
1184         case OT_ARRAY:
1185                 if(!sq_isnumeric(key)) {Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); return false; }
1186                 return _array(self)->Set(tointeger(key),val);
1187         default:
1188                 Raise_Error(_SC("trying to set '%s'"),GetTypeName(self));
1189                 return false;
1190         }
1191         if(fetchroot) {
1192                 if(_rawval(STK(0)) == _rawval(self) &&
1193                         type(STK(0)) == type(self)) {
1194                                 return _table(_roottable)->Set(key,val);
1195                         }
1196         }
1197         return false;
1198 }
1199
1200 bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target)
1201 {
1202         SQObjectPtr temp_reg;
1203         switch(type(self)){
1204         case OT_TABLE:
1205                 target = _table(self)->Clone();
1206                 goto cloned_mt;
1207         case OT_INSTANCE:
1208                 target = _instance(self)->Clone(_ss(this));
1209 cloned_mt:
1210                 if(_delegable(target)->_delegate){
1211                         Push(target);
1212                         Push(self);
1213                         CallMetaMethod(_delegable(target),MT_CLONED,2,temp_reg);
1214                 }
1215                 return true;
1216         case OT_ARRAY:
1217                 target=_array(self)->Clone();
1218                 return true;
1219         default: return false;
1220         }
1221 }
1222
1223 bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val)
1224 {
1225         if(type(key) == OT_NULL) { Raise_Error(_SC("null cannot be used as index")); return false; }
1226         switch(type(self)) {
1227         case OT_TABLE: {
1228                 bool rawcall = true;
1229                 if(_table(self)->_delegate) {
1230                         SQObjectPtr res;
1231                         if(!_table(self)->Get(key,res)) {
1232                                 Push(self);Push(key);Push(val);
1233                                 rawcall = !CallMetaMethod(_table(self),MT_NEWSLOT,3,res);
1234                         }
1235                 }
1236                 if(rawcall) _table(self)->NewSlot(key,val); //cannot fail
1237
1238                 break;}
1239         case OT_CLASS:
1240                 if(!_class(self)->NewSlot(key,val)) {
1241                         if(_class(self)->_locked) {
1242                                 Raise_Error(_SC("trying to modify a class that has already been instantiated"));
1243                                 return false;
1244                         }
1245                         else {
1246                                 SQObjectPtr oval = PrintObjVal(key);
1247                                 Raise_Error(_SC("the property '%s' already exists"),_stringval(oval));
1248                                 return false;
1249                         }
1250                 }
1251                 break;
1252         default:
1253                 Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key));
1254                 return false;
1255                 break;
1256         }
1257         return true;
1258 }
1259
1260 bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res)
1261 {
1262         switch(type(self)) {
1263         case OT_TABLE:
1264         case OT_INSTANCE:
1265         case OT_USERDATA: {
1266                 SQObjectPtr t;
1267                 bool handled = false;
1268                 if(_delegable(self)->_delegate) {
1269                         Push(self);Push(key);
1270                         handled = CallMetaMethod(_delegable(self),MT_DELSLOT,2,t);
1271                 }
1272
1273                 if(!handled) {
1274                         if(type(self) == OT_TABLE) {
1275                                 if(_table(self)->Get(key,t)) {
1276                                         _table(self)->Remove(key);
1277                                 }
1278                                 else {
1279                                         Raise_IdxError((SQObject &)key);
1280                                         return false;
1281                                 }
1282                         }
1283                         else {
1284                                 Raise_Error(_SC("cannot delete a slot from %s"),GetTypeName(self));
1285                                 return false;
1286                         }
1287                 }
1288                 res = t;
1289                                 }
1290                 break;
1291         default:
1292                 Raise_Error(_SC("attempt to delete a slot from a %s"),GetTypeName(self));
1293                 return false;
1294         }
1295         return true;
1296 }
1297
1298 bool SQVM::Call(SQObjectPtr &closure,int nparams,int stackbase,SQObjectPtr &outres)
1299 {
1300 #ifdef _DEBUG
1301 int prevstackbase = _stackbase;
1302 #endif
1303         switch(type(closure)) {
1304         case OT_CLOSURE:
1305                 return Execute(closure, _top - nparams, nparams, stackbase,outres);
1306                 break;
1307         case OT_NATIVECLOSURE:{
1308                 bool suspend;
1309                 return CallNative(_nativeclosure(closure), nparams, stackbase, false, outres,suspend);
1310
1311                                                   }
1312                 break;
1313         case OT_CLASS:
1314                 return CreateClassInstance(_class(closure),nparams,stackbase,outres);
1315                 break;
1316         default:
1317                 return false;
1318         }
1319 #ifdef _DEBUG
1320         if(!_suspended) {
1321                 assert(_stackbase == prevstackbase);
1322         }
1323 #endif
1324         return true;
1325 }
1326
1327 bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,int nparams,SQObjectPtr &outres)
1328 {
1329         SQObjectPtr closure;
1330         if(del->GetMetaMethod(mm, closure)) {
1331                 if(Call(closure, nparams, _top - nparams, outres)) {
1332                         Pop(nparams);
1333                         return true;
1334                 }
1335         }
1336         Pop(nparams);
1337         return false;
1338 }
1339
1340 void SQVM::Pop() {
1341         _stack[--_top] = _null_;
1342 }
1343 void SQVM::Pop(int n) {
1344         for(int i = 0; i < n; i++){
1345                 _stack[--_top] = _null_;
1346         }
1347 }
1348
1349 void SQVM::Remove(int n) {
1350         n = (n >= 0)?n + _stackbase - 1:_top + n;
1351         for(int i = n; i < _top; i++){
1352                 _stack[i] = _stack[i+1];
1353         }
1354         _stack[_top] = _null_;
1355         _top--;
1356 }
1357
1358 void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; }
1359 SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }
1360 SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }
1361 SQObjectPtr &SQVM::GetUp(int n) { return _stack[_top+n]; }
1362 SQObjectPtr &SQVM::GetAt(int n) { return _stack[n]; }
1363
1364 #ifdef _DEBUG_DUMP
1365 void SQVM::dumpstack(int stackbase,bool dumpall)
1366 {
1367         int size=dumpall?_stack.size():_top;
1368         int n=0;
1369         scprintf(_SC("\n>>>>stack dump<<<<\n"));
1370         CallInfo &ci=_callsstack.back();
1371         scprintf(_SC("IP: %d\n"),ci._ip);
1372         scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);
1373         scprintf(_SC("prev top: %d\n"),ci._prevtop);
1374         for(int i=0;i<size;i++){
1375                 SQObjectPtr &obj=_stack[i];
1376                 if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));
1377                 scprintf(_SC("[%d]:"),n);
1378                 switch(type(obj)){
1379                 case OT_FLOAT:                  scprintf(_SC("FLOAT %.3f"),_float(obj));break;
1380                 case OT_INTEGER:                scprintf(_SC("INTEGER %d"),_integer(obj));break;
1381                 case OT_BOOL:                   scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break;
1382                 case OT_STRING:                 scprintf(_SC("STRING %s"),_stringval(obj));break;
1383                 case OT_NULL:                   scprintf(_SC("NULL"));  break;
1384                 case OT_TABLE:                  scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break;
1385                 case OT_ARRAY:                  scprintf(_SC("ARRAY %p"),_array(obj));break;
1386                 case OT_CLOSURE:                scprintf(_SC("CLOSURE [%p]"),_closure(obj));break;
1387                 case OT_NATIVECLOSURE:  scprintf(_SC("NATIVECLOSURE"));break;
1388                 case OT_USERDATA:               scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break;
1389                 case OT_GENERATOR:              scprintf(_SC("GENERATOR"));break;
1390                 case OT_THREAD:                 scprintf(_SC("THREAD [%p]"),_thread(obj));break;
1391                 case OT_USERPOINTER:    scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break;
1392                 case OT_CLASS:                  scprintf(_SC("CLASS %p"),_class(obj));break;
1393                 case OT_INSTANCE:               scprintf(_SC("INSTANCE %p"),_instance(obj));break;
1394                 default:
1395                         assert(0);
1396                         break;
1397                 };
1398                 scprintf(_SC("\n"));
1399                 ++n;
1400         }
1401 }
1402
1403 #endif