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