src/squirrel/squirrel/sqbaselib.cpp

   1 /*
   2         see copyright notice in squirrel.h
   3 */
   4 #include "sqpcheader.h"
   5 #include "sqvm.h"
   6 #include "sqstring.h"
   7 #include "sqtable.h"
   8 #include "sqarray.h"
   9 #include "sqfuncproto.h"
  10 #include "sqclosure.h"
  11 #include "sqclass.h"
  12 #include <stdlib.h>
  13 #include <stdarg.h>
  14 #include <ctype.h>
  15
  16 bool str2num(const SQChar *s,SQObjectPtr &res)
  17 {
  18         SQChar *end;
  19         if(scstrstr(s,_SC("."))){
  20                 SQFloat r = SQFloat(scstrtod(s,&end));
  21                 if(s == end) return false;
  22                 res = r;
  23                 return true;
  24         }
  25         else{
  26                 SQInteger r = SQInteger(scstrtol(s,&end,10));
  27                 if(s == end) return false;
  28                 res = r;
  29                 return true;
  30         }
  31 }
  32
  33 #ifndef NO_GARBAGE_COLLECTOR
  34 static SQInteger base_collectgarbage(HSQUIRRELVM v)
  35 {
  36         sq_pushinteger(v, sq_collectgarbage(v));
  37         return 1;
  38 }
  39 #endif
  40
  41 static SQInteger base_getroottable(HSQUIRRELVM v)
  42 {
  43         v->Push(v->_roottable);
  44         return 1;
  45 }
  46
  47 static SQInteger base_setroottable(HSQUIRRELVM v)
  48 {
  49         SQObjectPtr &o=stack_get(v,2);
  50         if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
  51         v->Push(o);
  52         return 1;
  53 }
  54
  55 static SQInteger base_seterrorhandler(HSQUIRRELVM v)
  56 {
  57         sq_seterrorhandler(v);
  58         return 0;
  59 }
  60
  61 static SQInteger base_setdebughook(HSQUIRRELVM v)
  62 {
  63         sq_setdebughook(v);
  64         return 0;
  65 }
  66
  67 static SQInteger base_enabledebuginfo(HSQUIRRELVM v)
  68 {
  69         SQObjectPtr &o=stack_get(v,2);
  70         sq_enabledebuginfo(v,(type(o) != OT_NULL)?1:0);
  71         return 0;
  72 }
  73
  74 static SQInteger base_getstackinfos(HSQUIRRELVM v)
  75 {
  76         SQInteger level;
  77         SQStackInfos si;
  78         SQInteger seq = 0;
  79         const SQChar *name = NULL;
  80         sq_getinteger(v, -1, &level);
  81         if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
  82         {
  83                 const SQChar *fn = _SC("unknown");
  84                 const SQChar *src = _SC("unknown");
  85                 if(si.funcname)fn = si.funcname;
  86                 if(si.source)src = si.source;
  87                 sq_newtable(v);
  88                 sq_pushstring(v, _SC("func"), -1);
  89                 sq_pushstring(v, fn, -1);
  90                 sq_createslot(v, -3);
  91                 sq_pushstring(v, _SC("src"), -1);
  92                 sq_pushstring(v, src, -1);
  93                 sq_createslot(v, -3);
  94                 sq_pushstring(v, _SC("line"), -1);
  95                 sq_pushinteger(v, si.line);
  96                 sq_createslot(v, -3);
  97                 sq_pushstring(v, _SC("locals"), -1);
  98                 sq_newtable(v);
  99                 seq=0;
 100                 while ((name = sq_getlocal(v, level, seq))) {
 101                         sq_pushstring(v, name, -1);
 102                         sq_push(v, -2);
 103                         sq_createslot(v, -4);
 104                         sq_pop(v, 1);
 105                         seq++;
 106                 }
 107                 sq_createslot(v, -3);
 108                 return 1;
 109         }
 110
 111         return 0;
 112 }
 113
 114 static SQInteger base_assert(HSQUIRRELVM v)
 115 {
 116         if(v->IsFalse(stack_get(v,2))){
 117                 return sq_throwerror(v,_SC("assertion failed"));
 118         }
 119         return 0;
 120 }
 121
 122 static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o)
 123 {
 124         SQInteger top = sq_gettop(v);
 125         sidx=0;
 126         eidx=0;
 127         o=stack_get(v,1);
 128         SQObjectPtr &start=stack_get(v,2);
 129         if(type(start)!=OT_NULL && sq_isnumeric(start)){
 130                 sidx=tointeger(start);
 131         }
 132         if(top>2){
 133                 SQObjectPtr &end=stack_get(v,3);
 134                 if(sq_isnumeric(end)){
 135                         eidx=tointeger(end);
 136                 }
 137         }
 138         else {
 139                 eidx = sq_getsize(v,1);
 140         }
 141         return 1;
 142 }
 143
 144 static SQInteger base_print(HSQUIRRELVM v)
 145 {
 146         const SQChar *str;
 147         sq_tostring(v,2);
 148         sq_getstring(v,-1,&str);
 149         if(_ss(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str);
 150         return 0;
 151 }
 152
 153 static SQInteger base_compilestring(HSQUIRRELVM v)
 154 {
 155         SQInteger nargs=sq_gettop(v);
 156         const SQChar *src=NULL,*name=_SC("unnamedbuffer");
 157         SQInteger size;
 158         sq_getstring(v,2,&src);
 159         size=sq_getsize(v,2);
 160         if(nargs>2){
 161                 sq_getstring(v,3,&name);
 162         }
 163         if(SQ_SUCCEEDED(sq_compilebuffer(v,src,size,name,SQFalse)))
 164                 return 1;
 165         else
 166                 return SQ_ERROR;
 167 }
 168
 169 static SQInteger base_newthread(HSQUIRRELVM v)
 170 {
 171         SQObjectPtr &func = stack_get(v,2);
 172         SQInteger stksize = (_funcproto(_closure(func)->_function)->_stacksize << 1) +2;
 173         HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
 174         sq_move(newv,v,-2);
 175         return 1;
 176 }
 177
 178 static SQInteger base_suspend(HSQUIRRELVM v)
 179 {
 180         return sq_suspendvm(v);
 181 }
 182
 183 static SQInteger base_array(HSQUIRRELVM v)
 184 {
 185         SQArray *a;
 186         SQObject &size = stack_get(v,2);
 187         if(sq_gettop(v) > 2) {
 188                 a = SQArray::Create(_ss(v),0);
 189                 a->Resize(tointeger(size),stack_get(v,3));
 190         }
 191         else {
 192                 a = SQArray::Create(_ss(v),tointeger(size));
 193         }
 194         v->Push(a);
 195         return 1;
 196 }
 197
 198 static SQInteger base_type(HSQUIRRELVM v)
 199 {
 200         SQObjectPtr &o = stack_get(v,2);
 201         v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));
 202         return 1;
 203 }
 204
 205 static SQRegFunction base_funcs[]={
 206         //generic
 207         {_SC("seterrorhandler"),base_seterrorhandler,2, NULL},
 208         {_SC("setdebughook"),base_setdebughook,2, NULL},
 209         {_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL},
 210         {_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")},
 211         {_SC("getroottable"),base_getroottable,1, NULL},
 212         {_SC("setroottable"),base_setroottable,2, NULL},
 213         {_SC("assert"),base_assert,2, NULL},
 214         {_SC("print"),base_print,2, NULL},
 215         {_SC("compilestring"),base_compilestring,-2, _SC(".ss")},
 216         {_SC("newthread"),base_newthread,2, _SC(".c")},
 217         {_SC("suspend"),base_suspend,-1, NULL},
 218         {_SC("array"),base_array,-2, _SC(".n")},
 219         {_SC("type"),base_type,2, NULL},
 220 #ifndef NO_GARBAGE_COLLECTOR
 221         {_SC("collectgarbage"),base_collectgarbage,1, _SC("t")},
 222 #endif
 223         {0,0}
 224 };
 225
 226 void sq_base_register(HSQUIRRELVM v)
 227 {
 228         SQInteger i=0;
 229         sq_pushroottable(v);
 230         while(base_funcs[i].name!=0) {
 231                 sq_pushstring(v,base_funcs[i].name,-1);
 232                 sq_newclosure(v,base_funcs[i].f,0);
 233                 sq_setnativeclosurename(v,-1,base_funcs[i].name);
 234                 sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);
 235                 sq_createslot(v,-3);
 236                 i++;
 237         }
 238         sq_pushstring(v,_SC("_charsize_"),-1);
 239         sq_pushinteger(v,sizeof(SQChar));
 240         sq_createslot(v,-3);
 241         sq_pushstring(v,_SC("_intsize_"),-1);
 242         sq_pushinteger(v,sizeof(SQInteger));
 243         sq_createslot(v,-3);
 244         sq_pop(v,1);
 245 }
 246
 247 static SQInteger default_delegate_len(HSQUIRRELVM v)
 248 {
 249         v->Push(SQInteger(sq_getsize(v,1)));
 250         return 1;
 251 }
 252
 253 static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
 254 {
 255         SQObjectPtr &o=stack_get(v,1);
 256         switch(type(o)){
 257         case OT_STRING:{
 258                 SQObjectPtr res;
 259                 if(str2num(_stringval(o),res)){
 260                         v->Push(SQObjectPtr(tofloat(res)));
 261                         break;
 262                 }}
 263                 return sq_throwerror(v, _SC("cannot convert the string"));
 264                 break;
 265         case OT_INTEGER:case OT_FLOAT:
 266                 v->Push(SQObjectPtr(tofloat(o)));
 267                 break;
 268         case OT_BOOL:
 269                 v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));
 270                 break;
 271         default:
 272                 v->Push(_null_);
 273                 break;
 274         }
 275         return 1;
 276 }
 277
 278 static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
 279 {
 280         SQObjectPtr &o=stack_get(v,1);
 281         switch(type(o)){
 282         case OT_STRING:{
 283                 SQObjectPtr res;
 284                 if(str2num(_stringval(o),res)){
 285                         v->Push(SQObjectPtr(tointeger(res)));
 286                         break;
 287                 }}
 288                 return sq_throwerror(v, _SC("cannot convert the string"));
 289                 break;
 290         case OT_INTEGER:case OT_FLOAT:
 291                 v->Push(SQObjectPtr(tointeger(o)));
 292                 break;
 293         case OT_BOOL:
 294                 v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
 295                 break;
 296         default:
 297                 v->Push(_null_);
 298                 break;
 299         }
 300         return 1;
 301 }
 302
 303 static SQInteger default_delegate_tostring(HSQUIRRELVM v)
 304 {
 305         sq_tostring(v,1);
 306         return 1;
 307 }
 308
 309 static SQInteger obj_delegate_weakref(HSQUIRRELVM v)
 310 {
 311         sq_weakref(v,1);
 312         return 1;
 313 }
 314
 315 static SQInteger number_delegate_tochar(HSQUIRRELVM v)
 316 {
 317         SQObject &o=stack_get(v,1);
 318         SQChar c = (SQChar)tointeger(o);
 319         v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));
 320         return 1;
 321 }
 322
 323
 324 /////////////////////////////////////////////////////////////////
 325 //TABLE DEFAULT DELEGATE
 326
 327 static SQInteger table_rawdelete(HSQUIRRELVM v)
 328 {
 329         if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
 330                 return SQ_ERROR;
 331         return 1;
 332 }
 333
 334
 335 static SQInteger container_rawexists(HSQUIRRELVM v)
 336 {
 337         if(SQ_SUCCEEDED(sq_rawget(v,-2))) {
 338                 sq_pushbool(v,SQTrue);
 339                 return 1;
 340         }
 341         sq_pushbool(v,SQFalse);
 342         return 1;
 343 }
 344
 345 static SQInteger table_rawset(HSQUIRRELVM v)
 346 {
 347         return sq_rawset(v,-3);
 348 }
 349
 350
 351 static SQInteger table_rawget(HSQUIRRELVM v)
 352 {
 353         return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;
 354 }
 355
 356 SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
 357         {_SC("len"),default_delegate_len,1, _SC("t")},
 358         {_SC("rawget"),table_rawget,2, _SC("t")},
 359         {_SC("rawset"),table_rawset,3, _SC("t")},
 360         {_SC("rawdelete"),table_rawdelete,2, _SC("t")},
 361         {_SC("rawin"),container_rawexists,2, _SC("t")},
 362         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 363         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 364         {0,0}
 365 };
 366
 367 //ARRAY DEFAULT DELEGATE///////////////////////////////////////
 368
 369 static SQInteger array_append(HSQUIRRELVM v)
 370 {
 371         return sq_arrayappend(v,-2);
 372 }
 373
 374 static SQInteger array_extend(HSQUIRRELVM v)
 375 {
 376         _array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
 377         return 0;
 378 }
 379
 380 static SQInteger array_reverse(HSQUIRRELVM v)
 381 {
 382         return sq_arrayreverse(v,-1);
 383 }
 384
 385 static SQInteger array_pop(HSQUIRRELVM v)
 386 {
 387         return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;
 388 }
 389
 390 static SQInteger array_top(HSQUIRRELVM v)
 391 {
 392         SQObject &o=stack_get(v,1);
 393         if(_array(o)->Size()>0){
 394                 v->Push(_array(o)->Top());
 395                 return 1;
 396         }
 397         else return sq_throwerror(v,_SC("top() on a empty array"));
 398 }
 399
 400 static SQInteger array_insert(HSQUIRRELVM v)
 401 {
 402         SQObject &o=stack_get(v,1);
 403         SQObject &idx=stack_get(v,2);
 404         SQObject &val=stack_get(v,3);
 405         _array(o)->Insert(idx,val);
 406         return 0;
 407 }
 408
 409 static SQInteger array_remove(HSQUIRRELVM v)
 410 {
 411         SQObject &o = stack_get(v, 1);
 412         SQObject &idx = stack_get(v, 2);
 413         if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
 414         SQObjectPtr val;
 415         if(_array(o)->Get(tointeger(idx), val)) {
 416                 _array(o)->Remove(tointeger(idx));
 417                 v->Push(val);
 418                 return 1;
 419         }
 420         return sq_throwerror(v, _SC("idx out of range"));
 421 }
 422
 423 static SQInteger array_resize(HSQUIRRELVM v)
 424 {
 425         SQObject &o = stack_get(v, 1);
 426         SQObject &nsize = stack_get(v, 2);
 427         SQObjectPtr fill;
 428         if(sq_isnumeric(nsize)) {
 429                 if(sq_gettop(v) > 2)
 430                         fill = stack_get(v, 3);
 431                 _array(o)->Resize(tointeger(nsize),fill);
 432                 return 0;
 433         }
 434         return sq_throwerror(v, _SC("size must be a number"));
 435 }
 436
 437
 438 //QSORT ala Sedgewick
 439 bool _qsort_compare(HSQUIRRELVM v,SQObjectPtr &arr,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
 440 {
 441         if(func < 0) {
 442                 if(!v->ObjCmp(a,b,ret)) return false;
 443         }
 444         else {
 445                 SQInteger top = sq_gettop(v);
 446                 sq_push(v, func);
 447                 sq_pushroottable(v);
 448                 v->Push(a);
 449                 v->Push(b);
 450                 if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
 451                         v->Raise_Error(_SC("compare func failed"));
 452                         return false;
 453                 }
 454                 sq_getinteger(v, -1, &ret);
 455                 sq_settop(v, top);
 456                 return true;
 457         }
 458         return true;
 459 }
 460 //QSORT ala Sedgewick
 461 bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
 462 {
 463         SQInteger i, j;
 464         SQArray *a=_array(arr);
 465         SQObjectPtr pivot,t;
 466         if( l < r ){
 467                 pivot = a->_values[l];
 468                 i = l; j = r+1;
 469                 while(1){
 470                         SQInteger ret;
 471                         do {
 472                                 ++i;
 473                                 if(i > r) break;
 474                                 if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
 475                                         return false;
 476                         } while( ret <= 0);
 477                         do {
 478                                 --j;
 479                                 if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
 480                                         return false;
 481                         }
 482                         while( ret > 0 );
 483                         if( i >= j ) break;
 484                         t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
 485                 }
 486                 t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
 487                 if(!_qsort( v, arr, l, j-1,func)) return false;
 488                 if(!_qsort( v, arr, j+1, r,func)) return false;
 489         }
 490         return true;
 491 }
 492
 493 static SQInteger array_sort(HSQUIRRELVM v)
 494 {
 495         SQInteger func = -1;
 496         SQObjectPtr &o = stack_get(v,1);
 497         SQObject &funcobj = stack_get(v,2);
 498         if(_array(o)->Size() > 1) {
 499                 if(type(funcobj) == OT_CLOSURE || type(funcobj) == OT_NATIVECLOSURE) func = 2;
 500                 if(!_qsort(v, o, 0, _array(o)->Size()-1, func))
 501                         return SQ_ERROR;
 502
 503         }
 504         return 0;
 505 }
 506 static SQInteger array_slice(HSQUIRRELVM v)
 507 {
 508         SQInteger sidx,eidx;
 509         SQObjectPtr o;
 510         if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
 511         if(sidx<0)sidx=_array(o)->Size()+sidx;
 512         if(eidx<0)eidx=_array(o)->Size()+eidx;
 513         if(eidx <= sidx)return sq_throwerror(v,_SC("wrong indexes"));
 514         SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
 515         SQObjectPtr t;
 516         SQInteger count=0;
 517         for(SQInteger i=sidx;i<eidx;i++){
 518                 _array(o)->Get(i,t);
 519                 arr->Set(count++,t);
 520         }
 521         v->Push(arr);
 522         return 1;
 523
 524 }
 525
 526 SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
 527         {_SC("len"),default_delegate_len,1, _SC("a")},
 528         {_SC("append"),array_append,2, _SC("a")},
 529         {_SC("extend"),array_extend,2, _SC("aa")},
 530         {_SC("push"),array_append,2, _SC("a")},
 531         {_SC("pop"),array_pop,1, _SC("a")},
 532         {_SC("top"),array_top,1, _SC("a")},
 533         {_SC("insert"),array_insert,3, _SC("an")},
 534         {_SC("remove"),array_remove,2, _SC("an")},
 535         {_SC("resize"),array_resize,-2, _SC("an")},
 536         {_SC("reverse"),array_reverse,1, _SC("a")},
 537         {_SC("sort"),array_sort,-1, _SC("ac")},
 538         {_SC("slice"),array_slice,-1, _SC("ann")},
 539         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 540         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 541         {0,0}
 542 };
 543
 544 //STRING DEFAULT DELEGATE//////////////////////////
 545 static SQInteger string_slice(HSQUIRRELVM v)
 546 {
 547         SQInteger sidx,eidx;
 548         SQObjectPtr o;
 549         if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
 550         if(sidx<0)sidx=_string(o)->_len+sidx;
 551         if(eidx<0)eidx=_string(o)->_len+eidx;
 552         if(eidx<sidx)
 553                 return sq_throwerror(v,_SC("wrong indexes"));
 554         v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
 555         return 1;
 556 }
 557
 558 static SQInteger string_find(HSQUIRRELVM v)
 559 {
 560         SQInteger top,start_idx=0;
 561         const SQChar *str,*substr,*ret;
 562         if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
 563                 if(top>2)sq_getinteger(v,3,&start_idx);
 564                 if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
 565                         ret=scstrstr(&str[start_idx],substr);
 566                         if(ret){
 567                                 sq_pushinteger(v,(SQInteger)(ret-str));
 568                                 return 1;
 569                         }
 570                 }
 571                 return 0;
 572         }
 573         return sq_throwerror(v,_SC("invalid param"));
 574 }
 575
 576 #define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \
 577 { \
 578         SQObject str=stack_get(v,1); \
 579         SQInteger len=_string(str)->_len; \
 580         const SQChar *sThis=_stringval(str); \
 581         SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \
 582         for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \
 583         v->Push(SQString::Create(_ss(v),sNew,len)); \
 584         return 1; \
 585 }
 586
 587
 588 STRING_TOFUNCZ(tolower)
 589 STRING_TOFUNCZ(toupper)
 590
 591 SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
 592         {_SC("len"),default_delegate_len,1, _SC("s")},
 593         {_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},
 594         {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
 595         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 596         {_SC("slice"),string_slice,-1, _SC(" s n  n")},
 597         {_SC("find"),string_find,-2, _SC("s s n ")},
 598         {_SC("tolower"),string_tolower,1, _SC("s")},
 599         {_SC("toupper"),string_toupper,1, _SC("s")},
 600         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 601         {0,0}
 602 };
 603
 604 //INTEGER DEFAULT DELEGATE//////////////////////////
 605 SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
 606         {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
 607         {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
 608         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 609         {_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
 610         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 611         {0,0}
 612 };
 613
 614 //CLOSURE DEFAULT DELEGATE//////////////////////////
 615 static SQInteger closure_pcall(HSQUIRRELVM v)
 616 {
 617         return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
 618 }
 619
 620 static SQInteger closure_call(HSQUIRRELVM v)
 621 {
 622         return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;
 623 }
 624
 625 static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
 626 {
 627         SQArray *aparams=_array(stack_get(v,2));
 628         SQInteger nparams=aparams->Size();
 629         v->Push(stack_get(v,1));
 630         for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);
 631         return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
 632 }
 633
 634 static SQInteger closure_acall(HSQUIRRELVM v)
 635 {
 636         return _closure_acall(v,SQTrue);
 637 }
 638
 639 static SQInteger closure_pacall(HSQUIRRELVM v)
 640 {
 641         return _closure_acall(v,SQFalse);
 642 }
 643
 644 static SQInteger closure_bindenv(HSQUIRRELVM v)
 645 {
 646         if(SQ_FAILED(sq_bindenv(v,1)))
 647                 return SQ_ERROR;
 648         return 1;
 649 }
 650
 651 static SQInteger closure_getinfos(HSQUIRRELVM v) {
 652         SQObject o = stack_get(v,1);
 653         SQTable *res = SQTable::Create(_ss(v),4);
 654         if(type(o) == OT_CLOSURE) {
 655                 SQFunctionProto *f = _funcproto(_closure(o)->_function);
 656                 SQInteger nparams = f->_parameters.size() + (f->_varparams?1:0);
 657                 SQObjectPtr params = SQArray::Create(_ss(v),nparams);
 658                 for(SQUnsignedInteger n = 0; n<f->_parameters.size(); n++) {
 659                         _array(params)->Set((SQInteger)n,f->_parameters[n]);
 660                 }
 661                 if(f->_varparams) {
 662                         _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
 663                 }
 664                 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);
 665                 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);
 666                 res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);
 667                 res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);
 668                 res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);
 669         }
 670         else { //OT_NATIVECLOSURE
 671                 SQNativeClosure *nc = _nativeclosure(o);
 672                 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);
 673                 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);
 674                 res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);
 675                 SQObjectPtr typecheck;
 676                 if(nc->_typecheck.size() > 0) {
 677                         typecheck =
 678                                 SQArray::Create(_ss(v), nc->_typecheck.size());
 679                         for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
 680                                         _array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
 681                         }
 682                 }
 683                 res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
 684         }
 685         v->Push(res);
 686         return 1;
 687 }
 688
 689
 690 SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
 691         {_SC("call"),closure_call,-1, _SC("c")},
 692         {_SC("pcall"),closure_pcall,-1, _SC("c")},
 693         {_SC("acall"),closure_acall,2, _SC("ca")},
 694         {_SC("pacall"),closure_pacall,2, _SC("ca")},
 695         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 696         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 697         {_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
 698         {_SC("getinfos"),closure_getinfos,1, _SC("c")},
 699         {0,0}
 700 };
 701
 702 //GENERATOR DEFAULT DELEGATE
 703 static SQInteger generator_getstatus(HSQUIRRELVM v)
 704 {
 705         SQObject &o=stack_get(v,1);
 706         switch(_generator(o)->_state){
 707                 case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;
 708                 case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;
 709                 case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;
 710         }
 711         return 1;
 712 }
 713
 714 SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
 715         {_SC("getstatus"),generator_getstatus,1, _SC("g")},
 716         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 717         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 718         {0,0}
 719 };
 720
 721 //THREAD DEFAULT DELEGATE
 722
 723 static SQInteger thread_call(HSQUIRRELVM v)
 724 {
 725         SQObjectPtr o = stack_get(v,1);
 726         if(type(o) == OT_THREAD) {
 727                 SQInteger nparams = sq_gettop(v);
 728                 _thread(o)->Push(_thread(o)->_roottable);
 729                 for(SQInteger i = 2; i<(nparams+1); i++)
 730                         sq_move(_thread(o),v,i);
 731                 if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQFalse))) {
 732                         sq_move(v,_thread(o),-1);
 733                         return 1;
 734                 }
 735                 return SQ_ERROR;
 736         }
 737         return sq_throwerror(v,_SC("wrong parameter"));
 738 }
 739
 740 static SQInteger thread_wakeup(HSQUIRRELVM v)
 741 {
 742         SQObjectPtr o = stack_get(v,1);
 743         if(type(o) == OT_THREAD) {
 744                 SQVM *thread = _thread(o);
 745                 SQInteger state = sq_getvmstate(thread);
 746                 if(state != SQ_VMSTATE_SUSPENDED) {
 747                         switch(state) {
 748                                 case SQ_VMSTATE_IDLE:
 749                                         return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
 750                                 break;
 751                                 case SQ_VMSTATE_RUNNING:
 752                                         return sq_throwerror(v,_SC("cannot wakeup a running thread"));
 753                                 break;
 754                         }
 755                 }
 756
 757                 SQInteger wakeupret = sq_gettop(v)>1?1:0;
 758                 if(wakeupret) {
 759                         sq_move(thread,v,2);
 760                 }
 761                 if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,1,SQFalse))) {
 762                         sq_move(v,thread,-1);
 763                         sq_pop(thread,1);
 764                         if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {
 765                                 sq_pop(thread,1);
 766                         }
 767                         return 1;
 768                 }
 769                 return SQ_ERROR;
 770         }
 771         return sq_throwerror(v,_SC("wrong parameter"));
 772 }
 773
 774 static SQInteger thread_getstatus(HSQUIRRELVM v)
 775 {
 776         SQObjectPtr &o = stack_get(v,1);
 777         switch(sq_getvmstate(_thread(o))) {
 778                 case SQ_VMSTATE_IDLE:
 779                         sq_pushstring(v,_SC("idle"),-1);
 780                 break;
 781                 case SQ_VMSTATE_RUNNING:
 782                         sq_pushstring(v,_SC("running"),-1);
 783                 break;
 784                 case SQ_VMSTATE_SUSPENDED:
 785                         sq_pushstring(v,_SC("suspended"),-1);
 786                 break;
 787                 default:
 788                         return sq_throwerror(v,_SC("internal VM error"));
 789         }
 790         return 1;
 791 }
 792
 793 SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
 794         {_SC("call"), thread_call, -1, _SC("v")},
 795         {_SC("wakeup"), thread_wakeup, -1, _SC("v")},
 796         {_SC("getstatus"), thread_getstatus, 1, _SC("v")},
 797         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 798         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 799         {0,0},
 800 };
 801
 802 static SQInteger class_getattributes(HSQUIRRELVM v)
 803 {
 804         if(SQ_SUCCEEDED(sq_getattributes(v,-2)))
 805                 return 1;
 806         return SQ_ERROR;
 807 }
 808
 809 static SQInteger class_setattributes(HSQUIRRELVM v)
 810 {
 811         if(SQ_SUCCEEDED(sq_setattributes(v,-3)))
 812                 return 1;
 813         return SQ_ERROR;
 814 }
 815
 816 static SQInteger class_instance(HSQUIRRELVM v)
 817 {
 818         if(SQ_SUCCEEDED(sq_createinstance(v,-1)))
 819                 return 1;
 820         return SQ_ERROR;
 821 }
 822
 823 SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
 824         {_SC("getattributes"), class_getattributes, 2, _SC("y.")},
 825         {_SC("setattributes"), class_setattributes, 3, _SC("y..")},
 826         {_SC("rawin"),container_rawexists,2, _SC("y")},
 827         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 828         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 829         {_SC("instance"),class_instance,1, _SC("y")},
 830         {0,0}
 831 };
 832
 833 static SQInteger instance_getclass(HSQUIRRELVM v)
 834 {
 835         if(SQ_SUCCEEDED(sq_getclass(v,1)))
 836                 return 1;
 837         return SQ_ERROR;
 838 }
 839
 840 SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
 841         {_SC("getclass"), instance_getclass, 1, _SC("x")},
 842         {_SC("rawin"),container_rawexists,2, _SC("x")},
 843         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 844         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 845         {0,0}
 846 };
 847
 848 static SQInteger weakref_ref(HSQUIRRELVM v)
 849 {
 850         if(SQ_FAILED(sq_getweakrefval(v,1)))
 851                 return SQ_ERROR;
 852         return 1;
 853 }
 854
 855 SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {
 856         {_SC("ref"),weakref_ref,1, _SC("r")},
 857         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 858         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 859         {0,0}
 860 };