-/*
- see copyright notice in squirrel.h
-*/
-#include "sqpcheader.h"
-#include "sqvm.h"
-#include "sqstring.h"
-#include "sqtable.h"
-#include "sqarray.h"
-#include "sqfuncproto.h"
-#include "sqclosure.h"
-#include "sqclass.h"
-#include <stdlib.h>
-#include <stdarg.h>
-#include <ctype.h>
-
-bool str2num(const SQChar *s,SQObjectPtr &res)
-{
- SQChar *end;
- if(scstrstr(s,_SC("."))){
- SQFloat r = SQFloat(scstrtod(s,&end));
- if(s == end) return false;
- res = r;
- return true;
- }
- else{
- SQInteger r = SQInteger(scstrtol(s,&end,10));
- if(s == end) return false;
- res = r;
- return true;
- }
-}
-
-static SQInteger base_dummy(HSQUIRRELVM v)
-{
- return 0;
-}
-
-#ifndef NO_GARBAGE_COLLECTOR
-static SQInteger base_collectgarbage(HSQUIRRELVM v)
-{
- sq_pushinteger(v, sq_collectgarbage(v));
- return 1;
-}
-#endif
-
-static SQInteger base_getroottable(HSQUIRRELVM v)
-{
- v->Push(v->_roottable);
- return 1;
-}
-
-static SQInteger base_getconsttable(HSQUIRRELVM v)
-{
- v->Push(_ss(v)->_consts);
- return 1;
-}
-
-
-static SQInteger base_setroottable(HSQUIRRELVM v)
-{
- SQObjectPtr &o=stack_get(v,2);
- if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
- v->Push(o);
- return 1;
-}
-
-static SQInteger base_setconsttable(HSQUIRRELVM v)
-{
- SQObjectPtr &o=stack_get(v,2);
- if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;
- v->Push(o);
- return 1;
-}
-
-static SQInteger base_seterrorhandler(HSQUIRRELVM v)
-{
- sq_seterrorhandler(v);
- return 0;
-}
-
-static SQInteger base_setdebughook(HSQUIRRELVM v)
-{
- sq_setdebughook(v);
- return 0;
-}
-
-static SQInteger base_enabledebuginfo(HSQUIRRELVM v)
-{
- SQObjectPtr &o=stack_get(v,2);
- sq_enabledebuginfo(v,(type(o) != OT_NULL)?1:0);
- return 0;
-}
-
-static SQInteger base_getstackinfos(HSQUIRRELVM v)
-{
- SQInteger level;
- SQStackInfos si;
- SQInteger seq = 0;
- const SQChar *name = NULL;
- sq_getinteger(v, -1, &level);
- if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
- {
- const SQChar *fn = _SC("unknown");
- const SQChar *src = _SC("unknown");
- if(si.funcname)fn = si.funcname;
- if(si.source)src = si.source;
- sq_newtable(v);
- sq_pushstring(v, _SC("func"), -1);
- sq_pushstring(v, fn, -1);
- sq_createslot(v, -3);
- sq_pushstring(v, _SC("src"), -1);
- sq_pushstring(v, src, -1);
- sq_createslot(v, -3);
- sq_pushstring(v, _SC("line"), -1);
- sq_pushinteger(v, si.line);
- sq_createslot(v, -3);
- sq_pushstring(v, _SC("locals"), -1);
- sq_newtable(v);
- seq=0;
- while ((name = sq_getlocal(v, level, seq))) {
- sq_pushstring(v, name, -1);
- sq_push(v, -2);
- sq_createslot(v, -4);
- sq_pop(v, 1);
- seq++;
- }
- sq_createslot(v, -3);
- return 1;
- }
-
- return 0;
-}
-
-static SQInteger base_assert(HSQUIRRELVM v)
-{
- if(v->IsFalse(stack_get(v,2))){
- return sq_throwerror(v,_SC("assertion failed"));
- }
- return 0;
-}
-
-static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o)
-{
- SQInteger top = sq_gettop(v);
- sidx=0;
- eidx=0;
- o=stack_get(v,1);
- SQObjectPtr &start=stack_get(v,2);
- if(type(start)!=OT_NULL && sq_isnumeric(start)){
- sidx=tointeger(start);
- }
- if(top>2){
- SQObjectPtr &end=stack_get(v,3);
- if(sq_isnumeric(end)){
- eidx=tointeger(end);
- }
- }
- else {
- eidx = sq_getsize(v,1);
- }
- return 1;
-}
-
-static SQInteger base_print(HSQUIRRELVM v)
-{
- const SQChar *str;
- sq_tostring(v,2);
- sq_getstring(v,-1,&str);
- if(_ss(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str);
- return 0;
-}
-
-static SQInteger base_compilestring(HSQUIRRELVM v)
-{
- SQInteger nargs=sq_gettop(v);
- const SQChar *src=NULL,*name=_SC("unnamedbuffer");
- SQInteger size;
- sq_getstring(v,2,&src);
- size=sq_getsize(v,2);
- if(nargs>2){
- sq_getstring(v,3,&name);
- }
- if(SQ_SUCCEEDED(sq_compilebuffer(v,src,size,name,SQFalse)))
- return 1;
- else
- return SQ_ERROR;
-}
-
-static SQInteger base_newthread(HSQUIRRELVM v)
-{
- SQObjectPtr &func = stack_get(v,2);
- SQInteger stksize = (_funcproto(_closure(func)->_function)->_stacksize << 1) +2;
- HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
- sq_move(newv,v,-2);
- return 1;
-}
-
-static SQInteger base_suspend(HSQUIRRELVM v)
-{
- return sq_suspendvm(v);
-}
-
-static SQInteger base_array(HSQUIRRELVM v)
-{
- SQArray *a;
- SQObject &size = stack_get(v,2);
- if(sq_gettop(v) > 2) {
- a = SQArray::Create(_ss(v),0);
- a->Resize(tointeger(size),stack_get(v,3));
- }
- else {
- a = SQArray::Create(_ss(v),tointeger(size));
- }
- v->Push(a);
- return 1;
-}
-
-static SQInteger base_type(HSQUIRRELVM v)
-{
- SQObjectPtr &o = stack_get(v,2);
- v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));
- return 1;
-}
-
-static SQRegFunction base_funcs[]={
- //generic
- {_SC("seterrorhandler"),base_seterrorhandler,2, NULL},
- {_SC("setdebughook"),base_setdebughook,2, NULL},
- {_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL},
- {_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")},
- {_SC("getroottable"),base_getroottable,1, NULL},
- {_SC("setroottable"),base_setroottable,2, NULL},
- {_SC("getconsttable"),base_getconsttable,1, NULL},
- {_SC("setconsttable"),base_setconsttable,2, NULL},
- {_SC("assert"),base_assert,2, NULL},
- {_SC("print"),base_print,2, NULL},
- {_SC("compilestring"),base_compilestring,-2, _SC(".ss")},
- {_SC("newthread"),base_newthread,2, _SC(".c")},
- {_SC("suspend"),base_suspend,-1, NULL},
- {_SC("array"),base_array,-2, _SC(".n")},
- {_SC("type"),base_type,2, NULL},
- {_SC("dummy"),base_dummy,0,NULL},
-#ifndef NO_GARBAGE_COLLECTOR
- {_SC("collectgarbage"),base_collectgarbage,1, _SC("t")},
-#endif
- {0,0}
-};
-
-void sq_base_register(HSQUIRRELVM v)
-{
- SQInteger i=0;
- sq_pushroottable(v);
- while(base_funcs[i].name!=0) {
- sq_pushstring(v,base_funcs[i].name,-1);
- sq_newclosure(v,base_funcs[i].f,0);
- sq_setnativeclosurename(v,-1,base_funcs[i].name);
- sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);
- sq_createslot(v,-3);
- i++;
- }
- sq_pushstring(v,_SC("_version_"),-1);
- sq_pushstring(v,SQUIRREL_VERSION,-1);
- sq_createslot(v,-3);
- sq_pushstring(v,_SC("_charsize_"),-1);
- sq_pushinteger(v,sizeof(SQChar));
- sq_createslot(v,-3);
- sq_pushstring(v,_SC("_intsize_"),-1);
- sq_pushinteger(v,sizeof(SQInteger));
- sq_createslot(v,-3);
- sq_pushstring(v,_SC("_floatsize_"),-1);
- sq_pushinteger(v,sizeof(SQFloat));
- sq_createslot(v,-3);
- sq_pop(v,1);
-}
-
-static SQInteger default_delegate_len(HSQUIRRELVM v)
-{
- v->Push(SQInteger(sq_getsize(v,1)));
- return 1;
-}
-
-static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
-{
- SQObjectPtr &o=stack_get(v,1);
- switch(type(o)){
- case OT_STRING:{
- SQObjectPtr res;
- if(str2num(_stringval(o),res)){
- v->Push(SQObjectPtr(tofloat(res)));
- break;
- }}
- return sq_throwerror(v, _SC("cannot convert the string"));
- break;
- case OT_INTEGER:case OT_FLOAT:
- v->Push(SQObjectPtr(tofloat(o)));
- break;
- case OT_BOOL:
- v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));
- break;
- default:
- v->Push(_null_);
- break;
- }
- return 1;
-}
-
-static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
-{
- SQObjectPtr &o=stack_get(v,1);
- switch(type(o)){
- case OT_STRING:{
- SQObjectPtr res;
- if(str2num(_stringval(o),res)){
- v->Push(SQObjectPtr(tointeger(res)));
- break;
- }}
- return sq_throwerror(v, _SC("cannot convert the string"));
- break;
- case OT_INTEGER:case OT_FLOAT:
- v->Push(SQObjectPtr(tointeger(o)));
- break;
- case OT_BOOL:
- v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
- break;
- default:
- v->Push(_null_);
- break;
- }
- return 1;
-}
-
-static SQInteger default_delegate_tostring(HSQUIRRELVM v)
-{
- sq_tostring(v,1);
- return 1;
-}
-
-static SQInteger obj_delegate_weakref(HSQUIRRELVM v)
-{
- sq_weakref(v,1);
- return 1;
-}
-
-static SQInteger obj_clear(HSQUIRRELVM v)
-{
- return sq_clear(v,-1);
-}
-
-
-static SQInteger number_delegate_tochar(HSQUIRRELVM v)
-{
- SQObject &o=stack_get(v,1);
- SQChar c = (SQChar)tointeger(o);
- v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));
- return 1;
-}
-
-
-/////////////////////////////////////////////////////////////////
-//TABLE DEFAULT DELEGATE
-
-static SQInteger table_rawdelete(HSQUIRRELVM v)
-{
- if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
- return SQ_ERROR;
- return 1;
-}
-
-
-static SQInteger container_rawexists(HSQUIRRELVM v)
-{
- if(SQ_SUCCEEDED(sq_rawget(v,-2))) {
- sq_pushbool(v,SQTrue);
- return 1;
- }
- sq_pushbool(v,SQFalse);
- return 1;
-}
-
-static SQInteger table_rawset(HSQUIRRELVM v)
-{
- return sq_rawset(v,-3);
-}
-
-
-static SQInteger table_rawget(HSQUIRRELVM v)
-{
- return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;
-}
-
-
-SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
- {_SC("len"),default_delegate_len,1, _SC("t")},
- {_SC("rawget"),table_rawget,2, _SC("t")},
- {_SC("rawset"),table_rawset,3, _SC("t")},
- {_SC("rawdelete"),table_rawdelete,2, _SC("t")},
- {_SC("rawin"),container_rawexists,2, _SC("t")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {_SC("clear"),obj_clear,1, _SC(".")},
- {0,0}
-};
-
-//ARRAY DEFAULT DELEGATE///////////////////////////////////////
-
-static SQInteger array_append(HSQUIRRELVM v)
-{
- return sq_arrayappend(v,-2);
-}
-
-static SQInteger array_extend(HSQUIRRELVM v)
-{
- _array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
- return 0;
-}
-
-static SQInteger array_reverse(HSQUIRRELVM v)
-{
- return sq_arrayreverse(v,-1);
-}
-
-static SQInteger array_pop(HSQUIRRELVM v)
-{
- return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;
-}
-
-static SQInteger array_top(HSQUIRRELVM v)
-{
- SQObject &o=stack_get(v,1);
- if(_array(o)->Size()>0){
- v->Push(_array(o)->Top());
- return 1;
- }
- else return sq_throwerror(v,_SC("top() on a empty array"));
-}
-
-static SQInteger array_insert(HSQUIRRELVM v)
-{
- SQObject &o=stack_get(v,1);
- SQObject &idx=stack_get(v,2);
- SQObject &val=stack_get(v,3);
- if(!_array(o)->Insert(tointeger(idx),val))
- return sq_throwerror(v,_SC("index out of range"));
- return 0;
-}
-
-static SQInteger array_remove(HSQUIRRELVM v)
-{
- SQObject &o = stack_get(v, 1);
- SQObject &idx = stack_get(v, 2);
- if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
- SQObjectPtr val;
- if(_array(o)->Get(tointeger(idx), val)) {
- _array(o)->Remove(tointeger(idx));
- v->Push(val);
- return 1;
- }
- return sq_throwerror(v, _SC("idx out of range"));
-}
-
-static SQInteger array_resize(HSQUIRRELVM v)
-{
- SQObject &o = stack_get(v, 1);
- SQObject &nsize = stack_get(v, 2);
- SQObjectPtr fill;
- if(sq_isnumeric(nsize)) {
- if(sq_gettop(v) > 2)
- fill = stack_get(v, 3);
- _array(o)->Resize(tointeger(nsize),fill);
- return 0;
- }
- return sq_throwerror(v, _SC("size must be a number"));
-}
-
-
-//QSORT ala Sedgewick
-bool _qsort_compare(HSQUIRRELVM v,SQObjectPtr &arr,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
-{
- if(func < 0) {
- if(!v->ObjCmp(a,b,ret)) return false;
- }
- else {
- SQInteger top = sq_gettop(v);
- sq_push(v, func);
- sq_pushroottable(v);
- v->Push(a);
- v->Push(b);
- if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
- if(!sq_isstring( v->_lasterror))
- v->Raise_Error(_SC("compare func failed"));
- return false;
- }
- sq_getinteger(v, -1, &ret);
- sq_settop(v, top);
- return true;
- }
- return true;
-}
-//QSORT ala Sedgewick
-bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
-{
- SQInteger i, j;
- SQArray *a=_array(arr);
- SQObjectPtr pivot,t;
- if( l < r ){
- pivot = a->_values[l];
- i = l; j = r+1;
- while(1){
- SQInteger ret;
- do {
- ++i;
- if(i > r) break;
- if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
- return false;
- } while( ret <= 0);
- do {
- --j;
- if ( j < 0 ) {
- v->Raise_Error( _SC("Invalid qsort, probably compare function defect") );
- return false;
- }
- if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
- return false;
- }
- while( ret > 0 );
- if( i >= j ) break;
- t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
- }
- t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
- if(!_qsort( v, arr, l, j-1,func)) return false;
- if(!_qsort( v, arr, j+1, r,func)) return false;
- }
- return true;
-}
-
-static SQInteger array_sort(HSQUIRRELVM v)
-{
- SQInteger func = -1;
- SQObjectPtr &o = stack_get(v,1);
- SQObject &funcobj = stack_get(v,2);
- if(_array(o)->Size() > 1) {
- if(type(funcobj) == OT_CLOSURE || type(funcobj) == OT_NATIVECLOSURE) func = 2;
- if(!_qsort(v, o, 0, _array(o)->Size()-1, func))
- return SQ_ERROR;
-
- }
- return 0;
-}
-static SQInteger array_slice(HSQUIRRELVM v)
-{
- SQInteger sidx,eidx;
- SQObjectPtr o;
- if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
- SQInteger alen = _array(o)->Size();
- if(sidx < 0)sidx = alen + sidx;
- if(eidx < 0)eidx = alen + eidx;
- if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
- if(eidx > alen)return sq_throwerror(v,_SC("slice out of range"));
- SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
- SQObjectPtr t;
- SQInteger count=0;
- for(SQInteger i=sidx;i<eidx;i++){
- _array(o)->Get(i,t);
- arr->Set(count++,t);
- }
- v->Push(arr);
- return 1;
-
-}
-
-SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
- {_SC("len"),default_delegate_len,1, _SC("a")},
- {_SC("append"),array_append,2, _SC("a")},
- {_SC("extend"),array_extend,2, _SC("aa")},
- {_SC("push"),array_append,2, _SC("a")},
- {_SC("pop"),array_pop,1, _SC("a")},
- {_SC("top"),array_top,1, _SC("a")},
- {_SC("insert"),array_insert,3, _SC("an")},
- {_SC("remove"),array_remove,2, _SC("an")},
- {_SC("resize"),array_resize,-2, _SC("an")},
- {_SC("reverse"),array_reverse,1, _SC("a")},
- {_SC("sort"),array_sort,-1, _SC("ac")},
- {_SC("slice"),array_slice,-1, _SC("ann")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {_SC("clear"),obj_clear,1, _SC(".")},
- {0,0}
-};
-
-//STRING DEFAULT DELEGATE//////////////////////////
-static SQInteger string_slice(HSQUIRRELVM v)
-{
- SQInteger sidx,eidx;
- SQObjectPtr o;
- if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
- SQInteger slen = _string(o)->_len;
- if(sidx < 0)sidx = slen + sidx;
- if(eidx < 0)eidx = slen + eidx;
- if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
- if(eidx > slen) return sq_throwerror(v,_SC("slice out of range"));
- v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
- return 1;
-}
-
-static SQInteger string_find(HSQUIRRELVM v)
-{
- SQInteger top,start_idx=0;
- const SQChar *str,*substr,*ret;
- if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
- if(top>2)sq_getinteger(v,3,&start_idx);
- if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
- ret=scstrstr(&str[start_idx],substr);
- if(ret){
- sq_pushinteger(v,(SQInteger)(ret-str));
- return 1;
- }
- }
- return 0;
- }
- return sq_throwerror(v,_SC("invalid param"));
-}
-
-#define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \
-{ \
- SQObject str=stack_get(v,1); \
- SQInteger len=_string(str)->_len; \
- const SQChar *sThis=_stringval(str); \
- SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \
- for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \
- v->Push(SQString::Create(_ss(v),sNew,len)); \
- return 1; \
-}
-
-
-STRING_TOFUNCZ(tolower)
-STRING_TOFUNCZ(toupper)
-
-SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
- {_SC("len"),default_delegate_len,1, _SC("s")},
- {_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},
- {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {_SC("slice"),string_slice,-1, _SC(" s n n")},
- {_SC("find"),string_find,-2, _SC("s s n ")},
- {_SC("tolower"),string_tolower,1, _SC("s")},
- {_SC("toupper"),string_toupper,1, _SC("s")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {0,0}
-};
-
-//INTEGER DEFAULT DELEGATE//////////////////////////
-SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
- {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
- {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {0,0}
-};
-
-//CLOSURE DEFAULT DELEGATE//////////////////////////
-static SQInteger closure_pcall(HSQUIRRELVM v)
-{
- return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
-}
-
-static SQInteger closure_call(HSQUIRRELVM v)
-{
- return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;
-}
-
-static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
-{
- SQArray *aparams=_array(stack_get(v,2));
- SQInteger nparams=aparams->Size();
- v->Push(stack_get(v,1));
- for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);
- return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
-}
-
-static SQInteger closure_acall(HSQUIRRELVM v)
-{
- return _closure_acall(v,SQTrue);
-}
-
-static SQInteger closure_pacall(HSQUIRRELVM v)
-{
- return _closure_acall(v,SQFalse);
-}
-
-static SQInteger closure_bindenv(HSQUIRRELVM v)
-{
- if(SQ_FAILED(sq_bindenv(v,1)))
- return SQ_ERROR;
- return 1;
-}
-
-static SQInteger closure_getinfos(HSQUIRRELVM v) {
- SQObject o = stack_get(v,1);
- SQTable *res = SQTable::Create(_ss(v),4);
- if(type(o) == OT_CLOSURE) {
- SQFunctionProto *f = _funcproto(_closure(o)->_function);
- SQInteger nparams = f->_nparameters + (f->_varparams?1:0);
- SQObjectPtr params = SQArray::Create(_ss(v),nparams);
- for(SQInteger n = 0; n<f->_nparameters; n++) {
- _array(params)->Set((SQInteger)n,f->_parameters[n]);
- }
- if(f->_varparams) {
- _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
- }
- res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);
- res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);
- res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);
- res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);
- res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);
- }
- else { //OT_NATIVECLOSURE
- SQNativeClosure *nc = _nativeclosure(o);
- res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);
- res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);
- res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);
- SQObjectPtr typecheck;
- if(nc->_typecheck.size() > 0) {
- typecheck =
- SQArray::Create(_ss(v), nc->_typecheck.size());
- for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
- _array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
- }
- }
- res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
- }
- v->Push(res);
- return 1;
-}
-
-
-SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
- {_SC("call"),closure_call,-1, _SC("c")},
- {_SC("pcall"),closure_pcall,-1, _SC("c")},
- {_SC("acall"),closure_acall,2, _SC("ca")},
- {_SC("pacall"),closure_pacall,2, _SC("ca")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
- {_SC("getinfos"),closure_getinfos,1, _SC("c")},
- {0,0}
-};
-
-//GENERATOR DEFAULT DELEGATE
-static SQInteger generator_getstatus(HSQUIRRELVM v)
-{
- SQObject &o=stack_get(v,1);
- switch(_generator(o)->_state){
- case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;
- case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;
- case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;
- }
- return 1;
-}
-
-SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
- {_SC("getstatus"),generator_getstatus,1, _SC("g")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {0,0}
-};
-
-//THREAD DEFAULT DELEGATE
-
-static SQInteger thread_call(HSQUIRRELVM v)
-{
-
- SQObjectPtr o = stack_get(v,1);
- if(type(o) == OT_THREAD) {
- SQInteger nparams = sq_gettop(v);
- _thread(o)->Push(_thread(o)->_roottable);
- for(SQInteger i = 2; i<(nparams+1); i++)
- sq_move(_thread(o),v,i);
- if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQFalse))) {
- sq_move(v,_thread(o),-1);
- sq_pop(_thread(o),1);
- return 1;
- }
- v->_lasterror = _thread(o)->_lasterror;
- return SQ_ERROR;
- }
- return sq_throwerror(v,_SC("wrong parameter"));
-}
-
-static SQInteger thread_wakeup(HSQUIRRELVM v)
-{
- SQObjectPtr o = stack_get(v,1);
- if(type(o) == OT_THREAD) {
- SQVM *thread = _thread(o);
- SQInteger state = sq_getvmstate(thread);
- if(state != SQ_VMSTATE_SUSPENDED) {
- switch(state) {
- case SQ_VMSTATE_IDLE:
- return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
- break;
- case SQ_VMSTATE_RUNNING:
- return sq_throwerror(v,_SC("cannot wakeup a running thread"));
- break;
- }
- }
-
- SQInteger wakeupret = sq_gettop(v)>1?1:0;
- if(wakeupret) {
- sq_move(thread,v,2);
- }
- if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQTrue,SQFalse))) {
- sq_move(v,thread,-1);
- sq_pop(thread,1); //pop retval
- if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {
- sq_settop(thread,1); //pop roottable
- }
- return 1;
- }
- sq_settop(thread,1);
- v->_lasterror = thread->_lasterror;
- return SQ_ERROR;
- }
- return sq_throwerror(v,_SC("wrong parameter"));
-}
-
-static SQInteger thread_getstatus(HSQUIRRELVM v)
-{
- SQObjectPtr &o = stack_get(v,1);
- switch(sq_getvmstate(_thread(o))) {
- case SQ_VMSTATE_IDLE:
- sq_pushstring(v,_SC("idle"),-1);
- break;
- case SQ_VMSTATE_RUNNING:
- sq_pushstring(v,_SC("running"),-1);
- break;
- case SQ_VMSTATE_SUSPENDED:
- sq_pushstring(v,_SC("suspended"),-1);
- break;
- default:
- return sq_throwerror(v,_SC("internal VM error"));
- }
- return 1;
-}
-
-SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
- {_SC("call"), thread_call, -1, _SC("v")},
- {_SC("wakeup"), thread_wakeup, -1, _SC("v")},
- {_SC("getstatus"), thread_getstatus, 1, _SC("v")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {0,0},
-};
-
-static SQInteger class_getattributes(HSQUIRRELVM v)
-{
- if(SQ_SUCCEEDED(sq_getattributes(v,-2)))
- return 1;
- return SQ_ERROR;
-}
-
-static SQInteger class_setattributes(HSQUIRRELVM v)
-{
- if(SQ_SUCCEEDED(sq_setattributes(v,-3)))
- return 1;
- return SQ_ERROR;
-}
-
-static SQInteger class_instance(HSQUIRRELVM v)
-{
- if(SQ_SUCCEEDED(sq_createinstance(v,-1)))
- return 1;
- return SQ_ERROR;
-}
-
-SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
- {_SC("getattributes"), class_getattributes, 2, _SC("y.")},
- {_SC("setattributes"), class_setattributes, 3, _SC("y..")},
- {_SC("rawin"),container_rawexists,2, _SC("y")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {_SC("instance"),class_instance,1, _SC("y")},
- {0,0}
-};
-
-static SQInteger instance_getclass(HSQUIRRELVM v)
-{
- if(SQ_SUCCEEDED(sq_getclass(v,1)))
- return 1;
- return SQ_ERROR;
-}
-
-SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
- {_SC("getclass"), instance_getclass, 1, _SC("x")},
- {_SC("rawin"),container_rawexists,2, _SC("x")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {0,0}
-};
-
-static SQInteger weakref_ref(HSQUIRRELVM v)
-{
- if(SQ_FAILED(sq_getweakrefval(v,1)))
- return SQ_ERROR;
- return 1;
-}
-
-SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {
- {_SC("ref"),weakref_ref,1, _SC("r")},
- {_SC("weakref"),obj_delegate_weakref,1, NULL },
- {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
- {0,0}
-};
-
-
+/*\r
+ see copyright notice in squirrel.h\r
+*/\r
+#include "sqpcheader.h"\r
+#include "sqvm.h"\r
+#include "sqstring.h"\r
+#include "sqtable.h"\r
+#include "sqarray.h"\r
+#include "sqfuncproto.h"\r
+#include "sqclosure.h"\r
+#include "sqclass.h"\r
+#include <stdlib.h>\r
+#include <stdarg.h>\r
+#include <ctype.h>\r
+\r
+bool str2num(const SQChar *s,SQObjectPtr &res)\r
+{\r
+ SQChar *end;\r
+ const SQChar *e = s;\r
+ SQBool isfloat = SQFalse;\r
+ SQChar c;\r
+ while((c = *e) != _SC('\0'))\r
+ {\r
+ if(c == _SC('.') || c == _SC('E')|| c == _SC('e')) { //e and E is for scientific notation\r
+ isfloat = SQTrue;\r
+ break;\r
+ }\r
+ e++;\r
+ }\r
+ if(isfloat){\r
+ SQFloat r = SQFloat(scstrtod(s,&end));\r
+ if(s == end) return false;\r
+ res = r;\r
+ }\r
+ else{\r
+ SQInteger r = SQInteger(scstrtol(s,&end,10));\r
+ if(s == end) return false;\r
+ res = r;\r
+ }\r
+ return true;\r
+}\r
+\r
+static SQInteger base_dummy(HSQUIRRELVM v)\r
+{\r
+ return 0;\r
+}\r
+\r
+#ifndef NO_GARBAGE_COLLECTOR\r
+static SQInteger base_collectgarbage(HSQUIRRELVM v)\r
+{\r
+ sq_pushinteger(v, sq_collectgarbage(v));\r
+ return 1;\r
+}\r
+static SQInteger base_resurectureachable(HSQUIRRELVM v)\r
+{\r
+ sq_resurrectunreachable(v);\r
+ return 1;\r
+}\r
+#endif\r
+\r
+static SQInteger base_getroottable(HSQUIRRELVM v)\r
+{\r
+ v->Push(v->_roottable);\r
+ return 1;\r
+}\r
+\r
+static SQInteger base_getconsttable(HSQUIRRELVM v)\r
+{\r
+ v->Push(_ss(v)->_consts);\r
+ return 1;\r
+}\r
+\r
+\r
+static SQInteger base_setroottable(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr o = v->_roottable;\r
+ if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;\r
+ v->Push(o);\r
+ return 1;\r
+}\r
+\r
+static SQInteger base_setconsttable(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr o = _ss(v)->_consts;\r
+ if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;\r
+ v->Push(o);\r
+ return 1;\r
+}\r
+\r
+static SQInteger base_seterrorhandler(HSQUIRRELVM v)\r
+{\r
+ sq_seterrorhandler(v);\r
+ return 0;\r
+}\r
+\r
+static SQInteger base_setdebughook(HSQUIRRELVM v)\r
+{\r
+ sq_setdebughook(v);\r
+ return 0;\r
+}\r
+\r
+static SQInteger base_enabledebuginfo(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr &o=stack_get(v,2);\r
+ \r
+ sq_enabledebuginfo(v,SQVM::IsFalse(o)?SQFalse:SQTrue);\r
+ return 0;\r
+}\r
+\r
+static SQInteger __getcallstackinfos(HSQUIRRELVM v,SQInteger level)\r
+{\r
+ SQStackInfos si;\r
+ SQInteger seq = 0;\r
+ const SQChar *name = NULL;\r
+ \r
+ if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))\r
+ {\r
+ const SQChar *fn = _SC("unknown");\r
+ const SQChar *src = _SC("unknown");\r
+ if(si.funcname)fn = si.funcname;\r
+ if(si.source)src = si.source;\r
+ sq_newtable(v);\r
+ sq_pushstring(v, _SC("func"), -1);\r
+ sq_pushstring(v, fn, -1);\r
+ sq_newslot(v, -3, SQFalse);\r
+ sq_pushstring(v, _SC("src"), -1);\r
+ sq_pushstring(v, src, -1);\r
+ sq_newslot(v, -3, SQFalse);\r
+ sq_pushstring(v, _SC("line"), -1);\r
+ sq_pushinteger(v, si.line);\r
+ sq_newslot(v, -3, SQFalse);\r
+ sq_pushstring(v, _SC("locals"), -1);\r
+ sq_newtable(v);\r
+ seq=0;\r
+ while ((name = sq_getlocal(v, level, seq))) {\r
+ sq_pushstring(v, name, -1);\r
+ sq_push(v, -2);\r
+ sq_newslot(v, -4, SQFalse);\r
+ sq_pop(v, 1);\r
+ seq++;\r
+ }\r
+ sq_newslot(v, -3, SQFalse);\r
+ return 1;\r
+ }\r
+\r
+ return 0;\r
+}\r
+static SQInteger base_getstackinfos(HSQUIRRELVM v)\r
+{\r
+ SQInteger level;\r
+ sq_getinteger(v, -1, &level);\r
+ return __getcallstackinfos(v,level);\r
+}\r
+\r
+static SQInteger base_assert(HSQUIRRELVM v)\r
+{\r
+ if(SQVM::IsFalse(stack_get(v,2))){\r
+ return sq_throwerror(v,_SC("assertion failed"));\r
+ }\r
+ return 0;\r
+}\r
+\r
+static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o)\r
+{\r
+ SQInteger top = sq_gettop(v);\r
+ sidx=0;\r
+ eidx=0;\r
+ o=stack_get(v,1);\r
+ SQObjectPtr &start=stack_get(v,2);\r
+ if(type(start)!=OT_NULL && sq_isnumeric(start)){\r
+ sidx=tointeger(start);\r
+ }\r
+ if(top>2){\r
+ SQObjectPtr &end=stack_get(v,3);\r
+ if(sq_isnumeric(end)){\r
+ eidx=tointeger(end);\r
+ }\r
+ }\r
+ else {\r
+ eidx = sq_getsize(v,1);\r
+ }\r
+ return 1;\r
+}\r
+\r
+static SQInteger base_print(HSQUIRRELVM v)\r
+{\r
+ const SQChar *str;\r
+ if(SQ_SUCCEEDED(sq_tostring(v,2)))\r
+ {\r
+ if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {\r
+ if(_ss(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str);\r
+ return 0;\r
+ }\r
+ }\r
+ return SQ_ERROR;\r
+}\r
+\r
+static SQInteger base_error(HSQUIRRELVM v)\r
+{\r
+ const SQChar *str;\r
+ if(SQ_SUCCEEDED(sq_tostring(v,2)))\r
+ {\r
+ if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {\r
+ if(_ss(v)->_errorfunc) _ss(v)->_errorfunc(v,_SC("%s"),str);\r
+ return 0;\r
+ }\r
+ }\r
+ return SQ_ERROR;\r
+}\r
+\r
+static SQInteger base_compilestring(HSQUIRRELVM v)\r
+{\r
+ SQInteger nargs=sq_gettop(v);\r
+ const SQChar *src=NULL,*name=_SC("unnamedbuffer");\r
+ SQInteger size;\r
+ sq_getstring(v,2,&src);\r
+ size=sq_getsize(v,2);\r
+ if(nargs>2){\r
+ sq_getstring(v,3,&name);\r
+ }\r
+ if(SQ_SUCCEEDED(sq_compilebuffer(v,src,size,name,SQFalse)))\r
+ return 1;\r
+ else\r
+ return SQ_ERROR;\r
+}\r
+\r
+static SQInteger base_newthread(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr &func = stack_get(v,2);\r
+ SQInteger stksize = (_closure(func)->_function->_stacksize << 1) +2;\r
+ HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);\r
+ sq_move(newv,v,-2);\r
+ return 1;\r
+}\r
+\r
+static SQInteger base_suspend(HSQUIRRELVM v)\r
+{\r
+ return sq_suspendvm(v);\r
+}\r
+\r
+static SQInteger base_array(HSQUIRRELVM v)\r
+{\r
+ SQArray *a;\r
+ SQObject &size = stack_get(v,2);\r
+ if(sq_gettop(v) > 2) {\r
+ a = SQArray::Create(_ss(v),0);\r
+ a->Resize(tointeger(size),stack_get(v,3));\r
+ }\r
+ else {\r
+ a = SQArray::Create(_ss(v),tointeger(size));\r
+ }\r
+ v->Push(a);\r
+ return 1;\r
+}\r
+\r
+static SQInteger base_type(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr &o = stack_get(v,2);\r
+ v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));\r
+ return 1;\r
+}\r
+\r
+static SQInteger base_callee(HSQUIRRELVM v)\r
+{\r
+ if(v->_callsstacksize > 1)\r
+ {\r
+ v->Push(v->_callsstack[v->_callsstacksize - 2]._closure);\r
+ return 1;\r
+ }\r
+ return sq_throwerror(v,_SC("no closure in the calls stack"));\r
+}\r
+\r
+static SQRegFunction base_funcs[]={\r
+ //generic\r
+ {_SC("seterrorhandler"),base_seterrorhandler,2, NULL},\r
+ {_SC("setdebughook"),base_setdebughook,2, NULL},\r
+ {_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL},\r
+ {_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")},\r
+ {_SC("getroottable"),base_getroottable,1, NULL},\r
+ {_SC("setroottable"),base_setroottable,2, NULL},\r
+ {_SC("getconsttable"),base_getconsttable,1, NULL},\r
+ {_SC("setconsttable"),base_setconsttable,2, NULL},\r
+ {_SC("assert"),base_assert,2, NULL},\r
+ {_SC("print"),base_print,2, NULL},\r
+ {_SC("error"),base_error,2, NULL},\r
+ {_SC("compilestring"),base_compilestring,-2, _SC(".ss")},\r
+ {_SC("newthread"),base_newthread,2, _SC(".c")},\r
+ {_SC("suspend"),base_suspend,-1, NULL},\r
+ {_SC("array"),base_array,-2, _SC(".n")},\r
+ {_SC("type"),base_type,2, NULL},\r
+ {_SC("callee"),base_callee,0,NULL},\r
+ {_SC("dummy"),base_dummy,0,NULL},\r
+#ifndef NO_GARBAGE_COLLECTOR\r
+ {_SC("collectgarbage"),base_collectgarbage,0, NULL},\r
+ {_SC("resurrectunreachable"),base_resurectureachable,0, NULL},\r
+#endif\r
+ {0,0}\r
+};\r
+\r
+void sq_base_register(HSQUIRRELVM v)\r
+{\r
+ SQInteger i=0;\r
+ sq_pushroottable(v);\r
+ while(base_funcs[i].name!=0) {\r
+ sq_pushstring(v,base_funcs[i].name,-1);\r
+ sq_newclosure(v,base_funcs[i].f,0);\r
+ sq_setnativeclosurename(v,-1,base_funcs[i].name);\r
+ sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);\r
+ sq_newslot(v,-3, SQFalse);\r
+ i++;\r
+ }\r
+ \r
+ sq_pushstring(v,_SC("_versionnumber_"),-1);\r
+ sq_pushinteger(v,SQUIRREL_VERSION_NUMBER);\r
+ sq_newslot(v,-3, SQFalse);\r
+ sq_pushstring(v,_SC("_version_"),-1);\r
+ sq_pushstring(v,SQUIRREL_VERSION,-1);\r
+ sq_newslot(v,-3, SQFalse);\r
+ sq_pushstring(v,_SC("_charsize_"),-1);\r
+ sq_pushinteger(v,sizeof(SQChar));\r
+ sq_newslot(v,-3, SQFalse);\r
+ sq_pushstring(v,_SC("_intsize_"),-1);\r
+ sq_pushinteger(v,sizeof(SQInteger));\r
+ sq_newslot(v,-3, SQFalse);\r
+ sq_pushstring(v,_SC("_floatsize_"),-1);\r
+ sq_pushinteger(v,sizeof(SQFloat));\r
+ sq_newslot(v,-3, SQFalse);\r
+ sq_pop(v,1);\r
+}\r
+\r
+static SQInteger default_delegate_len(HSQUIRRELVM v)\r
+{\r
+ v->Push(SQInteger(sq_getsize(v,1)));\r
+ return 1;\r
+}\r
+\r
+static SQInteger default_delegate_tofloat(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr &o=stack_get(v,1);\r
+ switch(type(o)){\r
+ case OT_STRING:{\r
+ SQObjectPtr res;\r
+ if(str2num(_stringval(o),res)){\r
+ v->Push(SQObjectPtr(tofloat(res)));\r
+ break;\r
+ }}\r
+ return sq_throwerror(v, _SC("cannot convert the string"));\r
+ break;\r
+ case OT_INTEGER:case OT_FLOAT:\r
+ v->Push(SQObjectPtr(tofloat(o)));\r
+ break;\r
+ case OT_BOOL:\r
+ v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));\r
+ break;\r
+ default:\r
+ v->PushNull();\r
+ break;\r
+ }\r
+ return 1;\r
+}\r
+\r
+static SQInteger default_delegate_tointeger(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr &o=stack_get(v,1);\r
+ switch(type(o)){\r
+ case OT_STRING:{\r
+ SQObjectPtr res;\r
+ if(str2num(_stringval(o),res)){\r
+ v->Push(SQObjectPtr(tointeger(res)));\r
+ break;\r
+ }}\r
+ return sq_throwerror(v, _SC("cannot convert the string"));\r
+ break;\r
+ case OT_INTEGER:case OT_FLOAT:\r
+ v->Push(SQObjectPtr(tointeger(o)));\r
+ break;\r
+ case OT_BOOL:\r
+ v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));\r
+ break;\r
+ default:\r
+ v->PushNull();\r
+ break;\r
+ }\r
+ return 1;\r
+}\r
+\r
+static SQInteger default_delegate_tostring(HSQUIRRELVM v)\r
+{\r
+ if(SQ_FAILED(sq_tostring(v,1))) \r
+ return SQ_ERROR;\r
+ return 1;\r
+}\r
+\r
+static SQInteger obj_delegate_weakref(HSQUIRRELVM v)\r
+{\r
+ sq_weakref(v,1);\r
+ return 1;\r
+}\r
+\r
+static SQInteger obj_clear(HSQUIRRELVM v)\r
+{\r
+ return sq_clear(v,-1);\r
+}\r
+\r
+\r
+static SQInteger number_delegate_tochar(HSQUIRRELVM v)\r
+{\r
+ SQObject &o=stack_get(v,1);\r
+ SQChar c = (SQChar)tointeger(o);\r
+ v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));\r
+ return 1;\r
+}\r
+\r
+\r
+\r
+/////////////////////////////////////////////////////////////////\r
+//TABLE DEFAULT DELEGATE\r
+\r
+static SQInteger table_rawdelete(HSQUIRRELVM v)\r
+{\r
+ if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))\r
+ return SQ_ERROR;\r
+ return 1;\r
+}\r
+\r
+\r
+static SQInteger container_rawexists(HSQUIRRELVM v)\r
+{\r
+ if(SQ_SUCCEEDED(sq_rawget(v,-2))) {\r
+ sq_pushbool(v,SQTrue);\r
+ return 1;\r
+ }\r
+ sq_pushbool(v,SQFalse);\r
+ return 1;\r
+}\r
+\r
+static SQInteger container_rawset(HSQUIRRELVM v)\r
+{\r
+ return sq_rawset(v,-3);\r
+}\r
+\r
+\r
+static SQInteger container_rawget(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger table_setdelegate(HSQUIRRELVM v)\r
+{\r
+ if(SQ_FAILED(sq_setdelegate(v,-2)))\r
+ return SQ_ERROR;\r
+ sq_push(v,-1); // -1 because sq_setdelegate pops 1\r
+ return 1;\r
+}\r
+\r
+static SQInteger table_getdelegate(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_getdelegate(v,-1))?1:SQ_ERROR;\r
+}\r
+\r
+SQRegFunction SQSharedState::_table_default_delegate_funcz[]={\r
+ {_SC("len"),default_delegate_len,1, _SC("t")},\r
+ {_SC("rawget"),container_rawget,2, _SC("t")},\r
+ {_SC("rawset"),container_rawset,3, _SC("t")},\r
+ {_SC("rawdelete"),table_rawdelete,2, _SC("t")},\r
+ {_SC("rawin"),container_rawexists,2, _SC("t")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {_SC("clear"),obj_clear,1, _SC(".")},\r
+ {_SC("setdelegate"),table_setdelegate,2, _SC(".t|o")},\r
+ {_SC("getdelegate"),table_getdelegate,1, _SC(".")},\r
+ {0,0}\r
+};\r
+\r
+//ARRAY DEFAULT DELEGATE///////////////////////////////////////\r
+\r
+static SQInteger array_append(HSQUIRRELVM v)\r
+{\r
+ return sq_arrayappend(v,-2);\r
+}\r
+\r
+static SQInteger array_extend(HSQUIRRELVM v)\r
+{\r
+ _array(stack_get(v,1))->Extend(_array(stack_get(v,2)));\r
+ return 0;\r
+}\r
+\r
+static SQInteger array_reverse(HSQUIRRELVM v)\r
+{\r
+ return sq_arrayreverse(v,-1);\r
+}\r
+\r
+static SQInteger array_pop(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger array_top(HSQUIRRELVM v)\r
+{\r
+ SQObject &o=stack_get(v,1);\r
+ if(_array(o)->Size()>0){\r
+ v->Push(_array(o)->Top());\r
+ return 1;\r
+ }\r
+ else return sq_throwerror(v,_SC("top() on a empty array"));\r
+}\r
+\r
+static SQInteger array_insert(HSQUIRRELVM v)\r
+{\r
+ SQObject &o=stack_get(v,1);\r
+ SQObject &idx=stack_get(v,2);\r
+ SQObject &val=stack_get(v,3);\r
+ if(!_array(o)->Insert(tointeger(idx),val))\r
+ return sq_throwerror(v,_SC("index out of range"));\r
+ return 0;\r
+}\r
+\r
+static SQInteger array_remove(HSQUIRRELVM v)\r
+{\r
+ SQObject &o = stack_get(v, 1);\r
+ SQObject &idx = stack_get(v, 2);\r
+ if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));\r
+ SQObjectPtr val;\r
+ if(_array(o)->Get(tointeger(idx), val)) {\r
+ _array(o)->Remove(tointeger(idx));\r
+ v->Push(val);\r
+ return 1;\r
+ }\r
+ return sq_throwerror(v, _SC("idx out of range"));\r
+}\r
+\r
+static SQInteger array_resize(HSQUIRRELVM v)\r
+{\r
+ SQObject &o = stack_get(v, 1);\r
+ SQObject &nsize = stack_get(v, 2);\r
+ SQObjectPtr fill;\r
+ if(sq_isnumeric(nsize)) {\r
+ if(sq_gettop(v) > 2)\r
+ fill = stack_get(v, 3);\r
+ _array(o)->Resize(tointeger(nsize),fill);\r
+ return 0;\r
+ }\r
+ return sq_throwerror(v, _SC("size must be a number"));\r
+}\r
+\r
+static SQInteger __map_array(SQArray *dest,SQArray *src,HSQUIRRELVM v) {\r
+ SQObjectPtr temp;\r
+ SQInteger size = src->Size();\r
+ for(SQInteger n = 0; n < size; n++) {\r
+ src->Get(n,temp);\r
+ v->Push(src);\r
+ v->Push(temp);\r
+ if(SQ_FAILED(sq_call(v,2,SQTrue,SQFalse))) {\r
+ return SQ_ERROR;\r
+ }\r
+ dest->Set(n,v->GetUp(-1));\r
+ v->Pop();\r
+ }\r
+ return 0;\r
+}\r
+\r
+static SQInteger array_map(HSQUIRRELVM v)\r
+{\r
+ SQObject &o = stack_get(v,1);\r
+ SQInteger size = _array(o)->Size();\r
+ SQObjectPtr ret = SQArray::Create(_ss(v),size);\r
+ if(SQ_FAILED(__map_array(_array(ret),_array(o),v)))\r
+ return SQ_ERROR;\r
+ v->Push(ret);\r
+ return 1;\r
+}\r
+\r
+static SQInteger array_apply(HSQUIRRELVM v)\r
+{\r
+ SQObject &o = stack_get(v,1);\r
+ if(SQ_FAILED(__map_array(_array(o),_array(o),v)))\r
+ return SQ_ERROR;\r
+ return 0;\r
+}\r
+\r
+static SQInteger array_reduce(HSQUIRRELVM v)\r
+{\r
+ SQObject &o = stack_get(v,1);\r
+ SQArray *a = _array(o);\r
+ SQInteger size = a->Size();\r
+ if(size == 0) {\r
+ return 0;\r
+ }\r
+ SQObjectPtr res;\r
+ a->Get(0,res);\r
+ if(size > 1) {\r
+ SQObjectPtr other;\r
+ for(SQInteger n = 1; n < size; n++) {\r
+ a->Get(n,other);\r
+ v->Push(o);\r
+ v->Push(res);\r
+ v->Push(other);\r
+ if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) {\r
+ return SQ_ERROR;\r
+ }\r
+ res = v->GetUp(-1);\r
+ v->Pop();\r
+ }\r
+ }\r
+ v->Push(res);\r
+ return 1;\r
+}\r
+\r
+static SQInteger array_filter(HSQUIRRELVM v)\r
+{\r
+ SQObject &o = stack_get(v,1);\r
+ SQArray *a = _array(o);\r
+ SQObjectPtr ret = SQArray::Create(_ss(v),0);\r
+ SQInteger size = a->Size();\r
+ SQObjectPtr val;\r
+ for(SQInteger n = 0; n < size; n++) {\r
+ a->Get(n,val);\r
+ v->Push(o);\r
+ v->Push(n);\r
+ v->Push(val);\r
+ if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) {\r
+ return SQ_ERROR;\r
+ }\r
+ if(!SQVM::IsFalse(v->GetUp(-1))) {\r
+ _array(ret)->Append(val);\r
+ }\r
+ v->Pop();\r
+ }\r
+ v->Push(ret);\r
+ return 1;\r
+}\r
+\r
+static SQInteger array_find(HSQUIRRELVM v)\r
+{\r
+ SQObject &o = stack_get(v,1);\r
+ SQObjectPtr &val = stack_get(v,2);\r
+ SQArray *a = _array(o);\r
+ SQInteger size = a->Size();\r
+ SQObjectPtr temp;\r
+ for(SQInteger n = 0; n < size; n++) {\r
+ bool res = false;\r
+ a->Get(n,temp);\r
+ if(SQVM::IsEqual(temp,val,res) && res) {\r
+ v->Push(n);\r
+ return 1;\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+bool _sort_compare(HSQUIRRELVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)\r
+{\r
+ if(func < 0) {\r
+ if(!v->ObjCmp(a,b,ret)) return false;\r
+ }\r
+ else {\r
+ SQInteger top = sq_gettop(v);\r
+ sq_push(v, func);\r
+ sq_pushroottable(v);\r
+ v->Push(a);\r
+ v->Push(b);\r
+ if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {\r
+ if(!sq_isstring( v->_lasterror)) \r
+ v->Raise_Error(_SC("compare func failed"));\r
+ return false;\r
+ }\r
+ if(SQ_FAILED(sq_getinteger(v, -1, &ret))) {\r
+ v->Raise_Error(_SC("numeric value expected as return value of the compare function"));\r
+ return false;\r
+ }\r
+ sq_settop(v, top);\r
+ return true;\r
+ }\r
+ return true;\r
+}\r
+\r
+bool _hsort_sift_down(HSQUIRRELVM v,SQArray *arr, SQInteger root, SQInteger bottom, SQInteger func)\r
+{\r
+ SQInteger maxChild;\r
+ SQInteger done = 0;\r
+ SQInteger ret;\r
+ SQInteger root2;\r
+ while (((root2 = root * 2) <= bottom) && (!done))\r
+ {\r
+ if (root2 == bottom) {\r
+ maxChild = root2;\r
+ }\r
+ else {\r
+ if(!_sort_compare(v,arr->_values[root2],arr->_values[root2 + 1],func,ret))\r
+ return false;\r
+ if (ret > 0) {\r
+ maxChild = root2;\r
+ }\r
+ else {\r
+ maxChild = root2 + 1;\r
+ }\r
+ }\r
+\r
+ if(!_sort_compare(v,arr->_values[root],arr->_values[maxChild],func,ret))\r
+ return false;\r
+ if (ret < 0) {\r
+ if (root == maxChild) {\r
+ v->Raise_Error(_SC("inconsistent compare function"));\r
+ return false; // We'd be swapping ourselve. The compare function is incorrect\r
+ }\r
+\r
+ _Swap(arr->_values[root],arr->_values[maxChild]);\r
+ root = maxChild;\r
+ }\r
+ else {\r
+ done = 1;\r
+ }\r
+ }\r
+ return true;\r
+}\r
+\r
+bool _hsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)\r
+{\r
+ SQArray *a = _array(arr);\r
+ SQInteger i;\r
+ SQInteger array_size = a->Size();\r
+ for (i = (array_size / 2); i >= 0; i--) {\r
+ if(!_hsort_sift_down(v,a, i, array_size - 1,func)) return false;\r
+ }\r
+\r
+ for (i = array_size-1; i >= 1; i--)\r
+ {\r
+ _Swap(a->_values[0],a->_values[i]);\r
+ if(!_hsort_sift_down(v,a, 0, i-1,func)) return false;\r
+ }\r
+ return true;\r
+}\r
+\r
+static SQInteger array_sort(HSQUIRRELVM v)\r
+{\r
+ SQInteger func = -1;\r
+ SQObjectPtr &o = stack_get(v,1);\r
+ if(_array(o)->Size() > 1) {\r
+ if(sq_gettop(v) == 2) func = 2;\r
+ if(!_hsort(v, o, 0, _array(o)->Size()-1, func))\r
+ return SQ_ERROR;\r
+\r
+ }\r
+ return 0;\r
+}\r
+\r
+static SQInteger array_slice(HSQUIRRELVM v)\r
+{\r
+ SQInteger sidx,eidx;\r
+ SQObjectPtr o;\r
+ if(get_slice_params(v,sidx,eidx,o)==-1)return -1;\r
+ SQInteger alen = _array(o)->Size();\r
+ if(sidx < 0)sidx = alen + sidx;\r
+ if(eidx < 0)eidx = alen + eidx;\r
+ if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));\r
+ if(eidx > alen)return sq_throwerror(v,_SC("slice out of range"));\r
+ SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);\r
+ SQObjectPtr t;\r
+ SQInteger count=0;\r
+ for(SQInteger i=sidx;i<eidx;i++){\r
+ _array(o)->Get(i,t);\r
+ arr->Set(count++,t);\r
+ }\r
+ v->Push(arr);\r
+ return 1;\r
+ \r
+}\r
+\r
+SQRegFunction SQSharedState::_array_default_delegate_funcz[]={\r
+ {_SC("len"),default_delegate_len,1, _SC("a")},\r
+ {_SC("append"),array_append,2, _SC("a")},\r
+ {_SC("extend"),array_extend,2, _SC("aa")},\r
+ {_SC("push"),array_append,2, _SC("a")},\r
+ {_SC("pop"),array_pop,1, _SC("a")},\r
+ {_SC("top"),array_top,1, _SC("a")},\r
+ {_SC("insert"),array_insert,3, _SC("an")},\r
+ {_SC("remove"),array_remove,2, _SC("an")},\r
+ {_SC("resize"),array_resize,-2, _SC("an")},\r
+ {_SC("reverse"),array_reverse,1, _SC("a")},\r
+ {_SC("sort"),array_sort,-1, _SC("ac")},\r
+ {_SC("slice"),array_slice,-1, _SC("ann")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {_SC("clear"),obj_clear,1, _SC(".")},\r
+ {_SC("map"),array_map,2, _SC("ac")}, \r
+ {_SC("apply"),array_apply,2, _SC("ac")}, \r
+ {_SC("reduce"),array_reduce,2, _SC("ac")}, \r
+ {_SC("filter"),array_filter,2, _SC("ac")},\r
+ {_SC("find"),array_find,2, _SC("a.")},\r
+ {0,0}\r
+};\r
+\r
+//STRING DEFAULT DELEGATE//////////////////////////\r
+static SQInteger string_slice(HSQUIRRELVM v)\r
+{\r
+ SQInteger sidx,eidx;\r
+ SQObjectPtr o;\r
+ if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;\r
+ SQInteger slen = _string(o)->_len;\r
+ if(sidx < 0)sidx = slen + sidx;\r
+ if(eidx < 0)eidx = slen + eidx;\r
+ if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));\r
+ if(eidx > slen) return sq_throwerror(v,_SC("slice out of range"));\r
+ v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));\r
+ return 1;\r
+}\r
+\r
+static SQInteger string_find(HSQUIRRELVM v)\r
+{\r
+ SQInteger top,start_idx=0;\r
+ const SQChar *str,*substr,*ret;\r
+ if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){\r
+ if(top>2)sq_getinteger(v,3,&start_idx);\r
+ if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){\r
+ ret=scstrstr(&str[start_idx],substr);\r
+ if(ret){\r
+ sq_pushinteger(v,(SQInteger)(ret-str));\r
+ return 1;\r
+ }\r
+ }\r
+ return 0;\r
+ }\r
+ return sq_throwerror(v,_SC("invalid param"));\r
+}\r
+\r
+#define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \\r
+{ \\r
+ SQObject str=stack_get(v,1); \\r
+ SQInteger len=_string(str)->_len; \\r
+ const SQChar *sThis=_stringval(str); \\r
+ SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \\r
+ for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \\r
+ v->Push(SQString::Create(_ss(v),sNew,len)); \\r
+ return 1; \\r
+}\r
+\r
+\r
+STRING_TOFUNCZ(tolower)\r
+STRING_TOFUNCZ(toupper)\r
+\r
+SQRegFunction SQSharedState::_string_default_delegate_funcz[]={\r
+ {_SC("len"),default_delegate_len,1, _SC("s")},\r
+ {_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},\r
+ {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {_SC("slice"),string_slice,-1, _SC(" s n n")},\r
+ {_SC("find"),string_find,-2, _SC("s s n ")},\r
+ {_SC("tolower"),string_tolower,1, _SC("s")},\r
+ {_SC("toupper"),string_toupper,1, _SC("s")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {0,0}\r
+};\r
+\r
+//INTEGER DEFAULT DELEGATE//////////////////////////\r
+SQRegFunction SQSharedState::_number_default_delegate_funcz[]={\r
+ {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},\r
+ {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {0,0}\r
+};\r
+\r
+//CLOSURE DEFAULT DELEGATE//////////////////////////\r
+static SQInteger closure_pcall(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger closure_call(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)\r
+{\r
+ SQArray *aparams=_array(stack_get(v,2));\r
+ SQInteger nparams=aparams->Size();\r
+ v->Push(stack_get(v,1));\r
+ for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);\r
+ return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger closure_acall(HSQUIRRELVM v)\r
+{\r
+ return _closure_acall(v,SQTrue);\r
+}\r
+\r
+static SQInteger closure_pacall(HSQUIRRELVM v)\r
+{\r
+ return _closure_acall(v,SQFalse);\r
+}\r
+\r
+static SQInteger closure_bindenv(HSQUIRRELVM v)\r
+{\r
+ if(SQ_FAILED(sq_bindenv(v,1)))\r
+ return SQ_ERROR;\r
+ return 1;\r
+}\r
+\r
+static SQInteger closure_getinfos(HSQUIRRELVM v) {\r
+ SQObject o = stack_get(v,1);\r
+ SQTable *res = SQTable::Create(_ss(v),4);\r
+ if(type(o) == OT_CLOSURE) {\r
+ SQFunctionProto *f = _closure(o)->_function;\r
+ SQInteger nparams = f->_nparameters + (f->_varparams?1:0);\r
+ SQObjectPtr params = SQArray::Create(_ss(v),nparams);\r
+ SQObjectPtr defparams = SQArray::Create(_ss(v),f->_ndefaultparams);\r
+ for(SQInteger n = 0; n<f->_nparameters; n++) {\r
+ _array(params)->Set((SQInteger)n,f->_parameters[n]);\r
+ }\r
+ for(SQInteger j = 0; j<f->_ndefaultparams; j++) {\r
+ _array(defparams)->Set((SQInteger)j,_closure(o)->_defaultparams[j]);\r
+ }\r
+ if(f->_varparams) {\r
+ _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));\r
+ }\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("defparams"),-1),defparams);\r
+ }\r
+ else { //OT_NATIVECLOSURE \r
+ SQNativeClosure *nc = _nativeclosure(o);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);\r
+ SQObjectPtr typecheck;\r
+ if(nc->_typecheck.size() > 0) {\r
+ typecheck =\r
+ SQArray::Create(_ss(v), nc->_typecheck.size());\r
+ for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {\r
+ _array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);\r
+ }\r
+ }\r
+ res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);\r
+ }\r
+ v->Push(res);\r
+ return 1;\r
+}\r
+\r
+\r
+\r
+SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={\r
+ {_SC("call"),closure_call,-1, _SC("c")},\r
+ {_SC("pcall"),closure_pcall,-1, _SC("c")},\r
+ {_SC("acall"),closure_acall,2, _SC("ca")},\r
+ {_SC("pacall"),closure_pacall,2, _SC("ca")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},\r
+ {_SC("getinfos"),closure_getinfos,1, _SC("c")},\r
+ {0,0}\r
+};\r
+\r
+//GENERATOR DEFAULT DELEGATE\r
+static SQInteger generator_getstatus(HSQUIRRELVM v)\r
+{\r
+ SQObject &o=stack_get(v,1);\r
+ switch(_generator(o)->_state){\r
+ case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;\r
+ case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;\r
+ case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;\r
+ }\r
+ return 1;\r
+}\r
+\r
+SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={\r
+ {_SC("getstatus"),generator_getstatus,1, _SC("g")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {0,0}\r
+};\r
+\r
+//THREAD DEFAULT DELEGATE\r
+static SQInteger thread_call(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr o = stack_get(v,1);\r
+ if(type(o) == OT_THREAD) {\r
+ SQInteger nparams = sq_gettop(v);\r
+ _thread(o)->Push(_thread(o)->_roottable);\r
+ for(SQInteger i = 2; i<(nparams+1); i++)\r
+ sq_move(_thread(o),v,i);\r
+ if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQTrue))) {\r
+ sq_move(v,_thread(o),-1);\r
+ sq_pop(_thread(o),1);\r
+ return 1;\r
+ }\r
+ v->_lasterror = _thread(o)->_lasterror;\r
+ return SQ_ERROR;\r
+ }\r
+ return sq_throwerror(v,_SC("wrong parameter"));\r
+}\r
+\r
+static SQInteger thread_wakeup(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr o = stack_get(v,1);\r
+ if(type(o) == OT_THREAD) {\r
+ SQVM *thread = _thread(o);\r
+ SQInteger state = sq_getvmstate(thread);\r
+ if(state != SQ_VMSTATE_SUSPENDED) {\r
+ switch(state) {\r
+ case SQ_VMSTATE_IDLE:\r
+ return sq_throwerror(v,_SC("cannot wakeup a idle thread"));\r
+ break;\r
+ case SQ_VMSTATE_RUNNING:\r
+ return sq_throwerror(v,_SC("cannot wakeup a running thread"));\r
+ break;\r
+ }\r
+ }\r
+ \r
+ SQInteger wakeupret = sq_gettop(v)>1?1:0;\r
+ if(wakeupret) {\r
+ sq_move(thread,v,2);\r
+ }\r
+ if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQTrue,SQFalse))) {\r
+ sq_move(v,thread,-1);\r
+ sq_pop(thread,1); //pop retval\r
+ if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {\r
+ sq_settop(thread,1); //pop roottable\r
+ }\r
+ return 1;\r
+ }\r
+ sq_settop(thread,1);\r
+ v->_lasterror = thread->_lasterror;\r
+ return SQ_ERROR;\r
+ }\r
+ return sq_throwerror(v,_SC("wrong parameter"));\r
+}\r
+\r
+static SQInteger thread_getstatus(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr &o = stack_get(v,1);\r
+ switch(sq_getvmstate(_thread(o))) {\r
+ case SQ_VMSTATE_IDLE:\r
+ sq_pushstring(v,_SC("idle"),-1);\r
+ break;\r
+ case SQ_VMSTATE_RUNNING:\r
+ sq_pushstring(v,_SC("running"),-1);\r
+ break;\r
+ case SQ_VMSTATE_SUSPENDED:\r
+ sq_pushstring(v,_SC("suspended"),-1);\r
+ break;\r
+ default:\r
+ return sq_throwerror(v,_SC("internal VM error"));\r
+ }\r
+ return 1;\r
+}\r
+\r
+static SQInteger thread_getstackinfos(HSQUIRRELVM v)\r
+{\r
+ SQObjectPtr o = stack_get(v,1);\r
+ if(type(o) == OT_THREAD) {\r
+ SQVM *thread = _thread(o);\r
+ SQInteger threadtop = sq_gettop(thread);\r
+ SQInteger level;\r
+ sq_getinteger(v,-1,&level);\r
+ SQRESULT res = __getcallstackinfos(thread,level);\r
+ if(SQ_FAILED(res))\r
+ {\r
+ sq_settop(thread,threadtop);\r
+ if(type(thread->_lasterror) == OT_STRING) {\r
+ sq_throwerror(v,_stringval(thread->_lasterror));\r
+ }\r
+ else {\r
+ sq_throwerror(v,_SC("unknown error"));\r
+ }\r
+ }\r
+ if(res > 0) {\r
+ //some result\r
+ sq_move(v,thread,-1);\r
+ sq_settop(thread,threadtop);\r
+ return 1;\r
+ }\r
+ //no result\r
+ sq_settop(thread,threadtop);\r
+ return 0;\r
+ \r
+ }\r
+ return sq_throwerror(v,_SC("wrong parameter"));\r
+}\r
+\r
+SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {\r
+ {_SC("call"), thread_call, -1, _SC("v")},\r
+ {_SC("wakeup"), thread_wakeup, -1, _SC("v")},\r
+ {_SC("getstatus"), thread_getstatus, 1, _SC("v")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("getstackinfos"),thread_getstackinfos,2, _SC("vn")},\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {0,0},\r
+};\r
+\r
+static SQInteger class_getattributes(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_getattributes(v,-2))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger class_setattributes(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_setattributes(v,-3))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger class_instance(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_createinstance(v,-1))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger class_getbase(HSQUIRRELVM v)\r
+{\r
+ return SQ_SUCCEEDED(sq_getbase(v,-1))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger class_newmember(HSQUIRRELVM v)\r
+{\r
+ SQInteger top = sq_gettop(v);\r
+ SQBool bstatic = SQFalse;\r
+ if(top == 5)\r
+ {\r
+ sq_tobool(v,-1,&bstatic);\r
+ sq_pop(v,1);\r
+ }\r
+\r
+ if(top < 4) {\r
+ sq_pushnull(v);\r
+ }\r
+ return SQ_SUCCEEDED(sq_newmember(v,-4,bstatic))?1:SQ_ERROR;\r
+}\r
+\r
+static SQInteger class_rawnewmember(HSQUIRRELVM v)\r
+{\r
+ SQInteger top = sq_gettop(v);\r
+ SQBool bstatic = SQFalse;\r
+ if(top == 5)\r
+ {\r
+ sq_tobool(v,-1,&bstatic);\r
+ sq_pop(v,1);\r
+ }\r
+\r
+ if(top < 4) {\r
+ sq_pushnull(v);\r
+ }\r
+ return SQ_SUCCEEDED(sq_rawnewmember(v,-4,bstatic))?1:SQ_ERROR;\r
+}\r
+\r
+SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {\r
+ {_SC("getattributes"), class_getattributes, 2, _SC("y.")},\r
+ {_SC("setattributes"), class_setattributes, 3, _SC("y..")},\r
+ {_SC("rawget"),container_rawget,2, _SC("y")},\r
+ {_SC("rawset"),container_rawset,3, _SC("y")},\r
+ {_SC("rawin"),container_rawexists,2, _SC("y")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {_SC("instance"),class_instance,1, _SC("y")},\r
+ {_SC("getbase"),class_getbase,1, _SC("y")},\r
+ {_SC("newmember"),class_newmember,-3, _SC("y")},\r
+ {_SC("rawnewmember"),class_rawnewmember,-3, _SC("y")},\r
+ {0,0}\r
+};\r
+\r
+\r
+static SQInteger instance_getclass(HSQUIRRELVM v)\r
+{\r
+ if(SQ_SUCCEEDED(sq_getclass(v,1)))\r
+ return 1;\r
+ return SQ_ERROR;\r
+}\r
+\r
+SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {\r
+ {_SC("getclass"), instance_getclass, 1, _SC("x")},\r
+ {_SC("rawget"),container_rawget,2, _SC("x")},\r
+ {_SC("rawset"),container_rawset,3, _SC("x")},\r
+ {_SC("rawin"),container_rawexists,2, _SC("x")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {0,0}\r
+};\r
+\r
+static SQInteger weakref_ref(HSQUIRRELVM v)\r
+{\r
+ if(SQ_FAILED(sq_getweakrefval(v,1)))\r
+ return SQ_ERROR;\r
+ return 1;\r
+}\r
+\r
+SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {\r
+ {_SC("ref"),weakref_ref,1, _SC("r")},\r
+ {_SC("weakref"),obj_delegate_weakref,1, NULL },\r
+ {_SC("tostring"),default_delegate_tostring,1, _SC(".")},\r
+ {0,0}\r
+};\r
+\r
projects / supertux.git / blobdiff