2 see copyright notice in squirrel.h
\r
4 #include "sqpcheader.h"
\r
6 #include "sqstring.h"
\r
9 #include "sqfuncproto.h"
\r
10 #include "sqclosure.h"
\r
11 #include "squserdata.h"
\r
12 #include "sqcompiler.h"
\r
13 #include "sqfuncstate.h"
\r
14 #include "sqclass.h"
\r
16 bool sq_aux_gettypedarg(HSQUIRRELVM v,SQInteger idx,SQObjectType type,SQObjectPtr **o)
\r
18 *o = &stack_get(v,idx);
\r
19 if(type(**o) != type){
\r
20 SQObjectPtr oval = v->PrintObjVal(**o);
\r
21 v->Raise_Error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval));
\r
27 #define _GETSAFE_OBJ(v,idx,type,o) { if(!sq_aux_gettypedarg(v,idx,type,&o)) return SQ_ERROR; }
\r
29 #define sq_aux_paramscheck(v,count) \
\r
31 if(sq_gettop(v) < count){ v->Raise_Error(_SC("not enough params in the stack")); return SQ_ERROR; }\
\r
34 SQInteger sq_aux_throwobject(HSQUIRRELVM v,SQObjectPtr &e)
\r
40 SQInteger sq_aux_invalidtype(HSQUIRRELVM v,SQObjectType type)
\r
42 scsprintf(_ss(v)->GetScratchPad(100), _SC("unexpected type %s"), IdType2Name(type));
\r
43 return sq_throwerror(v, _ss(v)->GetScratchPad(-1));
\r
46 HSQUIRRELVM sq_open(SQInteger initialstacksize)
\r
50 sq_new(ss, SQSharedState);
\r
52 v = (SQVM *)SQ_MALLOC(sizeof(SQVM));
\r
55 if(v->Init(NULL, initialstacksize)) {
\r
64 HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, SQInteger initialstacksize)
\r
70 v= (SQVM *)SQ_MALLOC(sizeof(SQVM));
\r
73 if(v->Init(friendvm, initialstacksize)) {
\r
82 SQInteger sq_getvmstate(HSQUIRRELVM v)
\r
85 return SQ_VMSTATE_SUSPENDED;
\r
87 if(v->_callsstack.size() != 0) return SQ_VMSTATE_RUNNING;
\r
88 else return SQ_VMSTATE_IDLE;
\r
92 void sq_seterrorhandler(HSQUIRRELVM v)
\r
94 SQObject o = stack_get(v, -1);
\r
95 if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {
\r
96 v->_errorhandler = o;
\r
101 void sq_setdebughook(HSQUIRRELVM v)
\r
103 SQObject o = stack_get(v,-1);
\r
104 if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {
\r
110 void sq_close(HSQUIRRELVM v)
\r
112 SQSharedState *ss = _ss(v);
\r
113 _thread(ss->_root_vm)->Finalize();
\r
114 sq_delete(ss, SQSharedState);
\r
117 SQRESULT sq_compile(HSQUIRRELVM v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror)
\r
120 if(Compile(v, read, p, sourcename, o, raiseerror?true:false, _ss(v)->_debuginfo)) {
\r
121 v->Push(SQClosure::Create(_ss(v), _funcproto(o)));
\r
127 void sq_enabledebuginfo(HSQUIRRELVM v, SQBool enable)
\r
129 _ss(v)->_debuginfo = enable?true:false;
\r
132 void sq_notifyallexceptions(HSQUIRRELVM v, SQBool enable)
\r
134 _ss(v)->_notifyallexceptions = enable?true:false;
\r
137 void sq_addref(HSQUIRRELVM v,HSQOBJECT *po)
\r
139 if(!ISREFCOUNTED(type(*po))) return;
\r
140 _ss(v)->_refs_table.AddRef(*po);
\r
143 SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po)
\r
145 if(!ISREFCOUNTED(type(*po))) return SQTrue;
\r
146 return _ss(v)->_refs_table.Release(*po);
\r
149 const SQChar *sq_objtostring(HSQOBJECT *o)
\r
151 if(sq_type(*o) == OT_STRING) {
\r
152 return _stringval(*o);
\r
157 SQInteger sq_objtointeger(HSQOBJECT *o)
\r
159 if(sq_isnumeric(*o)) {
\r
160 return tointeger(*o);
\r
165 SQFloat sq_objtofloat(HSQOBJECT *o)
\r
167 if(sq_isnumeric(*o)) {
\r
168 return tofloat(*o);
\r
173 SQBool sq_objtobool(HSQOBJECT *o)
\r
175 if(sq_isbool(*o)) {
\r
176 return _integer(*o);
\r
181 void sq_pushnull(HSQUIRRELVM v)
\r
186 void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len)
\r
189 v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len)));
\r
190 else v->Push(_null_);
\r
193 void sq_pushinteger(HSQUIRRELVM v,SQInteger n)
\r
198 void sq_pushbool(HSQUIRRELVM v,SQBool b)
\r
200 v->Push(b?true:false);
\r
203 void sq_pushfloat(HSQUIRRELVM v,SQFloat n)
\r
208 void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p)
\r
213 SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size)
\r
215 SQUserData *ud = SQUserData::Create(_ss(v), size);
\r
220 void sq_newtable(HSQUIRRELVM v)
\r
222 v->Push(SQTable::Create(_ss(v), 0));
\r
225 void sq_newarray(HSQUIRRELVM v,SQInteger size)
\r
227 v->Push(SQArray::Create(_ss(v), size));
\r
230 SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase)
\r
232 SQClass *baseclass = NULL;
\r
234 SQObjectPtr &base = stack_get(v,-1);
\r
235 if(type(base) != OT_CLASS)
\r
236 return sq_throwerror(v,_SC("invalid base type"));
\r
237 baseclass = _class(base);
\r
239 SQClass *newclass = SQClass::Create(_ss(v), baseclass);
\r
240 if(baseclass) v->Pop();
\r
241 v->Push(newclass);
\r
245 SQBool sq_instanceof(HSQUIRRELVM v)
\r
247 SQObjectPtr &inst = stack_get(v,-1);
\r
248 SQObjectPtr &cl = stack_get(v,-2);
\r
249 if(type(inst) != OT_INSTANCE || type(cl) != OT_CLASS)
\r
250 return sq_throwerror(v,_SC("invalid param type"));
\r
251 return _instance(inst)->InstanceOf(_class(cl))?SQTrue:SQFalse;
\r
254 SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx)
\r
256 sq_aux_paramscheck(v,2);
\r
258 _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
\r
259 _array(*arr)->Append(v->GetUp(-1));
\r
264 SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
\r
266 sq_aux_paramscheck(v, 1);
\r
268 _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
\r
269 if(_array(*arr)->Size() > 0) {
\r
270 if(pushval != 0){ v->Push(_array(*arr)->Top()); }
\r
271 _array(*arr)->Pop();
\r
274 return sq_throwerror(v, _SC("empty array"));
\r
277 SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize)
\r
279 sq_aux_paramscheck(v,1);
\r
281 _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
\r
282 if(_array(*arr)->Size() > 0) {
\r
283 _array(*arr)->Resize(newsize);
\r
289 SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx)
\r
291 sq_aux_paramscheck(v, 1);
\r
293 _GETSAFE_OBJ(v, idx, OT_ARRAY,o);
\r
294 SQArray *arr = _array(*o);
\r
295 if(arr->Size() > 0) {
\r
297 SQInteger size = arr->Size();
\r
298 SQInteger n = size >> 1; size -= 1;
\r
299 for(SQInteger i = 0; i < n; i++) {
\r
300 t = arr->_values[i];
\r
301 arr->_values[i] = arr->_values[size-i];
\r
302 arr->_values[size-i] = t;
\r
309 void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,SQUnsignedInteger nfreevars)
\r
311 SQNativeClosure *nc = SQNativeClosure::Create(_ss(v), func);
\r
312 nc->_nparamscheck = 0;
\r
313 for(SQUnsignedInteger i = 0; i < nfreevars; i++) {
\r
314 nc->_outervalues.push_back(v->Top());
\r
317 v->Push(SQObjectPtr(nc));
\r
320 SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars)
\r
322 SQObject o = stack_get(v, idx);
\r
323 if(sq_isclosure(o)) {
\r
324 SQClosure *c = _closure(o);
\r
325 SQFunctionProto *proto = _funcproto(c->_function);
\r
326 *nparams = (SQUnsignedInteger)proto->_parameters.size();
\r
327 *nfreevars = (SQUnsignedInteger)c->_outervalues.size();
\r
330 return sq_throwerror(v,_SC("the object is not a closure"));
\r
333 SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,SQInteger idx,const SQChar *name)
\r
335 SQObject o = stack_get(v, idx);
\r
336 if(sq_isnativeclosure(o)) {
\r
337 SQNativeClosure *nc = _nativeclosure(o);
\r
338 nc->_name = SQString::Create(_ss(v),name);
\r
341 return sq_throwerror(v,_SC("the object is not a nativeclosure"));
\r
344 SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,const SQChar *typemask)
\r
346 SQObject o = stack_get(v, -1);
\r
347 if(!sq_isnativeclosure(o))
\r
348 return sq_throwerror(v, _SC("native closure expected"));
\r
349 SQNativeClosure *nc = _nativeclosure(o);
\r
350 nc->_nparamscheck = nparamscheck;
\r
353 if(!CompileTypemask(res, typemask))
\r
354 return sq_throwerror(v, _SC("invalid typemask"));
\r
355 nc->_typecheck.copy(res);
\r
358 nc->_typecheck.resize(0);
\r
360 if(nparamscheck == SQ_MATCHTYPEMASKSTRING) {
\r
361 nc->_nparamscheck = nc->_typecheck.size();
\r
366 SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx)
\r
368 SQObjectPtr &o = stack_get(v,idx);
\r
369 if(!sq_isnativeclosure(o) &&
\r
371 return sq_throwerror(v,_SC("the target is not a closure"));
\r
372 SQObjectPtr &env = stack_get(v,-1);
\r
373 if(!sq_istable(env) &&
\r
374 !sq_isclass(env) &&
\r
375 !sq_isinstance(env))
\r
376 return sq_throwerror(v,_SC("invalid environment"));
\r
377 SQObjectPtr w = _refcounted(env)->GetWeakRef(type(env));
\r
379 if(sq_isclosure(o)) {
\r
380 SQClosure *c = _closure(o)->Clone();
\r
384 else { //then must be a native closure
\r
385 SQNativeClosure *c = _nativeclosure(o)->Clone();
\r
394 void sq_pushroottable(HSQUIRRELVM v)
\r
396 v->Push(v->_roottable);
\r
399 void sq_pushregistrytable(HSQUIRRELVM v)
\r
401 v->Push(_ss(v)->_registry);
\r
404 SQRESULT sq_setroottable(HSQUIRRELVM v)
\r
406 SQObject o = stack_get(v, -1);
\r
407 if(sq_istable(o) || sq_isnull(o)) {
\r
412 return sq_throwerror(v, _SC("ivalid type"));
\r
415 void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p)
\r
417 v->_foreignptr = p;
\r
420 SQUserPointer sq_getforeignptr(HSQUIRRELVM v)
\r
422 return v->_foreignptr;
\r
425 void sq_push(HSQUIRRELVM v,SQInteger idx)
\r
427 v->Push(stack_get(v, idx));
\r
430 SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx)
\r
432 return type(stack_get(v, idx));
\r
435 void sq_tostring(HSQUIRRELVM v,SQInteger idx)
\r
437 SQObjectPtr &o = stack_get(v, idx);
\r
439 v->ToString(o,res);
\r
443 void sq_tobool(HSQUIRRELVM v, SQInteger idx, SQBool *b)
\r
445 SQObjectPtr &o = stack_get(v, idx);
\r
446 *b = v->IsFalse(o)?SQFalse:SQTrue;
\r
449 SQRESULT sq_getinteger(HSQUIRRELVM v,SQInteger idx,SQInteger *i)
\r
451 SQObjectPtr &o = stack_get(v, idx);
\r
452 if(sq_isnumeric(o)) {
\r
459 SQRESULT sq_getfloat(HSQUIRRELVM v,SQInteger idx,SQFloat *f)
\r
461 SQObjectPtr &o = stack_get(v, idx);
\r
462 if(sq_isnumeric(o)) {
\r
469 SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b)
\r
471 SQObjectPtr &o = stack_get(v, idx);
\r
479 SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c)
\r
481 SQObjectPtr *o = NULL;
\r
482 _GETSAFE_OBJ(v, idx, OT_STRING,o);
\r
483 *c = _stringval(*o);
\r
487 SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread)
\r
489 SQObjectPtr *o = NULL;
\r
490 _GETSAFE_OBJ(v, idx, OT_THREAD,o);
\r
491 *thread = _thread(*o);
\r
495 SQRESULT sq_clone(HSQUIRRELVM v,SQInteger idx)
\r
497 SQObjectPtr &o = stack_get(v,idx);
\r
499 if(!v->Clone(o, stack_get(v, -1))){
\r
501 return sq_aux_invalidtype(v, type(o));
\r
506 SQInteger sq_getsize(HSQUIRRELVM v, SQInteger idx)
\r
508 SQObjectPtr &o = stack_get(v, idx);
\r
509 SQObjectType type = type(o);
\r
511 case OT_STRING: return _string(o)->_len;
\r
512 case OT_TABLE: return _table(o)->CountUsed();
\r
513 case OT_ARRAY: return _array(o)->Size();
\r
514 case OT_USERDATA: return _userdata(o)->_size;
\r
516 return sq_aux_invalidtype(v, type);
\r
520 SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag)
\r
522 SQObjectPtr *o = NULL;
\r
523 _GETSAFE_OBJ(v, idx, OT_USERDATA,o);
\r
524 (*p) = _userdataval(*o);
\r
525 if(typetag) *typetag = _userdata(*o)->_typetag;
\r
529 SQRESULT sq_settypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer typetag)
\r
531 SQObjectPtr &o = stack_get(v,idx);
\r
533 case OT_USERDATA: _userdata(o)->_typetag = typetag; break;
\r
534 case OT_CLASS: _class(o)->_typetag = typetag; break;
\r
535 default: return sq_throwerror(v,_SC("invalid object type"));
\r
540 SQRESULT sq_getobjtypetag(HSQOBJECT *o,SQUserPointer * typetag)
\r
543 case OT_INSTANCE: *typetag = _instance(*o)->_class->_typetag; break;
\r
544 case OT_USERDATA: *typetag = _userdata(*o)->_typetag; break;
\r
545 case OT_CLASS: *typetag = _class(*o)->_typetag; break;
\r
546 default: return SQ_ERROR;
\r
551 SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag)
\r
553 SQObjectPtr &o = stack_get(v,idx);
\r
554 if(SQ_FAILED(sq_getobjtypetag(&o,typetag)))
\r
555 return sq_throwerror(v,_SC("invalid object type"));
\r
559 SQRESULT sq_getuserpointer(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p)
\r
561 SQObjectPtr *o = NULL;
\r
562 _GETSAFE_OBJ(v, idx, OT_USERPOINTER,o);
\r
563 (*p) = _userpointer(*o);
\r
567 SQRESULT sq_setinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer p)
\r
569 SQObjectPtr &o = stack_get(v,idx);
\r
570 if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
\r
571 _instance(o)->_userpointer = p;
\r
575 SQRESULT sq_getinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag)
\r
577 SQObjectPtr &o = stack_get(v,idx);
\r
578 if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
\r
579 (*p) = _instance(o)->_userpointer;
\r
581 SQClass *cl = _instance(o)->_class;
\r
583 if(cl->_typetag == typetag)
\r
586 }while(cl != NULL);
\r
587 return sq_throwerror(v,_SC("invalid type tag"));
\r
592 SQInteger sq_gettop(HSQUIRRELVM v)
\r
594 return (v->_top) - v->_stackbase;
\r
597 void sq_settop(HSQUIRRELVM v, SQInteger newtop)
\r
599 SQInteger top = sq_gettop(v);
\r
601 sq_pop(v, top - newtop);
\r
603 while(top < newtop) sq_pushnull(v);
\r
606 void sq_pop(HSQUIRRELVM v, SQInteger nelemstopop)
\r
608 assert(v->_top >= nelemstopop);
\r
609 v->Pop(nelemstopop);
\r
612 void sq_poptop(HSQUIRRELVM v)
\r
614 assert(v->_top >= 1);
\r
619 void sq_remove(HSQUIRRELVM v, SQInteger idx)
\r
624 SQInteger sq_cmp(HSQUIRRELVM v)
\r
627 v->ObjCmp(stack_get(v, -1), stack_get(v, -2),res);
\r
631 SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic)
\r
633 sq_aux_paramscheck(v, 3);
\r
634 SQObjectPtr &self = stack_get(v, idx);
\r
635 if(type(self) == OT_TABLE || type(self) == OT_CLASS) {
\r
636 SQObjectPtr &key = v->GetUp(-2);
\r
637 if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
\r
638 v->NewSlot(self, key, v->GetUp(-1),bstatic?true:false);
\r
644 /*SQRESULT sq_createslot(HSQUIRRELVM v, SQInteger idx)
\r
646 sq_aux_paramscheck(v, 3);
\r
647 SQObjectPtr &self = stack_get(v, idx);
\r
648 if(type(self) == OT_TABLE || type(self) == OT_CLASS) {
\r
649 SQObjectPtr &key = v->GetUp(-2);
\r
650 if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
\r
651 v->NewSlot(self, key, v->GetUp(-1));
\r
657 SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
\r
659 sq_aux_paramscheck(v, 2);
\r
661 _GETSAFE_OBJ(v, idx, OT_TABLE,self);
\r
662 SQObjectPtr &key = v->GetUp(-1);
\r
663 if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
\r
665 if(!v->DeleteSlot(*self, key, res)){
\r
668 if(pushval) v->GetUp(-1) = res;
\r
673 SQRESULT sq_set(HSQUIRRELVM v,SQInteger idx)
\r
675 SQObjectPtr &self = stack_get(v, idx);
\r
676 if(v->Set(self, v->GetUp(-2), v->GetUp(-1),false)) {
\r
680 v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
\r
683 SQRESULT sq_rawset(HSQUIRRELVM v,SQInteger idx)
\r
685 SQObjectPtr &self = stack_get(v, idx);
\r
686 if(type(v->GetUp(-2)) == OT_NULL) return sq_throwerror(v, _SC("null key"));
\r
687 switch(type(self)) {
\r
689 _table(self)->NewSlot(v->GetUp(-2), v->GetUp(-1));
\r
694 _class(self)->NewSlot(_ss(v), v->GetUp(-2), v->GetUp(-1),false);
\r
699 if(_instance(self)->Set(v->GetUp(-2), v->GetUp(-1))) {
\r
705 if(v->Set(self, v->GetUp(-2), v->GetUp(-1),false)) {
\r
712 return sq_throwerror(v, _SC("rawset works only on array/table/calsse and instance"));
\r
714 v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
\r
717 SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx)
\r
719 SQObjectPtr &self = stack_get(v, idx);
\r
720 SQObjectPtr &mt = v->GetUp(-1);
\r
721 SQObjectType type = type(self);
\r
724 if(type(mt) == OT_TABLE) {
\r
725 if(!_table(self)->SetDelegate(_table(mt))) return sq_throwerror(v, _SC("delagate cycle")); v->Pop();}
\r
726 else if(type(mt)==OT_NULL) {
\r
727 _table(self)->SetDelegate(NULL); v->Pop(); }
\r
728 else return sq_aux_invalidtype(v,type);
\r
731 if(type(mt)==OT_TABLE) {
\r
732 _userdata(self)->SetDelegate(_table(mt)); v->Pop(); }
\r
733 else if(type(mt)==OT_NULL) {
\r
734 _userdata(self)->SetDelegate(NULL); v->Pop(); }
\r
735 else return sq_aux_invalidtype(v, type);
\r
738 return sq_aux_invalidtype(v, type);
\r
744 SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
\r
746 sq_aux_paramscheck(v, 2);
\r
748 _GETSAFE_OBJ(v, idx, OT_TABLE,self);
\r
749 SQObjectPtr &key = v->GetUp(-1);
\r
751 if(_table(*self)->Get(key,t)) {
\r
752 _table(*self)->Remove(key);
\r
755 if(pushval) v->GetUp(-1) = t;
\r
761 SQRESULT sq_getdelegate(HSQUIRRELVM v,SQInteger idx)
\r
763 SQObjectPtr &self=stack_get(v,idx);
\r
764 switch(type(self)){
\r
766 if(!_table(self)->_delegate)break;
\r
767 v->Push(SQObjectPtr(_table(self)->_delegate));
\r
770 if(!_userdata(self)->_delegate)break;
\r
771 v->Push(SQObjectPtr(_userdata(self)->_delegate));
\r
773 default: return sq_throwerror(v,_SC("wrong type")); break;
\r
779 SQRESULT sq_get(HSQUIRRELVM v,SQInteger idx)
\r
781 SQObjectPtr &self=stack_get(v,idx);
\r
782 if(v->Get(self,v->GetUp(-1),v->GetUp(-1),false,false))
\r
785 return sq_throwerror(v,_SC("the index doesn't exist"));
\r
788 SQRESULT sq_rawget(HSQUIRRELVM v,SQInteger idx)
\r
790 SQObjectPtr &self=stack_get(v,idx);
\r
791 switch(type(self)) {
\r
793 if(_table(self)->Get(v->GetUp(-1),v->GetUp(-1)))
\r
797 if(_class(self)->Get(v->GetUp(-1),v->GetUp(-1)))
\r
801 if(_instance(self)->Get(v->GetUp(-1),v->GetUp(-1)))
\r
805 if(v->Get(self,v->GetUp(-1),v->GetUp(-1),false,false))
\r
810 return sq_throwerror(v,_SC("rawget works only on array/table/instance and class"));
\r
813 return sq_throwerror(v,_SC("the index doesn't exist"));
\r
816 SQRESULT sq_getstackobj(HSQUIRRELVM v,SQInteger idx,HSQOBJECT *po)
\r
818 *po=stack_get(v,idx);
\r
822 const SQChar *sq_getlocal(HSQUIRRELVM v,SQUnsignedInteger level,SQUnsignedInteger idx)
\r
824 SQUnsignedInteger cstksize=v->_callsstack.size();
\r
825 SQUnsignedInteger lvl=(cstksize-level)-1;
\r
826 SQInteger stackbase=v->_stackbase;
\r
828 for(SQUnsignedInteger i=0;i<level;i++){
\r
829 SQVM::CallInfo &ci=v->_callsstack[(cstksize-i)-1];
\r
830 stackbase-=ci._prevstkbase;
\r
832 SQVM::CallInfo &ci=v->_callsstack[lvl];
\r
833 if(type(ci._closure)!=OT_CLOSURE)
\r
835 SQClosure *c=_closure(ci._closure);
\r
836 SQFunctionProto *func=_funcproto(c->_function);
\r
837 return func->GetLocal(v,stackbase,idx,(SQInteger)(ci._ip-func->_instructions._vals)-1);
\r
842 void sq_pushobject(HSQUIRRELVM v,HSQOBJECT obj)
\r
844 v->Push(SQObjectPtr(obj));
\r
847 void sq_resetobject(HSQOBJECT *po)
\r
849 po->_unVal.pUserPointer=NULL;po->_type=OT_NULL;
\r
852 SQRESULT sq_throwerror(HSQUIRRELVM v,const SQChar *err)
\r
854 v->_lasterror=SQString::Create(_ss(v),err);
\r
858 void sq_reseterror(HSQUIRRELVM v)
\r
860 v->_lasterror = _null_;
\r
863 void sq_getlasterror(HSQUIRRELVM v)
\r
865 v->Push(v->_lasterror);
\r
868 void sq_reservestack(HSQUIRRELVM v,SQInteger nsize)
\r
870 if (((SQUnsignedInteger)v->_top + nsize) > v->_stack.size()) {
\r
871 v->_stack.resize(v->_stack.size() + ((v->_top + nsize) - v->_stack.size()));
\r
875 SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval,SQBool raiseerror)
\r
877 if(type(v->GetUp(-1))==OT_GENERATOR){
\r
878 v->Push(_null_); //retval
\r
879 if(!v->Execute(v->GetUp(-2),v->_top,0,v->_top,v->GetUp(-1),raiseerror,SQVM::ET_RESUME_GENERATOR))
\r
880 {v->Raise_Error(v->_lasterror); return SQ_ERROR;}
\r
885 return sq_throwerror(v,_SC("only generators can be resumed"));
\r
888 SQRESULT sq_call(HSQUIRRELVM v,SQInteger params,SQBool retval,SQBool raiseerror)
\r
891 if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){
\r
892 v->Pop(params);//pop closure and args
\r
894 v->Push(res); return SQ_OK;
\r
904 return sq_throwerror(v,_SC("call failed"));
\r
907 SQRESULT sq_suspendvm(HSQUIRRELVM v)
\r
909 return v->Suspend();
\r
912 SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool wakeupret,SQBool retval,SQBool raiseerror)
\r
916 return sq_throwerror(v,_SC("cannot resume a vm that is not running any code"));
\r
918 v->GetAt(v->_stackbase+v->_suspended_target)=v->GetUp(-1); //retval
\r
920 } else v->GetAt(v->_stackbase+v->_suspended_target)=_null_;
\r
921 if(!v->Execute(_null_,v->_top,-1,-1,ret,raiseerror,SQVM::ET_RESUME_VM))
\r
923 if(sq_getvmstate(v) == SQ_VMSTATE_IDLE) {
\r
924 while (v->_top > 1) v->_stack[--v->_top] = _null_;
\r
931 void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook)
\r
933 if(sq_gettop(v) >= 1){
\r
934 SQObjectPtr &ud=stack_get(v,idx);
\r
935 switch( type(ud) ) {
\r
936 case OT_USERDATA: _userdata(ud)->_hook = hook; break;
\r
937 case OT_INSTANCE: _instance(ud)->_hook = hook; break;
\r
938 case OT_CLASS: _class(ud)->_hook = hook; break;
\r
939 default: break; //shutup compiler
\r
944 void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f)
\r
946 _ss(v)->_compilererrorhandler = f;
\r
949 SQRESULT sq_writeclosure(HSQUIRRELVM v,SQWRITEFUNC w,SQUserPointer up)
\r
951 SQObjectPtr *o = NULL;
\r
952 _GETSAFE_OBJ(v, -1, OT_CLOSURE,o);
\r
953 unsigned short tag = SQ_BYTECODE_STREAM_TAG;
\r
954 if(w(up,&tag,2) != 2)
\r
955 return sq_throwerror(v,_SC("io error"));
\r
956 if(!_closure(*o)->Save(v,up,w))
\r
961 SQRESULT sq_readclosure(HSQUIRRELVM v,SQREADFUNC r,SQUserPointer up)
\r
963 SQObjectPtr func=SQFunctionProto::Create();
\r
964 SQObjectPtr closure=SQClosure::Create(_ss(v),_funcproto(func));
\r
965 unsigned short tag;
\r
966 if(r(up,&tag,2) != 2)
\r
967 return sq_throwerror(v,_SC("io error"));
\r
968 if(tag != SQ_BYTECODE_STREAM_TAG)
\r
969 return sq_throwerror(v,_SC("invalid stream"));
\r
970 if(!_closure(closure)->Load(v,up,r))
\r
976 SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize)
\r
978 return _ss(v)->GetScratchPad(minsize);
\r
981 SQInteger sq_collectgarbage(HSQUIRRELVM v)
\r
983 #ifndef NO_GARBAGE_COLLECTOR
\r
984 return _ss(v)->CollectGarbage(v);
\r
990 const SQChar *sq_getfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval)
\r
992 SQObjectPtr &self = stack_get(v,idx);
\r
993 const SQChar *name = NULL;
\r
994 if(type(self) == OT_CLOSURE) {
\r
995 if(_closure(self)->_outervalues.size()>nval) {
\r
996 v->Push(_closure(self)->_outervalues[nval]);
\r
997 SQFunctionProto *fp = _funcproto(_closure(self)->_function);
\r
998 SQOuterVar &ov = fp->_outervalues[nval];
\r
999 name = _stringval(ov._name);
\r
1005 SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval)
\r
1007 SQObjectPtr &self=stack_get(v,idx);
\r
1008 switch(type(self))
\r
1011 if(_closure(self)->_outervalues.size()>nval){
\r
1012 _closure(self)->_outervalues[nval]=stack_get(v,-1);
\r
1014 else return sq_throwerror(v,_SC("invalid free var index"));
\r
1016 case OT_NATIVECLOSURE:
\r
1017 if(_nativeclosure(self)->_outervalues.size()>nval){
\r
1018 _nativeclosure(self)->_outervalues[nval]=stack_get(v,-1);
\r
1020 else return sq_throwerror(v,_SC("invalid free var index"));
\r
1023 return sq_aux_invalidtype(v,type(self));
\r
1029 SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx)
\r
1031 SQObjectPtr *o = NULL;
\r
1032 _GETSAFE_OBJ(v, idx, OT_CLASS,o);
\r
1033 SQObjectPtr &key = stack_get(v,-2);
\r
1034 SQObjectPtr &val = stack_get(v,-1);
\r
1035 SQObjectPtr attrs;
\r
1036 if(type(key) == OT_NULL) {
\r
1037 attrs = _class(*o)->_attributes;
\r
1038 _class(*o)->_attributes = val;
\r
1042 }else if(_class(*o)->GetAttributes(key,attrs)) {
\r
1043 _class(*o)->SetAttributes(key,val);
\r
1048 return sq_throwerror(v,_SC("wrong index"));
\r
1051 SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx)
\r
1053 SQObjectPtr *o = NULL;
\r
1054 _GETSAFE_OBJ(v, idx, OT_CLASS,o);
\r
1055 SQObjectPtr &key = stack_get(v,-1);
\r
1056 SQObjectPtr attrs;
\r
1057 if(type(key) == OT_NULL) {
\r
1058 attrs = _class(*o)->_attributes;
\r
1063 else if(_class(*o)->GetAttributes(key,attrs)) {
\r
1068 return sq_throwerror(v,_SC("wrong index"));
\r
1071 SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx)
\r
1073 SQObjectPtr *o = NULL;
\r
1074 _GETSAFE_OBJ(v, idx, OT_CLASS,o);
\r
1075 if(_class(*o)->_base)
\r
1076 v->Push(SQObjectPtr(_class(*o)->_base));
\r
1082 SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx)
\r
1084 SQObjectPtr *o = NULL;
\r
1085 _GETSAFE_OBJ(v, idx, OT_INSTANCE,o);
\r
1086 v->Push(SQObjectPtr(_instance(*o)->_class));
\r
1090 SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx)
\r
1092 SQObjectPtr *o = NULL;
\r
1093 _GETSAFE_OBJ(v, idx, OT_CLASS,o);
\r
1094 v->Push(_class(*o)->CreateInstance());
\r
1098 void sq_weakref(HSQUIRRELVM v,SQInteger idx)
\r
1100 SQObject &o=stack_get(v,idx);
\r
1101 if(ISREFCOUNTED(type(o))) {
\r
1102 v->Push(_refcounted(o)->GetWeakRef(type(o)));
\r
1108 SQRESULT sq_getweakrefval(HSQUIRRELVM v,SQInteger idx)
\r
1110 SQObjectPtr &o = stack_get(v,idx);
\r
1111 if(type(o) != OT_WEAKREF) {
\r
1112 return sq_throwerror(v,_SC("the object must be a weakref"));
\r
1114 v->Push(_weakref(o)->_obj);
\r
1118 SQRESULT sq_getdefaultdelegate(HSQUIRRELVM v,SQObjectType t)
\r
1120 SQSharedState *ss = _ss(v);
\r
1122 case OT_TABLE: v->Push(ss->_table_default_delegate); break;
\r
1123 case OT_ARRAY: v->Push(ss->_array_default_delegate); break;
\r
1124 case OT_STRING: v->Push(ss->_string_default_delegate); break;
\r
1125 case OT_INTEGER: case OT_FLOAT: v->Push(ss->_number_default_delegate); break;
\r
1126 case OT_GENERATOR: v->Push(ss->_generator_default_delegate); break;
\r
1127 case OT_CLOSURE: case OT_NATIVECLOSURE: v->Push(ss->_closure_default_delegate); break;
\r
1128 case OT_THREAD: v->Push(ss->_thread_default_delegate); break;
\r
1129 case OT_CLASS: v->Push(ss->_class_default_delegate); break;
\r
1130 case OT_INSTANCE: v->Push(ss->_instance_default_delegate); break;
\r
1131 case OT_WEAKREF: v->Push(ss->_weakref_default_delegate); break;
\r
1132 default: return sq_throwerror(v,_SC("the type doesn't have a default delegate"));
\r
1137 SQRESULT sq_next(HSQUIRRELVM v,SQInteger idx)
\r
1139 SQObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val;
\r
1140 if(type(o) == OT_GENERATOR) {
\r
1141 return sq_throwerror(v,_SC("cannot iterate a generator"));
\r
1144 if(!v->FOREACH_OP(o,realkey,val,refpos,0,finished))
\r
1155 const SQChar *buf;
\r
1160 SQInteger buf_lexfeed(SQUserPointer file)
\r
1162 BufState *buf=(BufState*)file;
\r
1163 if(buf->size<(buf->ptr+1))
\r
1165 return buf->buf[buf->ptr++];
\r
1168 SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror) {
\r
1173 return sq_compile(v, buf_lexfeed, &buf, sourcename, raiseerror);
\r
1176 void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,SQInteger idx)
\r
1178 dest->Push(stack_get(src,idx));
\r
1181 void sq_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc)
\r
1183 _ss(v)->_printfunc = printfunc;
\r
1186 SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v)
\r
1188 return _ss(v)->_printfunc;
\r
1191 void *sq_malloc(SQUnsignedInteger size)
\r
1193 return SQ_MALLOC(size);
\r
1196 void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize)
\r
1198 return SQ_REALLOC(p,oldsize,newsize);
\r
1200 void sq_free(void *p,SQUnsignedInteger size)
\r