src/squirrel/squirrel/sqbaselib.cpp

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