src/squirrel/squirrel/sqapi.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 "squserdata.h"
  12 #include "sqcompiler.h"
  13 #include "sqfuncstate.h"
  14 #include "sqclass.h"
  15
  16 bool sq_aux_gettypedarg(HSQUIRRELVM v,SQInteger idx,SQObjectType type,SQObjectPtr **o)
  17 {
  18         *o = &stack_get(v,idx);
  19         if(type(**o) != type){
  20                 SQObjectPtr oval = v->PrintObjVal(**o);
  21                 v->Raise_Error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval));
  22                 return false;
  23         }
  24         return true;
  25 }
  26
  27 #define _GETSAFE_OBJ(v,idx,type,o) { if(!sq_aux_gettypedarg(v,idx,type,&o)) return SQ_ERROR; }
  28
  29 #define sq_aux_paramscheck(v,count) \
  30 { \
  31         if(sq_gettop(v) < count){ v->Raise_Error(_SC("not enough params in the stack")); return SQ_ERROR; }\
  32 }
  33
  34 SQInteger sq_aux_throwobject(HSQUIRRELVM v,SQObjectPtr &e)
  35 {
  36         v->_lasterror = e;
  37         return SQ_ERROR;
  38 }
  39
  40 SQInteger sq_aux_invalidtype(HSQUIRRELVM v,SQObjectType type)
  41 {
  42         scsprintf(_ss(v)->GetScratchPad(100), _SC("unexpected type %s"), IdType2Name(type));
  43         return sq_throwerror(v, _ss(v)->GetScratchPad(-1));
  44 }
  45
  46 HSQUIRRELVM sq_open(SQInteger initialstacksize)
  47 {
  48         SQSharedState *ss;
  49         SQVM *v;
  50         sq_new(ss, SQSharedState);
  51         ss->Init();
  52         v = (SQVM *)SQ_MALLOC(sizeof(SQVM));
  53         new (v) SQVM(ss);
  54         ss->_root_vm = v;
  55         if(v->Init(NULL, initialstacksize)) {
  56                 return v;
  57         } else {
  58                 sq_delete(v, SQVM);
  59                 return NULL;
  60         }
  61         return v;
  62 }
  63
  64 HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, SQInteger initialstacksize)
  65 {
  66         SQSharedState *ss;
  67         SQVM *v;
  68         ss=_ss(friendvm);
  69
  70         v= (SQVM *)SQ_MALLOC(sizeof(SQVM));
  71         new (v) SQVM(ss);
  72
  73         if(v->Init(friendvm, initialstacksize)) {
  74                 friendvm->Push(v);
  75                 return v;
  76         } else {
  77                 sq_delete(v, SQVM);
  78                 return NULL;
  79         }
  80 }
  81
  82 SQInteger sq_getvmstate(HSQUIRRELVM v)
  83 {
  84         if(v->_suspended)
  85                 return SQ_VMSTATE_SUSPENDED;
  86         else {
  87                 if(v->_callsstack.size() != 0) return SQ_VMSTATE_RUNNING;
  88                 else return SQ_VMSTATE_IDLE;
  89         }
  90 }
  91
  92 void sq_seterrorhandler(HSQUIRRELVM v)
  93 {
  94         SQObject o = stack_get(v, -1);
  95         if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {
  96                 v->_errorhandler = o;
  97                 v->Pop();
  98         }
  99 }
 100
 101 void sq_setdebughook(HSQUIRRELVM v)
 102 {
 103         SQObject o = stack_get(v,-1);
 104         if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {
 105                 v->_debughook = o;
 106                 v->Pop();
 107         }
 108 }
 109
 110 void sq_close(HSQUIRRELVM v)
 111 {
 112         SQSharedState *ss = _ss(v);
 113         _thread(ss->_root_vm)->Finalize();
 114         sq_delete(ss, SQSharedState);
 115 }
 116
 117 SQRESULT sq_compile(HSQUIRRELVM v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror)
 118 {
 119         SQObjectPtr o;
 120         if(Compile(v, read, p, sourcename, o, raiseerror?true:false, _ss(v)->_debuginfo)) {
 121                 v->Push(SQClosure::Create(_ss(v), _funcproto(o)));
 122                 return SQ_OK;
 123         }
 124         return SQ_ERROR;
 125 }
 126
 127 void sq_enabledebuginfo(HSQUIRRELVM v, SQBool enable)
 128 {
 129         _ss(v)->_debuginfo = enable?true:false;
 130 }
 131
 132 void sq_notifyallexceptions(HSQUIRRELVM v, SQBool enable)
 133 {
 134         _ss(v)->_notifyallexceptions = enable?true:false;
 135 }
 136
 137 void sq_addref(HSQUIRRELVM v,HSQOBJECT *po)
 138 {
 139         if(!ISREFCOUNTED(type(*po))) return;
 140         _ss(v)->_refs_table.AddRef(*po);
 141 }
 142
 143 SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po)
 144 {
 145         if(!ISREFCOUNTED(type(*po))) return SQTrue;
 146         return _ss(v)->_refs_table.Release(*po);
 147 }
 148
 149 const SQChar *sq_objtostring(HSQOBJECT *o)
 150 {
 151         if(sq_type(*o) == OT_STRING) {
 152                 return _stringval(*o);
 153         }
 154         return NULL;
 155 }
 156
 157 SQInteger sq_objtointeger(HSQOBJECT *o)
 158 {
 159         if(sq_isnumeric(*o)) {
 160                 return tointeger(*o);
 161         }
 162         return 0;
 163 }
 164
 165 SQFloat sq_objtofloat(HSQOBJECT *o)
 166 {
 167         if(sq_isnumeric(*o)) {
 168                 return tofloat(*o);
 169         }
 170         return 0;
 171 }
 172
 173 SQBool sq_objtobool(HSQOBJECT *o)
 174 {
 175         if(sq_isbool(*o)) {
 176                 return _integer(*o);
 177         }
 178         return SQFalse;
 179 }
 180
 181 void sq_pushnull(HSQUIRRELVM v)
 182 {
 183         v->Push(_null_);
 184 }
 185
 186 void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len)
 187 {
 188         if(s)
 189                 v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len)));
 190         else v->Push(_null_);
 191 }
 192
 193 void sq_pushinteger(HSQUIRRELVM v,SQInteger n)
 194 {
 195         v->Push(n);
 196 }
 197
 198 void sq_pushbool(HSQUIRRELVM v,SQBool b)
 199 {
 200         v->Push(b?true:false);
 201 }
 202
 203 void sq_pushfloat(HSQUIRRELVM v,SQFloat n)
 204 {
 205         v->Push(n);
 206 }
 207
 208 void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p)
 209 {
 210         v->Push(p);
 211 }
 212
 213 SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size)
 214 {
 215         SQUserData *ud = SQUserData::Create(_ss(v), size);
 216         v->Push(ud);
 217         return ud->_val;
 218 }
 219
 220 void sq_newtable(HSQUIRRELVM v)
 221 {
 222         v->Push(SQTable::Create(_ss(v), 0));
 223 }
 224
 225 void sq_newarray(HSQUIRRELVM v,SQInteger size)
 226 {
 227         v->Push(SQArray::Create(_ss(v), size));
 228 }
 229
 230 SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase)
 231 {
 232         SQClass *baseclass = NULL;
 233         if(hasbase) {
 234                 SQObjectPtr &base = stack_get(v,-1);
 235                 if(type(base) != OT_CLASS)
 236                         return sq_throwerror(v,_SC("invalid base type"));
 237                 baseclass = _class(base);
 238         }
 239         SQClass *newclass = SQClass::Create(_ss(v), baseclass);
 240         if(baseclass) v->Pop();
 241         v->Push(newclass);
 242         return SQ_OK;
 243 }
 244
 245 SQBool sq_instanceof(HSQUIRRELVM v)
 246 {
 247         SQObjectPtr &inst = stack_get(v,-1);
 248         SQObjectPtr &cl = stack_get(v,-2);
 249         if(type(inst) != OT_INSTANCE || type(cl) != OT_CLASS)
 250                 return sq_throwerror(v,_SC("invalid param type"));
 251         return _instance(inst)->InstanceOf(_class(cl))?SQTrue:SQFalse;
 252 }
 253
 254 SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx)
 255 {
 256         sq_aux_paramscheck(v,2);
 257         SQObjectPtr *arr;
 258         _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
 259         _array(*arr)->Append(v->GetUp(-1));
 260         v->Pop(1);
 261         return SQ_OK;
 262 }
 263
 264 SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
 265 {
 266         sq_aux_paramscheck(v, 1);
 267         SQObjectPtr *arr;
 268         _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
 269         if(_array(*arr)->Size() > 0) {
 270         if(pushval != 0){ v->Push(_array(*arr)->Top()); }
 271                 _array(*arr)->Pop();
 272                 return SQ_OK;
 273         }
 274         return sq_throwerror(v, _SC("empty array"));
 275 }
 276
 277 SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize)
 278 {
 279         sq_aux_paramscheck(v,1);
 280         SQObjectPtr *arr;
 281         _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
 282         if(_array(*arr)->Size() > 0) {
 283                 _array(*arr)->Resize(newsize);
 284                 return SQ_OK;
 285         }
 286         return SQ_OK;
 287 }
 288
 289 SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx)
 290 {
 291         sq_aux_paramscheck(v, 1);
 292         SQObjectPtr *o;
 293         _GETSAFE_OBJ(v, idx, OT_ARRAY,o);
 294         SQArray *arr = _array(*o);
 295         if(arr->Size() > 0) {
 296                 SQObjectPtr t;
 297                 SQInteger size = arr->Size();
 298                 SQInteger n = size >> 1; size -= 1;
 299                 for(SQInteger i = 0; i < n; i++) {
 300                         t = arr->_values[i];
 301                         arr->_values[i] = arr->_values[size-i];
 302                         arr->_values[size-i] = t;
 303                 }
 304                 return SQ_OK;
 305         }
 306         return SQ_OK;
 307 }
 308
 309 void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,SQUnsignedInteger nfreevars)
 310 {
 311         SQNativeClosure *nc = SQNativeClosure::Create(_ss(v), func);
 312         nc->_nparamscheck = 0;
 313         for(SQUnsignedInteger i = 0; i < nfreevars; i++) {
 314                 nc->_outervalues.push_back(v->Top());
 315                 v->Pop();
 316         }
 317         v->Push(SQObjectPtr(nc));
 318 }
 319
 320 SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars)
 321 {
 322         SQObject o = stack_get(v, idx);
 323         if(sq_isclosure(o)) {
 324                 SQClosure *c = _closure(o);
 325                 SQFunctionProto *proto = _funcproto(c->_function);
 326                 *nparams = (SQUnsignedInteger)proto->_parameters.size();
 327         *nfreevars = (SQUnsignedInteger)c->_outervalues.size();
 328                 return SQ_OK;
 329         }
 330         return sq_throwerror(v,_SC("the object is not a closure"));
 331 }
 332
 333 SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,SQInteger idx,const SQChar *name)
 334 {
 335         SQObject o = stack_get(v, idx);
 336         if(sq_isnativeclosure(o)) {
 337                 SQNativeClosure *nc = _nativeclosure(o);
 338                 nc->_name = SQString::Create(_ss(v),name);
 339                 return SQ_OK;
 340         }
 341         return sq_throwerror(v,_SC("the object is not a nativeclosure"));
 342 }
 343
 344 SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,const SQChar *typemask)
 345 {
 346         SQObject o = stack_get(v, -1);
 347         if(!sq_isnativeclosure(o))
 348                 return sq_throwerror(v, _SC("native closure expected"));
 349         SQNativeClosure *nc = _nativeclosure(o);
 350         nc->_nparamscheck = nparamscheck;
 351         if(typemask) {
 352                 SQIntVec res;
 353                 if(!CompileTypemask(res, typemask))
 354                         return sq_throwerror(v, _SC("invalid typemask"));
 355                 nc->_typecheck.copy(res);
 356         }
 357         else {
 358                 nc->_typecheck.resize(0);
 359         }
 360         if(nparamscheck == SQ_MATCHTYPEMASKSTRING) {
 361                 nc->_nparamscheck = nc->_typecheck.size();
 362         }
 363         return SQ_OK;
 364 }
 365
 366 SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx)
 367 {
 368         SQObjectPtr &o = stack_get(v,idx);
 369         if(!sq_isnativeclosure(o) &&
 370                 !sq_isclosure(o))
 371                 return sq_throwerror(v,_SC("the target is not a closure"));
 372     SQObjectPtr &env = stack_get(v,-1);
 373         if(!sq_istable(env) &&
 374                 !sq_isclass(env) &&
 375                 !sq_isinstance(env))
 376                 return sq_throwerror(v,_SC("invalid environment"));
 377         SQObjectPtr w = _refcounted(env)->GetWeakRef(type(env));
 378         SQObjectPtr ret;
 379         if(sq_isclosure(o)) {
 380                 SQClosure *c = _closure(o)->Clone();
 381                 c->_env = w;
 382                 ret = c;
 383         }
 384         else { //then must be a native closure
 385                 SQNativeClosure *c = _nativeclosure(o)->Clone();
 386                 c->_env = w;
 387                 ret = c;
 388         }
 389         v->Pop();
 390         v->Push(ret);
 391         return SQ_OK;
 392 }
 393
 394 void sq_pushroottable(HSQUIRRELVM v)
 395 {
 396         v->Push(v->_roottable);
 397 }
 398
 399 void sq_pushregistrytable(HSQUIRRELVM v)
 400 {
 401         v->Push(_ss(v)->_registry);
 402 }
 403
 404 SQRESULT sq_setroottable(HSQUIRRELVM v)
 405 {
 406         SQObject o = stack_get(v, -1);
 407         if(sq_istable(o) || sq_isnull(o)) {
 408                 v->_roottable = o;
 409                 v->Pop();
 410                 return SQ_OK;
 411         }
 412         return sq_throwerror(v, _SC("ivalid type"));
 413 }
 414
 415 void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p)
 416 {
 417         v->_foreignptr = p;
 418 }
 419
 420 SQUserPointer sq_getforeignptr(HSQUIRRELVM v)
 421 {
 422         return v->_foreignptr;
 423 }
 424
 425 void sq_push(HSQUIRRELVM v,SQInteger idx)
 426 {
 427         v->Push(stack_get(v, idx));
 428 }
 429
 430 SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx)
 431 {
 432         return type(stack_get(v, idx));
 433 }
 434
 435 void sq_tostring(HSQUIRRELVM v,SQInteger idx)
 436 {
 437         SQObjectPtr &o = stack_get(v, idx);
 438         SQObjectPtr res;
 439         v->ToString(o,res);
 440         v->Push(res);
 441 }
 442
 443 void sq_tobool(HSQUIRRELVM v, SQInteger idx, SQBool *b)
 444 {
 445         SQObjectPtr &o = stack_get(v, idx);
 446         *b = v->IsFalse(o)?SQFalse:SQTrue;
 447 }
 448
 449 SQRESULT sq_getinteger(HSQUIRRELVM v,SQInteger idx,SQInteger *i)
 450 {
 451         SQObjectPtr &o = stack_get(v, idx);
 452         if(sq_isnumeric(o)) {
 453                 *i = tointeger(o);
 454                 return SQ_OK;
 455         }
 456         return SQ_ERROR;
 457 }
 458
 459 SQRESULT sq_getfloat(HSQUIRRELVM v,SQInteger idx,SQFloat *f)
 460 {
 461         SQObjectPtr &o = stack_get(v, idx);
 462         if(sq_isnumeric(o)) {
 463                 *f = tofloat(o);
 464                 return SQ_OK;
 465         }
 466         return SQ_ERROR;
 467 }
 468
 469 SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b)
 470 {
 471         SQObjectPtr &o = stack_get(v, idx);
 472         if(sq_isbool(o)) {
 473                 *b = _integer(o);
 474                 return SQ_OK;
 475         }
 476         return SQ_ERROR;
 477 }
 478
 479 SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c)
 480 {
 481         SQObjectPtr *o = NULL;
 482         _GETSAFE_OBJ(v, idx, OT_STRING,o);
 483         *c = _stringval(*o);
 484         return SQ_OK;
 485 }
 486
 487 SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread)
 488 {
 489         SQObjectPtr *o = NULL;
 490         _GETSAFE_OBJ(v, idx, OT_THREAD,o);
 491         *thread = _thread(*o);
 492         return SQ_OK;
 493 }
 494
 495 SQRESULT sq_clone(HSQUIRRELVM v,SQInteger idx)
 496 {
 497         SQObjectPtr &o = stack_get(v,idx);
 498         v->Push(_null_);
 499         if(!v->Clone(o, stack_get(v, -1))){
 500                 v->Pop();
 501                 return sq_aux_invalidtype(v, type(o));
 502         }
 503         return SQ_OK;
 504 }
 505
 506 SQInteger sq_getsize(HSQUIRRELVM v, SQInteger idx)
 507 {
 508         SQObjectPtr &o = stack_get(v, idx);
 509         SQObjectType type = type(o);
 510         switch(type) {
 511         case OT_STRING:         return _string(o)->_len;
 512         case OT_TABLE:          return _table(o)->CountUsed();
 513         case OT_ARRAY:          return _array(o)->Size();
 514         case OT_USERDATA:       return _userdata(o)->_size;
 515         default:
 516                 return sq_aux_invalidtype(v, type);
 517         }
 518 }
 519
 520 SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag)
 521 {
 522         SQObjectPtr *o = NULL;
 523         _GETSAFE_OBJ(v, idx, OT_USERDATA,o);
 524         (*p) = _userdataval(*o);
 525         if(typetag) *typetag = _userdata(*o)->_typetag;
 526         return SQ_OK;
 527 }
 528
 529 SQRESULT sq_settypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer typetag)
 530 {
 531         SQObjectPtr &o = stack_get(v,idx);
 532         switch(type(o)) {
 533                 case OT_USERDATA:       _userdata(o)->_typetag = typetag;       break;
 534                 case OT_CLASS:          _class(o)->_typetag = typetag;          break;
 535                 default:                        return sq_throwerror(v,_SC("invalid object type"));
 536         }
 537         return SQ_OK;
 538 }
 539
 540 SQRESULT sq_getobjtypetag(HSQOBJECT *o,SQUserPointer * typetag)
 541 {
 542   switch(type(*o)) {
 543     case OT_INSTANCE: *typetag = _instance(*o)->_class->_typetag; break;
 544     case OT_USERDATA: *typetag = _userdata(*o)->_typetag; break;
 545     case OT_CLASS:    *typetag = _class(*o)->_typetag; break;
 546     default: return SQ_ERROR;
 547   }
 548   return SQ_OK;
 549 }
 550
 551 SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag)
 552 {
 553         SQObjectPtr &o = stack_get(v,idx);
 554         if(SQ_FAILED(sq_getobjtypetag(&o,typetag)))
 555                 return sq_throwerror(v,_SC("invalid object type"));
 556         return SQ_OK;
 557 }
 558
 559 SQRESULT sq_getuserpointer(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p)
 560 {
 561         SQObjectPtr *o = NULL;
 562         _GETSAFE_OBJ(v, idx, OT_USERPOINTER,o);
 563         (*p) = _userpointer(*o);
 564         return SQ_OK;
 565 }
 566
 567 SQRESULT sq_setinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer p)
 568 {
 569         SQObjectPtr &o = stack_get(v,idx);
 570         if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
 571         _instance(o)->_userpointer = p;
 572         return SQ_OK;
 573 }
 574
 575 SQRESULT sq_getinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag)
 576 {
 577         SQObjectPtr &o = stack_get(v,idx);
 578         if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
 579         (*p) = _instance(o)->_userpointer;
 580         if(typetag != 0) {
 581                 SQClass *cl = _instance(o)->_class;
 582                 do{
 583                         if(cl->_typetag == typetag)
 584                                 return SQ_OK;
 585                         cl = cl->_base;
 586                 }while(cl != NULL);
 587                 return sq_throwerror(v,_SC("invalid type tag"));
 588         }
 589         return SQ_OK;
 590 }
 591
 592 SQInteger sq_gettop(HSQUIRRELVM v)
 593 {
 594         return (v->_top) - v->_stackbase;
 595 }
 596
 597 void sq_settop(HSQUIRRELVM v, SQInteger newtop)
 598 {
 599         SQInteger top = sq_gettop(v);
 600         if(top > newtop)
 601                 sq_pop(v, top - newtop);
 602         else
 603                 while(top < newtop) sq_pushnull(v);
 604 }
 605
 606 void sq_pop(HSQUIRRELVM v, SQInteger nelemstopop)
 607 {
 608         assert(v->_top >= nelemstopop);
 609         v->Pop(nelemstopop);
 610 }
 611
 612 void sq_poptop(HSQUIRRELVM v)
 613 {
 614         assert(v->_top >= 1);
 615     v->Pop();
 616 }
 617
 618
 619 void sq_remove(HSQUIRRELVM v, SQInteger idx)
 620 {
 621         v->Remove(idx);
 622 }
 623
 624 SQInteger sq_cmp(HSQUIRRELVM v)
 625 {
 626         SQInteger res;
 627         v->ObjCmp(stack_get(v, -1), stack_get(v, -2),res);
 628         return res;
 629 }
 630
 631 SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic)
 632 {
 633         sq_aux_paramscheck(v, 3);
 634         SQObjectPtr &self = stack_get(v, idx);
 635         if(type(self) == OT_TABLE || type(self) == OT_CLASS) {
 636                 SQObjectPtr &key = v->GetUp(-2);
 637                 if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
 638                 v->NewSlot(self, key, v->GetUp(-1),bstatic?true:false);
 639                 v->Pop(2);
 640         }
 641         return SQ_OK;
 642 }
 643
 644 /*SQRESULT sq_createslot(HSQUIRRELVM v, SQInteger idx)
 645 {
 646         sq_aux_paramscheck(v, 3);
 647         SQObjectPtr &self = stack_get(v, idx);
 648         if(type(self) == OT_TABLE || type(self) == OT_CLASS) {
 649                 SQObjectPtr &key = v->GetUp(-2);
 650                 if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
 651                 v->NewSlot(self, key, v->GetUp(-1));
 652                 v->Pop(2);
 653         }
 654         return SQ_OK;
 655 }*/
 656
 657 SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
 658 {
 659         sq_aux_paramscheck(v, 2);
 660         SQObjectPtr *self;
 661         _GETSAFE_OBJ(v, idx, OT_TABLE,self);
 662         SQObjectPtr &key = v->GetUp(-1);
 663         if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
 664         SQObjectPtr res;
 665         if(!v->DeleteSlot(*self, key, res)){
 666                 return SQ_ERROR;
 667         }
 668         if(pushval)     v->GetUp(-1) = res;
 669         else v->Pop(1);
 670         return SQ_OK;
 671 }
 672
 673 SQRESULT sq_set(HSQUIRRELVM v,SQInteger idx)
 674 {
 675         SQObjectPtr &self = stack_get(v, idx);
 676         if(v->Set(self, v->GetUp(-2), v->GetUp(-1),false)) {
 677                 v->Pop(2);
 678                 return SQ_OK;
 679         }
 680         v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
 681 }
 682
 683 SQRESULT sq_rawset(HSQUIRRELVM v,SQInteger idx)
 684 {
 685         SQObjectPtr &self = stack_get(v, idx);
 686         if(type(v->GetUp(-2)) == OT_NULL) return sq_throwerror(v, _SC("null key"));
 687         switch(type(self)) {
 688         case OT_TABLE:
 689                 _table(self)->NewSlot(v->GetUp(-2), v->GetUp(-1));
 690                 v->Pop(2);
 691                 return SQ_OK;
 692         break;
 693         case OT_CLASS:
 694                 _class(self)->NewSlot(_ss(v), v->GetUp(-2), v->GetUp(-1),false);
 695                 v->Pop(2);
 696                 return SQ_OK;
 697         break;
 698         case OT_INSTANCE:
 699                 if(_instance(self)->Set(v->GetUp(-2), v->GetUp(-1))) {
 700                         v->Pop(2);
 701                         return SQ_OK;
 702                 }
 703         break;
 704         case OT_ARRAY:
 705                 if(v->Set(self, v->GetUp(-2), v->GetUp(-1),false)) {
 706                         v->Pop(2);
 707                         return SQ_OK;
 708                 }
 709         break;
 710         default:
 711                 v->Pop(2);
 712                 return sq_throwerror(v, _SC("rawset works only on array/table/calsse and instance"));
 713         }
 714         v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
 715 }
 716
 717 SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx)
 718 {
 719         SQObjectPtr &self = stack_get(v, idx);
 720         SQObjectPtr &mt = v->GetUp(-1);
 721         SQObjectType type = type(self);
 722         switch(type) {
 723         case OT_TABLE:
 724                 if(type(mt) == OT_TABLE) {
 725                         if(!_table(self)->SetDelegate(_table(mt))) return sq_throwerror(v, _SC("delagate cycle")); v->Pop();}
 726                 else if(type(mt)==OT_NULL) {
 727                         _table(self)->SetDelegate(NULL); v->Pop(); }
 728                 else return sq_aux_invalidtype(v,type);
 729                 break;
 730         case OT_USERDATA:
 731                 if(type(mt)==OT_TABLE) {
 732                         _userdata(self)->SetDelegate(_table(mt)); v->Pop(); }
 733                 else if(type(mt)==OT_NULL) {
 734                         _userdata(self)->SetDelegate(NULL); v->Pop(); }
 735                 else return sq_aux_invalidtype(v, type);
 736                 break;
 737         default:
 738                         return sq_aux_invalidtype(v, type);
 739                 break;
 740         }
 741         return SQ_OK;
 742 }
 743
 744 SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
 745 {
 746         sq_aux_paramscheck(v, 2);
 747         SQObjectPtr *self;
 748         _GETSAFE_OBJ(v, idx, OT_TABLE,self);
 749         SQObjectPtr &key = v->GetUp(-1);
 750         SQObjectPtr t;
 751         if(_table(*self)->Get(key,t)) {
 752                 _table(*self)->Remove(key);
 753         }
 754         if(pushval != 0)
 755                 if(pushval)     v->GetUp(-1) = t;
 756         else
 757                 v->Pop(1);
 758         return SQ_OK;
 759 }
 760
 761 SQRESULT sq_getdelegate(HSQUIRRELVM v,SQInteger idx)
 762 {
 763         SQObjectPtr &self=stack_get(v,idx);
 764         switch(type(self)){
 765         case OT_TABLE:
 766                 if(!_table(self)->_delegate)break;
 767                 v->Push(SQObjectPtr(_table(self)->_delegate));
 768                 break;
 769         case OT_USERDATA:
 770                 if(!_userdata(self)->_delegate)break;
 771                 v->Push(SQObjectPtr(_userdata(self)->_delegate));
 772                 break;
 773         default: return sq_throwerror(v,_SC("wrong type")); break;
 774         }
 775         return SQ_OK;
 776
 777 }
 778
 779 SQRESULT sq_get(HSQUIRRELVM v,SQInteger idx)
 780 {
 781         SQObjectPtr &self=stack_get(v,idx);
 782         if(v->Get(self,v->GetUp(-1),v->GetUp(-1),false,false))
 783                 return SQ_OK;
 784         v->Pop(1);
 785         return sq_throwerror(v,_SC("the index doesn't exist"));
 786 }
 787
 788 SQRESULT sq_rawget(HSQUIRRELVM v,SQInteger idx)
 789 {
 790         SQObjectPtr &self=stack_get(v,idx);
 791         switch(type(self)) {
 792         case OT_TABLE:
 793                 if(_table(self)->Get(v->GetUp(-1),v->GetUp(-1)))
 794                         return SQ_OK;
 795                 break;
 796         case OT_CLASS:
 797                 if(_class(self)->Get(v->GetUp(-1),v->GetUp(-1)))
 798                         return SQ_OK;
 799                 break;
 800         case OT_INSTANCE:
 801                 if(_instance(self)->Get(v->GetUp(-1),v->GetUp(-1)))
 802                         return SQ_OK;
 803                 break;
 804         case OT_ARRAY:
 805                 if(v->Get(self,v->GetUp(-1),v->GetUp(-1),false,false))
 806                         return SQ_OK;
 807                 break;
 808         default:
 809                 v->Pop(1);
 810                 return sq_throwerror(v,_SC("rawget works only on array/table/instance and class"));
 811         }
 812         v->Pop(1);
 813         return sq_throwerror(v,_SC("the index doesn't exist"));
 814 }
 815
 816 SQRESULT sq_getstackobj(HSQUIRRELVM v,SQInteger idx,HSQOBJECT *po)
 817 {
 818         *po=stack_get(v,idx);
 819         return SQ_OK;
 820 }
 821
 822 const SQChar *sq_getlocal(HSQUIRRELVM v,SQUnsignedInteger level,SQUnsignedInteger idx)
 823 {
 824         SQUnsignedInteger cstksize=v->_callsstack.size();
 825         SQUnsignedInteger lvl=(cstksize-level)-1;
 826         SQInteger stackbase=v->_stackbase;
 827         if(lvl<cstksize){
 828                 for(SQUnsignedInteger i=0;i<level;i++){
 829                         SQVM::CallInfo &ci=v->_callsstack[(cstksize-i)-1];
 830                         stackbase-=ci._prevstkbase;
 831                 }
 832                 SQVM::CallInfo &ci=v->_callsstack[lvl];
 833                 if(type(ci._closure)!=OT_CLOSURE)
 834                         return NULL;
 835                 SQClosure *c=_closure(ci._closure);
 836                 SQFunctionProto *func=_funcproto(c->_function);
 837                 return func->GetLocal(v,stackbase,idx,(SQInteger)(ci._ip-func->_instructions._vals)-1);
 838         }
 839         return NULL;
 840 }
 841
 842 void sq_pushobject(HSQUIRRELVM v,HSQOBJECT obj)
 843 {
 844         v->Push(SQObjectPtr(obj));
 845 }
 846
 847 void sq_resetobject(HSQOBJECT *po)
 848 {
 849         po->_unVal.pUserPointer=NULL;po->_type=OT_NULL;
 850 }
 851
 852 SQRESULT sq_throwerror(HSQUIRRELVM v,const SQChar *err)
 853 {
 854         v->_lasterror=SQString::Create(_ss(v),err);
 855         return -1;
 856 }
 857
 858 void sq_reseterror(HSQUIRRELVM v)
 859 {
 860         v->_lasterror = _null_;
 861 }
 862
 863 void sq_getlasterror(HSQUIRRELVM v)
 864 {
 865         v->Push(v->_lasterror);
 866 }
 867
 868 void sq_reservestack(HSQUIRRELVM v,SQInteger nsize)
 869 {
 870         if (((SQUnsignedInteger)v->_top + nsize) > v->_stack.size()) {
 871                 v->_stack.resize(v->_stack.size() + ((v->_top + nsize) - v->_stack.size()));
 872         }
 873 }
 874
 875 SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval,SQBool raiseerror)
 876 {
 877         if(type(v->GetUp(-1))==OT_GENERATOR){
 878                 v->Push(_null_); //retval
 879                 if(!v->Execute(v->GetUp(-2),v->_top,0,v->_top,v->GetUp(-1),raiseerror,SQVM::ET_RESUME_GENERATOR))
 880                 {v->Raise_Error(v->_lasterror); return SQ_ERROR;}
 881                 if(!retval)
 882                         v->Pop();
 883                 return SQ_OK;
 884         }
 885         return sq_throwerror(v,_SC("only generators can be resumed"));
 886 }
 887
 888 SQRESULT sq_call(HSQUIRRELVM v,SQInteger params,SQBool retval,SQBool raiseerror)
 889 {
 890         SQObjectPtr res;
 891         if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){
 892                 v->Pop(params);//pop closure and args
 893                 if(retval){
 894                         v->Push(res); return SQ_OK;
 895                 }
 896                 return SQ_OK;
 897         }
 898         else {
 899                 v->Pop(params);
 900                 return SQ_ERROR;
 901         }
 902         if(!v->_suspended)
 903                 v->Pop(params);
 904         return sq_throwerror(v,_SC("call failed"));
 905 }
 906
 907 SQRESULT sq_suspendvm(HSQUIRRELVM v)
 908 {
 909         return v->Suspend();
 910 }
 911
 912 SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool wakeupret,SQBool retval,SQBool raiseerror)
 913 {
 914         SQObjectPtr ret;
 915         if(!v->_suspended)
 916                 return sq_throwerror(v,_SC("cannot resume a vm that is not running any code"));
 917         if(wakeupret) {
 918                 v->GetAt(v->_stackbase+v->_suspended_target)=v->GetUp(-1); //retval
 919                 v->Pop();
 920         } else v->GetAt(v->_stackbase+v->_suspended_target)=_null_;
 921         if(!v->Execute(_null_,v->_top,-1,-1,ret,raiseerror,SQVM::ET_RESUME_VM))
 922                 return SQ_ERROR;
 923         if(sq_getvmstate(v) == SQ_VMSTATE_IDLE) {
 924                 while (v->_top > 1) v->_stack[--v->_top] = _null_;
 925         }
 926         if(retval)
 927                 v->Push(ret);
 928         return SQ_OK;
 929 }
 930
 931 void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook)
 932 {
 933         if(sq_gettop(v) >= 1){
 934                 SQObjectPtr &ud=stack_get(v,idx);
 935                 switch( type(ud) ) {
 936                 case OT_USERDATA:       _userdata(ud)->_hook = hook;    break;
 937                 case OT_INSTANCE:       _instance(ud)->_hook = hook;    break;
 938                 case OT_CLASS:          _class(ud)->_hook = hook;               break;
 939                 default: break; //shutup compiler
 940                 }
 941         }
 942 }
 943
 944 void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f)
 945 {
 946         _ss(v)->_compilererrorhandler = f;
 947 }
 948
 949 SQRESULT sq_writeclosure(HSQUIRRELVM v,SQWRITEFUNC w,SQUserPointer up)
 950 {
 951         SQObjectPtr *o = NULL;
 952         _GETSAFE_OBJ(v, -1, OT_CLOSURE,o);
 953         unsigned short tag = SQ_BYTECODE_STREAM_TAG;
 954         if(w(up,&tag,2) != 2)
 955                 return sq_throwerror(v,_SC("io error"));
 956         if(!_closure(*o)->Save(v,up,w))
 957                 return SQ_ERROR;
 958         return SQ_OK;
 959 }
 960
 961 SQRESULT sq_readclosure(HSQUIRRELVM v,SQREADFUNC r,SQUserPointer up)
 962 {
 963         SQObjectPtr func=SQFunctionProto::Create();
 964         SQObjectPtr closure=SQClosure::Create(_ss(v),_funcproto(func));
 965         unsigned short tag;
 966         if(r(up,&tag,2) != 2)
 967                 return sq_throwerror(v,_SC("io error"));
 968         if(tag != SQ_BYTECODE_STREAM_TAG)
 969                 return sq_throwerror(v,_SC("invalid stream"));
 970         if(!_closure(closure)->Load(v,up,r))
 971                 return SQ_ERROR;
 972         v->Push(closure);
 973         return SQ_OK;
 974 }
 975
 976 SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize)
 977 {
 978         return _ss(v)->GetScratchPad(minsize);
 979 }
 980
 981 SQInteger sq_collectgarbage(HSQUIRRELVM v)
 982 {
 983 #ifndef NO_GARBAGE_COLLECTOR
 984         return _ss(v)->CollectGarbage(v);
 985 #else
 986         return -1;
 987 #endif
 988 }
 989
 990 const SQChar *sq_getfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval)
 991 {
 992         SQObjectPtr &self = stack_get(v,idx);
 993         const SQChar *name = NULL;
 994         if(type(self) == OT_CLOSURE) {
 995                 if(_closure(self)->_outervalues.size()>nval) {
 996                         v->Push(_closure(self)->_outervalues[nval]);
 997                         SQFunctionProto *fp = _funcproto(_closure(self)->_function);
 998                         SQOuterVar &ov = fp->_outervalues[nval];
 999                         name = _stringval(ov._name);
1000                 }
1001         }
1002         return name;
1003 }
1004
1005 SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval)
1006 {
1007         SQObjectPtr &self=stack_get(v,idx);
1008         switch(type(self))
1009         {
1010         case OT_CLOSURE:
1011                 if(_closure(self)->_outervalues.size()>nval){
1012                         _closure(self)->_outervalues[nval]=stack_get(v,-1);
1013                 }
1014                 else return sq_throwerror(v,_SC("invalid free var index"));
1015                 break;
1016         case OT_NATIVECLOSURE:
1017                 if(_nativeclosure(self)->_outervalues.size()>nval){
1018                         _nativeclosure(self)->_outervalues[nval]=stack_get(v,-1);
1019                 }
1020                 else return sq_throwerror(v,_SC("invalid free var index"));
1021                 break;
1022         default:
1023                 return sq_aux_invalidtype(v,type(self));
1024         }
1025         v->Pop(1);
1026         return SQ_OK;
1027 }
1028
1029 SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx)
1030 {
1031         SQObjectPtr *o = NULL;
1032         _GETSAFE_OBJ(v, idx, OT_CLASS,o);
1033         SQObjectPtr &key = stack_get(v,-2);
1034         SQObjectPtr &val = stack_get(v,-1);
1035         SQObjectPtr attrs;
1036         if(type(key) == OT_NULL) {
1037                 attrs = _class(*o)->_attributes;
1038                 _class(*o)->_attributes = val;
1039                 v->Pop(2);
1040                 v->Push(attrs);
1041                 return SQ_OK;
1042         }else if(_class(*o)->GetAttributes(key,attrs)) {
1043                 _class(*o)->SetAttributes(key,val);
1044                 v->Pop(2);
1045                 v->Push(attrs);
1046                 return SQ_OK;
1047         }
1048         return sq_throwerror(v,_SC("wrong index"));
1049 }
1050
1051 SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx)
1052 {
1053         SQObjectPtr *o = NULL;
1054         _GETSAFE_OBJ(v, idx, OT_CLASS,o);
1055         SQObjectPtr &key = stack_get(v,-1);
1056         SQObjectPtr attrs;
1057         if(type(key) == OT_NULL) {
1058                 attrs = _class(*o)->_attributes;
1059                 v->Pop();
1060                 v->Push(attrs);
1061                 return SQ_OK;
1062         }
1063         else if(_class(*o)->GetAttributes(key,attrs)) {
1064                 v->Pop();
1065                 v->Push(attrs);
1066                 return SQ_OK;
1067         }
1068         return sq_throwerror(v,_SC("wrong index"));
1069 }
1070
1071 SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx)
1072 {
1073         SQObjectPtr *o = NULL;
1074         _GETSAFE_OBJ(v, idx, OT_CLASS,o);
1075         if(_class(*o)->_base)
1076                 v->Push(SQObjectPtr(_class(*o)->_base));
1077         else
1078                 v->Push(_null_);
1079         return SQ_OK;
1080 }
1081
1082 SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx)
1083 {
1084         SQObjectPtr *o = NULL;
1085         _GETSAFE_OBJ(v, idx, OT_INSTANCE,o);
1086         v->Push(SQObjectPtr(_instance(*o)->_class));
1087         return SQ_OK;
1088 }
1089
1090 SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx)
1091 {
1092         SQObjectPtr *o = NULL;
1093         _GETSAFE_OBJ(v, idx, OT_CLASS,o);
1094         v->Push(_class(*o)->CreateInstance());
1095         return SQ_OK;
1096 }
1097
1098 void sq_weakref(HSQUIRRELVM v,SQInteger idx)
1099 {
1100         SQObject &o=stack_get(v,idx);
1101         if(ISREFCOUNTED(type(o))) {
1102                 v->Push(_refcounted(o)->GetWeakRef(type(o)));
1103                 return;
1104         }
1105         v->Push(o);
1106 }
1107
1108 SQRESULT sq_getweakrefval(HSQUIRRELVM v,SQInteger idx)
1109 {
1110         SQObjectPtr &o = stack_get(v,idx);
1111         if(type(o) != OT_WEAKREF) {
1112                 return sq_throwerror(v,_SC("the object must be a weakref"));
1113         }
1114         v->Push(_weakref(o)->_obj);
1115         return SQ_OK;
1116 }
1117
1118 SQRESULT sq_getdefaultdelegate(HSQUIRRELVM v,SQObjectType t)
1119 {
1120         SQSharedState *ss = _ss(v);
1121         switch(t) {
1122         case OT_TABLE: v->Push(ss->_table_default_delegate); break;
1123         case OT_ARRAY: v->Push(ss->_array_default_delegate); break;
1124         case OT_STRING: v->Push(ss->_string_default_delegate); break;
1125         case OT_INTEGER: case OT_FLOAT: v->Push(ss->_number_default_delegate); break;
1126         case OT_GENERATOR: v->Push(ss->_generator_default_delegate); break;
1127         case OT_CLOSURE: case OT_NATIVECLOSURE: v->Push(ss->_closure_default_delegate); break;
1128         case OT_THREAD: v->Push(ss->_thread_default_delegate); break;
1129         case OT_CLASS: v->Push(ss->_class_default_delegate); break;
1130         case OT_INSTANCE: v->Push(ss->_instance_default_delegate); break;
1131         case OT_WEAKREF: v->Push(ss->_weakref_default_delegate); break;
1132         default: return sq_throwerror(v,_SC("the type doesn't have a default delegate"));
1133         }
1134         return SQ_OK;
1135 }
1136
1137 SQRESULT sq_next(HSQUIRRELVM v,SQInteger idx)
1138 {
1139         SQObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val;
1140         if(type(o) == OT_GENERATOR) {
1141                 return sq_throwerror(v,_SC("cannot iterate a generator"));
1142         }
1143         bool finished;
1144         if(!v->FOREACH_OP(o,realkey,val,refpos,0,finished))
1145                 return SQ_ERROR;
1146         if(!finished) {
1147                 v->Push(realkey);
1148                 v->Push(val);
1149                 return SQ_OK;
1150         }
1151         return SQ_ERROR;
1152 }
1153
1154 struct BufState{
1155         const SQChar *buf;
1156         SQInteger ptr;
1157         SQInteger size;
1158 };
1159
1160 SQInteger buf_lexfeed(SQUserPointer file)
1161 {
1162         BufState *buf=(BufState*)file;
1163         if(buf->size<(buf->ptr+1))
1164                 return 0;
1165         return buf->buf[buf->ptr++];
1166 }
1167
1168 SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror) {
1169         BufState buf;
1170         buf.buf = s;
1171         buf.size = size;
1172         buf.ptr = 0;
1173         return sq_compile(v, buf_lexfeed, &buf, sourcename, raiseerror);
1174 }
1175
1176 void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,SQInteger idx)
1177 {
1178         dest->Push(stack_get(src,idx));
1179 }
1180
1181 void sq_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc)
1182 {
1183         _ss(v)->_printfunc = printfunc;
1184 }
1185
1186 SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v)
1187 {
1188         return _ss(v)->_printfunc;
1189 }
1190
1191 void *sq_malloc(SQUnsignedInteger size)
1192 {
1193         return SQ_MALLOC(size);
1194 }
1195
1196 void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize)
1197 {
1198         return SQ_REALLOC(p,oldsize,newsize);
1199 }
1200 void sq_free(void *p,SQUnsignedInteger size)
1201 {
1202         SQ_FREE(p,size);
1203 }