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