2 see copyright notice in squirrel.h
4 #include "sqpcheader.h"
9 #include "sqfuncproto.h"
11 #include "sqclosure.h"
14 #include "squserdata.h"
18 #define TOP() (_stack[_top-1])
20 bool SQVM::BW_OP(unsigned int op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
23 SQInteger i1 = _integer(o1), i2 = _integer(o2);
24 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))
27 case BW_AND: res = i1 & i2; break;
28 case BW_OR: res = i1 | i2; break;
29 case BW_XOR: res = i1 ^ i2; break;
30 case BW_SHIFTL: res = i1 << i2; break;
31 case BW_SHIFTR: res = i1 >> i2; break;
32 case BW_USHIFTR:res = (SQInteger)(*((unsigned int*)&i1) >> i2); break;
33 default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; }
36 else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),GetTypeName(o1),GetTypeName(o2)); return false;}
41 bool SQVM::ARITH_OP(unsigned int op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
43 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
44 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER)) {
46 case '+': trg = _integer(o1) + _integer(o2); break;
47 case '-': trg = _integer(o1) - _integer(o2); break;
48 case '/': if(_integer(o2) == 0) { Raise_Error(_SC("division by zero")); return false; }
49 trg = _integer(o1) / _integer(o2);
51 case '*': trg = _integer(o1) * _integer(o2); break;
52 case '%': trg = _integer(o1) % _integer(o2); break;
56 case '+': trg = tofloat(o1) + tofloat(o2); break;
57 case '-': trg = tofloat(o1) - tofloat(o2); break;
58 case '/': trg = tofloat(o1) / tofloat(o2); break;
59 case '*': trg = tofloat(o1) * tofloat(o2); break;
60 case '%': trg = SQFloat(fmod((double)tofloat(o1),(double)tofloat(o2))); break;
64 if(op == '+' && (type(o1) == OT_STRING || type(o2) == OT_STRING)){
65 if(!StringCat(o1, o2, trg)) return false;
67 else if(!ArithMetaMethod(op,o1,o2,trg)) {
68 Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,GetTypeName(o1),GetTypeName(o2)); return false;
74 SQObjectPtr &stack_get(HSQUIRRELVM v,int idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));}
76 SQVM::SQVM(SQSharedState *ss)
81 _suspended_root=false;
87 _errorhandler = _null_;
89 INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);
96 _errorhandler = _null_;
99 int size=_stack.size();
100 for(int i=0;i<size;i++)
107 REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
110 bool SQVM::ArithMetaMethod(int op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)
114 case _SC('+'): mm=MT_ADD; break;
115 case _SC('-'): mm=MT_SUB; break;
116 case _SC('/'): mm=MT_DIV; break;
117 case _SC('*'): mm=MT_MUL; break;
118 case _SC('%'): mm=MT_MODULO; break;
119 default: mm=MT_ADD; assert(0); break;
121 if(is_delegable(o1) && _delegable(o1)->_delegate) {
123 return CallMetaMethod(_delegable(o1),mm,2,dest);
128 bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
141 if(_delegable(o)->_delegate) {
143 if(CallMetaMethod(_delegable(o), MT_UNM, 1, temp_reg)) {
152 Raise_Error(_SC("attempt to negate a %s"), GetTypeName(o));
156 #define _RET_SUCCEED(exp) { result = (exp); return true; }
157 bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,int &result)
159 if(type(o1)==type(o2)){
160 if(_userpointer(o1)==_userpointer(o2))_RET_SUCCEED(0);
164 _RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2)));
166 _RET_SUCCEED(_integer(o1)-_integer(o2));
168 _RET_SUCCEED((_float(o1)<_float(o2))?-1:1);
173 if(_delegable(o1)->_delegate)CallMetaMethod(_delegable(o1),MT_CMP,2,res);
178 if(type(res)!=OT_INTEGER) { Raise_CompareError(o1,o2); return false; }
179 _RET_SUCCEED(_integer(res));
182 if(sq_isnumeric(o1) && sq_isnumeric(o2)){
183 if((type(o1)==OT_INTEGER) && (type(o2)==OT_FLOAT)) {
184 if( _integer(o1)==_float(o2) ) { _RET_SUCCEED(0); }
185 else if( _integer(o1)<_float(o2) ) { _RET_SUCCEED(-1); }
189 if( _float(o1)==_integer(o2) ) { _RET_SUCCEED(0); }
190 else if( _float(o1)<_integer(o2) ) { _RET_SUCCEED(-1); }
194 else if(type(o1)==OT_NULL) {_RET_SUCCEED(-1);}
195 else if(type(o2)==OT_NULL) {_RET_SUCCEED(1);}
196 else { Raise_CompareError(o1,o2); return false; }
200 _RET_SUCCEED(0); //cannot happen
203 bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)
206 if(ObjCmp(o1,o2,r)) {
208 case CMP_G: res = (r > 0)?_true_:_false_; return true;
209 case CMP_GE: res = (r >= 0)?_true_:_false_; return true;
210 case CMP_L: res = (r < 0)?_true_:_false_; return true;
211 case CMP_LE: res = (r <= 0)?_true_:_false_; return true;
219 bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)
226 int l=_string(str)->_len,ol=_string(obj)->_len;
227 SQChar *s=_sp(rsl(l+ol+1));
228 memcpy(s,_stringval(str),rsl(l));memcpy(s+l,_stringval(obj),rsl(ol));s[l+ol]=_SC('\0');
232 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(obj)->_len+1)),_SC("%g%s"),_float(str),_stringval(obj));
235 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(obj)->_len+1)),_SC("%d%s"),_integer(str),_stringval(obj));
238 Raise_Error(_SC("string concatenation between '%s' and '%s'"),GetTypeName(str),GetTypeName(obj));
241 dest=SQString::Create(_ss(this),_spval);
244 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(str)->_len+1)),_SC("%s%g"),_stringval(str),_float(obj));
245 dest=SQString::Create(_ss(this),_spval);
248 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+_string(str)->_len+1)),_SC("%s%d"),_stringval(str),_integer(obj));
249 dest=SQString::Create(_ss(this),_spval);
252 Raise_Error(_SC("string concatenation between '%s' and '%s'"),GetTypeName(str),GetTypeName(obj));
258 const SQChar *IdType2Name(SQObjectType type)
260 switch(_RAW_TYPE(type))
262 case _RT_NULL:return _SC("null");
263 case _RT_INTEGER:return _SC("integer");
264 case _RT_FLOAT:return _SC("float");
265 case _RT_BOOL:return _SC("bool");
266 case _RT_STRING:return _SC("string");
267 case _RT_TABLE:return _SC("table");
268 case _RT_ARRAY:return _SC("array");
269 case _RT_GENERATOR:return _SC("generator");
271 case _RT_NATIVECLOSURE:
272 return _SC("function");
274 case _RT_USERPOINTER:
275 return _SC("userdata");
276 case _RT_THREAD: return _SC("thread");
277 case _RT_FUNCPROTO: return _SC("function");
278 case _RT_CLASS: return _SC("class");
279 case _RT_INSTANCE: return _SC("instance");
285 const SQChar *GetTypeName(const SQObjectPtr &obj1)
287 return IdType2Name(type(obj1));
290 void SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
292 if(is_delegable(obj1) && _delegable(obj1)->_delegate) {
294 if(CallMetaMethod(_delegable(obj1),MT_TYPEOF,1,dest))
297 dest = SQString::Create(_ss(this),GetTypeName(obj1));
300 bool SQVM::Init(SQVM *friendvm, int stacksize)
302 _stack.resize(stacksize);
303 _callsstack.reserve(4);
307 _roottable = SQTable::Create(_ss(this), 0);
309 _roottable = friendvm->_roottable;
310 _errorhandler = friendvm->_errorhandler;
311 _debughook = friendvm->_debughook;
314 sq_base_register(this);
318 extern SQInstructionDesc g_InstrDesc[];
320 bool SQVM::StartCall(SQClosure *closure,int target,int nargs,int stackbase,bool tailcall)
322 SQFunctionProto *func = _funcproto(closure->_function);
323 //const int outerssize = func->_outervalues.size();
325 const int paramssize = func->_parameters.size();
326 // const int oldtop = _top;
327 const int newtop = stackbase + func->_stacksize;
332 if (nargs < paramssize) {
333 Raise_Error(_SC("wrong number of parameters"));
336 for(int n = 0; n < nargs - paramssize; n++) {
337 _vargsstack.push_back(_stack[stackbase+paramssize+n]);
338 _stack[stackbase+paramssize+n] = _null_;
342 if (paramssize != nargs) {
343 Raise_Error(_SC("wrong number of parameters"));
350 PUSH_CALLINFO(this, CallInfo());
352 ci->_prevstkbase = stackbase - _stackbase;
353 ci->_target = target;
354 ci->_prevtop = _top - _stackbase;
361 ci->_vargs.size = (nargs - paramssize);
362 ci->_vargs.base = _vargsstack.size()-(nargs - paramssize);
363 ci->_closure._unVal.pClosure = closure;
364 ci->_closure._type = OT_CLOSURE;
365 ci->_iv = &func->_instructions;
366 ci->_literals = &func->_literals;
367 //grows the stack if needed
368 if (((unsigned int)newtop + (func->_stacksize<<1)) > _stack.size()) {
369 _stack.resize(_stack.size() + (func->_stacksize<<1));
373 _stackbase = stackbase;
374 ci->_ip = ci->_iv->_vals;
378 bool SQVM::Return(int _arg0, int _arg1, SQObjectPtr &retval)
380 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
381 for(int i=0;i<ci->_ncalls;i++)
382 CallDebugHook(_SC('r'));
384 bool broot = ci->_root;
386 int target = ci->_target;
387 int oldstackbase = _stackbase;
388 _stackbase -= ci->_prevstkbase;
389 _top = _stackbase + ci->_prevtop;
390 PopVarArgs(ci->_vargs);
393 if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack[oldstackbase+_arg1];
394 else retval = _null_;
397 if (_arg0 != MAX_FUNC_STACKSIZE)
398 STK(target) = _stack[oldstackbase+_arg1];
400 STK(target) = _null_;
403 while (last_top >= _top) _stack[last_top--].Null();
404 assert(oldstackbase >= _stackbase);
408 #define _RET_ON_FAIL(exp) { if(!exp) return false; }
410 bool SQVM::LOCAL_INC(int op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
412 _RET_ON_FAIL(ARITH_OP( op , target, a, incr));
417 bool SQVM::PLOCAL_INC(int op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
420 _RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
426 bool SQVM::DerefInc(int op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)
428 SQObjectPtr tmp, tself = self, tkey = key;
429 if (!Get(tself, tkey, tmp, false, true)) { Raise_IdxError(tkey); return false; }
430 _RET_ON_FAIL(ARITH_OP( op , target, tmp, incr))
431 Set(tself, tkey, target,true);
432 if (postfix) target = tmp;
436 #define arg0 (_i_._arg0)
437 #define arg1 (_i_._arg1)
438 #define sarg1 (*((int *)&_i_._arg1))
439 #define arg2 (_i_._arg2)
440 #define arg3 (_i_._arg3)
441 #define sarg3 (*((char *)&_i_._arg3))
443 SQRESULT SQVM::Suspend()
446 return sq_throwerror(this, _SC("cannot suspend an already suspended vm"));
447 if (_nnativecalls!=2)
448 return sq_throwerror(this, _SC("cannot suspend through native calls/metamethods"));
449 return SQ_SUSPEND_FLAG;
452 void SQVM::PopVarArgs(VarArgs &vargs)
454 for(int n = 0; n< vargs.size; n++)
455 _vargsstack.pop_back();
458 #define _FINISH(stoploop) {finished = stoploop; return true; }
459 bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
460 &o3,SQObjectPtr &o4,int arg_2,bool &finished)
465 if((nrefidx = _table(o1)->Next(o4, o2, o3)) == -1) _FINISH(true);
466 o4 = (SQInteger)nrefidx; _FINISH(false);
468 if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(true);
469 o4 = (SQInteger) nrefidx; _FINISH(false);
471 if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(true);
472 o4 = (SQInteger)nrefidx; _FINISH(false);
474 if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(true);
475 o4 = (SQInteger)nrefidx; _FINISH(false);
478 if(_delegable(o1)->_delegate) {
482 if(CallMetaMethod(_delegable(o1), MT_NEXTI, 2, itr)){
484 if(type(itr) == OT_NULL) _FINISH(true);
485 if(!Get(o1, itr, o3, false,false)) {
486 Raise_Error(_SC("_nexti returned an invalid idx"));
491 Raise_Error(_SC("_nexti failed"));
496 if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(true);
497 if(_generator(o1)->_state == SQGenerator::eSuspended) {
499 if(type(o4) == OT_INTEGER) {
500 idx = _integer(o4) + 1;
504 _generator(o1)->Resume(this, arg_2+1);
510 Raise_Error(_SC("cannot iterate %s"), GetTypeName(o1));
511 return false; //cannot be hit(just to avoid warnings)
514 bool SQVM::DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2)
516 if(type(o1) != OT_TABLE) { Raise_Error(_SC("delegating a '%s'"), GetTypeName(o1)); return false; }
519 if(!_table(o1)->SetDelegate(_table(o2))){
520 Raise_Error(_SC("delegate cycle detected"));
525 _table(o1)->SetDelegate(NULL);
528 Raise_Error(_SC("using '%s' as delegate"), GetTypeName(o2));
535 #define COND_LITERAL (arg3!=0?(*ci->_literals)[arg1]:STK(arg1))
537 #define _GUARD(exp) { if(!exp) { Raise_Error(_lasterror); SQ_THROW();} }
539 #define SQ_THROW() { goto exception_trap; }
541 bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
544 SQClosure *closure = SQClosure::Create(_ss(this), func);
545 if( (nouters = func->_outervalues.size()) ) {
546 closure->_outervalues.reserve(nouters);
547 for(int i = 0; i<nouters; i++) {
548 SQOuterVar &v = func->_outervalues[i];
551 closure->_outervalues.push_back(_null_);
552 if(!Get(_stack._vals[_stackbase]/*STK(0)*/, v._src, closure->_outervalues.top(), false,true))
553 {Raise_IdxError(v._src); return false; }
556 closure->_outervalues.push_back(_stack._vals[_stackbase+_integer(v._src)]);
559 closure->_outervalues.push_back(_closure(ci->_closure)->_outervalues[_integer(v._src)]);
569 bool SQVM::GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &index,CallInfo *ci)
571 if(ci->_vargs.size == 0) {
572 Raise_Error(_SC("the function doesn't have var args"));
575 if(!sq_isnumeric(index)){
576 Raise_Error(_SC("indexing 'vargv' with %s"),GetTypeName(index));
579 int idx = tointeger(index);
580 if(idx < 0 || idx >= ci->_vargs.size){ Raise_Error(_SC("vargv index out of range")); return false; }
581 target = _vargsstack[ci->_vargs.base+idx];
585 bool SQVM::CLASS_OP(SQObjectPtr &target,int baseclass,int attributes)
587 SQClass *base = NULL;
589 if(baseclass != MAX_LITERALS) {
590 if(type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { Raise_Error(_SC("trying to inherit from a %s"),GetTypeName(_stack._vals[_stackbase+baseclass])); return false; }
591 base = _class(_stack._vals[_stackbase + baseclass]);
593 if(attributes != MAX_FUNC_STACKSIZE) {
594 attrs = _stack._vals[_stackbase+attributes];
596 target = SQClass::Create(_ss(this),base);
597 _class(target)->_attributes = attrs;
601 bool SQVM::IsFalse(SQObjectPtr &o)
603 SQObjectType t = type(o);
604 if((t & SQOBJECT_CANBEFALSE)
605 && ((t == OT_NULL) || ((t == OT_INTEGER || t == OT_BOOL) && _integer(o) == 0)
606 || (t == OT_FLOAT && _float(o) == SQFloat(0.0)))) {
612 bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)
614 if(type(o1) == type(o2)) {
615 res = ((_userpointer(o1) == _userpointer(o2)?true:false));
618 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
620 if(!ObjCmp(o1, o2,cmpres)) return false;
630 bool SQVM::Execute(SQObjectPtr &closure, int target, int nargs, int stackbase,SQObjectPtr &outres, ExecutionType et)
632 if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
634 AutoDec ad(&_nnativecalls);
636 //temp_reg vars for OP_CALL
642 if(!StartCall(_closure(closure), _top - nargs, nargs, stackbase, false)) {
643 //call the handler if there are no calls in the stack, if not relies on the previous node
644 if(ci == NULL) CallErrorHandler(_lasterror);
649 case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = true; traps += ci->_etraps; break;
651 traps = _suspended_traps;
652 ci->_root = _suspended_root;
662 const SQInstruction &_i_ = *ci->_ip++;
663 //dumpstack(_stackbase);
664 //scprintf("\n[%d] %s %d %d %d %d\n",ci->_ip-ci->_iv->_vals,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3);
668 if(type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
669 CallDebugHook(_SC('l'),arg1);
671 case _OP_LOAD: TARGET = (*ci->_literals)[arg1]; continue;
673 temp_reg = STK(arg1);
674 if (type(temp_reg) == OT_CLOSURE){
676 PopVarArgs(ci->_vargs);
677 for (int i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);
678 ct_target = ci->_target;
684 temp_reg = STK(arg1);
687 switch (type(temp_reg)) {
689 StartCall(_closure(temp_reg), ct_target, arg3, ct_tailcall?_stackbase:_stackbase+arg2, ct_tailcall);
690 if (_funcproto(_closure(temp_reg)->_function)->_bgenerator) {
691 SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(temp_reg));
692 _GUARD(gen->Yield(this));
693 Return(1, ct_target, temp_reg);
694 STK(ct_target) = gen;
695 while (last_top >= _top) _stack[last_top--].Null();
698 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
699 CallDebugHook(_SC('c'));
702 case OT_NATIVECLOSURE: {
704 _GUARD(CallNative(_nativeclosure(temp_reg), arg3, _stackbase+arg2, ct_tailcall, temp_reg,suspend));
707 _suspended_target = ct_target;
708 _suspended_root = ci->_root;
709 _suspended_traps = traps;
713 STK(ct_target) = temp_reg;
717 _GUARD(CreateClassInstance(_class(temp_reg),arg3,_stackbase+arg2,STK(ct_target)));
725 for (int i = 0; i < arg3; i++) Push(STK(arg2 + i));
726 if (_delegable(temp_reg) && CallMetaMethod(_delegable(temp_reg), MT_CALL, arg3+1, temp_reg)){
727 STK(ct_target) = temp_reg;
730 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(temp_reg));
734 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(temp_reg));
740 if (!Get(STK(arg2), STK(arg1), temp_reg, false,true))
741 { Raise_IdxError(STK(arg1)); SQ_THROW(); }
742 goto common_prepcall;
744 if (!Get(STK(arg2), (*ci->_literals)[arg1], temp_reg,false,true)) {
745 if(type(STK(arg2)) == OT_CLASS) { //hack?
746 if(_class_ddel->Get((*ci->_literals)[arg1],temp_reg)) {
747 STK(arg3) = STK(arg2);
752 { Raise_IdxError((*ci->_literals)[arg1]); SQ_THROW();}
755 if(type(STK(arg2)) == OT_CLASS) {
756 STK(arg3) = STK(0); // this
759 STK(arg3) = STK(arg2);
764 if (!Get(STK(arg2), (*ci->_literals)[arg1], temp_reg, false,true)) { Raise_IdxError((*ci->_literals)[arg1]); SQ_THROW();}
767 case _OP_MOVE: TARGET = STK(arg1); continue;
769 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3)));
770 if(arg0 != arg3) TARGET = STK(arg3);
772 case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue;
774 if (!Set(STK(arg1), STK(arg2), STK(arg3),true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
775 if (arg0 != arg3) TARGET = STK(arg3);
778 if (!Get(STK(arg1), STK(arg2), temp_reg, false,true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
783 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
784 TARGET = res?_true_:_false_;
788 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
789 TARGET = (!res)?_true_:_false_;
791 case _OP_ARITH: _GUARD(ARITH_OP( arg3 , temp_reg, STK(arg2), STK(arg1))); TARGET = temp_reg; continue;
792 case _OP_BITW: _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;
794 if(type((ci)->_generator) == OT_GENERATOR) {
795 _generator((ci)->_generator)->Kill();
797 if(Return(arg0, arg1, temp_reg)){
803 case _OP_LOADNULLS:{ for(unsigned int n=0;n<arg1;n++) STK(arg0+n) = _null_; }continue;
804 case _OP_LOADROOTTABLE: TARGET = _roottable; continue;
805 case _OP_LOADBOOL: TARGET = arg1?_true_:_false_; continue;
806 case _OP_DMOVE: STK(arg0) = STK(arg1); STK(arg2) = STK(arg3); continue;
807 case _OP_JMP: ci->_ip += (sarg1); continue;
808 case _OP_JNZ: if(!IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
809 case _OP_JZ: if(IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
810 case _OP_LOADFREEVAR: TARGET = _closure(ci->_closure)->_outervalues[arg1]; continue;
811 case _OP_VARGC: TARGET = SQInteger(ci->_vargs.size); continue;
813 if(!GETVARGV_OP(TARGET,STK(arg1),ci)) { SQ_THROW(); }
815 case _OP_NEWTABLE: TARGET = SQTable::Create(_ss(this), arg1); continue;
816 case _OP_NEWARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue;
817 case _OP_APPENDARRAY: _array(STK(arg0))->Append(COND_LITERAL); continue;
819 switch(type(STK(arg1))) {
821 TARGET = _table(STK(arg1))->_delegate?SQObjectPtr(_table(STK(arg1))->_delegate):_null_;
823 case OT_CLASS: TARGET = _class(STK(arg1))->_base?_class(STK(arg1))->_base:_null_;
828 Raise_Error(_SC("the %s type doesn't have a parent slot"), GetTypeName(STK(arg1)));
831 case _OP_COMPARITH: _GUARD(DerefInc(arg3, TARGET, STK((((unsigned int)arg1&0xFFFF0000)>>16)), STK(arg2), STK(arg1&0x0000FFFF), false)); continue;
832 case _OP_COMPARITHL: _GUARD(LOCAL_INC(arg3, TARGET, STK(arg1), STK(arg2))); continue;
833 case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, false));} continue;
834 case _OP_INCL: {SQObjectPtr o(sarg3); _GUARD(LOCAL_INC('+',TARGET, STK(arg1), o));} continue;
835 case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, true));} continue;
836 case _OP_PINCL: {SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o));} continue;
837 case _OP_CMP: _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET)) continue;
838 case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, true,false)?_true_:_false_;continue;
840 if(type(STK(arg1)) != OT_CLASS || type(STK(arg2)) != OT_INSTANCE)
841 {Raise_Error(_SC("cannot apply instanceof between a %s and a %s"),GetTypeName(STK(arg1)),GetTypeName(STK(arg2))); SQ_THROW();}
842 TARGET = _instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?_true_:_false_;
845 if(IsFalse(STK(arg2))) {
851 if(!IsFalse(STK(arg2))) {
856 case _OP_NEG: _GUARD(NEG_OP(TARGET,STK(arg1))); continue;
857 case _OP_NOT: TARGET = (IsFalse(STK(arg1))?_true_:_false_); continue;
859 if(type(STK(arg1)) == OT_INTEGER) {
860 TARGET = SQInteger(~_integer(STK(arg1)));
863 Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1)));
866 SQClosure *c = ci->_closure._unVal.pClosure;
867 SQFunctionProto *fp = c->_function._unVal.pFunctionProto;
868 if(!CLOSURE_OP(TARGET,fp->_functions[arg1]._unVal.pFunctionProto)) { SQ_THROW(); }
872 if(type(ci->_generator) == OT_GENERATOR) {
873 if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1);
874 _GUARD(_generator(ci->_generator)->Yield(this));
875 traps -= ci->_etraps;
876 if(sarg1 != MAX_FUNC_STACKSIZE) STK(arg1) = temp_reg;
878 else { Raise_Error(_SC("trying to yield a '%s',only genenerator can be yielded"), GetTypeName(ci->_generator)); SQ_THROW();}
879 if(Return(arg0, arg1, temp_reg)){
888 if(type(STK(arg1)) != OT_GENERATOR){ Raise_Error(_SC("trying to resume a '%s',only genenerator can be resumed"), GetTypeName(STK(arg1))); SQ_THROW();}
889 _GUARD(_generator(STK(arg1))->Resume(this, arg0));
890 traps += ci->_etraps;
892 case _OP_FOREACH:{ bool finished;
893 _GUARD(FOREACH_OP(STK(arg0),STK(arg2),STK(arg2+1),STK(arg2+2),arg2,finished));
894 if(finished) ci->_ip += sarg1; }
896 case _OP_DELEGATE: _GUARD(DELEGATE_OP(TARGET,STK(arg1),STK(arg2))); continue;
898 if(!Clone(STK(arg1), TARGET))
899 { Raise_Error(_SC("cloning a %s"), GetTypeName(STK(arg1))); SQ_THROW();}
901 case _OP_TYPEOF: TypeOf(STK(arg1), TARGET); continue;
903 _etraps.push_back(SQExceptionTrap(_top,_stackbase, &ci->_iv->_vals[(ci->_ip-ci->_iv->_vals)+arg1], arg0)); traps++;
907 for(int i=0; i<arg0; i++) {
908 _etraps.pop_back(); traps--;
912 case _OP_THROW: Raise_Error(TARGET); SQ_THROW(); continue;
913 case _OP_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;
915 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3)));
916 _class(STK(arg1))->SetAttributes(STK(arg2),STK(arg2-1));
917 if(arg0 != arg3) TARGET = STK(arg3);
925 SQObjectPtr currerror = _lasterror;
926 // dumpstack(_stackbase);
932 if(ci->_etraps > 0) {
933 SQExceptionTrap &et = _etraps.top();
935 _top = et._stacksize;
936 _stackbase = et._stackbase;
937 _stack[_stackbase+et._extarget] = currerror;
938 _etraps.pop_back(); traps--; ci->_etraps--;
939 while(last_top >= _top) _stack[last_top--].Null();
940 goto exception_restore;
942 //if is a native closure
943 if(type(ci->_closure) != OT_CLOSURE && n)
945 if(type(ci->_generator) == OT_GENERATOR) _generator(ci->_generator)->Kill();
946 PopVarArgs(ci->_vargs);
949 }while(_callsstack.size());
952 CallErrorHandler(currerror);
953 //remove call stack until a C function is found or the cstack is empty
955 bool exitafterthisone = ci->_root;
956 if(type(ci->_generator) == OT_GENERATOR) _generator(ci->_generator)->Kill();
957 _stackbase -= ci->_prevstkbase;
958 _top = _stackbase + ci->_prevtop;
959 PopVarArgs(ci->_vargs);
961 if( (ci && type(ci->_closure) != OT_CLOSURE) || exitafterthisone) break;
962 }while(_callsstack.size());
964 while(last_top >= _top) _stack[last_top--].Null();
966 _lasterror = currerror;
972 bool SQVM::CreateClassInstance(SQClass *theclass, int nargs, int stackbase, SQObjectPtr &retval)
975 SQObjectPtr inst = theclass->CreateInstance();
976 _stack[stackbase] = inst;
977 if(theclass->Get(_ss(this)->_constructoridx,constr)) {
978 if(!Call(constr,nargs,stackbase,constr))
985 void SQVM::CallErrorHandler(SQObjectPtr &error)
987 if(type(_errorhandler) != OT_NULL) {
989 Push(_roottable); Push(error);
990 Call(_errorhandler, 2, _top-2, out);
995 void SQVM::CallDebugHook(int type,int forcedline)
997 SQObjectPtr temp_reg;
999 SQFunctionProto *func=_funcproto(_closure(ci->_closure)->_function);
1000 Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);
1001 Call(_debughook,nparams,_top-nparams,temp_reg);
1005 bool SQVM::CallNative(SQNativeClosure *nclosure,int nargs,int stackbase,bool tailcall,SQObjectPtr &retval,bool &suspend)
1008 if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
1009 int nparamscheck = nclosure->_nparamscheck;
1010 if(((nparamscheck > 0) && (nparamscheck != nargs))
1011 || ((nparamscheck < 0) && (nargs < (-nparamscheck)))) {
1012 Raise_Error(_SC("wrong number of parameters"));
1017 if( (tcs = nclosure->_typecheck.size()) ) {
1018 for(int i = 0; i < nargs && i < tcs; i++)
1019 if((nclosure->_typecheck[i] != -1) && !(type(_stack[stackbase+i]) & nclosure->_typecheck[i])) {
1020 Raise_ParamTypeError(i,nclosure->_typecheck[i],type(_stack[stackbase+i]));
1025 if ((_top + MIN_STACK_OVERHEAD) > (int)_stack.size()) {
1026 _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));
1029 int oldstackbase = _stackbase;
1030 _top = stackbase + nargs;
1031 PUSH_CALLINFO(this, CallInfo());
1033 ci->_closure._unVal.pNativeClosure = nclosure;
1034 ci->_closure._type = OT_NATIVECLOSURE;
1035 ci->_prevstkbase = stackbase - _stackbase;
1037 _stackbase = stackbase;
1038 //push free variables
1039 int outers = nclosure->_outervalues.size();
1040 for (int i = 0; i < outers; i++) {
1041 Push(nclosure->_outervalues[i]);
1043 ci->_prevtop = (oldtop - oldstackbase);
1044 int ret = (nclosure->_function)(this);
1047 if( ret == SQ_SUSPEND_FLAG) suspend = true;
1049 _stackbase = oldstackbase;
1052 Raise_Error(_lasterror);
1056 if (ret != 0){ retval = TOP(); }
1057 else { retval = _null_; }
1058 _stackbase = oldstackbase;
1064 bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, bool fetchroot)
1068 if(_table(self)->Get(key,dest))return true;
1071 if(sq_isnumeric(key)){
1072 return _array(self)->Get(tointeger(key),dest);
1076 if(_instance(self)->Get(key,dest)) return true;
1081 if(FallBackGet(self,key,dest,raw)) return true;
1084 if(_rawval(STK(0)) == _rawval(self) &&
1085 type(STK(0)) == type(self)) {
1086 return _table(_roottable)->Get(key,dest);
1092 bool SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw)
1096 return _class(self)->Get(key,dest);
1101 if(_delegable(self)->_delegate) {
1102 if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,raw,false))
1104 if(raw)return false;
1105 Push(self);Push(key);
1106 if(CallMetaMethod(_delegable(self),MT_GET,2,dest))
1109 if(type(self) == OT_TABLE) {
1110 if(raw) return false;
1111 return _table_ddel->Get(key,dest);
1116 if(raw)return false;
1117 return _array_ddel->Get(key,dest);
1119 if(sq_isnumeric(key)){
1120 SQInteger n=tointeger(key);
1121 if(abs(n)<_string(self)->_len){
1122 if(n<0)n=_string(self)->_len-n;
1123 dest=SQInteger(_stringval(self)[n]);
1129 if(raw)return false;
1130 return _string_ddel->Get(key,dest);
1134 if(raw)return false;
1135 Push(self);Push(key);
1136 if(!CallMetaMethod(_delegable(self),MT_GET,2,dest)) {
1137 return _instance_ddel->Get(key,dest);
1140 case OT_INTEGER:case OT_FLOAT:case OT_BOOL:
1141 if(raw)return false;
1142 return _number_ddel->Get(key,dest);
1144 if(raw)return false;
1145 return _generator_ddel->Get(key,dest);
1146 case OT_CLOSURE: case OT_NATIVECLOSURE:
1147 if(raw)return false;
1148 return _closure_ddel->Get(key,dest);
1150 if(raw)return false;
1151 return _thread_ddel->Get(key,dest);
1152 default:return false;
1157 bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool fetchroot)
1161 if(_table(self)->Set(key,val))
1163 if(_table(self)->_delegate) {
1164 if(Set(_table(self)->_delegate,key,val,false)) {
1170 if(_delegable(self)->_delegate) {
1172 Push(self);Push(key);Push(val);
1173 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1177 if(_instance(self)->Set(key,val))
1180 Push(self);Push(key);Push(val);
1181 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1185 if(!sq_isnumeric(key)) {Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); return false; }
1186 return _array(self)->Set(tointeger(key),val);
1188 Raise_Error(_SC("trying to set '%s'"),GetTypeName(self));
1192 if(_rawval(STK(0)) == _rawval(self) &&
1193 type(STK(0)) == type(self)) {
1194 return _table(_roottable)->Set(key,val);
1200 bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target)
1202 SQObjectPtr temp_reg;
1205 target = _table(self)->Clone();
1208 target = _instance(self)->Clone(_ss(this));
1210 if(_delegable(target)->_delegate){
1213 CallMetaMethod(_delegable(target),MT_CLONED,2,temp_reg);
1217 target=_array(self)->Clone();
1219 default: return false;
1223 bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val)
1225 if(type(key) == OT_NULL) { Raise_Error(_SC("null cannot be used as index")); return false; }
1226 switch(type(self)) {
1228 bool rawcall = true;
1229 if(_table(self)->_delegate) {
1231 if(!_table(self)->Get(key,res)) {
1232 Push(self);Push(key);Push(val);
1233 rawcall = !CallMetaMethod(_table(self),MT_NEWSLOT,3,res);
1236 if(rawcall) _table(self)->NewSlot(key,val); //cannot fail
1240 if(!_class(self)->NewSlot(key,val)) {
1241 if(_class(self)->_locked) {
1242 Raise_Error(_SC("trying to modify a class that has already been instantiated"));
1246 SQObjectPtr oval = PrintObjVal(key);
1247 Raise_Error(_SC("the property '%s' already exists"),_stringval(oval));
1253 Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key));
1260 bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res)
1262 switch(type(self)) {
1267 bool handled = false;
1268 if(_delegable(self)->_delegate) {
1269 Push(self);Push(key);
1270 handled = CallMetaMethod(_delegable(self),MT_DELSLOT,2,t);
1274 if(type(self) == OT_TABLE) {
1275 if(_table(self)->Get(key,t)) {
1276 _table(self)->Remove(key);
1279 Raise_IdxError((SQObject &)key);
1284 Raise_Error(_SC("cannot delete a slot from %s"),GetTypeName(self));
1292 Raise_Error(_SC("attempt to delete a slot from a %s"),GetTypeName(self));
1298 bool SQVM::Call(SQObjectPtr &closure,int nparams,int stackbase,SQObjectPtr &outres)
1301 int prevstackbase = _stackbase;
1303 switch(type(closure)) {
1305 return Execute(closure, _top - nparams, nparams, stackbase,outres);
1307 case OT_NATIVECLOSURE:{
1309 return CallNative(_nativeclosure(closure), nparams, stackbase, false, outres,suspend);
1314 return CreateClassInstance(_class(closure),nparams,stackbase,outres);
1321 assert(_stackbase == prevstackbase);
1327 bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,int nparams,SQObjectPtr &outres)
1329 SQObjectPtr closure;
1330 if(del->GetMetaMethod(mm, closure)) {
1331 if(Call(closure, nparams, _top - nparams, outres)) {
1341 _stack[--_top] = _null_;
1343 void SQVM::Pop(int n) {
1344 for(int i = 0; i < n; i++){
1345 _stack[--_top] = _null_;
1349 void SQVM::Remove(int n) {
1350 n = (n >= 0)?n + _stackbase - 1:_top + n;
1351 for(int i = n; i < _top; i++){
1352 _stack[i] = _stack[i+1];
1354 _stack[_top] = _null_;
1358 void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; }
1359 SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }
1360 SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }
1361 SQObjectPtr &SQVM::GetUp(int n) { return _stack[_top+n]; }
1362 SQObjectPtr &SQVM::GetAt(int n) { return _stack[n]; }
1365 void SQVM::dumpstack(int stackbase,bool dumpall)
1367 int size=dumpall?_stack.size():_top;
1369 scprintf(_SC("\n>>>>stack dump<<<<\n"));
1370 CallInfo &ci=_callsstack.back();
1371 scprintf(_SC("IP: %d\n"),ci._ip);
1372 scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);
1373 scprintf(_SC("prev top: %d\n"),ci._prevtop);
1374 for(int i=0;i<size;i++){
1375 SQObjectPtr &obj=_stack[i];
1376 if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));
1377 scprintf(_SC("[%d]:"),n);
1379 case OT_FLOAT: scprintf(_SC("FLOAT %.3f"),_float(obj));break;
1380 case OT_INTEGER: scprintf(_SC("INTEGER %d"),_integer(obj));break;
1381 case OT_BOOL: scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break;
1382 case OT_STRING: scprintf(_SC("STRING %s"),_stringval(obj));break;
1383 case OT_NULL: scprintf(_SC("NULL")); break;
1384 case OT_TABLE: scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break;
1385 case OT_ARRAY: scprintf(_SC("ARRAY %p"),_array(obj));break;
1386 case OT_CLOSURE: scprintf(_SC("CLOSURE [%p]"),_closure(obj));break;
1387 case OT_NATIVECLOSURE: scprintf(_SC("NATIVECLOSURE"));break;
1388 case OT_USERDATA: scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break;
1389 case OT_GENERATOR: scprintf(_SC("GENERATOR"));break;
1390 case OT_THREAD: scprintf(_SC("THREAD [%p]"),_thread(obj));break;
1391 case OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break;
1392 case OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break;
1393 case OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break;
1398 scprintf(_SC("\n"));