2 see copyright notice in squirrel.h
4 #include "sqpcheader.h"
9 #include "sqfuncproto.h"
10 #include "sqclosure.h"
16 bool str2num(const SQChar *s,SQObjectPtr &res)
19 if(scstrstr(s,_SC("."))){
20 SQFloat r = SQFloat(scstrtod(s,&end));
21 if(s == end) return false;
26 SQInteger r = SQInteger(scstrtol(s,&end,10));
27 if(s == end) return false;
33 static SQInteger base_dummy(HSQUIRRELVM v)
38 #ifndef NO_GARBAGE_COLLECTOR
39 static SQInteger base_collectgarbage(HSQUIRRELVM v)
41 sq_pushinteger(v, sq_collectgarbage(v));
46 static SQInteger base_getroottable(HSQUIRRELVM v)
48 v->Push(v->_roottable);
52 static SQInteger base_getconsttable(HSQUIRRELVM v)
54 v->Push(_ss(v)->_consts);
59 static SQInteger base_setroottable(HSQUIRRELVM v)
61 SQObjectPtr &o=stack_get(v,2);
62 if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
67 static SQInteger base_setconsttable(HSQUIRRELVM v)
69 SQObjectPtr &o=stack_get(v,2);
70 if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;
75 static SQInteger base_seterrorhandler(HSQUIRRELVM v)
77 sq_seterrorhandler(v);
81 static SQInteger base_setdebughook(HSQUIRRELVM v)
87 static SQInteger base_enabledebuginfo(HSQUIRRELVM v)
89 SQObjectPtr &o=stack_get(v,2);
90 sq_enabledebuginfo(v,(type(o) != OT_NULL)?1:0);
94 static SQInteger base_getstackinfos(HSQUIRRELVM v)
99 const SQChar *name = NULL;
100 sq_getinteger(v, -1, &level);
101 if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
103 const SQChar *fn = _SC("unknown");
104 const SQChar *src = _SC("unknown");
105 if(si.funcname)fn = si.funcname;
106 if(si.source)src = si.source;
108 sq_pushstring(v, _SC("func"), -1);
109 sq_pushstring(v, fn, -1);
110 sq_createslot(v, -3);
111 sq_pushstring(v, _SC("src"), -1);
112 sq_pushstring(v, src, -1);
113 sq_createslot(v, -3);
114 sq_pushstring(v, _SC("line"), -1);
115 sq_pushinteger(v, si.line);
116 sq_createslot(v, -3);
117 sq_pushstring(v, _SC("locals"), -1);
120 while ((name = sq_getlocal(v, level, seq))) {
121 sq_pushstring(v, name, -1);
123 sq_createslot(v, -4);
127 sq_createslot(v, -3);
134 static SQInteger base_assert(HSQUIRRELVM v)
136 if(v->IsFalse(stack_get(v,2))){
137 return sq_throwerror(v,_SC("assertion failed"));
142 static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o)
144 SQInteger top = sq_gettop(v);
148 SQObjectPtr &start=stack_get(v,2);
149 if(type(start)!=OT_NULL && sq_isnumeric(start)){
150 sidx=tointeger(start);
153 SQObjectPtr &end=stack_get(v,3);
154 if(sq_isnumeric(end)){
159 eidx = sq_getsize(v,1);
164 static SQInteger base_print(HSQUIRRELVM v)
168 sq_getstring(v,-1,&str);
169 if(_ss(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str);
173 static SQInteger base_compilestring(HSQUIRRELVM v)
175 SQInteger nargs=sq_gettop(v);
176 const SQChar *src=NULL,*name=_SC("unnamedbuffer");
178 sq_getstring(v,2,&src);
179 size=sq_getsize(v,2);
181 sq_getstring(v,3,&name);
183 if(SQ_SUCCEEDED(sq_compilebuffer(v,src,size,name,SQFalse)))
189 static SQInteger base_newthread(HSQUIRRELVM v)
191 SQObjectPtr &func = stack_get(v,2);
192 SQInteger stksize = (_funcproto(_closure(func)->_function)->_stacksize << 1) +2;
193 HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
198 static SQInteger base_suspend(HSQUIRRELVM v)
200 return sq_suspendvm(v);
203 static SQInteger base_array(HSQUIRRELVM v)
206 SQObject &size = stack_get(v,2);
207 if(sq_gettop(v) > 2) {
208 a = SQArray::Create(_ss(v),0);
209 a->Resize(tointeger(size),stack_get(v,3));
212 a = SQArray::Create(_ss(v),tointeger(size));
218 static SQInteger base_type(HSQUIRRELVM v)
220 SQObjectPtr &o = stack_get(v,2);
221 v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));
225 static SQRegFunction base_funcs[]={
227 {_SC("seterrorhandler"),base_seterrorhandler,2, NULL},
228 {_SC("setdebughook"),base_setdebughook,2, NULL},
229 {_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL},
230 {_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")},
231 {_SC("getroottable"),base_getroottable,1, NULL},
232 {_SC("setroottable"),base_setroottable,2, NULL},
233 {_SC("getconsttable"),base_getconsttable,1, NULL},
234 {_SC("setconsttable"),base_setconsttable,2, NULL},
235 {_SC("assert"),base_assert,2, NULL},
236 {_SC("print"),base_print,2, NULL},
237 {_SC("compilestring"),base_compilestring,-2, _SC(".ss")},
238 {_SC("newthread"),base_newthread,2, _SC(".c")},
239 {_SC("suspend"),base_suspend,-1, NULL},
240 {_SC("array"),base_array,-2, _SC(".n")},
241 {_SC("type"),base_type,2, NULL},
242 {_SC("dummy"),base_dummy,0,NULL},
243 #ifndef NO_GARBAGE_COLLECTOR
244 {_SC("collectgarbage"),base_collectgarbage,1, _SC("t")},
249 void sq_base_register(HSQUIRRELVM v)
253 while(base_funcs[i].name!=0) {
254 sq_pushstring(v,base_funcs[i].name,-1);
255 sq_newclosure(v,base_funcs[i].f,0);
256 sq_setnativeclosurename(v,-1,base_funcs[i].name);
257 sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);
261 sq_pushstring(v,_SC("_version_"),-1);
262 sq_pushstring(v,SQUIRREL_VERSION,-1);
264 sq_pushstring(v,_SC("_charsize_"),-1);
265 sq_pushinteger(v,sizeof(SQChar));
267 sq_pushstring(v,_SC("_intsize_"),-1);
268 sq_pushinteger(v,sizeof(SQInteger));
273 static SQInteger default_delegate_len(HSQUIRRELVM v)
275 v->Push(SQInteger(sq_getsize(v,1)));
279 static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
281 SQObjectPtr &o=stack_get(v,1);
285 if(str2num(_stringval(o),res)){
286 v->Push(SQObjectPtr(tofloat(res)));
289 return sq_throwerror(v, _SC("cannot convert the string"));
291 case OT_INTEGER:case OT_FLOAT:
292 v->Push(SQObjectPtr(tofloat(o)));
295 v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));
304 static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
306 SQObjectPtr &o=stack_get(v,1);
310 if(str2num(_stringval(o),res)){
311 v->Push(SQObjectPtr(tointeger(res)));
314 return sq_throwerror(v, _SC("cannot convert the string"));
316 case OT_INTEGER:case OT_FLOAT:
317 v->Push(SQObjectPtr(tointeger(o)));
320 v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
329 static SQInteger default_delegate_tostring(HSQUIRRELVM v)
335 static SQInteger obj_delegate_weakref(HSQUIRRELVM v)
341 static SQInteger obj_clear(HSQUIRRELVM v)
343 return sq_clear(v,-1);
347 static SQInteger number_delegate_tochar(HSQUIRRELVM v)
349 SQObject &o=stack_get(v,1);
350 SQChar c = (SQChar)tointeger(o);
351 v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));
356 /////////////////////////////////////////////////////////////////
357 //TABLE DEFAULT DELEGATE
359 static SQInteger table_rawdelete(HSQUIRRELVM v)
361 if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
367 static SQInteger container_rawexists(HSQUIRRELVM v)
369 if(SQ_SUCCEEDED(sq_rawget(v,-2))) {
370 sq_pushbool(v,SQTrue);
373 sq_pushbool(v,SQFalse);
377 static SQInteger table_rawset(HSQUIRRELVM v)
379 return sq_rawset(v,-3);
383 static SQInteger table_rawget(HSQUIRRELVM v)
385 return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;
389 SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
390 {_SC("len"),default_delegate_len,1, _SC("t")},
391 {_SC("rawget"),table_rawget,2, _SC("t")},
392 {_SC("rawset"),table_rawset,3, _SC("t")},
393 {_SC("rawdelete"),table_rawdelete,2, _SC("t")},
394 {_SC("rawin"),container_rawexists,2, _SC("t")},
395 {_SC("weakref"),obj_delegate_weakref,1, NULL },
396 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
397 {_SC("clear"),obj_clear,1, _SC(".")},
401 //ARRAY DEFAULT DELEGATE///////////////////////////////////////
403 static SQInteger array_append(HSQUIRRELVM v)
405 return sq_arrayappend(v,-2);
408 static SQInteger array_extend(HSQUIRRELVM v)
410 _array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
414 static SQInteger array_reverse(HSQUIRRELVM v)
416 return sq_arrayreverse(v,-1);
419 static SQInteger array_pop(HSQUIRRELVM v)
421 return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;
424 static SQInteger array_top(HSQUIRRELVM v)
426 SQObject &o=stack_get(v,1);
427 if(_array(o)->Size()>0){
428 v->Push(_array(o)->Top());
431 else return sq_throwerror(v,_SC("top() on a empty array"));
434 static SQInteger array_insert(HSQUIRRELVM v)
436 SQObject &o=stack_get(v,1);
437 SQObject &idx=stack_get(v,2);
438 SQObject &val=stack_get(v,3);
439 _array(o)->Insert(idx,val);
443 static SQInteger array_remove(HSQUIRRELVM v)
445 SQObject &o = stack_get(v, 1);
446 SQObject &idx = stack_get(v, 2);
447 if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
449 if(_array(o)->Get(tointeger(idx), val)) {
450 _array(o)->Remove(tointeger(idx));
454 return sq_throwerror(v, _SC("idx out of range"));
457 static SQInteger array_resize(HSQUIRRELVM v)
459 SQObject &o = stack_get(v, 1);
460 SQObject &nsize = stack_get(v, 2);
462 if(sq_isnumeric(nsize)) {
464 fill = stack_get(v, 3);
465 _array(o)->Resize(tointeger(nsize),fill);
468 return sq_throwerror(v, _SC("size must be a number"));
472 //QSORT ala Sedgewick
473 bool _qsort_compare(HSQUIRRELVM v,SQObjectPtr &arr,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
476 if(!v->ObjCmp(a,b,ret)) return false;
479 SQInteger top = sq_gettop(v);
484 if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
485 v->Raise_Error(_SC("compare func failed"));
488 sq_getinteger(v, -1, &ret);
494 //QSORT ala Sedgewick
495 bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
498 SQArray *a=_array(arr);
501 pivot = a->_values[l];
508 if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
513 if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
518 t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
520 t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
521 if(!_qsort( v, arr, l, j-1,func)) return false;
522 if(!_qsort( v, arr, j+1, r,func)) return false;
527 static SQInteger array_sort(HSQUIRRELVM v)
530 SQObjectPtr &o = stack_get(v,1);
531 SQObject &funcobj = stack_get(v,2);
532 if(_array(o)->Size() > 1) {
533 if(type(funcobj) == OT_CLOSURE || type(funcobj) == OT_NATIVECLOSURE) func = 2;
534 if(!_qsort(v, o, 0, _array(o)->Size()-1, func))
540 static SQInteger array_slice(HSQUIRRELVM v)
544 if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
545 SQInteger alen = _array(o)->Size();
546 if(sidx < 0)sidx = alen + sidx;
547 if(eidx < 0)eidx = alen + eidx;
548 if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
549 if(eidx > alen)return sq_throwerror(v,_SC("slice out of range"));
550 SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
553 for(SQInteger i=sidx;i<eidx;i++){
562 SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
563 {_SC("len"),default_delegate_len,1, _SC("a")},
564 {_SC("append"),array_append,2, _SC("a")},
565 {_SC("extend"),array_extend,2, _SC("aa")},
566 {_SC("push"),array_append,2, _SC("a")},
567 {_SC("pop"),array_pop,1, _SC("a")},
568 {_SC("top"),array_top,1, _SC("a")},
569 {_SC("insert"),array_insert,3, _SC("an")},
570 {_SC("remove"),array_remove,2, _SC("an")},
571 {_SC("resize"),array_resize,-2, _SC("an")},
572 {_SC("reverse"),array_reverse,1, _SC("a")},
573 {_SC("sort"),array_sort,-1, _SC("ac")},
574 {_SC("slice"),array_slice,-1, _SC("ann")},
575 {_SC("weakref"),obj_delegate_weakref,1, NULL },
576 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
577 {_SC("clear"),obj_clear,1, _SC(".")},
581 //STRING DEFAULT DELEGATE//////////////////////////
582 static SQInteger string_slice(HSQUIRRELVM v)
586 if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
587 SQInteger slen = _string(o)->_len;
588 if(sidx < 0)sidx = slen + sidx;
589 if(eidx < 0)eidx = slen + eidx;
590 if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
591 if(eidx > slen) return sq_throwerror(v,_SC("slice out of range"));
592 v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
596 static SQInteger string_find(HSQUIRRELVM v)
598 SQInteger top,start_idx=0;
599 const SQChar *str,*substr,*ret;
600 if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
601 if(top>2)sq_getinteger(v,3,&start_idx);
602 if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
603 ret=scstrstr(&str[start_idx],substr);
605 sq_pushinteger(v,(SQInteger)(ret-str));
611 return sq_throwerror(v,_SC("invalid param"));
614 #define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \
616 SQObject str=stack_get(v,1); \
617 SQInteger len=_string(str)->_len; \
618 const SQChar *sThis=_stringval(str); \
619 SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \
620 for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \
621 v->Push(SQString::Create(_ss(v),sNew,len)); \
626 STRING_TOFUNCZ(tolower)
627 STRING_TOFUNCZ(toupper)
629 SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
630 {_SC("len"),default_delegate_len,1, _SC("s")},
631 {_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},
632 {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
633 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
634 {_SC("slice"),string_slice,-1, _SC(" s n n")},
635 {_SC("find"),string_find,-2, _SC("s s n ")},
636 {_SC("tolower"),string_tolower,1, _SC("s")},
637 {_SC("toupper"),string_toupper,1, _SC("s")},
638 {_SC("weakref"),obj_delegate_weakref,1, NULL },
642 //INTEGER DEFAULT DELEGATE//////////////////////////
643 SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
644 {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
645 {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
646 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
647 {_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
648 {_SC("weakref"),obj_delegate_weakref,1, NULL },
652 //CLOSURE DEFAULT DELEGATE//////////////////////////
653 static SQInteger closure_pcall(HSQUIRRELVM v)
655 return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
658 static SQInteger closure_call(HSQUIRRELVM v)
660 return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;
663 static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
665 SQArray *aparams=_array(stack_get(v,2));
666 SQInteger nparams=aparams->Size();
667 v->Push(stack_get(v,1));
668 for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);
669 return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
672 static SQInteger closure_acall(HSQUIRRELVM v)
674 return _closure_acall(v,SQTrue);
677 static SQInteger closure_pacall(HSQUIRRELVM v)
679 return _closure_acall(v,SQFalse);
682 static SQInteger closure_bindenv(HSQUIRRELVM v)
684 if(SQ_FAILED(sq_bindenv(v,1)))
689 static SQInteger closure_getinfos(HSQUIRRELVM v) {
690 SQObject o = stack_get(v,1);
691 SQTable *res = SQTable::Create(_ss(v),4);
692 if(type(o) == OT_CLOSURE) {
693 SQFunctionProto *f = _funcproto(_closure(o)->_function);
694 SQInteger nparams = f->_nparameters + (f->_varparams?1:0);
695 SQObjectPtr params = SQArray::Create(_ss(v),nparams);
696 for(SQInteger n = 0; n<f->_nparameters; n++) {
697 _array(params)->Set((SQInteger)n,f->_parameters[n]);
700 _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
702 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);
703 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);
704 res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);
705 res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);
706 res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);
708 else { //OT_NATIVECLOSURE
709 SQNativeClosure *nc = _nativeclosure(o);
710 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);
711 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);
712 res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);
713 SQObjectPtr typecheck;
714 if(nc->_typecheck.size() > 0) {
716 SQArray::Create(_ss(v), nc->_typecheck.size());
717 for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
718 _array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
721 res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
728 SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
729 {_SC("call"),closure_call,-1, _SC("c")},
730 {_SC("pcall"),closure_pcall,-1, _SC("c")},
731 {_SC("acall"),closure_acall,2, _SC("ca")},
732 {_SC("pacall"),closure_pacall,2, _SC("ca")},
733 {_SC("weakref"),obj_delegate_weakref,1, NULL },
734 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
735 {_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
736 {_SC("getinfos"),closure_getinfos,1, _SC("c")},
740 //GENERATOR DEFAULT DELEGATE
741 static SQInteger generator_getstatus(HSQUIRRELVM v)
743 SQObject &o=stack_get(v,1);
744 switch(_generator(o)->_state){
745 case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;
746 case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;
747 case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;
752 SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
753 {_SC("getstatus"),generator_getstatus,1, _SC("g")},
754 {_SC("weakref"),obj_delegate_weakref,1, NULL },
755 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
759 //THREAD DEFAULT DELEGATE
761 static SQInteger thread_call(HSQUIRRELVM v)
763 SQObjectPtr o = stack_get(v,1);
764 if(type(o) == OT_THREAD) {
765 SQInteger nparams = sq_gettop(v);
766 _thread(o)->Push(_thread(o)->_roottable);
767 for(SQInteger i = 2; i<(nparams+1); i++)
768 sq_move(_thread(o),v,i);
769 if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQFalse))) {
770 sq_move(v,_thread(o),-1);
775 return sq_throwerror(v,_SC("wrong parameter"));
778 static SQInteger thread_wakeup(HSQUIRRELVM v)
780 SQObjectPtr o = stack_get(v,1);
781 if(type(o) == OT_THREAD) {
782 SQVM *thread = _thread(o);
783 SQInteger state = sq_getvmstate(thread);
784 if(state != SQ_VMSTATE_SUSPENDED) {
786 case SQ_VMSTATE_IDLE:
787 return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
789 case SQ_VMSTATE_RUNNING:
790 return sq_throwerror(v,_SC("cannot wakeup a running thread"));
795 SQInteger wakeupret = sq_gettop(v)>1?1:0;
799 if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,1,SQFalse))) {
800 sq_move(v,thread,-1);
802 if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {
809 return sq_throwerror(v,_SC("wrong parameter"));
812 static SQInteger thread_getstatus(HSQUIRRELVM v)
814 SQObjectPtr &o = stack_get(v,1);
815 switch(sq_getvmstate(_thread(o))) {
816 case SQ_VMSTATE_IDLE:
817 sq_pushstring(v,_SC("idle"),-1);
819 case SQ_VMSTATE_RUNNING:
820 sq_pushstring(v,_SC("running"),-1);
822 case SQ_VMSTATE_SUSPENDED:
823 sq_pushstring(v,_SC("suspended"),-1);
826 return sq_throwerror(v,_SC("internal VM error"));
831 SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
832 {_SC("call"), thread_call, -1, _SC("v")},
833 {_SC("wakeup"), thread_wakeup, -1, _SC("v")},
834 {_SC("getstatus"), thread_getstatus, 1, _SC("v")},
835 {_SC("weakref"),obj_delegate_weakref,1, NULL },
836 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
840 static SQInteger class_getattributes(HSQUIRRELVM v)
842 if(SQ_SUCCEEDED(sq_getattributes(v,-2)))
847 static SQInteger class_setattributes(HSQUIRRELVM v)
849 if(SQ_SUCCEEDED(sq_setattributes(v,-3)))
854 static SQInteger class_instance(HSQUIRRELVM v)
856 if(SQ_SUCCEEDED(sq_createinstance(v,-1)))
861 SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
862 {_SC("getattributes"), class_getattributes, 2, _SC("y.")},
863 {_SC("setattributes"), class_setattributes, 3, _SC("y..")},
864 {_SC("rawin"),container_rawexists,2, _SC("y")},
865 {_SC("weakref"),obj_delegate_weakref,1, NULL },
866 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
867 {_SC("instance"),class_instance,1, _SC("y")},
871 static SQInteger instance_getclass(HSQUIRRELVM v)
873 if(SQ_SUCCEEDED(sq_getclass(v,1)))
878 SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
879 {_SC("getclass"), instance_getclass, 1, _SC("x")},
880 {_SC("rawin"),container_rawexists,2, _SC("x")},
881 {_SC("weakref"),obj_delegate_weakref,1, NULL },
882 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
886 static SQInteger weakref_ref(HSQUIRRELVM v)
888 if(SQ_FAILED(sq_getweakrefval(v,1)))
893 SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {
894 {_SC("ref"),weakref_ref,1, _SC("r")},
895 {_SC("weakref"),obj_delegate_weakref,1, NULL },
896 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},