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         if(!_array(o)->Insert(tointeger(idx),val))
 440                 return sq_throwerror(v,_SC("index out of range"));
 441         return 0;
 442 }
 443
 444 static SQInteger array_remove(HSQUIRRELVM v)
 445 {
 446         SQObject &o = stack_get(v, 1);
 447         SQObject &idx = stack_get(v, 2);
 448         if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
 449         SQObjectPtr val;
 450         if(_array(o)->Get(tointeger(idx), val)) {
 451                 _array(o)->Remove(tointeger(idx));
 452                 v->Push(val);
 453                 return 1;
 454         }
 455         return sq_throwerror(v, _SC("idx out of range"));
 456 }
 457
 458 static SQInteger array_resize(HSQUIRRELVM v)
 459 {
 460         SQObject &o = stack_get(v, 1);
 461         SQObject &nsize = stack_get(v, 2);
 462         SQObjectPtr fill;
 463         if(sq_isnumeric(nsize)) {
 464                 if(sq_gettop(v) > 2)
 465                         fill = stack_get(v, 3);
 466                 _array(o)->Resize(tointeger(nsize),fill);
 467                 return 0;
 468         }
 469         return sq_throwerror(v, _SC("size must be a number"));
 470 }
 471
 472
 473 //QSORT ala Sedgewick
 474 bool _qsort_compare(HSQUIRRELVM v,SQObjectPtr &arr,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
 475 {
 476         if(func < 0) {
 477                 if(!v->ObjCmp(a,b,ret)) return false;
 478         }
 479         else {
 480                 SQInteger top = sq_gettop(v);
 481                 sq_push(v, func);
 482                 sq_pushroottable(v);
 483                 v->Push(a);
 484                 v->Push(b);
 485                 if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
 486                         if(!sq_isstring( v->_lasterror))
 487                                 v->Raise_Error(_SC("compare func failed"));
 488                         return false;
 489                 }
 490                 sq_getinteger(v, -1, &ret);
 491                 sq_settop(v, top);
 492                 return true;
 493         }
 494         return true;
 495 }
 496 //QSORT ala Sedgewick
 497 bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
 498 {
 499         SQInteger i, j;
 500         SQArray *a=_array(arr);
 501         SQObjectPtr pivot,t;
 502         if( l < r ){
 503                 pivot = a->_values[l];
 504                 i = l; j = r+1;
 505                 while(1){
 506                         SQInteger ret;
 507                         do {
 508                                 ++i;
 509                                 if(i > r) break;
 510                                 if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
 511                                         return false;
 512                         } while( ret <= 0);
 513                         do {
 514                                 --j;
 515                                 if ( j < 0 ) {
 516                                         v->Raise_Error( _SC("Invalid qsort, probably compare function defect") );
 517                                         return false;
 518                                 }
 519                                 if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
 520                                         return false;
 521                         }
 522                         while( ret > 0 );
 523                         if( i >= j ) break;
 524                         t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
 525                 }
 526                 t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
 527                 if(!_qsort( v, arr, l, j-1,func)) return false;
 528                 if(!_qsort( v, arr, j+1, r,func)) return false;
 529         }
 530         return true;
 531 }
 532
 533 static SQInteger array_sort(HSQUIRRELVM v)
 534 {
 535         SQInteger func = -1;
 536         SQObjectPtr &o = stack_get(v,1);
 537         SQObject &funcobj = stack_get(v,2);
 538         if(_array(o)->Size() > 1) {
 539                 if(type(funcobj) == OT_CLOSURE || type(funcobj) == OT_NATIVECLOSURE) func = 2;
 540                 if(!_qsort(v, o, 0, _array(o)->Size()-1, func))
 541                         return SQ_ERROR;
 542
 543         }
 544         return 0;
 545 }
 546 static SQInteger array_slice(HSQUIRRELVM v)
 547 {
 548         SQInteger sidx,eidx;
 549         SQObjectPtr o;
 550         if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
 551         SQInteger alen = _array(o)->Size();
 552         if(sidx < 0)sidx = alen + sidx;
 553         if(eidx < 0)eidx = alen + eidx;
 554         if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
 555         if(eidx > alen)return sq_throwerror(v,_SC("slice out of range"));
 556         SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
 557         SQObjectPtr t;
 558         SQInteger count=0;
 559         for(SQInteger i=sidx;i<eidx;i++){
 560                 _array(o)->Get(i,t);
 561                 arr->Set(count++,t);
 562         }
 563         v->Push(arr);
 564         return 1;
 565
 566 }
 567
 568 SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
 569         {_SC("len"),default_delegate_len,1, _SC("a")},
 570         {_SC("append"),array_append,2, _SC("a")},
 571         {_SC("extend"),array_extend,2, _SC("aa")},
 572         {_SC("push"),array_append,2, _SC("a")},
 573         {_SC("pop"),array_pop,1, _SC("a")},
 574         {_SC("top"),array_top,1, _SC("a")},
 575         {_SC("insert"),array_insert,3, _SC("an")},
 576         {_SC("remove"),array_remove,2, _SC("an")},
 577         {_SC("resize"),array_resize,-2, _SC("an")},
 578         {_SC("reverse"),array_reverse,1, _SC("a")},
 579         {_SC("sort"),array_sort,-1, _SC("ac")},
 580         {_SC("slice"),array_slice,-1, _SC("ann")},
 581         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 582         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 583         {_SC("clear"),obj_clear,1, _SC(".")},
 584         {0,0}
 585 };
 586
 587 //STRING DEFAULT DELEGATE//////////////////////////
 588 static SQInteger string_slice(HSQUIRRELVM v)
 589 {
 590         SQInteger sidx,eidx;
 591         SQObjectPtr o;
 592         if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
 593         SQInteger slen = _string(o)->_len;
 594         if(sidx < 0)sidx = slen + sidx;
 595         if(eidx < 0)eidx = slen + eidx;
 596         if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
 597         if(eidx > slen) return sq_throwerror(v,_SC("slice out of range"));
 598         v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
 599         return 1;
 600 }
 601
 602 static SQInteger string_find(HSQUIRRELVM v)
 603 {
 604         SQInteger top,start_idx=0;
 605         const SQChar *str,*substr,*ret;
 606         if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
 607                 if(top>2)sq_getinteger(v,3,&start_idx);
 608                 if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
 609                         ret=scstrstr(&str[start_idx],substr);
 610                         if(ret){
 611                                 sq_pushinteger(v,(SQInteger)(ret-str));
 612                                 return 1;
 613                         }
 614                 }
 615                 return 0;
 616         }
 617         return sq_throwerror(v,_SC("invalid param"));
 618 }
 619
 620 #define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \
 621 { \
 622         SQObject str=stack_get(v,1); \
 623         SQInteger len=_string(str)->_len; \
 624         const SQChar *sThis=_stringval(str); \
 625         SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \
 626         for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \
 627         v->Push(SQString::Create(_ss(v),sNew,len)); \
 628         return 1; \
 629 }
 630
 631
 632 STRING_TOFUNCZ(tolower)
 633 STRING_TOFUNCZ(toupper)
 634
 635 SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
 636         {_SC("len"),default_delegate_len,1, _SC("s")},
 637         {_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},
 638         {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
 639         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 640         {_SC("slice"),string_slice,-1, _SC(" s n  n")},
 641         {_SC("find"),string_find,-2, _SC("s s n ")},
 642         {_SC("tolower"),string_tolower,1, _SC("s")},
 643         {_SC("toupper"),string_toupper,1, _SC("s")},
 644         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 645         {0,0}
 646 };
 647
 648 //INTEGER DEFAULT DELEGATE//////////////////////////
 649 SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
 650         {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
 651         {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
 652         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 653         {_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
 654         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 655         {0,0}
 656 };
 657
 658 //CLOSURE DEFAULT DELEGATE//////////////////////////
 659 static SQInteger closure_pcall(HSQUIRRELVM v)
 660 {
 661         return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
 662 }
 663
 664 static SQInteger closure_call(HSQUIRRELVM v)
 665 {
 666         return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;
 667 }
 668
 669 static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
 670 {
 671         SQArray *aparams=_array(stack_get(v,2));
 672         SQInteger nparams=aparams->Size();
 673         v->Push(stack_get(v,1));
 674         for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);
 675         return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
 676 }
 677
 678 static SQInteger closure_acall(HSQUIRRELVM v)
 679 {
 680         return _closure_acall(v,SQTrue);
 681 }
 682
 683 static SQInteger closure_pacall(HSQUIRRELVM v)
 684 {
 685         return _closure_acall(v,SQFalse);
 686 }
 687
 688 static SQInteger closure_bindenv(HSQUIRRELVM v)
 689 {
 690         if(SQ_FAILED(sq_bindenv(v,1)))
 691                 return SQ_ERROR;
 692         return 1;
 693 }
 694
 695 static SQInteger closure_getinfos(HSQUIRRELVM v) {
 696         SQObject o = stack_get(v,1);
 697         SQTable *res = SQTable::Create(_ss(v),4);
 698         if(type(o) == OT_CLOSURE) {
 699                 SQFunctionProto *f = _funcproto(_closure(o)->_function);
 700                 SQInteger nparams = f->_nparameters + (f->_varparams?1:0);
 701                 SQObjectPtr params = SQArray::Create(_ss(v),nparams);
 702                 for(SQInteger n = 0; n<f->_nparameters; n++) {
 703                         _array(params)->Set((SQInteger)n,f->_parameters[n]);
 704                 }
 705                 if(f->_varparams) {
 706                         _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
 707                 }
 708                 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);
 709                 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);
 710                 res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);
 711                 res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);
 712                 res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);
 713         }
 714         else { //OT_NATIVECLOSURE
 715                 SQNativeClosure *nc = _nativeclosure(o);
 716                 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);
 717                 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);
 718                 res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);
 719                 SQObjectPtr typecheck;
 720                 if(nc->_typecheck.size() > 0) {
 721                         typecheck =
 722                                 SQArray::Create(_ss(v), nc->_typecheck.size());
 723                         for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
 724                                         _array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
 725                         }
 726                 }
 727                 res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
 728         }
 729         v->Push(res);
 730         return 1;
 731 }
 732
 733
 734 SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
 735         {_SC("call"),closure_call,-1, _SC("c")},
 736         {_SC("pcall"),closure_pcall,-1, _SC("c")},
 737         {_SC("acall"),closure_acall,2, _SC("ca")},
 738         {_SC("pacall"),closure_pacall,2, _SC("ca")},
 739         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 740         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 741         {_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
 742         {_SC("getinfos"),closure_getinfos,1, _SC("c")},
 743         {0,0}
 744 };
 745
 746 //GENERATOR DEFAULT DELEGATE
 747 static SQInteger generator_getstatus(HSQUIRRELVM v)
 748 {
 749         SQObject &o=stack_get(v,1);
 750         switch(_generator(o)->_state){
 751                 case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;
 752                 case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;
 753                 case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;
 754         }
 755         return 1;
 756 }
 757
 758 SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
 759         {_SC("getstatus"),generator_getstatus,1, _SC("g")},
 760         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 761         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 762         {0,0}
 763 };
 764
 765 //THREAD DEFAULT DELEGATE
 766
 767 static SQInteger thread_call(HSQUIRRELVM v)
 768 {
 769
 770         SQObjectPtr o = stack_get(v,1);
 771         if(type(o) == OT_THREAD) {
 772                 SQInteger nparams = sq_gettop(v);
 773                 _thread(o)->Push(_thread(o)->_roottable);
 774                 for(SQInteger i = 2; i<(nparams+1); i++)
 775                         sq_move(_thread(o),v,i);
 776                 if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQFalse))) {
 777                         sq_move(v,_thread(o),-1);
 778                         sq_pop(_thread(o),1);
 779                         return 1;
 780                 }
 781                 v->_lasterror = _thread(o)->_lasterror;
 782                 return SQ_ERROR;
 783         }
 784         return sq_throwerror(v,_SC("wrong parameter"));
 785 }
 786
 787 static SQInteger thread_wakeup(HSQUIRRELVM v)
 788 {
 789         SQObjectPtr o = stack_get(v,1);
 790         if(type(o) == OT_THREAD) {
 791                 SQVM *thread = _thread(o);
 792                 SQInteger state = sq_getvmstate(thread);
 793                 if(state != SQ_VMSTATE_SUSPENDED) {
 794                         switch(state) {
 795                                 case SQ_VMSTATE_IDLE:
 796                                         return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
 797                                 break;
 798                                 case SQ_VMSTATE_RUNNING:
 799                                         return sq_throwerror(v,_SC("cannot wakeup a running thread"));
 800                                 break;
 801                         }
 802                 }
 803
 804                 SQInteger wakeupret = sq_gettop(v)>1?1:0;
 805                 if(wakeupret) {
 806                         sq_move(thread,v,2);
 807                 }
 808                 if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQFalse))) {
 809                         sq_move(v,thread,-1);
 810                         sq_pop(thread,1); //pop retval
 811                         if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {
 812                                 sq_settop(thread,1); //pop roottable
 813                         }
 814                         return 1;
 815                 }
 816                 sq_settop(thread,1);
 817                 v->_lasterror = thread->_lasterror;
 818                 return SQ_ERROR;
 819         }
 820         return sq_throwerror(v,_SC("wrong parameter"));
 821 }
 822
 823 static SQInteger thread_getstatus(HSQUIRRELVM v)
 824 {
 825         SQObjectPtr &o = stack_get(v,1);
 826         switch(sq_getvmstate(_thread(o))) {
 827                 case SQ_VMSTATE_IDLE:
 828                         sq_pushstring(v,_SC("idle"),-1);
 829                 break;
 830                 case SQ_VMSTATE_RUNNING:
 831                         sq_pushstring(v,_SC("running"),-1);
 832                 break;
 833                 case SQ_VMSTATE_SUSPENDED:
 834                         sq_pushstring(v,_SC("suspended"),-1);
 835                 break;
 836                 default:
 837                         return sq_throwerror(v,_SC("internal VM error"));
 838         }
 839         return 1;
 840 }
 841
 842 SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
 843         {_SC("call"), thread_call, -1, _SC("v")},
 844         {_SC("wakeup"), thread_wakeup, -1, _SC("v")},
 845         {_SC("getstatus"), thread_getstatus, 1, _SC("v")},
 846         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 847         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 848         {0,0},
 849 };
 850
 851 static SQInteger class_getattributes(HSQUIRRELVM v)
 852 {
 853         if(SQ_SUCCEEDED(sq_getattributes(v,-2)))
 854                 return 1;
 855         return SQ_ERROR;
 856 }
 857
 858 static SQInteger class_setattributes(HSQUIRRELVM v)
 859 {
 860         if(SQ_SUCCEEDED(sq_setattributes(v,-3)))
 861                 return 1;
 862         return SQ_ERROR;
 863 }
 864
 865 static SQInteger class_instance(HSQUIRRELVM v)
 866 {
 867         if(SQ_SUCCEEDED(sq_createinstance(v,-1)))
 868                 return 1;
 869         return SQ_ERROR;
 870 }
 871
 872 SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
 873         {_SC("getattributes"), class_getattributes, 2, _SC("y.")},
 874         {_SC("setattributes"), class_setattributes, 3, _SC("y..")},
 875         {_SC("rawin"),container_rawexists,2, _SC("y")},
 876         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 877         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 878         {_SC("instance"),class_instance,1, _SC("y")},
 879         {0,0}
 880 };
 881
 882 static SQInteger instance_getclass(HSQUIRRELVM v)
 883 {
 884         if(SQ_SUCCEEDED(sq_getclass(v,1)))
 885                 return 1;
 886         return SQ_ERROR;
 887 }
 888
 889 SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
 890         {_SC("getclass"), instance_getclass, 1, _SC("x")},
 891         {_SC("rawin"),container_rawexists,2, _SC("x")},
 892         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 893         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 894         {0,0}
 895 };
 896
 897 static SQInteger weakref_ref(HSQUIRRELVM v)
 898 {
 899         if(SQ_FAILED(sq_getweakrefval(v,1)))
 900                 return SQ_ERROR;
 901         return 1;
 902 }
 903
 904 SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {
 905         {_SC("ref"),weakref_ref,1, _SC("r")},
 906         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 907         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 908         {0,0}
 909 };
 910
 911