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