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