2 see copyright notice in squirrel.h
\r
4 #include "sqpcheader.h"
\r
6 #include "sqstring.h"
\r
9 #include "sqfuncproto.h"
\r
10 #include "sqclosure.h"
\r
11 #include "sqclass.h"
\r
16 bool str2num(const SQChar *s,SQObjectPtr &res)
\r
19 const SQChar *e = s;
\r
20 SQBool isfloat = SQFalse;
\r
22 while((c = *e) != _SC('\0'))
\r
24 if(c == _SC('.') || c == _SC('E')|| c == _SC('e')) { //e and E is for scientific notation
\r
31 SQFloat r = SQFloat(scstrtod(s,&end));
\r
32 if(s == end) return false;
\r
36 SQInteger r = SQInteger(scstrtol(s,&end,10));
\r
37 if(s == end) return false;
\r
43 static SQInteger base_dummy(HSQUIRRELVM v)
\r
48 #ifndef NO_GARBAGE_COLLECTOR
\r
49 static SQInteger base_collectgarbage(HSQUIRRELVM v)
\r
51 sq_pushinteger(v, sq_collectgarbage(v));
\r
54 static SQInteger base_resurectureachable(HSQUIRRELVM v)
\r
56 sq_resurrectunreachable(v);
\r
61 static SQInteger base_getroottable(HSQUIRRELVM v)
\r
63 v->Push(v->_roottable);
\r
67 static SQInteger base_getconsttable(HSQUIRRELVM v)
\r
69 v->Push(_ss(v)->_consts);
\r
74 static SQInteger base_setroottable(HSQUIRRELVM v)
\r
76 SQObjectPtr o = v->_roottable;
\r
77 if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
\r
82 static SQInteger base_setconsttable(HSQUIRRELVM v)
\r
84 SQObjectPtr o = _ss(v)->_consts;
\r
85 if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;
\r
90 static SQInteger base_seterrorhandler(HSQUIRRELVM v)
\r
92 sq_seterrorhandler(v);
\r
96 static SQInteger base_setdebughook(HSQUIRRELVM v)
\r
102 static SQInteger base_enabledebuginfo(HSQUIRRELVM v)
\r
104 SQObjectPtr &o=stack_get(v,2);
\r
106 sq_enabledebuginfo(v,SQVM::IsFalse(o)?SQFalse:SQTrue);
\r
110 static SQInteger __getcallstackinfos(HSQUIRRELVM v,SQInteger level)
\r
114 const SQChar *name = NULL;
\r
116 if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
\r
118 const SQChar *fn = _SC("unknown");
\r
119 const SQChar *src = _SC("unknown");
\r
120 if(si.funcname)fn = si.funcname;
\r
121 if(si.source)src = si.source;
\r
123 sq_pushstring(v, _SC("func"), -1);
\r
124 sq_pushstring(v, fn, -1);
\r
125 sq_newslot(v, -3, SQFalse);
\r
126 sq_pushstring(v, _SC("src"), -1);
\r
127 sq_pushstring(v, src, -1);
\r
128 sq_newslot(v, -3, SQFalse);
\r
129 sq_pushstring(v, _SC("line"), -1);
\r
130 sq_pushinteger(v, si.line);
\r
131 sq_newslot(v, -3, SQFalse);
\r
132 sq_pushstring(v, _SC("locals"), -1);
\r
135 while ((name = sq_getlocal(v, level, seq))) {
\r
136 sq_pushstring(v, name, -1);
\r
138 sq_newslot(v, -4, SQFalse);
\r
142 sq_newslot(v, -3, SQFalse);
\r
148 static SQInteger base_getstackinfos(HSQUIRRELVM v)
\r
151 sq_getinteger(v, -1, &level);
\r
152 return __getcallstackinfos(v,level);
\r
155 static SQInteger base_assert(HSQUIRRELVM v)
\r
157 if(SQVM::IsFalse(stack_get(v,2))){
\r
158 return sq_throwerror(v,_SC("assertion failed"));
\r
163 static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o)
\r
165 SQInteger top = sq_gettop(v);
\r
169 SQObjectPtr &start=stack_get(v,2);
\r
170 if(type(start)!=OT_NULL && sq_isnumeric(start)){
\r
171 sidx=tointeger(start);
\r
174 SQObjectPtr &end=stack_get(v,3);
\r
175 if(sq_isnumeric(end)){
\r
176 eidx=tointeger(end);
\r
180 eidx = sq_getsize(v,1);
\r
185 static SQInteger base_print(HSQUIRRELVM v)
\r
188 if(SQ_SUCCEEDED(sq_tostring(v,2)))
\r
190 if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
\r
191 if(_ss(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str);
\r
198 static SQInteger base_error(HSQUIRRELVM v)
\r
201 if(SQ_SUCCEEDED(sq_tostring(v,2)))
\r
203 if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
\r
204 if(_ss(v)->_errorfunc) _ss(v)->_errorfunc(v,_SC("%s"),str);
\r
211 static SQInteger base_compilestring(HSQUIRRELVM v)
\r
213 SQInteger nargs=sq_gettop(v);
\r
214 const SQChar *src=NULL,*name=_SC("unnamedbuffer");
\r
216 sq_getstring(v,2,&src);
\r
217 size=sq_getsize(v,2);
\r
219 sq_getstring(v,3,&name);
\r
221 if(SQ_SUCCEEDED(sq_compilebuffer(v,src,size,name,SQFalse)))
\r
227 static SQInteger base_newthread(HSQUIRRELVM v)
\r
229 SQObjectPtr &func = stack_get(v,2);
\r
230 SQInteger stksize = (_closure(func)->_function->_stacksize << 1) +2;
\r
231 HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
\r
232 sq_move(newv,v,-2);
\r
236 static SQInteger base_suspend(HSQUIRRELVM v)
\r
238 return sq_suspendvm(v);
\r
241 static SQInteger base_array(HSQUIRRELVM v)
\r
244 SQObject &size = stack_get(v,2);
\r
245 if(sq_gettop(v) > 2) {
\r
246 a = SQArray::Create(_ss(v),0);
\r
247 a->Resize(tointeger(size),stack_get(v,3));
\r
250 a = SQArray::Create(_ss(v),tointeger(size));
\r
256 static SQInteger base_type(HSQUIRRELVM v)
\r
258 SQObjectPtr &o = stack_get(v,2);
\r
259 v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));
\r
263 static SQInteger base_callee(HSQUIRRELVM v)
\r
265 if(v->_callsstacksize > 1)
\r
267 v->Push(v->_callsstack[v->_callsstacksize - 2]._closure);
\r
270 return sq_throwerror(v,_SC("no closure in the calls stack"));
\r
273 static SQRegFunction base_funcs[]={
\r
275 {_SC("seterrorhandler"),base_seterrorhandler,2, NULL},
\r
276 {_SC("setdebughook"),base_setdebughook,2, NULL},
\r
277 {_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL},
\r
278 {_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")},
\r
279 {_SC("getroottable"),base_getroottable,1, NULL},
\r
280 {_SC("setroottable"),base_setroottable,2, NULL},
\r
281 {_SC("getconsttable"),base_getconsttable,1, NULL},
\r
282 {_SC("setconsttable"),base_setconsttable,2, NULL},
\r
283 {_SC("assert"),base_assert,2, NULL},
\r
284 {_SC("print"),base_print,2, NULL},
\r
285 {_SC("error"),base_error,2, NULL},
\r
286 {_SC("compilestring"),base_compilestring,-2, _SC(".ss")},
\r
287 {_SC("newthread"),base_newthread,2, _SC(".c")},
\r
288 {_SC("suspend"),base_suspend,-1, NULL},
\r
289 {_SC("array"),base_array,-2, _SC(".n")},
\r
290 {_SC("type"),base_type,2, NULL},
\r
291 {_SC("callee"),base_callee,0,NULL},
\r
292 {_SC("dummy"),base_dummy,0,NULL},
\r
293 #ifndef NO_GARBAGE_COLLECTOR
\r
294 {_SC("collectgarbage"),base_collectgarbage,0, NULL},
\r
295 {_SC("resurrectunreachable"),base_resurectureachable,0, NULL},
\r
300 void sq_base_register(HSQUIRRELVM v)
\r
303 sq_pushroottable(v);
\r
304 while(base_funcs[i].name!=0) {
\r
305 sq_pushstring(v,base_funcs[i].name,-1);
\r
306 sq_newclosure(v,base_funcs[i].f,0);
\r
307 sq_setnativeclosurename(v,-1,base_funcs[i].name);
\r
308 sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);
\r
309 sq_newslot(v,-3, SQFalse);
\r
313 sq_pushstring(v,_SC("_versionnumber_"),-1);
\r
314 sq_pushinteger(v,SQUIRREL_VERSION_NUMBER);
\r
315 sq_newslot(v,-3, SQFalse);
\r
316 sq_pushstring(v,_SC("_version_"),-1);
\r
317 sq_pushstring(v,SQUIRREL_VERSION,-1);
\r
318 sq_newslot(v,-3, SQFalse);
\r
319 sq_pushstring(v,_SC("_charsize_"),-1);
\r
320 sq_pushinteger(v,sizeof(SQChar));
\r
321 sq_newslot(v,-3, SQFalse);
\r
322 sq_pushstring(v,_SC("_intsize_"),-1);
\r
323 sq_pushinteger(v,sizeof(SQInteger));
\r
324 sq_newslot(v,-3, SQFalse);
\r
325 sq_pushstring(v,_SC("_floatsize_"),-1);
\r
326 sq_pushinteger(v,sizeof(SQFloat));
\r
327 sq_newslot(v,-3, SQFalse);
\r
331 static SQInteger default_delegate_len(HSQUIRRELVM v)
\r
333 v->Push(SQInteger(sq_getsize(v,1)));
\r
337 static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
\r
339 SQObjectPtr &o=stack_get(v,1);
\r
343 if(str2num(_stringval(o),res)){
\r
344 v->Push(SQObjectPtr(tofloat(res)));
\r
347 return sq_throwerror(v, _SC("cannot convert the string"));
\r
349 case OT_INTEGER:case OT_FLOAT:
\r
350 v->Push(SQObjectPtr(tofloat(o)));
\r
353 v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));
\r
362 static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
\r
364 SQObjectPtr &o=stack_get(v,1);
\r
368 if(str2num(_stringval(o),res)){
\r
369 v->Push(SQObjectPtr(tointeger(res)));
\r
372 return sq_throwerror(v, _SC("cannot convert the string"));
\r
374 case OT_INTEGER:case OT_FLOAT:
\r
375 v->Push(SQObjectPtr(tointeger(o)));
\r
378 v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
\r
387 static SQInteger default_delegate_tostring(HSQUIRRELVM v)
\r
389 if(SQ_FAILED(sq_tostring(v,1)))
\r
394 static SQInteger obj_delegate_weakref(HSQUIRRELVM v)
\r
400 static SQInteger obj_clear(HSQUIRRELVM v)
\r
402 return sq_clear(v,-1);
\r
406 static SQInteger number_delegate_tochar(HSQUIRRELVM v)
\r
408 SQObject &o=stack_get(v,1);
\r
409 SQChar c = (SQChar)tointeger(o);
\r
410 v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));
\r
416 /////////////////////////////////////////////////////////////////
\r
417 //TABLE DEFAULT DELEGATE
\r
419 static SQInteger table_rawdelete(HSQUIRRELVM v)
\r
421 if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
\r
427 static SQInteger container_rawexists(HSQUIRRELVM v)
\r
429 if(SQ_SUCCEEDED(sq_rawget(v,-2))) {
\r
430 sq_pushbool(v,SQTrue);
\r
433 sq_pushbool(v,SQFalse);
\r
437 static SQInteger container_rawset(HSQUIRRELVM v)
\r
439 return sq_rawset(v,-3);
\r
443 static SQInteger container_rawget(HSQUIRRELVM v)
\r
445 return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;
\r
448 static SQInteger table_setdelegate(HSQUIRRELVM v)
\r
450 if(SQ_FAILED(sq_setdelegate(v,-2)))
\r
452 sq_push(v,-1); // -1 because sq_setdelegate pops 1
\r
456 static SQInteger table_getdelegate(HSQUIRRELVM v)
\r
458 return SQ_SUCCEEDED(sq_getdelegate(v,-1))?1:SQ_ERROR;
\r
461 SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
\r
462 {_SC("len"),default_delegate_len,1, _SC("t")},
\r
463 {_SC("rawget"),container_rawget,2, _SC("t")},
\r
464 {_SC("rawset"),container_rawset,3, _SC("t")},
\r
465 {_SC("rawdelete"),table_rawdelete,2, _SC("t")},
\r
466 {_SC("rawin"),container_rawexists,2, _SC("t")},
\r
467 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
468 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
469 {_SC("clear"),obj_clear,1, _SC(".")},
\r
470 {_SC("setdelegate"),table_setdelegate,2, _SC(".t|o")},
\r
471 {_SC("getdelegate"),table_getdelegate,1, _SC(".")},
\r
475 //ARRAY DEFAULT DELEGATE///////////////////////////////////////
\r
477 static SQInteger array_append(HSQUIRRELVM v)
\r
479 return sq_arrayappend(v,-2);
\r
482 static SQInteger array_extend(HSQUIRRELVM v)
\r
484 _array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
\r
488 static SQInteger array_reverse(HSQUIRRELVM v)
\r
490 return sq_arrayreverse(v,-1);
\r
493 static SQInteger array_pop(HSQUIRRELVM v)
\r
495 return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;
\r
498 static SQInteger array_top(HSQUIRRELVM v)
\r
500 SQObject &o=stack_get(v,1);
\r
501 if(_array(o)->Size()>0){
\r
502 v->Push(_array(o)->Top());
\r
505 else return sq_throwerror(v,_SC("top() on a empty array"));
\r
508 static SQInteger array_insert(HSQUIRRELVM v)
\r
510 SQObject &o=stack_get(v,1);
\r
511 SQObject &idx=stack_get(v,2);
\r
512 SQObject &val=stack_get(v,3);
\r
513 if(!_array(o)->Insert(tointeger(idx),val))
\r
514 return sq_throwerror(v,_SC("index out of range"));
\r
518 static SQInteger array_remove(HSQUIRRELVM v)
\r
520 SQObject &o = stack_get(v, 1);
\r
521 SQObject &idx = stack_get(v, 2);
\r
522 if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
\r
524 if(_array(o)->Get(tointeger(idx), val)) {
\r
525 _array(o)->Remove(tointeger(idx));
\r
529 return sq_throwerror(v, _SC("idx out of range"));
\r
532 static SQInteger array_resize(HSQUIRRELVM v)
\r
534 SQObject &o = stack_get(v, 1);
\r
535 SQObject &nsize = stack_get(v, 2);
\r
537 if(sq_isnumeric(nsize)) {
\r
538 if(sq_gettop(v) > 2)
\r
539 fill = stack_get(v, 3);
\r
540 _array(o)->Resize(tointeger(nsize),fill);
\r
543 return sq_throwerror(v, _SC("size must be a number"));
\r
546 static SQInteger __map_array(SQArray *dest,SQArray *src,HSQUIRRELVM v) {
\r
548 SQInteger size = src->Size();
\r
549 for(SQInteger n = 0; n < size; n++) {
\r
553 if(SQ_FAILED(sq_call(v,2,SQTrue,SQFalse))) {
\r
556 dest->Set(n,v->GetUp(-1));
\r
562 static SQInteger array_map(HSQUIRRELVM v)
\r
564 SQObject &o = stack_get(v,1);
\r
565 SQInteger size = _array(o)->Size();
\r
566 SQObjectPtr ret = SQArray::Create(_ss(v),size);
\r
567 if(SQ_FAILED(__map_array(_array(ret),_array(o),v)))
\r
573 static SQInteger array_apply(HSQUIRRELVM v)
\r
575 SQObject &o = stack_get(v,1);
\r
576 if(SQ_FAILED(__map_array(_array(o),_array(o),v)))
\r
581 static SQInteger array_reduce(HSQUIRRELVM v)
\r
583 SQObject &o = stack_get(v,1);
\r
584 SQArray *a = _array(o);
\r
585 SQInteger size = a->Size();
\r
593 for(SQInteger n = 1; n < size; n++) {
\r
598 if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) {
\r
601 res = v->GetUp(-1);
\r
609 static SQInteger array_filter(HSQUIRRELVM v)
\r
611 SQObject &o = stack_get(v,1);
\r
612 SQArray *a = _array(o);
\r
613 SQObjectPtr ret = SQArray::Create(_ss(v),0);
\r
614 SQInteger size = a->Size();
\r
616 for(SQInteger n = 0; n < size; n++) {
\r
621 if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) {
\r
624 if(!SQVM::IsFalse(v->GetUp(-1))) {
\r
625 _array(ret)->Append(val);
\r
633 static SQInteger array_find(HSQUIRRELVM v)
\r
635 SQObject &o = stack_get(v,1);
\r
636 SQObjectPtr &val = stack_get(v,2);
\r
637 SQArray *a = _array(o);
\r
638 SQInteger size = a->Size();
\r
640 for(SQInteger n = 0; n < size; n++) {
\r
643 if(SQVM::IsEqual(temp,val,res) && res) {
\r
652 bool _sort_compare(HSQUIRRELVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
\r
655 if(!v->ObjCmp(a,b,ret)) return false;
\r
658 SQInteger top = sq_gettop(v);
\r
660 sq_pushroottable(v);
\r
663 if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
\r
664 if(!sq_isstring( v->_lasterror))
\r
665 v->Raise_Error(_SC("compare func failed"));
\r
668 if(SQ_FAILED(sq_getinteger(v, -1, &ret))) {
\r
669 v->Raise_Error(_SC("numeric value expected as return value of the compare function"));
\r
678 bool _hsort_sift_down(HSQUIRRELVM v,SQArray *arr, SQInteger root, SQInteger bottom, SQInteger func)
\r
680 SQInteger maxChild;
\r
681 SQInteger done = 0;
\r
684 while (((root2 = root * 2) <= bottom) && (!done))
\r
686 if (root2 == bottom) {
\r
690 if(!_sort_compare(v,arr->_values[root2],arr->_values[root2 + 1],func,ret))
\r
696 maxChild = root2 + 1;
\r
700 if(!_sort_compare(v,arr->_values[root],arr->_values[maxChild],func,ret))
\r
703 if (root == maxChild) {
\r
704 v->Raise_Error(_SC("inconsistent compare function"));
\r
705 return false; // We'd be swapping ourselve. The compare function is incorrect
\r
708 _Swap(arr->_values[root],arr->_values[maxChild]);
\r
718 bool _hsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
\r
720 SQArray *a = _array(arr);
\r
722 SQInteger array_size = a->Size();
\r
723 for (i = (array_size / 2); i >= 0; i--) {
\r
724 if(!_hsort_sift_down(v,a, i, array_size - 1,func)) return false;
\r
727 for (i = array_size-1; i >= 1; i--)
\r
729 _Swap(a->_values[0],a->_values[i]);
\r
730 if(!_hsort_sift_down(v,a, 0, i-1,func)) return false;
\r
735 static SQInteger array_sort(HSQUIRRELVM v)
\r
737 SQInteger func = -1;
\r
738 SQObjectPtr &o = stack_get(v,1);
\r
739 if(_array(o)->Size() > 1) {
\r
740 if(sq_gettop(v) == 2) func = 2;
\r
741 if(!_hsort(v, o, 0, _array(o)->Size()-1, func))
\r
748 static SQInteger array_slice(HSQUIRRELVM v)
\r
750 SQInteger sidx,eidx;
\r
752 if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
\r
753 SQInteger alen = _array(o)->Size();
\r
754 if(sidx < 0)sidx = alen + sidx;
\r
755 if(eidx < 0)eidx = alen + eidx;
\r
756 if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
\r
757 if(eidx > alen)return sq_throwerror(v,_SC("slice out of range"));
\r
758 SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
\r
761 for(SQInteger i=sidx;i<eidx;i++){
\r
762 _array(o)->Get(i,t);
\r
763 arr->Set(count++,t);
\r
770 SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
\r
771 {_SC("len"),default_delegate_len,1, _SC("a")},
\r
772 {_SC("append"),array_append,2, _SC("a")},
\r
773 {_SC("extend"),array_extend,2, _SC("aa")},
\r
774 {_SC("push"),array_append,2, _SC("a")},
\r
775 {_SC("pop"),array_pop,1, _SC("a")},
\r
776 {_SC("top"),array_top,1, _SC("a")},
\r
777 {_SC("insert"),array_insert,3, _SC("an")},
\r
778 {_SC("remove"),array_remove,2, _SC("an")},
\r
779 {_SC("resize"),array_resize,-2, _SC("an")},
\r
780 {_SC("reverse"),array_reverse,1, _SC("a")},
\r
781 {_SC("sort"),array_sort,-1, _SC("ac")},
\r
782 {_SC("slice"),array_slice,-1, _SC("ann")},
\r
783 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
784 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
785 {_SC("clear"),obj_clear,1, _SC(".")},
\r
786 {_SC("map"),array_map,2, _SC("ac")},
\r
787 {_SC("apply"),array_apply,2, _SC("ac")},
\r
788 {_SC("reduce"),array_reduce,2, _SC("ac")},
\r
789 {_SC("filter"),array_filter,2, _SC("ac")},
\r
790 {_SC("find"),array_find,2, _SC("a.")},
\r
794 //STRING DEFAULT DELEGATE//////////////////////////
\r
795 static SQInteger string_slice(HSQUIRRELVM v)
\r
797 SQInteger sidx,eidx;
\r
799 if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
\r
800 SQInteger slen = _string(o)->_len;
\r
801 if(sidx < 0)sidx = slen + sidx;
\r
802 if(eidx < 0)eidx = slen + eidx;
\r
803 if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
\r
804 if(eidx > slen) return sq_throwerror(v,_SC("slice out of range"));
\r
805 v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
\r
809 static SQInteger string_find(HSQUIRRELVM v)
\r
811 SQInteger top,start_idx=0;
\r
812 const SQChar *str,*substr,*ret;
\r
813 if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
\r
814 if(top>2)sq_getinteger(v,3,&start_idx);
\r
815 if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
\r
816 ret=scstrstr(&str[start_idx],substr);
\r
818 sq_pushinteger(v,(SQInteger)(ret-str));
\r
824 return sq_throwerror(v,_SC("invalid param"));
\r
827 #define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \
\r
829 SQObject str=stack_get(v,1); \
\r
830 SQInteger len=_string(str)->_len; \
\r
831 const SQChar *sThis=_stringval(str); \
\r
832 SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \
\r
833 for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \
\r
834 v->Push(SQString::Create(_ss(v),sNew,len)); \
\r
839 STRING_TOFUNCZ(tolower)
\r
840 STRING_TOFUNCZ(toupper)
\r
842 SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
\r
843 {_SC("len"),default_delegate_len,1, _SC("s")},
\r
844 {_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},
\r
845 {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
\r
846 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
847 {_SC("slice"),string_slice,-1, _SC(" s n n")},
\r
848 {_SC("find"),string_find,-2, _SC("s s n ")},
\r
849 {_SC("tolower"),string_tolower,1, _SC("s")},
\r
850 {_SC("toupper"),string_toupper,1, _SC("s")},
\r
851 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
855 //INTEGER DEFAULT DELEGATE//////////////////////////
\r
856 SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
\r
857 {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
\r
858 {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
\r
859 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
860 {_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
\r
861 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
865 //CLOSURE DEFAULT DELEGATE//////////////////////////
\r
866 static SQInteger closure_pcall(HSQUIRRELVM v)
\r
868 return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
\r
871 static SQInteger closure_call(HSQUIRRELVM v)
\r
873 return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;
\r
876 static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
\r
878 SQArray *aparams=_array(stack_get(v,2));
\r
879 SQInteger nparams=aparams->Size();
\r
880 v->Push(stack_get(v,1));
\r
881 for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);
\r
882 return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
\r
885 static SQInteger closure_acall(HSQUIRRELVM v)
\r
887 return _closure_acall(v,SQTrue);
\r
890 static SQInteger closure_pacall(HSQUIRRELVM v)
\r
892 return _closure_acall(v,SQFalse);
\r
895 static SQInteger closure_bindenv(HSQUIRRELVM v)
\r
897 if(SQ_FAILED(sq_bindenv(v,1)))
\r
902 static SQInteger closure_getinfos(HSQUIRRELVM v) {
\r
903 SQObject o = stack_get(v,1);
\r
904 SQTable *res = SQTable::Create(_ss(v),4);
\r
905 if(type(o) == OT_CLOSURE) {
\r
906 SQFunctionProto *f = _closure(o)->_function;
\r
907 SQInteger nparams = f->_nparameters + (f->_varparams?1:0);
\r
908 SQObjectPtr params = SQArray::Create(_ss(v),nparams);
\r
909 SQObjectPtr defparams = SQArray::Create(_ss(v),f->_ndefaultparams);
\r
910 for(SQInteger n = 0; n<f->_nparameters; n++) {
\r
911 _array(params)->Set((SQInteger)n,f->_parameters[n]);
\r
913 for(SQInteger j = 0; j<f->_ndefaultparams; j++) {
\r
914 _array(defparams)->Set((SQInteger)j,_closure(o)->_defaultparams[j]);
\r
916 if(f->_varparams) {
\r
917 _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
\r
919 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);
\r
920 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);
\r
921 res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);
\r
922 res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);
\r
923 res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);
\r
924 res->NewSlot(SQString::Create(_ss(v),_SC("defparams"),-1),defparams);
\r
926 else { //OT_NATIVECLOSURE
\r
927 SQNativeClosure *nc = _nativeclosure(o);
\r
928 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);
\r
929 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);
\r
930 res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);
\r
931 SQObjectPtr typecheck;
\r
932 if(nc->_typecheck.size() > 0) {
\r
934 SQArray::Create(_ss(v), nc->_typecheck.size());
\r
935 for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
\r
936 _array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
\r
939 res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
\r
947 SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
\r
948 {_SC("call"),closure_call,-1, _SC("c")},
\r
949 {_SC("pcall"),closure_pcall,-1, _SC("c")},
\r
950 {_SC("acall"),closure_acall,2, _SC("ca")},
\r
951 {_SC("pacall"),closure_pacall,2, _SC("ca")},
\r
952 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
953 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
954 {_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
\r
955 {_SC("getinfos"),closure_getinfos,1, _SC("c")},
\r
959 //GENERATOR DEFAULT DELEGATE
\r
960 static SQInteger generator_getstatus(HSQUIRRELVM v)
\r
962 SQObject &o=stack_get(v,1);
\r
963 switch(_generator(o)->_state){
\r
964 case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;
\r
965 case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;
\r
966 case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;
\r
971 SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
\r
972 {_SC("getstatus"),generator_getstatus,1, _SC("g")},
\r
973 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
974 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
978 //THREAD DEFAULT DELEGATE
\r
979 static SQInteger thread_call(HSQUIRRELVM v)
\r
981 SQObjectPtr o = stack_get(v,1);
\r
982 if(type(o) == OT_THREAD) {
\r
983 SQInteger nparams = sq_gettop(v);
\r
984 _thread(o)->Push(_thread(o)->_roottable);
\r
985 for(SQInteger i = 2; i<(nparams+1); i++)
\r
986 sq_move(_thread(o),v,i);
\r
987 if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQTrue))) {
\r
988 sq_move(v,_thread(o),-1);
\r
989 sq_pop(_thread(o),1);
\r
992 v->_lasterror = _thread(o)->_lasterror;
\r
995 return sq_throwerror(v,_SC("wrong parameter"));
\r
998 static SQInteger thread_wakeup(HSQUIRRELVM v)
\r
1000 SQObjectPtr o = stack_get(v,1);
\r
1001 if(type(o) == OT_THREAD) {
\r
1002 SQVM *thread = _thread(o);
\r
1003 SQInteger state = sq_getvmstate(thread);
\r
1004 if(state != SQ_VMSTATE_SUSPENDED) {
\r
1006 case SQ_VMSTATE_IDLE:
\r
1007 return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
\r
1009 case SQ_VMSTATE_RUNNING:
\r
1010 return sq_throwerror(v,_SC("cannot wakeup a running thread"));
\r
1015 SQInteger wakeupret = sq_gettop(v)>1?1:0;
\r
1017 sq_move(thread,v,2);
\r
1019 if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQTrue,SQFalse))) {
\r
1020 sq_move(v,thread,-1);
\r
1021 sq_pop(thread,1); //pop retval
\r
1022 if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {
\r
1023 sq_settop(thread,1); //pop roottable
\r
1027 sq_settop(thread,1);
\r
1028 v->_lasterror = thread->_lasterror;
\r
1031 return sq_throwerror(v,_SC("wrong parameter"));
\r
1034 static SQInteger thread_getstatus(HSQUIRRELVM v)
\r
1036 SQObjectPtr &o = stack_get(v,1);
\r
1037 switch(sq_getvmstate(_thread(o))) {
\r
1038 case SQ_VMSTATE_IDLE:
\r
1039 sq_pushstring(v,_SC("idle"),-1);
\r
1041 case SQ_VMSTATE_RUNNING:
\r
1042 sq_pushstring(v,_SC("running"),-1);
\r
1044 case SQ_VMSTATE_SUSPENDED:
\r
1045 sq_pushstring(v,_SC("suspended"),-1);
\r
1048 return sq_throwerror(v,_SC("internal VM error"));
\r
1053 static SQInteger thread_getstackinfos(HSQUIRRELVM v)
\r
1055 SQObjectPtr o = stack_get(v,1);
\r
1056 if(type(o) == OT_THREAD) {
\r
1057 SQVM *thread = _thread(o);
\r
1058 SQInteger threadtop = sq_gettop(thread);
\r
1060 sq_getinteger(v,-1,&level);
\r
1061 SQRESULT res = __getcallstackinfos(thread,level);
\r
1062 if(SQ_FAILED(res))
\r
1064 sq_settop(thread,threadtop);
\r
1065 if(type(thread->_lasterror) == OT_STRING) {
\r
1066 sq_throwerror(v,_stringval(thread->_lasterror));
\r
1069 sq_throwerror(v,_SC("unknown error"));
\r
1074 sq_move(v,thread,-1);
\r
1075 sq_settop(thread,threadtop);
\r
1079 sq_settop(thread,threadtop);
\r
1083 return sq_throwerror(v,_SC("wrong parameter"));
\r
1086 SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
\r
1087 {_SC("call"), thread_call, -1, _SC("v")},
\r
1088 {_SC("wakeup"), thread_wakeup, -1, _SC("v")},
\r
1089 {_SC("getstatus"), thread_getstatus, 1, _SC("v")},
\r
1090 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
1091 {_SC("getstackinfos"),thread_getstackinfos,2, _SC("vn")},
\r
1092 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
1096 static SQInteger class_getattributes(HSQUIRRELVM v)
\r
1098 return SQ_SUCCEEDED(sq_getattributes(v,-2))?1:SQ_ERROR;
\r
1101 static SQInteger class_setattributes(HSQUIRRELVM v)
\r
1103 return SQ_SUCCEEDED(sq_setattributes(v,-3))?1:SQ_ERROR;
\r
1106 static SQInteger class_instance(HSQUIRRELVM v)
\r
1108 return SQ_SUCCEEDED(sq_createinstance(v,-1))?1:SQ_ERROR;
\r
1111 static SQInteger class_getbase(HSQUIRRELVM v)
\r
1113 return SQ_SUCCEEDED(sq_getbase(v,-1))?1:SQ_ERROR;
\r
1116 static SQInteger class_newmember(HSQUIRRELVM v)
\r
1118 SQInteger top = sq_gettop(v);
\r
1119 SQBool bstatic = SQFalse;
\r
1122 sq_tobool(v,-1,&bstatic);
\r
1129 return SQ_SUCCEEDED(sq_newmember(v,-4,bstatic))?1:SQ_ERROR;
\r
1132 static SQInteger class_rawnewmember(HSQUIRRELVM v)
\r
1134 SQInteger top = sq_gettop(v);
\r
1135 SQBool bstatic = SQFalse;
\r
1138 sq_tobool(v,-1,&bstatic);
\r
1145 return SQ_SUCCEEDED(sq_rawnewmember(v,-4,bstatic))?1:SQ_ERROR;
\r
1148 SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
\r
1149 {_SC("getattributes"), class_getattributes, 2, _SC("y.")},
\r
1150 {_SC("setattributes"), class_setattributes, 3, _SC("y..")},
\r
1151 {_SC("rawget"),container_rawget,2, _SC("y")},
\r
1152 {_SC("rawset"),container_rawset,3, _SC("y")},
\r
1153 {_SC("rawin"),container_rawexists,2, _SC("y")},
\r
1154 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
1155 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
1156 {_SC("instance"),class_instance,1, _SC("y")},
\r
1157 {_SC("getbase"),class_getbase,1, _SC("y")},
\r
1158 {_SC("newmember"),class_newmember,-3, _SC("y")},
\r
1159 {_SC("rawnewmember"),class_rawnewmember,-3, _SC("y")},
\r
1164 static SQInteger instance_getclass(HSQUIRRELVM v)
\r
1166 if(SQ_SUCCEEDED(sq_getclass(v,1)))
\r
1171 SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
\r
1172 {_SC("getclass"), instance_getclass, 1, _SC("x")},
\r
1173 {_SC("rawget"),container_rawget,2, _SC("x")},
\r
1174 {_SC("rawset"),container_rawset,3, _SC("x")},
\r
1175 {_SC("rawin"),container_rawexists,2, _SC("x")},
\r
1176 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
1177 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r
1181 static SQInteger weakref_ref(HSQUIRRELVM v)
\r
1183 if(SQ_FAILED(sq_getweakrefval(v,1)))
\r
1188 SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {
\r
1189 {_SC("ref"),weakref_ref,1, _SC("r")},
\r
1190 {_SC("weakref"),obj_delegate_weakref,1, NULL },
\r
1191 {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
\r