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_pushstring(v,_SC("_floatsize_"),-1);
 271         sq_pushinteger(v,sizeof(SQFloat));
 272         sq_createslot(v,-3);
 273         sq_pop(v,1);
 274 }
 275
 276 static SQInteger default_delegate_len(HSQUIRRELVM v)
 277 {
 278         v->Push(SQInteger(sq_getsize(v,1)));
 279         return 1;
 280 }
 281
 282 static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
 283 {
 284         SQObjectPtr &o=stack_get(v,1);
 285         switch(type(o)){
 286         case OT_STRING:{
 287                 SQObjectPtr res;
 288                 if(str2num(_stringval(o),res)){
 289                         v->Push(SQObjectPtr(tofloat(res)));
 290                         break;
 291                 }}
 292                 return sq_throwerror(v, _SC("cannot convert the string"));
 293                 break;
 294         case OT_INTEGER:case OT_FLOAT:
 295                 v->Push(SQObjectPtr(tofloat(o)));
 296                 break;
 297         case OT_BOOL:
 298                 v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));
 299                 break;
 300         default:
 301                 v->Push(_null_);
 302                 break;
 303         }
 304         return 1;
 305 }
 306
 307 static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
 308 {
 309         SQObjectPtr &o=stack_get(v,1);
 310         switch(type(o)){
 311         case OT_STRING:{
 312                 SQObjectPtr res;
 313                 if(str2num(_stringval(o),res)){
 314                         v->Push(SQObjectPtr(tointeger(res)));
 315                         break;
 316                 }}
 317                 return sq_throwerror(v, _SC("cannot convert the string"));
 318                 break;
 319         case OT_INTEGER:case OT_FLOAT:
 320                 v->Push(SQObjectPtr(tointeger(o)));
 321                 break;
 322         case OT_BOOL:
 323                 v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
 324                 break;
 325         default:
 326                 v->Push(_null_);
 327                 break;
 328         }
 329         return 1;
 330 }
 331
 332 static SQInteger default_delegate_tostring(HSQUIRRELVM v)
 333 {
 334         sq_tostring(v,1);
 335         return 1;
 336 }
 337
 338 static SQInteger obj_delegate_weakref(HSQUIRRELVM v)
 339 {
 340         sq_weakref(v,1);
 341         return 1;
 342 }
 343
 344 static SQInteger obj_clear(HSQUIRRELVM v)
 345 {
 346         return sq_clear(v,-1);
 347 }
 348
 349
 350 static SQInteger number_delegate_tochar(HSQUIRRELVM v)
 351 {
 352         SQObject &o=stack_get(v,1);
 353         SQChar c = (SQChar)tointeger(o);
 354         v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));
 355         return 1;
 356 }
 357
 358
 359 /////////////////////////////////////////////////////////////////
 360 //TABLE DEFAULT DELEGATE
 361
 362 static SQInteger table_rawdelete(HSQUIRRELVM v)
 363 {
 364         if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
 365                 return SQ_ERROR;
 366         return 1;
 367 }
 368
 369
 370 static SQInteger container_rawexists(HSQUIRRELVM v)
 371 {
 372         if(SQ_SUCCEEDED(sq_rawget(v,-2))) {
 373                 sq_pushbool(v,SQTrue);
 374                 return 1;
 375         }
 376         sq_pushbool(v,SQFalse);
 377         return 1;
 378 }
 379
 380 static SQInteger table_rawset(HSQUIRRELVM v)
 381 {
 382         return sq_rawset(v,-3);
 383 }
 384
 385
 386 static SQInteger table_rawget(HSQUIRRELVM v)
 387 {
 388         return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;
 389 }
 390
 391
 392 SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
 393         {_SC("len"),default_delegate_len,1, _SC("t")},
 394         {_SC("rawget"),table_rawget,2, _SC("t")},
 395         {_SC("rawset"),table_rawset,3, _SC("t")},
 396         {_SC("rawdelete"),table_rawdelete,2, _SC("t")},
 397         {_SC("rawin"),container_rawexists,2, _SC("t")},
 398         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 399         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 400         {_SC("clear"),obj_clear,1, _SC(".")},
 401         {0,0}
 402 };
 403
 404 //ARRAY DEFAULT DELEGATE///////////////////////////////////////
 405
 406 static SQInteger array_append(HSQUIRRELVM v)
 407 {
 408         return sq_arrayappend(v,-2);
 409 }
 410
 411 static SQInteger array_extend(HSQUIRRELVM v)
 412 {
 413         _array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
 414         return 0;
 415 }
 416
 417 static SQInteger array_reverse(HSQUIRRELVM v)
 418 {
 419         return sq_arrayreverse(v,-1);
 420 }
 421
 422 static SQInteger array_pop(HSQUIRRELVM v)
 423 {
 424         return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;
 425 }
 426
 427 static SQInteger array_top(HSQUIRRELVM v)
 428 {
 429         SQObject &o=stack_get(v,1);
 430         if(_array(o)->Size()>0){
 431                 v->Push(_array(o)->Top());
 432                 return 1;
 433         }
 434         else return sq_throwerror(v,_SC("top() on a empty array"));
 435 }
 436
 437 static SQInteger array_insert(HSQUIRRELVM v)
 438 {
 439         SQObject &o=stack_get(v,1);
 440         SQObject &idx=stack_get(v,2);
 441         SQObject &val=stack_get(v,3);
 442         if(!_array(o)->Insert(tointeger(idx),val))
 443                 return sq_throwerror(v,_SC("index out of range"));
 444         return 0;
 445 }
 446
 447 static SQInteger array_remove(HSQUIRRELVM v)
 448 {
 449         SQObject &o = stack_get(v, 1);
 450         SQObject &idx = stack_get(v, 2);
 451         if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
 452         SQObjectPtr val;
 453         if(_array(o)->Get(tointeger(idx), val)) {
 454                 _array(o)->Remove(tointeger(idx));
 455                 v->Push(val);
 456                 return 1;
 457         }
 458         return sq_throwerror(v, _SC("idx out of range"));
 459 }
 460
 461 static SQInteger array_resize(HSQUIRRELVM v)
 462 {
 463         SQObject &o = stack_get(v, 1);
 464         SQObject &nsize = stack_get(v, 2);
 465         SQObjectPtr fill;
 466         if(sq_isnumeric(nsize)) {
 467                 if(sq_gettop(v) > 2)
 468                         fill = stack_get(v, 3);
 469                 _array(o)->Resize(tointeger(nsize),fill);
 470                 return 0;
 471         }
 472         return sq_throwerror(v, _SC("size must be a number"));
 473 }
 474
 475
 476 //QSORT ala Sedgewick
 477 bool _qsort_compare(HSQUIRRELVM v,SQObjectPtr &arr,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
 478 {
 479         if(func < 0) {
 480                 if(!v->ObjCmp(a,b,ret)) return false;
 481         }
 482         else {
 483                 SQInteger top = sq_gettop(v);
 484                 sq_push(v, func);
 485                 sq_pushroottable(v);
 486                 v->Push(a);
 487                 v->Push(b);
 488                 if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
 489                         if(!sq_isstring( v->_lasterror))
 490                                 v->Raise_Error(_SC("compare func failed"));
 491                         return false;
 492                 }
 493                 sq_getinteger(v, -1, &ret);
 494                 sq_settop(v, top);
 495                 return true;
 496         }
 497         return true;
 498 }
 499 //QSORT ala Sedgewick
 500 bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
 501 {
 502         SQInteger i, j;
 503         SQArray *a=_array(arr);
 504         SQObjectPtr pivot,t;
 505         if( l < r ){
 506                 pivot = a->_values[l];
 507                 i = l; j = r+1;
 508                 while(1){
 509                         SQInteger ret;
 510                         do {
 511                                 ++i;
 512                                 if(i > r) break;
 513                                 if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
 514                                         return false;
 515                         } while( ret <= 0);
 516                         do {
 517                                 --j;
 518                                 if ( j < 0 ) {
 519                                         v->Raise_Error( _SC("Invalid qsort, probably compare function defect") );
 520                                         return false;
 521                                 }
 522                                 if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
 523                                         return false;
 524                         }
 525                         while( ret > 0 );
 526                         if( i >= j ) break;
 527                         t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
 528                 }
 529                 t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
 530                 if(!_qsort( v, arr, l, j-1,func)) return false;
 531                 if(!_qsort( v, arr, j+1, r,func)) return false;
 532         }
 533         return true;
 534 }
 535
 536 static SQInteger array_sort(HSQUIRRELVM v)
 537 {
 538         SQInteger func = -1;
 539         SQObjectPtr &o = stack_get(v,1);
 540         SQObject &funcobj = stack_get(v,2);
 541         if(_array(o)->Size() > 1) {
 542                 if(type(funcobj) == OT_CLOSURE || type(funcobj) == OT_NATIVECLOSURE) func = 2;
 543                 if(!_qsort(v, o, 0, _array(o)->Size()-1, func))
 544                         return SQ_ERROR;
 545
 546         }
 547         return 0;
 548 }
 549 static SQInteger array_slice(HSQUIRRELVM v)
 550 {
 551         SQInteger sidx,eidx;
 552         SQObjectPtr o;
 553         if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
 554         SQInteger alen = _array(o)->Size();
 555         if(sidx < 0)sidx = alen + sidx;
 556         if(eidx < 0)eidx = alen + eidx;
 557         if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
 558         if(eidx > alen)return sq_throwerror(v,_SC("slice out of range"));
 559         SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
 560         SQObjectPtr t;
 561         SQInteger count=0;
 562         for(SQInteger i=sidx;i<eidx;i++){
 563                 _array(o)->Get(i,t);
 564                 arr->Set(count++,t);
 565         }
 566         v->Push(arr);
 567         return 1;
 568
 569 }
 570
 571 SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
 572         {_SC("len"),default_delegate_len,1, _SC("a")},
 573         {_SC("append"),array_append,2, _SC("a")},
 574         {_SC("extend"),array_extend,2, _SC("aa")},
 575         {_SC("push"),array_append,2, _SC("a")},
 576         {_SC("pop"),array_pop,1, _SC("a")},
 577         {_SC("top"),array_top,1, _SC("a")},
 578         {_SC("insert"),array_insert,3, _SC("an")},
 579         {_SC("remove"),array_remove,2, _SC("an")},
 580         {_SC("resize"),array_resize,-2, _SC("an")},
 581         {_SC("reverse"),array_reverse,1, _SC("a")},
 582         {_SC("sort"),array_sort,-1, _SC("ac")},
 583         {_SC("slice"),array_slice,-1, _SC("ann")},
 584         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 585         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 586         {_SC("clear"),obj_clear,1, _SC(".")},
 587         {0,0}
 588 };
 589
 590 //STRING DEFAULT DELEGATE//////////////////////////
 591 static SQInteger string_slice(HSQUIRRELVM v)
 592 {
 593         SQInteger sidx,eidx;
 594         SQObjectPtr o;
 595         if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
 596         SQInteger slen = _string(o)->_len;
 597         if(sidx < 0)sidx = slen + sidx;
 598         if(eidx < 0)eidx = slen + eidx;
 599         if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
 600         if(eidx > slen) return sq_throwerror(v,_SC("slice out of range"));
 601         v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
 602         return 1;
 603 }
 604
 605 static SQInteger string_find(HSQUIRRELVM v)
 606 {
 607         SQInteger top,start_idx=0;
 608         const SQChar *str,*substr,*ret;
 609         if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
 610                 if(top>2)sq_getinteger(v,3,&start_idx);
 611                 if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
 612                         ret=scstrstr(&str[start_idx],substr);
 613                         if(ret){
 614                                 sq_pushinteger(v,(SQInteger)(ret-str));
 615                                 return 1;
 616                         }
 617                 }
 618                 return 0;
 619         }
 620         return sq_throwerror(v,_SC("invalid param"));
 621 }
 622
 623 #define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \
 624 { \
 625         SQObject str=stack_get(v,1); \
 626         SQInteger len=_string(str)->_len; \
 627         const SQChar *sThis=_stringval(str); \
 628         SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \
 629         for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \
 630         v->Push(SQString::Create(_ss(v),sNew,len)); \
 631         return 1; \
 632 }
 633
 634
 635 STRING_TOFUNCZ(tolower)
 636 STRING_TOFUNCZ(toupper)
 637
 638 SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
 639         {_SC("len"),default_delegate_len,1, _SC("s")},
 640         {_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},
 641         {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
 642         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 643         {_SC("slice"),string_slice,-1, _SC(" s n  n")},
 644         {_SC("find"),string_find,-2, _SC("s s n ")},
 645         {_SC("tolower"),string_tolower,1, _SC("s")},
 646         {_SC("toupper"),string_toupper,1, _SC("s")},
 647         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 648         {0,0}
 649 };
 650
 651 //INTEGER DEFAULT DELEGATE//////////////////////////
 652 SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
 653         {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
 654         {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
 655         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 656         {_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
 657         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 658         {0,0}
 659 };
 660
 661 //CLOSURE DEFAULT DELEGATE//////////////////////////
 662 static SQInteger closure_pcall(HSQUIRRELVM v)
 663 {
 664         return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
 665 }
 666
 667 static SQInteger closure_call(HSQUIRRELVM v)
 668 {
 669         return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;
 670 }
 671
 672 static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
 673 {
 674         SQArray *aparams=_array(stack_get(v,2));
 675         SQInteger nparams=aparams->Size();
 676         v->Push(stack_get(v,1));
 677         for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);
 678         return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
 679 }
 680
 681 static SQInteger closure_acall(HSQUIRRELVM v)
 682 {
 683         return _closure_acall(v,SQTrue);
 684 }
 685
 686 static SQInteger closure_pacall(HSQUIRRELVM v)
 687 {
 688         return _closure_acall(v,SQFalse);
 689 }
 690
 691 static SQInteger closure_bindenv(HSQUIRRELVM v)
 692 {
 693         if(SQ_FAILED(sq_bindenv(v,1)))
 694                 return SQ_ERROR;
 695         return 1;
 696 }
 697
 698 static SQInteger closure_getinfos(HSQUIRRELVM v) {
 699         SQObject o = stack_get(v,1);
 700         SQTable *res = SQTable::Create(_ss(v),4);
 701         if(type(o) == OT_CLOSURE) {
 702                 SQFunctionProto *f = _funcproto(_closure(o)->_function);
 703                 SQInteger nparams = f->_nparameters + (f->_varparams?1:0);
 704                 SQObjectPtr params = SQArray::Create(_ss(v),nparams);
 705                 for(SQInteger n = 0; n<f->_nparameters; n++) {
 706                         _array(params)->Set((SQInteger)n,f->_parameters[n]);
 707                 }
 708                 if(f->_varparams) {
 709                         _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
 710                 }
 711                 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);
 712                 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);
 713                 res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);
 714                 res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);
 715                 res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);
 716         }
 717         else { //OT_NATIVECLOSURE
 718                 SQNativeClosure *nc = _nativeclosure(o);
 719                 res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);
 720                 res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);
 721                 res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);
 722                 SQObjectPtr typecheck;
 723                 if(nc->_typecheck.size() > 0) {
 724                         typecheck =
 725                                 SQArray::Create(_ss(v), nc->_typecheck.size());
 726                         for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
 727                                         _array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
 728                         }
 729                 }
 730                 res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
 731         }
 732         v->Push(res);
 733         return 1;
 734 }
 735
 736
 737 SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
 738         {_SC("call"),closure_call,-1, _SC("c")},
 739         {_SC("pcall"),closure_pcall,-1, _SC("c")},
 740         {_SC("acall"),closure_acall,2, _SC("ca")},
 741         {_SC("pacall"),closure_pacall,2, _SC("ca")},
 742         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 743         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 744         {_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
 745         {_SC("getinfos"),closure_getinfos,1, _SC("c")},
 746         {0,0}
 747 };
 748
 749 //GENERATOR DEFAULT DELEGATE
 750 static SQInteger generator_getstatus(HSQUIRRELVM v)
 751 {
 752         SQObject &o=stack_get(v,1);
 753         switch(_generator(o)->_state){
 754                 case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;
 755                 case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;
 756                 case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;
 757         }
 758         return 1;
 759 }
 760
 761 SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
 762         {_SC("getstatus"),generator_getstatus,1, _SC("g")},
 763         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 764         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 765         {0,0}
 766 };
 767
 768 //THREAD DEFAULT DELEGATE
 769
 770 static SQInteger thread_call(HSQUIRRELVM v)
 771 {
 772
 773         SQObjectPtr o = stack_get(v,1);
 774         if(type(o) == OT_THREAD) {
 775                 SQInteger nparams = sq_gettop(v);
 776                 _thread(o)->Push(_thread(o)->_roottable);
 777                 for(SQInteger i = 2; i<(nparams+1); i++)
 778                         sq_move(_thread(o),v,i);
 779                 if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQFalse))) {
 780                         sq_move(v,_thread(o),-1);
 781                         sq_pop(_thread(o),1);
 782                         return 1;
 783                 }
 784                 v->_lasterror = _thread(o)->_lasterror;
 785                 return SQ_ERROR;
 786         }
 787         return sq_throwerror(v,_SC("wrong parameter"));
 788 }
 789
 790 static SQInteger thread_wakeup(HSQUIRRELVM v)
 791 {
 792         SQObjectPtr o = stack_get(v,1);
 793         if(type(o) == OT_THREAD) {
 794                 SQVM *thread = _thread(o);
 795                 SQInteger state = sq_getvmstate(thread);
 796                 if(state != SQ_VMSTATE_SUSPENDED) {
 797                         switch(state) {
 798                                 case SQ_VMSTATE_IDLE:
 799                                         return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
 800                                 break;
 801                                 case SQ_VMSTATE_RUNNING:
 802                                         return sq_throwerror(v,_SC("cannot wakeup a running thread"));
 803                                 break;
 804                         }
 805                 }
 806
 807                 SQInteger wakeupret = sq_gettop(v)>1?1:0;
 808                 if(wakeupret) {
 809                         sq_move(thread,v,2);
 810                 }
 811                 if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQTrue,SQFalse))) {
 812                         sq_move(v,thread,-1);
 813                         sq_pop(thread,1); //pop retval
 814                         if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {
 815                                 sq_settop(thread,1); //pop roottable
 816                         }
 817                         return 1;
 818                 }
 819                 sq_settop(thread,1);
 820                 v->_lasterror = thread->_lasterror;
 821                 return SQ_ERROR;
 822         }
 823         return sq_throwerror(v,_SC("wrong parameter"));
 824 }
 825
 826 static SQInteger thread_getstatus(HSQUIRRELVM v)
 827 {
 828         SQObjectPtr &o = stack_get(v,1);
 829         switch(sq_getvmstate(_thread(o))) {
 830                 case SQ_VMSTATE_IDLE:
 831                         sq_pushstring(v,_SC("idle"),-1);
 832                 break;
 833                 case SQ_VMSTATE_RUNNING:
 834                         sq_pushstring(v,_SC("running"),-1);
 835                 break;
 836                 case SQ_VMSTATE_SUSPENDED:
 837                         sq_pushstring(v,_SC("suspended"),-1);
 838                 break;
 839                 default:
 840                         return sq_throwerror(v,_SC("internal VM error"));
 841         }
 842         return 1;
 843 }
 844
 845 SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
 846         {_SC("call"), thread_call, -1, _SC("v")},
 847         {_SC("wakeup"), thread_wakeup, -1, _SC("v")},
 848         {_SC("getstatus"), thread_getstatus, 1, _SC("v")},
 849         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 850         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 851         {0,0},
 852 };
 853
 854 static SQInteger class_getattributes(HSQUIRRELVM v)
 855 {
 856         if(SQ_SUCCEEDED(sq_getattributes(v,-2)))
 857                 return 1;
 858         return SQ_ERROR;
 859 }
 860
 861 static SQInteger class_setattributes(HSQUIRRELVM v)
 862 {
 863         if(SQ_SUCCEEDED(sq_setattributes(v,-3)))
 864                 return 1;
 865         return SQ_ERROR;
 866 }
 867
 868 static SQInteger class_instance(HSQUIRRELVM v)
 869 {
 870         if(SQ_SUCCEEDED(sq_createinstance(v,-1)))
 871                 return 1;
 872         return SQ_ERROR;
 873 }
 874
 875 SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
 876         {_SC("getattributes"), class_getattributes, 2, _SC("y.")},
 877         {_SC("setattributes"), class_setattributes, 3, _SC("y..")},
 878         {_SC("rawin"),container_rawexists,2, _SC("y")},
 879         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 880         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 881         {_SC("instance"),class_instance,1, _SC("y")},
 882         {0,0}
 883 };
 884
 885 static SQInteger instance_getclass(HSQUIRRELVM v)
 886 {
 887         if(SQ_SUCCEEDED(sq_getclass(v,1)))
 888                 return 1;
 889         return SQ_ERROR;
 890 }
 891
 892 SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
 893         {_SC("getclass"), instance_getclass, 1, _SC("x")},
 894         {_SC("rawin"),container_rawexists,2, _SC("x")},
 895         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 896         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 897         {0,0}
 898 };
 899
 900 static SQInteger weakref_ref(HSQUIRRELVM v)
 901 {
 902         if(SQ_FAILED(sq_getweakrefval(v,1)))
 903                 return SQ_ERROR;
 904         return 1;
 905 }
 906
 907 SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {
 908         {_SC("ref"),weakref_ref,1, _SC("r")},
 909         {_SC("weakref"),obj_delegate_weakref,1, NULL },
 910         {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
 911         {0,0}
 912 };
 913
 914