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