src/squirrel/squirrel/sqvm.cpp

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