2 see copyright notice in squirrel.h
4 #include "sqpcheader.h"
8 #include "sqfuncproto.h"
10 #include "sqclosure.h"
13 #include "squserdata.h"
17 #define TOP() (_stack._vals[_top-1])
19 #define CLEARSTACK(_last_top) { if((_last_top) >= _top) ClearStack(_last_top); }
20 void SQVM::ClearStack(SQInteger last_top)
22 SQObjectType tOldType;
23 SQObjectValue unOldVal;
24 while (last_top >= _top) {
25 SQObjectPtr &o = _stack._vals[last_top--];
29 o._unVal.pUserPointer = NULL;
30 __Release(tOldType,unOldVal);
34 bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
37 SQInteger i1 = _integer(o1), i2 = _integer(o2);
38 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))
41 case BW_AND: res = i1 & i2; break;
42 case BW_OR: res = i1 | i2; break;
43 case BW_XOR: res = i1 ^ i2; break;
44 case BW_SHIFTL: res = i1 << i2; break;
45 case BW_SHIFTR: res = i1 >> i2; break;
46 case BW_USHIFTR:res = (SQInteger)(*((SQUnsignedInteger*)&i1) >> i2); break;
47 default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; }
50 else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),GetTypeName(o1),GetTypeName(o2)); return false;}
55 bool SQVM::ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
57 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
58 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER)) {
59 SQInteger res, i1 = _integer(o1), i2 = _integer(o2);
61 case '+': res = i1 + i2; break;
62 case '-': res = i1 - i2; break;
63 case '/': if(i2 == 0) { Raise_Error(_SC("division by zero")); return false; }
66 case '*': res = i1 * i2; break;
67 case '%': if(i2 == 0) { Raise_Error(_SC("modulo by zero")); return false; }
70 default: res = 0xDEADBEEF;
74 SQFloat res, f1 = tofloat(o1), f2 = tofloat(o2);
76 case '+': res = f1 + f2; break;
77 case '-': res = f1 - f2; break;
78 case '/': res = f1 / f2; break;
79 case '*': res = f1 * f2; break;
80 case '%': res = SQFloat(fmod((double)f1,(double)f2)); break;
86 if(op == '+' && (type(o1) == OT_STRING || type(o2) == OT_STRING)){
87 if(!StringCat(o1, o2, trg)) return false;
89 else if(!ArithMetaMethod(op,o1,o2,trg)) {
90 Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,GetTypeName(o1),GetTypeName(o2)); return false;
96 SQVM::SQVM(SQSharedState *ss)
100 _suspended_target=-1;
101 _suspended_root = SQFalse;
106 _errorhandler = _null_;
109 INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);
112 void SQVM::Finalize()
116 _errorhandler = _null_;
119 _callstackdata.resize(0);
120 SQInteger size=_stack.size();
121 for(SQInteger i=0;i<size;i++)
128 //sq_free(_callsstack,_alloccallsstacksize*sizeof(CallInfo));
129 REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
132 bool SQVM::ArithMetaMethod(SQInteger op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)
136 case _SC('+'): mm=MT_ADD; break;
137 case _SC('-'): mm=MT_SUB; break;
138 case _SC('/'): mm=MT_DIV; break;
139 case _SC('*'): mm=MT_MUL; break;
140 case _SC('%'): mm=MT_MODULO; break;
141 default: mm = MT_ADD; assert(0); break; //shutup compiler
143 if(is_delegable(o1) && _delegable(o1)->_delegate) {
145 return CallMetaMethod(_delegable(o1),mm,2,dest);
150 bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
163 if(_delegable(o)->_delegate) {
165 if(CallMetaMethod(_delegable(o), MT_UNM, 1, temp_reg)) {
170 default:break; //shutup compiler
172 Raise_Error(_SC("attempt to negate a %s"), GetTypeName(o));
176 #define _RET_SUCCEED(exp) { result = (exp); return true; }
177 bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result)
179 if(type(o1)==type(o2)){
180 if(_userpointer(o1)==_userpointer(o2))_RET_SUCCEED(0);
184 _RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2)));
186 _RET_SUCCEED(_integer(o1)-_integer(o2));
188 _RET_SUCCEED((_float(o1)<_float(o2))?-1:1);
192 if(_delegable(o1)->_delegate) {
194 if(CallMetaMethod(_delegable(o1),MT_CMP,2,res)) break;
196 //continues through (no break needed)
198 _RET_SUCCEED( _userpointer(o1) < _userpointer(o2)?-1:1 );
200 if(type(res)!=OT_INTEGER) { Raise_CompareError(o1,o2); return false; }
201 _RET_SUCCEED(_integer(res));
205 if(sq_isnumeric(o1) && sq_isnumeric(o2)){
206 if((type(o1)==OT_INTEGER) && (type(o2)==OT_FLOAT)) {
207 if( _integer(o1)==_float(o2) ) { _RET_SUCCEED(0); }
208 else if( _integer(o1)<_float(o2) ) { _RET_SUCCEED(-1); }
212 if( _float(o1)==_integer(o2) ) { _RET_SUCCEED(0); }
213 else if( _float(o1)<_integer(o2) ) { _RET_SUCCEED(-1); }
217 else if(type(o1)==OT_NULL) {_RET_SUCCEED(-1);}
218 else if(type(o2)==OT_NULL) {_RET_SUCCEED(1);}
219 else { Raise_CompareError(o1,o2); return false; }
223 _RET_SUCCEED(0); //cannot happen
226 bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)
229 if(ObjCmp(o1,o2,r)) {
231 case CMP_G: res = (r > 0)?_true_:_false_; return true;
232 case CMP_GE: res = (r >= 0)?_true_:_false_; return true;
233 case CMP_L: res = (r < 0)?_true_:_false_; return true;
234 case CMP_LE: res = (r <= 0)?_true_:_false_; return true;
242 void SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res)
249 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%g"),_float(o));
252 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%d"),_integer(o));
255 scsprintf(_sp(rsl(6)),_integer(o)?_SC("true"):_SC("false"));
260 if(_delegable(o)->_delegate) {
262 if(CallMetaMethod(_delegable(o),MT_TOSTRING,1,res)) {
263 if(type(res) == OT_STRING)
265 //else keeps going to the default
269 scsprintf(_sp(rsl(sizeof(void*)+20)),_SC("(%s : 0x%p)"),GetTypeName(o),(void*)_rawval(o));
271 res = SQString::Create(_ss(this),_spval);
275 bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)
280 SQInteger l = _string(a)->_len , ol = _string(b)->_len;
281 SQChar *s = _sp(rsl(l + ol + 1));
282 memcpy(s, _stringval(a), rsl(l));
283 memcpy(s + l, _stringval(b), rsl(ol));
284 dest = SQString::Create(_ss(this), _spval, l + ol);
288 void SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
290 if(is_delegable(obj1) && _delegable(obj1)->_delegate) {
292 if(CallMetaMethod(_delegable(obj1),MT_TYPEOF,1,dest))
295 dest = SQString::Create(_ss(this),GetTypeName(obj1));
298 bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)
300 _stack.resize(stacksize);
301 _alloccallsstacksize = 4;
302 _callstackdata.resize(_alloccallsstacksize);
304 _callsstack = &_callstackdata[0];
308 _roottable = SQTable::Create(_ss(this), 0);
310 _roottable = friendvm->_roottable;
311 _errorhandler = friendvm->_errorhandler;
312 _debughook = friendvm->_debughook;
315 sq_base_register(this);
319 extern SQInstructionDesc g_InstrDesc[];
321 bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQInteger stackbase,bool tailcall)
323 SQFunctionProto *func = _funcproto(closure->_function);
325 const SQInteger paramssize = func->_nparameters;
326 const SQInteger newtop = stackbase + func->_stacksize;
327 SQInteger nargs = args;
328 if (paramssize != nargs) {
329 SQInteger ndef = func->_ndefaultparams;
330 if(ndef && nargs < paramssize) {
331 SQInteger diff = paramssize - nargs;
332 for(SQInteger n = ndef - diff; n < ndef; n++) {
333 _stack._vals[stackbase + (nargs++)] = closure->_defaultparams[n];
336 else if(func->_varparams)
338 if (nargs < paramssize) {
339 Raise_Error(_SC("wrong number of parameters"));
342 for(SQInteger n = 0; n < nargs - paramssize; n++) {
343 _vargsstack.push_back(_stack._vals[stackbase+paramssize+n]);
344 _stack._vals[stackbase+paramssize+n] = _null_;
348 Raise_Error(_SC("wrong number of parameters"));
353 if(type(closure->_env) == OT_WEAKREF) {
354 _stack._vals[stackbase] = _weakref(closure->_env)->_obj;
359 lc._generator = NULL;
361 lc._prevstkbase = (SQInt32) ( stackbase - _stackbase );
362 lc._target = (SQInt32) target;
363 lc._prevtop = (SQInt32) (_top - _stackbase);
366 PUSH_CALLINFO(this, lc);
371 ci->_vargs.size = (SQInt32)(nargs - paramssize);
372 ci->_vargs.base = (SQInt32)(_vargsstack.size()-(ci->_vargs.size));
373 ci->_closure = closure;
374 ci->_literals = func->_literals;
375 ci->_ip = func->_instructions;
376 //grows the stack if needed
377 if (((SQUnsignedInteger)newtop + (func->_stacksize<<1)) > _stack.size()) {
378 _stack.resize(_stack.size() + (func->_stacksize<<1));
382 _stackbase = stackbase;
383 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
384 CallDebugHook(_SC('c'));
388 bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval)
390 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
391 for(SQInteger i=0;i<ci->_ncalls;i++)
392 CallDebugHook(_SC('r'));
394 SQBool broot = ci->_root;
395 SQInteger last_top = _top;
396 SQInteger target = ci->_target;
397 SQInteger oldstackbase = _stackbase;
398 _stackbase -= ci->_prevstkbase;
399 _top = _stackbase + ci->_prevtop;
400 if(ci->_vargs.size) PopVarArgs(ci->_vargs);
403 if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack._vals[oldstackbase+_arg1];
404 else retval = _null_;
407 if(target != -1) { //-1 is when a class contructor ret value has to be ignored
408 if (_arg0 != MAX_FUNC_STACKSIZE)
409 STK(target) = _stack._vals[oldstackbase+_arg1];
411 STK(target) = _null_;
415 CLEARSTACK(last_top);
416 assert(oldstackbase >= _stackbase);
417 return broot?true:false;
420 #define _RET_ON_FAIL(exp) { if(!exp) return false; }
422 bool SQVM::LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
424 _RET_ON_FAIL(ARITH_OP( op , target, a, incr));
429 bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
432 _RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
438 bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)
440 SQObjectPtr tmp, tself = self, tkey = key;
441 if (!Get(tself, tkey, tmp, false, true)) { Raise_IdxError(tkey); return false; }
442 _RET_ON_FAIL(ARITH_OP( op , target, tmp, incr))
443 Set(tself, tkey, target,true);
444 if (postfix) target = tmp;
448 #define arg0 (_i_._arg0)
449 #define arg1 (_i_._arg1)
450 #define sarg1 (*((SQInt32 *)&_i_._arg1))
451 #define arg2 (_i_._arg2)
452 #define arg3 (_i_._arg3)
453 #define sarg3 ((SQInteger)*((signed char *)&_i_._arg3))
455 SQRESULT SQVM::Suspend()
458 return sq_throwerror(this, _SC("cannot suspend an already suspended vm"));
459 if (_nnativecalls!=2)
460 return sq_throwerror(this, _SC("cannot suspend through native calls/metamethods"));
461 return SQ_SUSPEND_FLAG;
464 void SQVM::PopVarArgs(VarArgs &vargs)
466 for(SQInteger n = 0; n< vargs.size; n++)
467 _vargsstack.pop_back();
470 #define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; }
471 bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
472 &o3,SQObjectPtr &o4,SQInteger arg_2,int exitpos,int &jump)
477 if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(exitpos);
478 o4 = (SQInteger)nrefidx; _FINISH(1);
480 if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(exitpos);
481 o4 = (SQInteger) nrefidx; _FINISH(1);
483 if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
484 o4 = (SQInteger)nrefidx; _FINISH(1);
486 if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
487 o4 = (SQInteger)nrefidx; _FINISH(1);
490 if(_delegable(o1)->_delegate) {
494 if(CallMetaMethod(_delegable(o1), MT_NEXTI, 2, itr)){
496 if(type(itr) == OT_NULL) _FINISH(exitpos);
497 if(!Get(o1, itr, o3, false,false)) {
498 Raise_Error(_SC("_nexti returned an invalid idx"));
503 Raise_Error(_SC("_nexti failed"));
508 if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(exitpos);
509 if(_generator(o1)->_state == SQGenerator::eSuspended) {
511 if(type(o4) == OT_INTEGER) {
512 idx = _integer(o4) + 1;
516 _generator(o1)->Resume(this, arg_2+1);
520 Raise_Error(_SC("cannot iterate %s"), GetTypeName(o1));
522 return false; //cannot be hit(just to avoid warnings)
525 bool SQVM::DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2)
527 if(type(o1) != OT_TABLE) { Raise_Error(_SC("delegating a '%s'"), GetTypeName(o1)); return false; }
530 if(!_table(o1)->SetDelegate(_table(o2))){
531 Raise_Error(_SC("delegate cycle detected"));
536 _table(o1)->SetDelegate(NULL);
539 Raise_Error(_SC("using '%s' as delegate"), GetTypeName(o2));
546 #define COND_LITERAL (arg3!=0?ci->_literals[arg1]:STK(arg1))
548 #define _GUARD(exp) { if(!exp) { Raise_Error(_lasterror); SQ_THROW();} }
550 #define SQ_THROW() { goto exception_trap; }
552 bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
555 SQClosure *closure = SQClosure::Create(_ss(this), func);
556 if((nouters = func->_noutervalues)) {
557 closure->_outervalues.reserve(nouters);
558 for(SQInteger i = 0; i<nouters; i++) {
559 SQOuterVar &v = func->_outervalues[i];
562 closure->_outervalues.push_back(_null_);
563 if(!Get(_stack._vals[_stackbase]/*STK(0)*/, v._src, closure->_outervalues.top(), false,true))
564 {Raise_IdxError(v._src); return false; }
567 closure->_outervalues.push_back(_stack._vals[_stackbase+_integer(v._src)]);
570 closure->_outervalues.push_back(_closure(ci->_closure)->_outervalues[_integer(v._src)]);
575 SQInteger ndefparams;
576 if((ndefparams = func->_ndefaultparams)) {
577 closure->_defaultparams.reserve(ndefparams);
578 for(SQInteger i = 0; i < ndefparams; i++) {
579 SQInteger spos = func->_defaultparams[i];
580 closure->_defaultparams.push_back(_stack._vals[_stackbase + spos]);
588 bool SQVM::GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &index,CallInfo *ci)
590 if(ci->_vargs.size == 0) {
591 Raise_Error(_SC("the function doesn't have var args"));
594 if(!sq_isnumeric(index)){
595 Raise_Error(_SC("indexing 'vargv' with %s"),GetTypeName(index));
598 SQInteger idx = tointeger(index);
599 if(idx < 0 || idx >= ci->_vargs.size){ Raise_Error(_SC("vargv index out of range")); return false; }
600 target = _vargsstack[ci->_vargs.base+idx];
604 bool SQVM::CLASS_OP(SQObjectPtr &target,SQInteger baseclass,SQInteger attributes)
606 SQClass *base = NULL;
608 if(baseclass != -1) {
609 if(type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { Raise_Error(_SC("trying to inherit from a %s"),GetTypeName(_stack._vals[_stackbase+baseclass])); return false; }
610 base = _class(_stack._vals[_stackbase + baseclass]);
612 if(attributes != MAX_FUNC_STACKSIZE) {
613 attrs = _stack._vals[_stackbase+attributes];
615 target = SQClass::Create(_ss(this),base);
616 if(type(_class(target)->_metamethods[MT_INHERITED]) != OT_NULL) {
619 Push(target); Push(attrs);
620 Call(_class(target)->_metamethods[MT_INHERITED],nparams,_top - nparams, ret, false);
623 _class(target)->_attributes = attrs;
629 bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)
631 if(type(o1) == type(o2)) {
632 res = ((_userpointer(o1) == _userpointer(o2)?true:false));
635 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
637 if(!ObjCmp(o1, o2,cmpres)) return false;
647 bool SQVM::IsFalse(SQObjectPtr &o)
649 if((type(o) & SQOBJECT_CANBEFALSE) && ( (type(o) == OT_FLOAT) && (_float(o) == SQFloat(0.0)) )
650 || (_integer(o) == 0) ) { //OT_NULL|OT_INTEGER|OT_BOOL
656 bool SQVM::GETPARENT_OP(SQObjectPtr &o,SQObjectPtr &target)
659 case OT_TABLE: target = _table(o)->_delegate?SQObjectPtr(_table(o)->_delegate):_null_;
661 case OT_CLASS: target = _class(o)->_base?_class(o)->_base:_null_;
664 Raise_Error(_SC("the %s type doesn't have a parent slot"), GetTypeName(o));
670 bool SQVM::Execute(SQObjectPtr &closure, SQInteger target, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et)
672 if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
674 AutoDec ad(&_nnativecalls);
676 //temp_reg vars for OP_CALL
678 SQInteger ct_stackbase;
683 SQInteger last_top = _top;
685 if(!StartCall(_closure(temp_reg), _top - nargs, nargs, stackbase, false)) {
686 //call the handler if there are no calls in the stack, if not relies on the previous node
687 if(ci == NULL) CallErrorHandler(_lasterror);
690 if (_funcproto(_closure(temp_reg)->_function)->_bgenerator) {
691 SQFunctionProto *f = _funcproto(_closure(temp_reg)->_function);
692 SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(temp_reg));
693 _GUARD(gen->Yield(this));
694 Return(1, ci->_target, temp_reg);
696 CLEARSTACK(last_top);
702 case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = SQTrue; traps += ci->_etraps; break;
704 case ET_RESUME_THROW_VM:
705 traps = _suspended_traps;
706 ci->_root = _suspended_root;
707 ci->_vargs = _suspend_varargs;
708 _suspended = SQFalse;
709 if(et == ET_RESUME_THROW_VM) { SQ_THROW(); }
718 const SQInstruction &_i_ = *ci->_ip++;
719 //dumpstack(_stackbase);
720 //scprintf("\n[%d] %s %d %d %d %d\n",ci->_ip-ci->_iv->_vals,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3);
724 if(type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
725 CallDebugHook(_SC('l'),arg1);
727 case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;
728 case _OP_LOADINT: TARGET = (SQInteger)arg1; continue;
729 case _OP_LOADFLOAT: TARGET = *((SQFloat *)&arg1); continue;
730 case _OP_DLOAD: TARGET = ci->_literals[arg1]; STK(arg2) = ci->_literals[arg3];continue;
732 temp_reg = STK(arg1);
733 if (type(temp_reg) == OT_CLOSURE && !_funcproto(_closure(temp_reg)->_function)->_bgenerator){
735 if(ci->_vargs.size) PopVarArgs(ci->_vargs);
736 for (SQInteger i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);
737 ct_target = ci->_target;
738 ct_stackbase = _stackbase;
744 temp_reg = STK(arg1);
745 ct_stackbase = _stackbase+arg2;
748 SQObjectPtr clo = temp_reg;
749 SQInteger last_top = _top;
752 _GUARD(StartCall(_closure(clo), ct_target, arg3, ct_stackbase, ct_tailcall));
753 if (_funcproto(_closure(clo)->_function)->_bgenerator) {
754 SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(clo));
755 _GUARD(gen->Yield(this));
756 Return(1, ct_target, clo);
757 STK(ct_target) = gen;
758 CLEARSTACK(last_top);
763 case OT_NATIVECLOSURE: {
765 _GUARD(CallNative(_nativeclosure(clo), arg3, ct_stackbase, clo,suspend));
768 _suspended_target = ct_target;
769 _suspended_root = ci->_root;
770 _suspended_traps = traps;
771 _suspend_varargs = ci->_vargs;
775 if(ct_target != -1) { //skip return value for constructors
776 STK(ct_target) = clo;
782 _GUARD(CreateClassInstance(_class(clo),inst,temp_reg));
783 STK(ct_target) = inst;
784 ct_target = -1; //fakes return value target so that is not overwritten by the constructor
785 if(type(temp_reg) != OT_NULL) {
786 _stack._vals[ct_stackbase] = inst;
787 goto common_call; //hard core spaghetti code(reissues the OP_CALL to invoke the constructor)
796 for (SQInteger i = 0; i < arg3; i++) Push(STK(arg2 + i));
797 if (_delegable(clo) && CallMetaMethod(_delegable(clo), MT_CALL, arg3+1, clo)){
798 STK(ct_target) = clo;
801 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo));
805 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo));
813 SQObjectPtr &key = _i_.op == _OP_PREPCALLK?(ci->_literals)[arg1]:STK(arg1);
814 SQObjectPtr &o = STK(arg2);
815 if (!Get(o, key, temp_reg,false,true)) {
816 if(type(o) == OT_CLASS) { //hack?
817 if(_class_ddel->Get(key,temp_reg)) {
823 { Raise_IdxError(key); SQ_THROW();}
826 STK(arg3) = type(o) == OT_CLASS?STK(0):o;
831 if (!Get(STK(arg2), ci->_literals[arg1], temp_reg, false,true)) { Raise_IdxError(ci->_literals[arg1]); SQ_THROW();}
834 case _OP_MOVE: TARGET = STK(arg1); continue;
836 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),false));
837 if(arg0 != arg3) TARGET = STK(arg3);
839 case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue;
841 if (!Set(STK(arg1), STK(arg2), STK(arg3),true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
842 if (arg0 != arg3) TARGET = STK(arg3);
845 if (!Get(STK(arg1), STK(arg2), temp_reg, false,true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
850 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
851 TARGET = res?_true_:_false_;
855 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
856 TARGET = (!res)?_true_:_false_;
858 case _OP_ARITH: _GUARD(ARITH_OP( arg3 , temp_reg, STK(arg2), STK(arg1))); TARGET = temp_reg; continue;
859 case _OP_BITW: _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;
862 ci->_generator->Kill();
864 if(Return(arg0, arg1, temp_reg)){
870 case _OP_LOADNULLS:{ for(SQInt32 n=0; n < arg1; n++) STK(arg0+n) = _null_; }continue;
871 case _OP_LOADROOTTABLE: TARGET = _roottable; continue;
872 case _OP_LOADBOOL: TARGET = arg1?_true_:_false_; continue;
873 case _OP_DMOVE: STK(arg0) = STK(arg1); STK(arg2) = STK(arg3); continue;
874 case _OP_JMP: ci->_ip += (sarg1); continue;
875 case _OP_JNZ: if(!IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
876 case _OP_JZ: if(IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
877 case _OP_LOADFREEVAR: TARGET = _closure(ci->_closure)->_outervalues[arg1]; continue;
878 case _OP_VARGC: TARGET = SQInteger(ci->_vargs.size); continue;
880 if(!GETVARGV_OP(TARGET,STK(arg1),ci)) { SQ_THROW(); }
882 case _OP_NEWTABLE: TARGET = SQTable::Create(_ss(this), arg1); continue;
883 case _OP_NEWARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue;
884 case _OP_APPENDARRAY: _array(STK(arg0))->Append(COND_LITERAL); continue;
885 case _OP_GETPARENT: _GUARD(GETPARENT_OP(STK(arg1),TARGET)); continue;
886 case _OP_COMPARITH: _GUARD(DerefInc(arg3, TARGET, STK((((SQUnsignedInteger)arg1&0xFFFF0000)>>16)), STK(arg2), STK(arg1&0x0000FFFF), false)); continue;
887 case _OP_COMPARITHL: _GUARD(LOCAL_INC(arg3, TARGET, STK(arg1), STK(arg2))); continue;
888 case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, false));} continue;
889 case _OP_INCL: {SQObjectPtr o(sarg3); _GUARD(LOCAL_INC('+',TARGET, STK(arg1), o));} continue;
890 case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, true));} continue;
891 case _OP_PINCL: {SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o));} continue;
892 case _OP_CMP: _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET)) continue;
893 case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, true,false)?_true_:_false_;continue;
895 if(type(STK(arg1)) != OT_CLASS || type(STK(arg2)) != OT_INSTANCE)
896 {Raise_Error(_SC("cannot apply instanceof between a %s and a %s"),GetTypeName(STK(arg1)),GetTypeName(STK(arg2))); SQ_THROW();}
897 TARGET = _instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?_true_:_false_;
900 if(IsFalse(STK(arg2))) {
906 if(!IsFalse(STK(arg2))) {
911 case _OP_NEG: _GUARD(NEG_OP(TARGET,STK(arg1))); continue;
912 case _OP_NOT: TARGET = (IsFalse(STK(arg1))?_true_:_false_); continue;
914 if(type(STK(arg1)) == OT_INTEGER) {
915 SQInteger t = _integer(STK(arg1));
916 TARGET = SQInteger(~t);
919 Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1)));
922 SQClosure *c = ci->_closure._unVal.pClosure;
923 SQFunctionProto *fp = c->_function._unVal.pFunctionProto;
924 if(!CLOSURE_OP(TARGET,fp->_functions[arg1]._unVal.pFunctionProto)) { SQ_THROW(); }
929 if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1);
930 _GUARD(ci->_generator->Yield(this));
931 traps -= ci->_etraps;
932 if(sarg1 != MAX_FUNC_STACKSIZE) STK(arg1) = temp_reg;
934 else { Raise_Error(_SC("trying to yield a '%s',only genenerator can be yielded"), GetTypeName(ci->_generator)); SQ_THROW();}
935 if(Return(arg0, arg1, temp_reg)){
944 if(type(STK(arg1)) != OT_GENERATOR){ Raise_Error(_SC("trying to resume a '%s',only genenerator can be resumed"), GetTypeName(STK(arg1))); SQ_THROW();}
945 _GUARD(_generator(STK(arg1))->Resume(this, arg0));
946 traps += ci->_etraps;
948 case _OP_FOREACH:{ int tojump;
949 _GUARD(FOREACH_OP(STK(arg0),STK(arg2),STK(arg2+1),STK(arg2+2),arg2,sarg1,tojump));
952 case _OP_POSTFOREACH:
953 assert(type(STK(arg0)) == OT_GENERATOR);
954 if(_generator(STK(arg0))->_state == SQGenerator::eDead)
955 ci->_ip += (sarg1 - 1);
957 case _OP_DELEGATE: _GUARD(DELEGATE_OP(TARGET,STK(arg1),STK(arg2))); continue;
959 if(!Clone(STK(arg1), TARGET))
960 { Raise_Error(_SC("cloning a %s"), GetTypeName(STK(arg1))); SQ_THROW();}
962 case _OP_TYPEOF: TypeOf(STK(arg1), TARGET); continue;
964 SQInstruction *_iv = _funcproto(_closure(ci->_closure)->_function)->_instructions;
965 _etraps.push_back(SQExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++;
970 for(SQInteger i = 0; i < arg0; i++) {
971 _etraps.pop_back(); traps--;
976 case _OP_THROW: Raise_Error(TARGET); SQ_THROW(); continue;
977 case _OP_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;
979 bool bstatic = (arg0&NEW_SLOT_STATIC_FLAG)?true:false;
980 if(type(STK(arg1)) == OT_CLASS) {
981 if(type(_class(STK(arg1))->_metamethods[MT_NEWMEMBER]) != OT_NULL ) {
982 Push(STK(arg1)); Push(STK(arg2)); Push(STK(arg3));
983 Push((arg0&NEW_SLOT_ATTRIBUTES_FLAG) ? STK(arg2-1) : _null_);
985 if(Call(_class(STK(arg1))->_metamethods[MT_NEWMEMBER], nparams, _top - nparams, temp_reg,SQFalse)) {
991 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),bstatic));
992 if((arg0&NEW_SLOT_ATTRIBUTES_FLAG)) {
993 _class(STK(arg1))->SetAttributes(STK(arg2),STK(arg2-1));
1002 SQObjectPtr currerror = _lasterror;
1003 // dumpstack(_stackbase);
1005 SQInteger last_top = _top;
1007 if(_ss(this)->_notifyallexceptions) CallErrorHandler(currerror);
1011 if(ci->_etraps > 0) {
1012 SQExceptionTrap &et = _etraps.top();
1014 _top = et._stacksize;
1015 _stackbase = et._stackbase;
1016 _stack._vals[_stackbase+et._extarget] = currerror;
1017 _etraps.pop_back(); traps--; ci->_etraps--;
1018 CLEARSTACK(last_top);
1019 goto exception_restore;
1021 //if is a native closure
1022 if(type(ci->_closure) != OT_CLOSURE && n)
1024 if(ci->_generator) ci->_generator->Kill();
1025 PopVarArgs(ci->_vargs);
1028 } while(_callsstacksize);
1032 if(raiseerror && !_ss(this)->_notifyallexceptions)
1033 CallErrorHandler(currerror);
1035 //remove call stack until a C function is found or the cstack is empty
1037 SQBool exitafterthisone = ci->_root;
1038 if(ci->_generator) ci->_generator->Kill();
1039 _stackbase -= ci->_prevstkbase;
1040 _top = _stackbase + ci->_prevtop;
1041 PopVarArgs(ci->_vargs);
1043 if( (ci && type(ci->_closure) != OT_CLOSURE) || exitafterthisone) break;
1044 } while(_callsstacksize);
1046 CLEARSTACK(last_top);
1048 _lasterror = currerror;
1054 bool SQVM::CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor)
1056 inst = theclass->CreateInstance();
1057 if(!theclass->Get(_ss(this)->_constructoridx,constructor)) {
1058 constructor = _null_;
1063 void SQVM::CallErrorHandler(SQObjectPtr &error)
1065 if(type(_errorhandler) != OT_NULL) {
1067 Push(_roottable); Push(error);
1068 Call(_errorhandler, 2, _top-2, out,SQFalse);
1073 void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)
1075 SQObjectPtr temp_reg;
1076 SQInteger nparams=5;
1077 SQFunctionProto *func=_funcproto(_closure(ci->_closure)->_function);
1078 Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);
1079 Call(_debughook,nparams,_top-nparams,temp_reg,SQFalse);
1083 bool SQVM::CallNative(SQNativeClosure *nclosure,SQInteger nargs,SQInteger stackbase,SQObjectPtr &retval,bool &suspend)
1085 if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
1086 SQInteger nparamscheck = nclosure->_nparamscheck;
1087 if(((nparamscheck > 0) && (nparamscheck != nargs))
1088 || ((nparamscheck < 0) && (nargs < (-nparamscheck)))) {
1089 Raise_Error(_SC("wrong number of parameters"));
1094 if((tcs = nclosure->_typecheck.size())) {
1095 for(SQInteger i = 0; i < nargs && i < tcs; i++)
1096 if((nclosure->_typecheck._vals[i] != -1) && !(type(_stack._vals[stackbase+i]) & nclosure->_typecheck[i])) {
1097 Raise_ParamTypeError(i,nclosure->_typecheck._vals[i],type(_stack._vals[stackbase+i]));
1102 if ((_top + MIN_STACK_OVERHEAD) > (SQInteger)_stack.size()) {
1103 _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));
1105 SQInteger oldtop = _top;
1106 SQInteger oldstackbase = _stackbase;
1107 _top = stackbase + nargs;
1109 lci._closure = nclosure;
1110 lci._generator = NULL;
1112 lci._prevstkbase = (SQInt32) (stackbase - _stackbase);
1114 lci._prevtop = (SQInt32) (oldtop - oldstackbase);
1115 PUSH_CALLINFO(this, lci);
1116 _stackbase = stackbase;
1117 //push free variables
1118 SQInteger outers = nclosure->_outervalues.size();
1119 for (SQInteger i = 0; i < outers; i++) {
1120 Push(nclosure->_outervalues[i]);
1123 if(type(nclosure->_env) == OT_WEAKREF) {
1124 _stack[stackbase] = _weakref(nclosure->_env)->_obj;
1128 SQInteger ret = (nclosure->_function)(this);
1131 if( ret == SQ_SUSPEND_FLAG) suspend = true;
1133 _stackbase = oldstackbase;
1136 Raise_Error(_lasterror);
1140 if (ret != 0){ retval = TOP(); TOP().Null(); }
1141 else { retval = _null_; }
1142 _stackbase = oldstackbase;
1148 bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, bool fetchroot)
1152 if(_table(self)->Get(key,dest))return true;
1155 if(sq_isnumeric(key)){
1156 return _array(self)->Get(tointeger(key),dest);
1160 if(_instance(self)->Get(key,dest)) return true;
1162 default:break; //shut up compiler
1164 if(FallBackGet(self,key,dest,raw)) return true;
1167 if(_rawval(STK(0)) == _rawval(self) &&
1168 type(STK(0)) == type(self)) {
1169 return _table(_roottable)->Get(key,dest);
1175 bool SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw)
1179 return _class(self)->Get(key,dest);
1184 if(_delegable(self)->_delegate) {
1185 if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,raw,false))
1187 if(raw)return false;
1188 Push(self);Push(key);
1189 if(CallMetaMethod(_delegable(self),MT_GET,2,dest))
1192 if(type(self) == OT_TABLE) {
1193 if(raw) return false;
1194 return _table_ddel->Get(key,dest);
1199 if(raw)return false;
1200 return _array_ddel->Get(key,dest);
1202 if(sq_isnumeric(key)){
1203 SQInteger n=tointeger(key);
1204 if(abs((int)n)<_string(self)->_len){
1205 if(n<0)n=_string(self)->_len-n;
1206 dest=SQInteger(_stringval(self)[n]);
1212 if(raw)return false;
1213 return _string_ddel->Get(key,dest);
1217 if(raw)return false;
1218 Push(self);Push(key);
1219 if(!CallMetaMethod(_delegable(self),MT_GET,2,dest)) {
1220 return _instance_ddel->Get(key,dest);
1223 case OT_INTEGER:case OT_FLOAT:case OT_BOOL:
1224 if(raw)return false;
1225 return _number_ddel->Get(key,dest);
1227 if(raw)return false;
1228 return _generator_ddel->Get(key,dest);
1229 case OT_CLOSURE: case OT_NATIVECLOSURE:
1230 if(raw)return false;
1231 return _closure_ddel->Get(key,dest);
1233 if(raw)return false;
1234 return _thread_ddel->Get(key,dest);
1236 if(raw)return false;
1237 return _weakref_ddel->Get(key,dest);
1238 default:return false;
1243 bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool fetchroot)
1247 if(_table(self)->Set(key,val))
1249 if(_table(self)->_delegate) {
1250 if(Set(_table(self)->_delegate,key,val,false)) {
1256 if(_delegable(self)->_delegate) {
1258 Push(self);Push(key);Push(val);
1259 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1263 if(_instance(self)->Set(key,val))
1266 Push(self);Push(key);Push(val);
1267 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1271 if(!sq_isnumeric(key)) {Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); return false; }
1272 return _array(self)->Set(tointeger(key),val);
1274 Raise_Error(_SC("trying to set '%s'"),GetTypeName(self));
1278 if(_rawval(STK(0)) == _rawval(self) &&
1279 type(STK(0)) == type(self)) {
1280 return _table(_roottable)->Set(key,val);
1286 bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target)
1288 SQObjectPtr temp_reg;
1292 newobj = _table(self)->Clone();
1295 newobj = _instance(self)->Clone(_ss(this));
1297 if(_delegable(newobj)->_delegate){
1300 CallMetaMethod(_delegable(newobj),MT_CLONED,2,temp_reg);
1305 target = _array(self)->Clone();
1307 default: return false;
1311 bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic)
1313 if(type(key) == OT_NULL) { Raise_Error(_SC("null cannot be used as index")); return false; }
1314 switch(type(self)) {
1316 bool rawcall = true;
1317 if(_table(self)->_delegate) {
1319 if(!_table(self)->Get(key,res)) {
1320 Push(self);Push(key);Push(val);
1321 rawcall = !CallMetaMethod(_table(self),MT_NEWSLOT,3,res);
1324 if(rawcall) _table(self)->NewSlot(key,val); //cannot fail
1329 Push(self);Push(key);Push(val);
1330 if(!CallMetaMethod(_instance(self),MT_NEWSLOT,3,res)) {
1331 Raise_Error(_SC("class instances do not support the new slot operator"));
1336 if(!_class(self)->NewSlot(_ss(this),key,val,bstatic)) {
1337 if(_class(self)->_locked) {
1338 Raise_Error(_SC("trying to modify a class that has already been instantiated"));
1342 SQObjectPtr oval = PrintObjVal(key);
1343 Raise_Error(_SC("the property '%s' already exists"),_stringval(oval));
1349 Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key));
1356 bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res)
1358 switch(type(self)) {
1363 bool handled = false;
1364 if(_delegable(self)->_delegate) {
1365 Push(self);Push(key);
1366 handled = CallMetaMethod(_delegable(self),MT_DELSLOT,2,t);
1370 if(type(self) == OT_TABLE) {
1371 if(_table(self)->Get(key,t)) {
1372 _table(self)->Remove(key);
1375 Raise_IdxError((SQObject &)key);
1380 Raise_Error(_SC("cannot delete a slot from %s"),GetTypeName(self));
1388 Raise_Error(_SC("attempt to delete a slot from a %s"),GetTypeName(self));
1394 bool SQVM::Call(SQObjectPtr &closure,SQInteger nparams,SQInteger stackbase,SQObjectPtr &outres,SQBool raiseerror)
1397 SQInteger prevstackbase = _stackbase;
1399 switch(type(closure)) {
1401 return Execute(closure, _top - nparams, nparams, stackbase,outres,raiseerror);
1403 case OT_NATIVECLOSURE:{
1405 return CallNative(_nativeclosure(closure), nparams, stackbase, outres,suspend);
1412 CreateClassInstance(_class(closure),outres,constr);
1413 if(type(constr) != OT_NULL) {
1414 _stack[stackbase] = outres;
1415 return Call(constr,nparams,stackbase,temp,raiseerror);
1425 assert(_stackbase == prevstackbase);
1431 bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,SQInteger nparams,SQObjectPtr &outres)
1433 SQObjectPtr closure;
1434 if(del->GetMetaMethod(this, mm, closure)) {
1435 if(Call(closure, nparams, _top - nparams, outres, SQFalse)) {
1444 void SQVM::Remove(SQInteger n) {
1445 n = (n >= 0)?n + _stackbase - 1:_top + n;
1446 for(SQInteger i = n; i < _top; i++){
1447 _stack[i] = _stack[i+1];
1449 _stack[_top] = _null_;
1454 _stack[--_top] = _null_;
1457 void SQVM::Pop(SQInteger n) {
1458 for(SQInteger i = 0; i < n; i++){
1459 _stack[--_top] = _null_;
1463 void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; }
1464 SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }
1465 SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }
1466 SQObjectPtr &SQVM::GetUp(SQInteger n) { return _stack[_top+n]; }
1467 SQObjectPtr &SQVM::GetAt(SQInteger n) { return _stack[n]; }
1470 void SQVM::dumpstack(SQInteger stackbase,bool dumpall)
1472 SQInteger size=dumpall?_stack.size():_top;
1474 scprintf(_SC("\n>>>>stack dump<<<<\n"));
1475 CallInfo &ci=_callsstack[_callsstacksize-1];
1476 scprintf(_SC("IP: %p\n"),ci._ip);
1477 scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);
1478 scprintf(_SC("prev top: %d\n"),ci._prevtop);
1479 for(SQInteger i=0;i<size;i++){
1480 SQObjectPtr &obj=_stack[i];
1481 if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));
1482 scprintf(_SC("[%d]:"),n);
1484 case OT_FLOAT: scprintf(_SC("FLOAT %.3f"),_float(obj));break;
1485 case OT_INTEGER: scprintf(_SC("INTEGER %d"),_integer(obj));break;
1486 case OT_BOOL: scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break;
1487 case OT_STRING: scprintf(_SC("STRING %s"),_stringval(obj));break;
1488 case OT_NULL: scprintf(_SC("NULL")); break;
1489 case OT_TABLE: scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break;
1490 case OT_ARRAY: scprintf(_SC("ARRAY %p"),_array(obj));break;
1491 case OT_CLOSURE: scprintf(_SC("CLOSURE [%p]"),_closure(obj));break;
1492 case OT_NATIVECLOSURE: scprintf(_SC("NATIVECLOSURE"));break;
1493 case OT_USERDATA: scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break;
1494 case OT_GENERATOR: scprintf(_SC("GENERATOR %p"),_generator(obj));break;
1495 case OT_THREAD: scprintf(_SC("THREAD [%p]"),_thread(obj));break;
1496 case OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break;
1497 case OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break;
1498 case OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break;
1499 case OT_WEAKREF: scprintf(_SC("WEAKERF %p"),_weakref(obj));break;
1504 scprintf(_SC("\n"));