#include "sqfuncstate.h"
#include "sqclass.h"
-bool sq_aux_gettypedarg(HSQUIRRELVM v,int idx,SQObjectType type,SQObjectPtr **o)
+bool sq_aux_gettypedarg(HSQUIRRELVM v,SQInteger idx,SQObjectType type,SQObjectPtr **o)
{
*o = &stack_get(v,idx);
if(type(**o) != type){
if(sq_gettop(v) < count){ v->Raise_Error(_SC("not enough params in the stack")); return SQ_ERROR; }\
}
-int sq_aux_throwobject(HSQUIRRELVM v,SQObjectPtr &e)
+SQInteger sq_aux_throwobject(HSQUIRRELVM v,SQObjectPtr &e)
{
v->_lasterror = e;
return SQ_ERROR;
}
-int sq_aux_invalidtype(HSQUIRRELVM v,SQObjectType type)
+SQInteger sq_aux_invalidtype(HSQUIRRELVM v,SQObjectType type)
{
scsprintf(_ss(v)->GetScratchPad(100), _SC("unexpected type %s"), IdType2Name(type));
return sq_throwerror(v, _ss(v)->GetScratchPad(-1));
}
-HSQUIRRELVM sq_open(int initialstacksize)
+HSQUIRRELVM sq_open(SQInteger initialstacksize)
{
SQSharedState *ss;
SQVM *v;
return v;
}
-HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, int initialstacksize)
+HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, SQInteger initialstacksize)
{
SQSharedState *ss;
SQVM *v;
}
}
-int sq_getvmstate(HSQUIRRELVM v)
+SQInteger sq_getvmstate(HSQUIRRELVM v)
{
if(v->_suspended)
return SQ_VMSTATE_SUSPENDED;
else {
- if(v->_callsstack.size() != 0) return SQ_VMSTATE_RUNNING;
+ if(v->_callsstacksize != 0) return SQ_VMSTATE_RUNNING;
else return SQ_VMSTATE_IDLE;
}
}
return SQ_ERROR;
}
-void sq_enabledebuginfo(HSQUIRRELVM v, SQBool debuginfo)
+void sq_enabledebuginfo(HSQUIRRELVM v, SQBool enable)
{
- _ss(v)->_debuginfo = debuginfo?true:false;
+ _ss(v)->_debuginfo = enable?true:false;
+}
+
+void sq_notifyallexceptions(HSQUIRRELVM v, SQBool enable)
+{
+ _ss(v)->_notifyallexceptions = enable?true:false;
}
void sq_addref(HSQUIRRELVM v,HSQOBJECT *po)
{
- SQObjectPtr refs;
if(!ISREFCOUNTED(type(*po))) return;
- if(_table(_ss(v)->_refs_table)->Get(*po, refs)) {
- refs = _integer(refs) + 1;
- }
- else{
- refs = 1;
- }
- _table(_ss(v)->_refs_table)->NewSlot(*po, refs);
+#ifdef NO_GARBAGE_COLLECTOR
+ __AddRef(po->_type,po->_unVal);
+#else
+ _ss(v)->_refs_table.AddRef(*po);
+#endif
}
SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po)
{
- SQObjectPtr refs;
if(!ISREFCOUNTED(type(*po))) return SQTrue;
- if(_table(_ss(v)->_refs_table)->Get(*po, refs)) {
- int n = _integer(refs) - 1;
- if(n <= 0) {
- _table(_ss(v)->_refs_table)->Remove(*po);
- sq_resetobject(po);
- }
- else {
- refs = n;_table(_ss(v)->_refs_table)->Set(*po, refs);
- return SQFalse;
- }
- }
- return SQTrue;
+#ifdef NO_GARBAGE_COLLECTOR
+ __Release(po->_type,po->_unVal);
+ return SQFalse; //the ret val doesn't work(and cannot be fixed)
+#else
+ return _ss(v)->_refs_table.Release(*po);
+#endif
}
const SQChar *sq_objtostring(HSQOBJECT *o)
{
if(sq_type(*o) == OT_STRING) {
- return o->_unVal.pString->_val;
+ return _stringval(*o);
}
return NULL;
}
return 0;
}
+SQBool sq_objtobool(HSQOBJECT *o)
+{
+ if(sq_isbool(*o)) {
+ return _integer(*o);
+ }
+ return SQFalse;
+}
+
void sq_pushnull(HSQUIRRELVM v)
{
v->Push(_null_);
}
-void sq_pushstring(HSQUIRRELVM v,const SQChar *s,int len)
+void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len)
{
if(s)
v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len)));
v->Push(p);
}
-SQUserPointer sq_newuserdata(HSQUIRRELVM v,unsigned int size)
+SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size)
{
SQUserData *ud = SQUserData::Create(_ss(v), size);
v->Push(ud);
v->Push(SQTable::Create(_ss(v), 0));
}
-void sq_newarray(HSQUIRRELVM v,int size)
+void sq_newarray(HSQUIRRELVM v,SQInteger size)
{
v->Push(SQArray::Create(_ss(v), size));
}
return SQ_OK;
}
-int sq_instanceof(HSQUIRRELVM v)
+SQBool sq_instanceof(HSQUIRRELVM v)
{
SQObjectPtr &inst = stack_get(v,-1);
SQObjectPtr &cl = stack_get(v,-2);
if(type(inst) != OT_INSTANCE || type(cl) != OT_CLASS)
return sq_throwerror(v,_SC("invalid param type"));
- return _instance(inst)->InstanceOf(_class(cl))?1:0;
+ return _instance(inst)->InstanceOf(_class(cl))?SQTrue:SQFalse;
}
-SQRESULT sq_arrayappend(HSQUIRRELVM v,int idx)
+SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx)
{
sq_aux_paramscheck(v,2);
SQObjectPtr *arr;
return SQ_OK;
}
-SQRESULT sq_arraypop(HSQUIRRELVM v,int idx,SQBool pushval)
+SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
{
sq_aux_paramscheck(v, 1);
SQObjectPtr *arr;
return sq_throwerror(v, _SC("empty array"));
}
-SQRESULT sq_arrayresize(HSQUIRRELVM v,int idx,int newsize)
+SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize)
{
sq_aux_paramscheck(v,1);
SQObjectPtr *arr;
_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
- if(_array(*arr)->Size() > 0) {
+ if(newsize >= 0) {
_array(*arr)->Resize(newsize);
return SQ_OK;
}
- return sq_throwerror(v, _SC("empty array"));
+ return sq_throwerror(v,_SC("negative size"));
}
-SQRESULT sq_arrayreverse(HSQUIRRELVM v,int idx)
+
+SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx)
{
sq_aux_paramscheck(v, 1);
SQObjectPtr *o;
SQArray *arr = _array(*o);
if(arr->Size() > 0) {
SQObjectPtr t;
- int size = arr->Size();
- int n = size >> 1; size -= 1;
- for(int i = 0; i < n; i++) {
+ SQInteger size = arr->Size();
+ SQInteger n = size >> 1; size -= 1;
+ for(SQInteger i = 0; i < n; i++) {
t = arr->_values[i];
arr->_values[i] = arr->_values[size-i];
arr->_values[size-i] = t;
}
return SQ_OK;
}
- return sq_throwerror(v, _SC("empty array"));
+ return SQ_OK;
+}
+
+SQRESULT sq_arrayremove(HSQUIRRELVM v,SQInteger idx,SQInteger itemidx)
+{
+ sq_aux_paramscheck(v, 1);
+ SQObjectPtr *arr;
+ _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
+ return _array(*arr)->Remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
+}
+
+SQRESULT sq_arrayinsert(HSQUIRRELVM v,SQInteger idx,SQInteger destpos)
+{
+ sq_aux_paramscheck(v, 1);
+ SQObjectPtr *arr;
+ _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
+ SQRESULT ret = _array(*arr)->Insert(destpos, v->GetUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
+ v->Pop();
+ return ret;
}
-void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,unsigned int nfreevars)
+
+void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,SQUnsignedInteger nfreevars)
{
SQNativeClosure *nc = SQNativeClosure::Create(_ss(v), func);
nc->_nparamscheck = 0;
- for(unsigned int i = 0; i < nfreevars; i++) {
+ for(SQUnsignedInteger i = 0; i < nfreevars; i++) {
nc->_outervalues.push_back(v->Top());
v->Pop();
}
v->Push(SQObjectPtr(nc));
}
-SQRESULT sq_getclosureinfo(HSQUIRRELVM v,int idx,unsigned int *nparams,unsigned int *nfreevars)
+SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars)
{
SQObject o = stack_get(v, idx);
if(sq_isclosure(o)) {
SQClosure *c = _closure(o);
SQFunctionProto *proto = _funcproto(c->_function);
- *nparams = (unsigned int)proto->_parameters.size();
- *nfreevars = (unsigned int)c->_outervalues.size();
+ *nparams = (SQUnsignedInteger)proto->_nparameters;
+ *nfreevars = (SQUnsignedInteger)c->_outervalues.size();
return SQ_OK;
}
return sq_throwerror(v,_SC("the object is not a closure"));
}
-SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,int idx,const SQChar *name)
+SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,SQInteger idx,const SQChar *name)
{
SQObject o = stack_get(v, idx);
if(sq_isnativeclosure(o)) {
return sq_throwerror(v,_SC("the object is not a nativeclosure"));
}
-SQRESULT sq_setparamscheck(HSQUIRRELVM v,int nparamscheck,const SQChar *typemask)
+SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,const SQChar *typemask)
{
SQObject o = stack_get(v, -1);
if(!sq_isnativeclosure(o))
return SQ_OK;
}
+SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx)
+{
+ SQObjectPtr &o = stack_get(v,idx);
+ if(!sq_isnativeclosure(o) &&
+ !sq_isclosure(o))
+ return sq_throwerror(v,_SC("the target is not a closure"));
+ SQObjectPtr &env = stack_get(v,-1);
+ if(!sq_istable(env) &&
+ !sq_isclass(env) &&
+ !sq_isinstance(env))
+ return sq_throwerror(v,_SC("invalid environment"));
+ SQObjectPtr w = _refcounted(env)->GetWeakRef(type(env));
+ SQObjectPtr ret;
+ if(sq_isclosure(o)) {
+ SQClosure *c = _closure(o)->Clone();
+ c->_env = w;
+ ret = c;
+ }
+ else { //then must be a native closure
+ SQNativeClosure *c = _nativeclosure(o)->Clone();
+ c->_env = w;
+ ret = c;
+ }
+ v->Pop();
+ v->Push(ret);
+ return SQ_OK;
+}
+
+SQRESULT sq_clear(HSQUIRRELVM v,SQInteger idx)
+{
+ SQObject &o=stack_get(v,idx);
+ switch(type(o)) {
+ case OT_TABLE: _table(o)->Clear(); break;
+ case OT_ARRAY: _array(o)->Resize(0); break;
+ default:
+ return sq_throwerror(v, _SC("clear only works on table and array"));
+ break;
+
+ }
+ return SQ_OK;
+}
+
void sq_pushroottable(HSQUIRRELVM v)
{
v->Push(v->_roottable);
v->Push(_ss(v)->_registry);
}
+void sq_pushconsttable(HSQUIRRELVM v)
+{
+ v->Push(_ss(v)->_consts);
+}
+
SQRESULT sq_setroottable(HSQUIRRELVM v)
{
SQObject o = stack_get(v, -1);
return sq_throwerror(v, _SC("ivalid type"));
}
+SQRESULT sq_setconsttable(HSQUIRRELVM v)
+{
+ SQObject o = stack_get(v, -1);
+ if(sq_istable(o)) {
+ _ss(v)->_consts = o;
+ v->Pop();
+ return SQ_OK;
+ }
+ return sq_throwerror(v, _SC("ivalid type, expected table"));
+}
+
void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p)
{
v->_foreignptr = p;
return v->_foreignptr;
}
-void sq_push(HSQUIRRELVM v,int idx)
+void sq_push(HSQUIRRELVM v,SQInteger idx)
{
v->Push(stack_get(v, idx));
}
-SQObjectType sq_gettype(HSQUIRRELVM v,int idx)
+SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx)
{
return type(stack_get(v, idx));
}
-SQRESULT sq_getinteger(HSQUIRRELVM v,int idx,SQInteger *i)
+
+void sq_tostring(HSQUIRRELVM v,SQInteger idx)
+{
+ SQObjectPtr &o = stack_get(v, idx);
+ SQObjectPtr res;
+ v->ToString(o,res);
+ v->Push(res);
+}
+
+void sq_tobool(HSQUIRRELVM v, SQInteger idx, SQBool *b)
+{
+ SQObjectPtr &o = stack_get(v, idx);
+ *b = v->IsFalse(o)?SQFalse:SQTrue;
+}
+
+SQRESULT sq_getinteger(HSQUIRRELVM v,SQInteger idx,SQInteger *i)
{
SQObjectPtr &o = stack_get(v, idx);
if(sq_isnumeric(o)) {
return SQ_ERROR;
}
-SQRESULT sq_getfloat(HSQUIRRELVM v,int idx,SQFloat *f)
+SQRESULT sq_getfloat(HSQUIRRELVM v,SQInteger idx,SQFloat *f)
{
SQObjectPtr &o = stack_get(v, idx);
if(sq_isnumeric(o)) {
return SQ_ERROR;
}
-SQRESULT sq_getbool(HSQUIRRELVM v,int idx,SQBool *b)
+SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b)
{
SQObjectPtr &o = stack_get(v, idx);
if(sq_isbool(o)) {
return SQ_ERROR;
}
-SQRESULT sq_getstring(HSQUIRRELVM v,int idx,const SQChar **c)
+SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_STRING,o);
return SQ_OK;
}
-SQRESULT sq_getthread(HSQUIRRELVM v,int idx,HSQUIRRELVM *thread)
+SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_THREAD,o);
return SQ_OK;
}
-SQRESULT sq_clone(HSQUIRRELVM v,int idx)
+SQRESULT sq_clone(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr &o = stack_get(v,idx);
v->Push(_null_);
return SQ_OK;
}
-SQInteger sq_getsize(HSQUIRRELVM v, int idx)
+SQInteger sq_getsize(HSQUIRRELVM v, SQInteger idx)
{
SQObjectPtr &o = stack_get(v, idx);
SQObjectType type = type(o);
}
}
-SQRESULT sq_getuserdata(HSQUIRRELVM v,int idx,SQUserPointer *p,unsigned int *typetag)
+SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_USERDATA,o);
return SQ_OK;
}
-SQRESULT sq_settypetag(HSQUIRRELVM v,int idx,unsigned int typetag)
+SQRESULT sq_settypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer typetag)
{
SQObjectPtr &o = stack_get(v,idx);
switch(type(o)) {
return SQ_OK;
}
-SQRESULT sq_gettypetag(HSQUIRRELVM v,int idx,unsigned int *typetag)
+SQRESULT sq_getobjtypetag(HSQOBJECT *o,SQUserPointer * typetag)
+{
+ switch(type(*o)) {
+ case OT_INSTANCE: *typetag = _instance(*o)->_class->_typetag; break;
+ case OT_USERDATA: *typetag = _userdata(*o)->_typetag; break;
+ case OT_CLASS: *typetag = _class(*o)->_typetag; break;
+ default: return SQ_ERROR;
+ }
+ return SQ_OK;
+}
+
+SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag)
{
SQObjectPtr &o = stack_get(v,idx);
- switch(type(o)) {
- case OT_USERDATA: *typetag = _userdata(o)->_typetag; break;
- case OT_CLASS: *typetag = _class(o)->_typetag; break;
- default: return sq_throwerror(v,_SC("invalid object type"));
- }
+ if(SQ_FAILED(sq_getobjtypetag(&o,typetag)))
+ return sq_throwerror(v,_SC("invalid object type"));
return SQ_OK;
}
-SQRESULT sq_getuserpointer(HSQUIRRELVM v, int idx, SQUserPointer *p)
+SQRESULT sq_getuserpointer(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_USERPOINTER,o);
return SQ_OK;
}
-SQRESULT sq_setinstanceup(HSQUIRRELVM v, int idx, SQUserPointer p)
+SQRESULT sq_setinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer p)
{
SQObjectPtr &o = stack_get(v,idx);
if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
return SQ_OK;
}
-SQRESULT sq_getinstanceup(HSQUIRRELVM v, int idx, SQUserPointer *p,unsigned int typetag)
+SQRESULT sq_setclassudsize(HSQUIRRELVM v, SQInteger idx, SQInteger udsize)
+{
+ SQObjectPtr &o = stack_get(v,idx);
+ if(type(o) != OT_CLASS) return sq_throwerror(v,_SC("the object is not a class"));
+ if(_class(o)->_locked) return sq_throwerror(v,_SC("the class is locked"));
+ _class(o)->_udsize = udsize;
+ return SQ_OK;
+}
+
+
+SQRESULT sq_getinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag)
{
SQObjectPtr &o = stack_get(v,idx);
if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
return SQ_OK;
}
-int sq_gettop(HSQUIRRELVM v)
+SQInteger sq_gettop(HSQUIRRELVM v)
{
return (v->_top) - v->_stackbase;
}
-void sq_settop(HSQUIRRELVM v, int newtop)
+void sq_settop(HSQUIRRELVM v, SQInteger newtop)
{
- int top = sq_gettop(v);
+ SQInteger top = sq_gettop(v);
if(top > newtop)
sq_pop(v, top - newtop);
else
- while(top < newtop) sq_pushnull(v);
+ while(top++ < newtop) sq_pushnull(v);
}
-void sq_pop(HSQUIRRELVM v, int nelemstopop)
+void sq_pop(HSQUIRRELVM v, SQInteger nelemstopop)
{
assert(v->_top >= nelemstopop);
v->Pop(nelemstopop);
}
-void sq_remove(HSQUIRRELVM v, int idx)
+void sq_poptop(HSQUIRRELVM v)
+{
+ assert(v->_top >= 1);
+ v->Pop();
+}
+
+
+void sq_remove(HSQUIRRELVM v, SQInteger idx)
{
v->Remove(idx);
}
-int sq_cmp(HSQUIRRELVM v)
+SQInteger sq_cmp(HSQUIRRELVM v)
{
- int res;
+ SQInteger res;
v->ObjCmp(stack_get(v, -1), stack_get(v, -2),res);
return res;
}
-SQRESULT sq_createslot(HSQUIRRELVM v, int idx)
+SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic)
{
sq_aux_paramscheck(v, 3);
SQObjectPtr &self = stack_get(v, idx);
if(type(self) == OT_TABLE || type(self) == OT_CLASS) {
SQObjectPtr &key = v->GetUp(-2);
if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
- v->NewSlot(self, key, v->GetUp(-1));
+ v->NewSlot(self, key, v->GetUp(-1),bstatic?true:false);
v->Pop(2);
}
return SQ_OK;
}
-SQRESULT sq_deleteslot(HSQUIRRELVM v,int idx,SQBool pushval)
+SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
{
sq_aux_paramscheck(v, 2);
SQObjectPtr *self;
return SQ_OK;
}
-SQRESULT sq_set(HSQUIRRELVM v,int idx)
+SQRESULT sq_set(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr &self = stack_get(v, idx);
if(v->Set(self, v->GetUp(-2), v->GetUp(-1),false)) {
v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
}
-SQRESULT sq_rawset(HSQUIRRELVM v,int idx)
+SQRESULT sq_rawset(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr &self = stack_get(v, idx);
if(type(v->GetUp(-2)) == OT_NULL) return sq_throwerror(v, _SC("null key"));
return SQ_OK;
break;
case OT_CLASS:
- _class(self)->NewSlot(v->GetUp(-2), v->GetUp(-1));
+ _class(self)->NewSlot(_ss(v), v->GetUp(-2), v->GetUp(-1),false);
v->Pop(2);
return SQ_OK;
break;
break;
default:
v->Pop(2);
- return sq_throwerror(v, _SC("rawset works only on arrays,tables,calsses and instances"));
+ return sq_throwerror(v, _SC("rawset works only on array/table/class and instance"));
}
v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
}
-SQRESULT sq_setdelegate(HSQUIRRELVM v,int idx)
+SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr &self = stack_get(v, idx);
SQObjectPtr &mt = v->GetUp(-1);
return SQ_OK;
}
-SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,int idx,SQBool pushval)
+SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
{
sq_aux_paramscheck(v, 2);
SQObjectPtr *self;
return SQ_OK;
}
-SQRESULT sq_getdelegate(HSQUIRRELVM v,int idx)
+SQRESULT sq_getdelegate(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr &self=stack_get(v,idx);
switch(type(self)){
case OT_TABLE:
- if(!_table(self)->_delegate)break;
- v->Push(SQObjectPtr(_table(self)->_delegate));
- return SQ_OK;
- break;
case OT_USERDATA:
- if(!_userdata(self)->_delegate)break;
- v->Push(SQObjectPtr(_userdata(self)->_delegate));
- return SQ_OK;
+ if(!_delegable(self)->_delegate){
+ v->Push(_null_);
+ break;
+ }
+ v->Push(SQObjectPtr(_delegable(self)->_delegate));
break;
+ default: return sq_throwerror(v,_SC("wrong type")); break;
}
- return sq_throwerror(v,_SC("wrong type"));
+ return SQ_OK;
+
}
-SQRESULT sq_get(HSQUIRRELVM v,int idx)
+SQRESULT sq_get(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr &self=stack_get(v,idx);
if(v->Get(self,v->GetUp(-1),v->GetUp(-1),false,false))
return sq_throwerror(v,_SC("the index doesn't exist"));
}
-SQRESULT sq_rawget(HSQUIRRELVM v,int idx)
+SQRESULT sq_rawget(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr &self=stack_get(v,idx);
switch(type(self)) {
break;
default:
v->Pop(1);
- return sq_throwerror(v,_SC("rawget works only on arrays and tables"));
+ return sq_throwerror(v,_SC("rawget works only on array/table/instance and class"));
}
v->Pop(1);
return sq_throwerror(v,_SC("the index doesn't exist"));
}
-SQRESULT sq_getstackobj(HSQUIRRELVM v,int idx,HSQOBJECT *po)
+SQRESULT sq_getstackobj(HSQUIRRELVM v,SQInteger idx,HSQOBJECT *po)
{
*po=stack_get(v,idx);
return SQ_OK;
}
-const SQChar *sq_getlocal(HSQUIRRELVM v,unsigned int level,unsigned int idx)
+const SQChar *sq_getlocal(HSQUIRRELVM v,SQUnsignedInteger level,SQUnsignedInteger idx)
{
- unsigned int cstksize=v->_callsstack.size();
- unsigned int lvl=(cstksize-level)-1;
- int stackbase=v->_stackbase;
+ SQUnsignedInteger cstksize=v->_callsstacksize;
+ SQUnsignedInteger lvl=(cstksize-level)-1;
+ SQInteger stackbase=v->_stackbase;
if(lvl<cstksize){
- for(unsigned int i=0;i<level;i++){
+ for(SQUnsignedInteger i=0;i<level;i++){
SQVM::CallInfo &ci=v->_callsstack[(cstksize-i)-1];
stackbase-=ci._prevstkbase;
}
return NULL;
SQClosure *c=_closure(ci._closure);
SQFunctionProto *func=_funcproto(c->_function);
- return func->GetLocal(v,stackbase,idx,(ci._ip-func->_instructions._vals)-1);
+ if(func->_noutervalues > (SQInteger)idx) {
+ v->Push(c->_outervalues[idx]);
+ return _stringval(func->_outervalues[idx]._name);
+ }
+ idx -= func->_noutervalues;
+ return func->GetLocal(v,stackbase,idx,(SQInteger)(ci._ip-func->_instructions)-1);
}
return NULL;
}
v->Push(v->_lasterror);
}
-void sq_reservestack(HSQUIRRELVM v,int nsize)
+void sq_reservestack(HSQUIRRELVM v,SQInteger nsize)
{
- if (((unsigned int)v->_top + nsize) > v->_stack.size()) {
+ if (((SQUnsignedInteger)v->_top + nsize) > v->_stack.size()) {
v->_stack.resize(v->_stack.size() + ((v->_top + nsize) - v->_stack.size()));
}
}
-SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval)
+SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval,SQBool raiseerror)
{
if(type(v->GetUp(-1))==OT_GENERATOR){
v->Push(_null_); //retval
- if(!v->Execute(v->GetUp(-2),v->_top,0,v->_top,v->GetUp(-1),SQVM::ET_RESUME_GENERATOR))
+ if(!v->Execute(v->GetUp(-2),v->_top,0,v->_top,v->GetUp(-1),raiseerror,SQVM::ET_RESUME_GENERATOR))
{v->Raise_Error(v->_lasterror); return SQ_ERROR;}
if(!retval)
v->Pop();
return sq_throwerror(v,_SC("only generators can be resumed"));
}
-SQRESULT sq_call(HSQUIRRELVM v,int params,SQBool retval)
+SQRESULT sq_call(HSQUIRRELVM v,SQInteger params,SQBool retval,SQBool raiseerror)
{
SQObjectPtr res;
- if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res)){
- v->Pop(params);//pop closure and args
+ if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){
+ if(!v->_suspended) {
+ v->Pop(params);//pop closure and args
+ }
if(retval){
v->Push(res); return SQ_OK;
}
return v->Suspend();
}
-SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool wakeupret,SQBool retval)
+SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool wakeupret,SQBool retval,SQBool raiseerror,SQBool throwerror)
{
SQObjectPtr ret;
if(!v->_suspended)
v->GetAt(v->_stackbase+v->_suspended_target)=v->GetUp(-1); //retval
v->Pop();
} else v->GetAt(v->_stackbase+v->_suspended_target)=_null_;
- if(!v->Execute(_null_,v->_top,-1,-1,ret,SQVM::ET_RESUME_VM))
+ if(!v->Execute(_null_,v->_top,-1,-1,ret,raiseerror,throwerror?SQVM::ET_RESUME_THROW_VM : SQVM::ET_RESUME_VM))
return SQ_ERROR;
if(sq_getvmstate(v) == SQ_VMSTATE_IDLE) {
while (v->_top > 1) v->_stack[--v->_top] = _null_;
return SQ_OK;
}
-void sq_setreleasehook(HSQUIRRELVM v,int idx,SQRELEASEHOOK hook)
+void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook)
{
if(sq_gettop(v) >= 1){
SQObjectPtr &ud=stack_get(v,idx);
switch( type(ud) ) {
- case OT_USERDATA:
- _userdata(ud)->_hook = hook;
- break;
- case OT_INSTANCE:
- _instance(ud)->_hook = hook;
- break;
+ case OT_USERDATA: _userdata(ud)->_hook = hook; break;
+ case OT_INSTANCE: _instance(ud)->_hook = hook; break;
+ case OT_CLASS: _class(ud)->_hook = hook; break;
+ default: break; //shutup compiler
}
}
}
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, -1, OT_CLOSURE,o);
- SQClosure *c=_closure(*o);
unsigned short tag = SQ_BYTECODE_STREAM_TAG;
if(w(up,&tag,2) != 2)
return sq_throwerror(v,_SC("io error"));
SQRESULT sq_readclosure(HSQUIRRELVM v,SQREADFUNC r,SQUserPointer up)
{
- SQObjectPtr func=SQFunctionProto::Create();
- SQObjectPtr closure=SQClosure::Create(_ss(v),_funcproto(func));
+ SQObjectPtr closure;
+
unsigned short tag;
if(r(up,&tag,2) != 2)
return sq_throwerror(v,_SC("io error"));
if(tag != SQ_BYTECODE_STREAM_TAG)
return sq_throwerror(v,_SC("invalid stream"));
- if(!_closure(closure)->Load(v,up,r))
+ if(!SQClosure::Load(v,up,r,closure))
return SQ_ERROR;
v->Push(closure);
return SQ_OK;
}
-SQChar *sq_getscratchpad(HSQUIRRELVM v,int minsize)
+SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize)
{
return _ss(v)->GetScratchPad(minsize);
}
-int sq_collectgarbage(HSQUIRRELVM v)
+SQInteger sq_collectgarbage(HSQUIRRELVM v)
{
#ifndef NO_GARBAGE_COLLECTOR
return _ss(v)->CollectGarbage(v);
#endif
}
-SQRESULT sq_setfreevariable(HSQUIRRELVM v,int idx,unsigned int nval)
+const SQChar *sq_getfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval)
+{
+ SQObjectPtr &self = stack_get(v,idx);
+ const SQChar *name = NULL;
+ if(type(self) == OT_CLOSURE) {
+ if(_closure(self)->_outervalues.size()>nval) {
+ v->Push(_closure(self)->_outervalues[nval]);
+ SQFunctionProto *fp = _funcproto(_closure(self)->_function);
+ SQOuterVar &ov = fp->_outervalues[nval];
+ name = _stringval(ov._name);
+ }
+ }
+ return name;
+}
+
+SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval)
{
SQObjectPtr &self=stack_get(v,idx);
switch(type(self))
return SQ_OK;
}
-SQRESULT sq_setattributes(HSQUIRRELVM v,int idx)
+SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o);
return sq_throwerror(v,_SC("wrong index"));
}
-SQRESULT sq_getattributes(HSQUIRRELVM v,int idx)
+SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o);
if(type(key) == OT_NULL) {
attrs = _class(*o)->_attributes;
v->Pop();
- v->Push(attrs);
+ v->Push(attrs);
return SQ_OK;
}
else if(_class(*o)->GetAttributes(key,attrs)) {
return sq_throwerror(v,_SC("wrong index"));
}
-SQRESULT sq_getclass(HSQUIRRELVM v,int idx)
+SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx)
+{
+ SQObjectPtr *o = NULL;
+ _GETSAFE_OBJ(v, idx, OT_CLASS,o);
+ if(_class(*o)->_base)
+ v->Push(SQObjectPtr(_class(*o)->_base));
+ else
+ v->Push(_null_);
+ return SQ_OK;
+}
+
+SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_INSTANCE,o);
return SQ_OK;
}
-SQRESULT sq_createinstance(HSQUIRRELVM v,int idx)
+SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o);
return SQ_OK;
}
-SQRESULT sq_next(HSQUIRRELVM v,int idx)
+void sq_weakref(HSQUIRRELVM v,SQInteger idx)
+{
+ SQObject &o=stack_get(v,idx);
+ if(ISREFCOUNTED(type(o))) {
+ v->Push(_refcounted(o)->GetWeakRef(type(o)));
+ return;
+ }
+ v->Push(o);
+}
+
+SQRESULT sq_getweakrefval(HSQUIRRELVM v,SQInteger idx)
+{
+ SQObjectPtr &o = stack_get(v,idx);
+ if(type(o) != OT_WEAKREF) {
+ return sq_throwerror(v,_SC("the object must be a weakref"));
+ }
+ v->Push(_weakref(o)->_obj);
+ return SQ_OK;
+}
+
+SQRESULT sq_getdefaultdelegate(HSQUIRRELVM v,SQObjectType t)
+{
+ SQSharedState *ss = _ss(v);
+ switch(t) {
+ case OT_TABLE: v->Push(ss->_table_default_delegate); break;
+ case OT_ARRAY: v->Push(ss->_array_default_delegate); break;
+ case OT_STRING: v->Push(ss->_string_default_delegate); break;
+ case OT_INTEGER: case OT_FLOAT: v->Push(ss->_number_default_delegate); break;
+ case OT_GENERATOR: v->Push(ss->_generator_default_delegate); break;
+ case OT_CLOSURE: case OT_NATIVECLOSURE: v->Push(ss->_closure_default_delegate); break;
+ case OT_THREAD: v->Push(ss->_thread_default_delegate); break;
+ case OT_CLASS: v->Push(ss->_class_default_delegate); break;
+ case OT_INSTANCE: v->Push(ss->_instance_default_delegate); break;
+ case OT_WEAKREF: v->Push(ss->_weakref_default_delegate); break;
+ default: return sq_throwerror(v,_SC("the type doesn't have a default delegate"));
+ }
+ return SQ_OK;
+}
+
+SQRESULT sq_next(HSQUIRRELVM v,SQInteger idx)
{
SQObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val;
if(type(o) == OT_GENERATOR) {
return sq_throwerror(v,_SC("cannot iterate a generator"));
}
- bool finished;
- if(!v->FOREACH_OP(o,realkey,val,refpos,0,finished))
+ int faketojump;
+ if(!v->FOREACH_OP(o,realkey,val,refpos,0,666,faketojump))
return SQ_ERROR;
- if(!finished) {
+ if(faketojump != 666) {
v->Push(realkey);
v->Push(val);
return SQ_OK;
struct BufState{
const SQChar *buf;
- int ptr;
- int size;
+ SQInteger ptr;
+ SQInteger size;
};
SQInteger buf_lexfeed(SQUserPointer file)
return buf->buf[buf->ptr++];
}
-SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,int size,const SQChar *sourcename,SQBool raiseerror) {
+SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror) {
BufState buf;
buf.buf = s;
buf.size = size;
return sq_compile(v, buf_lexfeed, &buf, sourcename, raiseerror);
}
-void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,int idx)
+void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,SQInteger idx)
{
dest->Push(stack_get(src,idx));
}
return _ss(v)->_printfunc;
}
-void *sq_malloc(unsigned int size)
+void *sq_malloc(SQUnsignedInteger size)
{
return SQ_MALLOC(size);
}
-void *sq_realloc(void* p,unsigned int oldsize,unsigned int newsize)
+void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize)
{
return SQ_REALLOC(p,oldsize,newsize);
}
-void sq_free(void *p,unsigned int size)
+
+void sq_free(void *p,SQUnsignedInteger size)
{
SQ_FREE(p,size);
}
projects / supertux.git / blobdiff