2 see copyright notice in squirrel.h
\r
4 #include "sqpcheader.h"
\r
7 #include "sqopcodes.h"
\r
8 #include "sqfuncproto.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
17 #define TOP() (_stack[_top-1])
\r
19 bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
\r
22 SQInteger i1 = _integer(o1), i2 = _integer(o2);
\r
23 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))
\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
35 else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),GetTypeName(o1),GetTypeName(o2)); return false;}
\r
40 bool SQVM::ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
\r
42 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
\r
43 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER)) {
\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
50 case '*': trg = _integer(o1) * _integer(o2); break;
\r
51 case '%': trg = _integer(o1) % _integer(o2); break;
\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
63 if(op == '+' && (type(o1) == OT_STRING || type(o2) == OT_STRING)){
\r
64 if(!StringCat(o1, o2, trg)) return false;
\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
73 SQVM::SQVM(SQSharedState *ss)
\r
76 _suspended = SQFalse;
\r
77 _suspended_target=-1;
\r
78 _suspended_root = SQFalse;
\r
79 _suspended_traps=-1;
\r
82 _lasterror = _null_;
\r
83 _errorhandler = _null_;
\r
84 _debughook = _null_;
\r
86 INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);
\r
89 void SQVM::Finalize()
\r
91 _roottable = _null_;
\r
92 _lasterror = _null_;
\r
93 _errorhandler = _null_;
\r
94 _debughook = _null_;
\r
96 SQInteger size=_stack.size();
\r
97 for(SQInteger i=0;i<size;i++)
\r
104 REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
\r
107 bool SQVM::ArithMetaMethod(SQInteger op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)
\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
118 if(is_delegable(o1) && _delegable(o1)->_delegate) {
\r
120 return CallMetaMethod(_delegable(o1),mm,2,dest);
\r
125 bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
\r
130 trg = -_integer(o);
\r
138 if(_delegable(o)->_delegate) {
\r
140 if(CallMetaMethod(_delegable(o), MT_UNM, 1, temp_reg)) {
\r
145 default:break; //shutup compiler
\r
147 Raise_Error(_SC("attempt to negate a %s"), GetTypeName(o));
\r
151 #define _RET_SUCCEED(exp) { result = (exp); return true; }
\r
152 bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result)
\r
154 if(type(o1)==type(o2)){
\r
155 if(_userpointer(o1)==_userpointer(o2))_RET_SUCCEED(0);
\r
159 _RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2)));
\r
161 _RET_SUCCEED(_integer(o1)-_integer(o2));
\r
163 _RET_SUCCEED((_float(o1)<_float(o2))?-1:1);
\r
168 if(_delegable(o1)->_delegate)CallMetaMethod(_delegable(o1),MT_CMP,2,res);
\r
170 default: break; //shutup compiler
\r
172 if(type(res)!=OT_INTEGER) { Raise_CompareError(o1,o2); return false; }
\r
173 _RET_SUCCEED(_integer(res));
\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
184 if( _float(o1)==_integer(o2) ) { _RET_SUCCEED(0); }
\r
185 else if( _float(o1)<_integer(o2) ) { _RET_SUCCEED(-1); }
\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
195 _RET_SUCCEED(0); //cannot happen
\r
198 bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)
\r
201 if(ObjCmp(o1,o2,r)) {
\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
214 void SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res)
\r
221 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%g"),_float(o));
\r
224 scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)),_SC("%d"),_integer(o));
\r
227 scsprintf(_sp(rsl(6)),_integer(o)?_SC("true"):_SC("false"));
\r
232 if(_delegable(o)->_delegate) {
\r
234 if(CallMetaMethod(_delegable(o),MT_TOSTRING,1,res)) {
\r
235 if(type(res) == OT_STRING)
\r
237 //else keeps going to the default
\r
241 scsprintf(_sp(rsl(sizeof(void*)+20)),_SC("(%s : 0x%p)"),GetTypeName(o),(void*)_rawval(o));
\r
243 res = SQString::Create(_ss(this),_spval);
\r
247 bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)
\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
260 const SQChar *IdType2Name(SQObjectType type)
\r
262 switch(_RAW_TYPE(type))
\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
273 case _RT_NATIVECLOSURE:
\r
274 return _SC("function");
\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
288 const SQChar *GetTypeName(const SQObjectPtr &obj1)
\r
290 return IdType2Name(type(obj1));
\r
293 void SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
\r
295 if(is_delegable(obj1) && _delegable(obj1)->_delegate) {
\r
297 if(CallMetaMethod(_delegable(obj1),MT_TYPEOF,1,dest))
\r
300 dest = SQString::Create(_ss(this),GetTypeName(obj1));
\r
303 bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)
\r
305 _stack.resize(stacksize);
\r
306 _callsstack.reserve(4);
\r
310 _roottable = SQTable::Create(_ss(this), 0);
\r
312 _roottable = friendvm->_roottable;
\r
313 _errorhandler = friendvm->_errorhandler;
\r
314 _debughook = friendvm->_debughook;
\r
317 sq_base_register(this);
\r
321 extern SQInstructionDesc g_InstrDesc[];
\r
323 bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger nargs,SQInteger stackbase,bool tailcall)
\r
325 SQFunctionProto *func = _funcproto(closure->_function);
\r
327 const SQInteger paramssize = func->_parameters.size();
\r
328 const SQInteger newtop = stackbase + func->_stacksize;
\r
331 if (paramssize != nargs) {
\r
332 if(func->_varparams)
\r
334 if (nargs < paramssize) {
\r
335 Raise_Error(_SC("wrong number of parameters"));
\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
344 Raise_Error(_SC("wrong number of parameters"));
\r
349 if(type(closure->_env) == OT_WEAKREF) {
\r
350 _stack[stackbase] = _weakref(closure->_env)->_obj;
\r
356 lc._prevstkbase = stackbase - _stackbase;
\r
357 lc._target = target;
\r
358 lc._prevtop = _top - _stackbase;
\r
360 lc._root = SQFalse;
\r
361 PUSH_CALLINFO(this, lc);
\r
365 if(ci->_vargs.size) PopVarArgs(ci->_vargs);
\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
379 _stackbase = stackbase;
\r
380 ci->_ip = ci->_iv->_vals;
\r
384 bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval)
\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
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
399 if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack[oldstackbase+_arg1];
\r
400 else retval = _null_;
\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
407 STK(target) = _null_;
\r
411 while (last_top >= _top) _stack[last_top--].Null();
\r
412 assert(oldstackbase >= _stackbase);
\r
413 return broot?true:false;
\r
416 #define _RET_ON_FAIL(exp) { if(!exp) return false; }
\r
418 bool SQVM::LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
\r
420 _RET_ON_FAIL(ARITH_OP( op , target, a, incr));
\r
425 bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
\r
428 _RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
\r
434 bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)
\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
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
451 SQRESULT SQVM::Suspend()
\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
460 void SQVM::PopVarArgs(VarArgs &vargs)
\r
462 for(SQInteger n = 0; n< vargs.size; n++)
\r
463 _vargsstack.pop_back();
\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
473 if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(true);
\r
474 o4 = (SQInteger)nrefidx; _FINISH(false);
\r
476 if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(true);
\r
477 o4 = (SQInteger) nrefidx; _FINISH(false);
\r
479 if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(true);
\r
480 o4 = (SQInteger)nrefidx; _FINISH(false);
\r
482 if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(true);
\r
483 o4 = (SQInteger)nrefidx; _FINISH(false);
\r
486 if(_delegable(o1)->_delegate) {
\r
490 if(CallMetaMethod(_delegable(o1), MT_NEXTI, 2, 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
499 Raise_Error(_SC("_nexti failed"));
\r
504 if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(true);
\r
505 if(_generator(o1)->_state == SQGenerator::eSuspended) {
\r
507 if(type(o4) == OT_INTEGER) {
\r
508 idx = _integer(o4) + 1;
\r
512 _generator(o1)->Resume(this, arg_2+1);
\r
516 Raise_Error(_SC("cannot iterate %s"), GetTypeName(o1));
\r
518 return false; //cannot be hit(just to avoid warnings)
\r
521 bool SQVM::DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2)
\r
523 if(type(o1) != OT_TABLE) { Raise_Error(_SC("delegating a '%s'"), GetTypeName(o1)); return false; }
\r
526 if(!_table(o1)->SetDelegate(_table(o2))){
\r
527 Raise_Error(_SC("delegate cycle detected"));
\r
532 _table(o1)->SetDelegate(NULL);
\r
535 Raise_Error(_SC("using '%s' as delegate"), GetTypeName(o2));
\r
542 #define COND_LITERAL (arg3!=0?(*ci->_literals)[arg1]:STK(arg1))
\r
544 #define _GUARD(exp) { if(!exp) { Raise_Error(_lasterror); SQ_THROW();} }
\r
546 #define SQ_THROW() { goto exception_trap; }
\r
548 bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
\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
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
563 closure->_outervalues.push_back(_stack._vals[_stackbase+_integer(v._src)]);
\r
566 closure->_outervalues.push_back(_closure(ci->_closure)->_outervalues[_integer(v._src)]);
\r
576 bool SQVM::GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &index,CallInfo *ci)
\r
578 if(ci->_vargs.size == 0) {
\r
579 Raise_Error(_SC("the function doesn't have var args"));
\r
582 if(!sq_isnumeric(index)){
\r
583 Raise_Error(_SC("indexing 'vargv' with %s"),GetTypeName(index));
\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
592 bool SQVM::CLASS_OP(SQObjectPtr &target,SQInteger baseclass,SQInteger attributes)
\r
594 SQClass *base = NULL;
\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
600 if(attributes != MAX_FUNC_STACKSIZE) {
\r
601 attrs = _stack._vals[_stackbase+attributes];
\r
603 target = SQClass::Create(_ss(this),base);
\r
604 if(type(_class(target)->_metamethods[MT_INHERITED]) != OT_NULL) {
\r
607 Push(target); Push(attrs);
\r
608 Call(_class(target)->_metamethods[MT_INHERITED],nparams,_top - nparams, ret, false);
\r
611 _class(target)->_attributes = attrs;
\r
617 bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)
\r
619 if(type(o1) == type(o2)) {
\r
620 res = ((_userpointer(o1) == _userpointer(o2)?true:false));
\r
623 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
\r
625 if(!ObjCmp(o1, o2,cmpres)) return false;
\r
626 res = (cmpres == 0);
\r
635 bool SQVM::IsFalse(SQObjectPtr &o)
\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
644 bool SQVM::GETPARENT_OP(SQObjectPtr &o,SQObjectPtr &target)
\r
647 case OT_TABLE: target = _table(o)->_delegate?SQObjectPtr(_table(o)->_delegate):_null_;
\r
649 case OT_CLASS: target = _class(o)->_base?_class(o)->_base:_null_;
\r
652 Raise_Error(_SC("the %s type doesn't have a parent slot"), GetTypeName(o));
\r
658 bool SQVM::Execute(SQObjectPtr &closure, SQInteger target, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et)
\r
660 if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
\r
662 AutoDec ad(&_nnativecalls);
\r
663 SQInteger traps = 0;
\r
664 //temp_reg vars for OP_CALL
\r
665 SQInteger ct_target;
\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
675 ci->_root = SQTrue;
\r
677 case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = SQTrue; traps += ci->_etraps; break;
\r
679 traps = _suspended_traps;
\r
680 ci->_root = _suspended_root;
\r
681 _suspended = SQFalse;
\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
696 if(type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
\r
697 CallDebugHook(_SC('l'),arg1);
\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
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
712 ct_tailcall = false;
\r
714 temp_reg = STK(arg1);
\r
716 SQInteger last_top = _top;
\r
717 switch (type(temp_reg)) {
\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
728 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
\r
729 CallDebugHook(_SC('c'));
\r
732 case OT_NATIVECLOSURE: {
\r
734 _GUARD(CallNative(_nativeclosure(temp_reg), arg3, _stackbase+arg2, ct_tailcall, temp_reg,suspend));
\r
736 _suspended = SQTrue;
\r
737 _suspended_target = ct_target;
\r
738 _suspended_root = ci->_root;
\r
739 _suspended_traps = traps;
\r
743 if(ct_target != -1) { //skip return value for contructors
\r
744 STK(ct_target) = temp_reg;
\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
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
769 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(temp_reg));
\r
773 Raise_Error(_SC("attempt to call '%s'"), GetTypeName(temp_reg));
\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
791 { Raise_IdxError((*ci->_literals)[arg1]); SQ_THROW();}
\r
794 if(type(STK(arg2)) == OT_CLASS) {
\r
795 STK(arg3) = STK(0); // this
\r
798 STK(arg3) = STK(arg2);
\r
803 if (!Get(STK(arg2), (*ci->_literals)[arg1], temp_reg, false,true)) { Raise_IdxError((*ci->_literals)[arg1]); SQ_THROW();}
\r
806 case _OP_MOVE: TARGET = STK(arg1); continue;
\r
808 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),false));
\r
809 if(arg0 != arg3) TARGET = STK(arg3);
\r
811 case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue;
\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
817 if (!Get(STK(arg1), STK(arg2), temp_reg, false,true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
\r
822 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
\r
823 TARGET = res?_true_:_false_;
\r
827 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
\r
828 TARGET = (!res)?_true_:_false_;
\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
833 if(type((ci)->_generator) == OT_GENERATOR) {
\r
834 _generator((ci)->_generator)->Kill();
\r
836 if(Return(arg0, arg1, temp_reg)){
\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
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
872 if(IsFalse(STK(arg2))) {
\r
873 TARGET = STK(arg2);
\r
874 ci->_ip += (sarg1);
\r
878 if(!IsFalse(STK(arg2))) {
\r
879 TARGET = STK(arg2);
\r
880 ci->_ip += (sarg1);
\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
886 if(type(STK(arg1)) == OT_INTEGER) {
\r
887 SQInteger t = _integer(STK(arg1));
\r
888 TARGET = SQInteger(~t);
\r
891 Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1)));
\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
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
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
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
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
924 case _OP_DELEGATE: _GUARD(DELEGATE_OP(TARGET,STK(arg1),STK(arg2))); continue;
\r
926 if(!Clone(STK(arg1), TARGET))
\r
927 { Raise_Error(_SC("cloning a %s"), GetTypeName(STK(arg1))); SQ_THROW();}
\r
929 case _OP_TYPEOF: TypeOf(STK(arg1), TARGET); continue;
\r
931 _etraps.push_back(SQExceptionTrap(_top,_stackbase, &ci->_iv->_vals[(ci->_ip-ci->_iv->_vals)+arg1], arg0)); traps++;
\r
935 for(SQInteger i = 0; i < arg0; i++) {
\r
936 _etraps.pop_back(); traps--;
\r
940 case _OP_THROW: Raise_Error(TARGET); SQ_THROW(); continue;
\r
941 case _OP_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;
\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
949 if(Call(_class(STK(arg1))->_metamethods[MT_NEWMEMBER], nparams, _top - nparams, temp_reg,SQFalse)) {
\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
966 SQObjectPtr currerror = _lasterror;
\r
967 // dumpstack(_stackbase);
\r
969 SQInteger last_top = _top;
\r
971 if(_ss(this)->_notifyallexceptions) CallErrorHandler(currerror);
\r
975 if(ci->_etraps > 0) {
\r
976 SQExceptionTrap &et = _etraps.top();
\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
985 //if is a native closure
\r
986 if(type(ci->_closure) != OT_CLOSURE && n)
\r
988 if(type(ci->_generator) == OT_GENERATOR) _generator(ci->_generator)->Kill();
\r
989 PopVarArgs(ci->_vargs);
\r
990 POP_CALLINFO(this);
\r
992 } while(_callsstack.size());
\r
996 if(raiseerror && !_ss(this)->_notifyallexceptions)
\r
997 CallErrorHandler(currerror);
\r
999 //remove call stack until a C function is found or the cstack is empty
\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
1010 while(last_top >= _top) _stack[last_top--].Null();
\r
1012 _lasterror = currerror;
\r
1018 bool SQVM::CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor)
\r
1020 inst = theclass->CreateInstance();
\r
1021 if(!theclass->Get(_ss(this)->_constructoridx,constructor)) {
\r
1022 //if(!Call(constr,nargs,stackbase,constr,false))
\r
1024 constructor = _null_;
\r
1029 void SQVM::CallErrorHandler(SQObjectPtr &error)
\r
1031 if(type(_errorhandler) != OT_NULL) {
\r
1033 Push(_roottable); Push(error);
\r
1034 Call(_errorhandler, 2, _top-2, out,SQFalse);
\r
1039 void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)
\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
1049 bool SQVM::CallNative(SQNativeClosure *nclosure,SQInteger nargs,SQInteger stackbase,bool tailcall,SQObjectPtr &retval,bool &suspend)
\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
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
1068 if ((_top + MIN_STACK_OVERHEAD) > (SQInteger)_stack.size()) {
\r
1069 _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));
\r
1071 SQInteger oldtop = _top;
\r
1072 SQInteger oldstackbase = _stackbase;
\r
1073 _top = stackbase + nargs;
\r
1074 PUSH_CALLINFO(this, CallInfo());
\r
1076 ci->_closure._unVal.pNativeClosure = nclosure;
\r
1077 ci->_closure._type = OT_NATIVECLOSURE;
\r
1078 ci->_prevstkbase = stackbase - _stackbase;
\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
1087 if(type(nclosure->_env) == OT_WEAKREF) {
\r
1088 _stack[stackbase] = _weakref(nclosure->_env)->_obj;
\r
1091 ci->_prevtop = (oldtop - oldstackbase);
\r
1092 SQInteger ret = (nclosure->_function)(this);
\r
1095 if( ret == SQ_SUSPEND_FLAG) suspend = true;
\r
1096 else if (ret < 0) {
\r
1097 _stackbase = oldstackbase;
\r
1099 POP_CALLINFO(this);
\r
1100 Raise_Error(_lasterror);
\r
1104 if (ret != 0){ retval = TOP(); }
\r
1105 else { retval = _null_; }
\r
1106 _stackbase = oldstackbase;
\r
1108 POP_CALLINFO(this);
\r
1112 bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, bool fetchroot)
\r
1114 switch(type(self)){
\r
1116 if(_table(self)->Get(key,dest))return true;
\r
1119 if(sq_isnumeric(key)){
\r
1120 return _array(self)->Get(tointeger(key),dest);
\r
1124 if(_instance(self)->Get(key,dest)) return true;
\r
1126 default:break; //shut up compiler
\r
1128 if(FallBackGet(self,key,dest,raw)) return true;
\r
1131 if(_rawval(STK(0)) == _rawval(self) &&
\r
1132 type(STK(0)) == type(self)) {
\r
1133 return _table(_roottable)->Get(key,dest);
\r
1139 bool SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw)
\r
1141 switch(type(self)){
\r
1143 return _class(self)->Get(key,dest);
\r
1148 if(_delegable(self)->_delegate) {
\r
1149 if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,raw,false))
\r
1151 if(raw)return false;
\r
1152 Push(self);Push(key);
\r
1153 if(CallMetaMethod(_delegable(self),MT_GET,2,dest))
\r
1156 if(type(self) == OT_TABLE) {
\r
1157 if(raw) return false;
\r
1158 return _table_ddel->Get(key,dest);
\r
1163 if(raw)return false;
\r
1164 return _array_ddel->Get(key,dest);
\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
1176 if(raw)return false;
\r
1177 return _string_ddel->Get(key,dest);
\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
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
1197 if(raw)return false;
\r
1198 return _thread_ddel->Get(key,dest);
\r
1200 if(raw)return false;
\r
1201 return _weakref_ddel->Get(key,dest);
\r
1202 default:return false;
\r
1207 bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool fetchroot)
\r
1209 switch(type(self)){
\r
1211 if(_table(self)->Set(key,val))
\r
1213 if(_table(self)->_delegate) {
\r
1214 if(Set(_table(self)->_delegate,key,val,false)) {
\r
1220 if(_delegable(self)->_delegate) {
\r
1222 Push(self);Push(key);Push(val);
\r
1223 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
\r
1226 case OT_INSTANCE:{
\r
1227 if(_instance(self)->Set(key,val))
\r
1230 Push(self);Push(key);Push(val);
\r
1231 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
\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
1238 Raise_Error(_SC("trying to set '%s'"),GetTypeName(self));
\r
1242 if(_rawval(STK(0)) == _rawval(self) &&
\r
1243 type(STK(0)) == type(self)) {
\r
1244 return _table(_roottable)->Set(key,val);
\r
1250 bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target)
\r
1252 SQObjectPtr temp_reg;
\r
1253 SQObjectPtr newobj;
\r
1254 switch(type(self)){
\r
1256 newobj = _table(self)->Clone();
\r
1259 newobj = _instance(self)->Clone(_ss(this));
\r
1261 if(_delegable(newobj)->_delegate){
\r
1264 CallMetaMethod(_delegable(newobj),MT_CLONED,2,temp_reg);
\r
1269 target = _array(self)->Clone();
\r
1271 default: return false;
\r
1275 bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic)
\r
1277 if(type(key) == OT_NULL) { Raise_Error(_SC("null cannot be used as index")); return false; }
\r
1278 switch(type(self)) {
\r
1280 bool rawcall = true;
\r
1281 if(_table(self)->_delegate) {
\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
1288 if(rawcall) _table(self)->NewSlot(key,val); //cannot fail
\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
1298 SQObjectPtr oval = PrintObjVal(key);
\r
1299 Raise_Error(_SC("the property '%s' already exists"),_stringval(oval));
\r
1305 Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key));
\r
1312 bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res)
\r
1314 switch(type(self)) {
\r
1317 case OT_USERDATA: {
\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
1326 if(type(self) == OT_TABLE) {
\r
1327 if(_table(self)->Get(key,t)) {
\r
1328 _table(self)->Remove(key);
\r
1331 Raise_IdxError((SQObject &)key);
\r
1336 Raise_Error(_SC("cannot delete a slot from %s"),GetTypeName(self));
\r
1344 Raise_Error(_SC("attempt to delete a slot from a %s"),GetTypeName(self));
\r
1350 bool SQVM::Call(SQObjectPtr &closure,SQInteger nparams,SQInteger stackbase,SQObjectPtr &outres,SQBool raiseerror)
\r
1353 SQInteger prevstackbase = _stackbase;
\r
1355 switch(type(closure)) {
\r
1357 return Execute(closure, _top - nparams, nparams, stackbase,outres,raiseerror);
\r
1359 case OT_NATIVECLOSURE:{
\r
1361 return CallNative(_nativeclosure(closure), nparams, stackbase, false, outres,suspend);
\r
1366 SQObjectPtr constr;
\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
1381 assert(_stackbase == prevstackbase);
\r
1387 bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,SQInteger nparams,SQObjectPtr &outres)
\r
1389 SQObjectPtr closure;
\r
1390 if(del->GetMetaMethod(this, mm, closure)) {
\r
1391 if(Call(closure, nparams, _top - nparams, outres, SQFalse)) {
\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
1405 _stack[_top] = _null_;
\r
1409 void SQVM::Pop() {
\r
1410 _stack[--_top] = _null_;
\r
1413 void SQVM::Pop(SQInteger n) {
\r
1414 for(SQInteger i = 0; i < n; i++){
\r
1415 _stack[--_top] = _null_;
\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
1425 #ifdef _DEBUG_DUMP
\r
1426 void SQVM::dumpstack(SQInteger stackbase,bool dumpall)
\r
1428 SQInteger size=dumpall?_stack.size():_top;
\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
1460 scprintf(_SC("\n"));
\r