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,int 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 int sq_aux_throwobject(HSQUIRRELVM v,SQObjectPtr &e)
  35 {
  36         v->_lasterror = e;
  37         return SQ_ERROR;
  38 }
  39
  40 int 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(int 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, int 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 int 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 debuginfo)
 128 {
 129         _ss(v)->_debuginfo = debuginfo?true:false;
 130 }
 131
 132 void sq_addref(HSQUIRRELVM v,HSQOBJECT *po)
 133 {
 134         SQObjectPtr refs;
 135         if(!ISREFCOUNTED(type(*po))) return;
 136         if(_table(_ss(v)->_refs_table)->Get(*po, refs)) {
 137                 refs = _integer(refs) + 1;
 138         }
 139         else{
 140                 refs = 1;
 141         }
 142         _table(_ss(v)->_refs_table)->NewSlot(*po, refs);
 143 }
 144
 145 SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po)
 146 {
 147         SQObjectPtr refs;
 148         if(!ISREFCOUNTED(type(*po))) return SQTrue;
 149         if(_table(_ss(v)->_refs_table)->Get(*po, refs)) {
 150                 int n = _integer(refs) - 1;
 151                 if(n <= 0) {
 152                         _table(_ss(v)->_refs_table)->Remove(*po);
 153                         sq_resetobject(po);
 154                 }
 155                 else {
 156                         refs = n;_table(_ss(v)->_refs_table)->Set(*po, refs);
 157                         return SQFalse;
 158                 }
 159         }
 160         return SQTrue;
 161 }
 162
 163 const SQChar *sq_objtostring(HSQOBJECT *o)
 164 {
 165         if(sq_type(*o) == OT_STRING) {
 166                 return o->_unVal.pString->_val;
 167         }
 168         return NULL;
 169 }
 170
 171 SQInteger sq_objtointeger(HSQOBJECT *o)
 172 {
 173         if(sq_isnumeric(*o)) {
 174                 return tointeger(*o);
 175         }
 176         return 0;
 177 }
 178
 179 SQFloat sq_objtofloat(HSQOBJECT *o)
 180 {
 181         if(sq_isnumeric(*o)) {
 182                 return tofloat(*o);
 183         }
 184         return 0;
 185 }
 186
 187 void sq_pushnull(HSQUIRRELVM v)
 188 {
 189         v->Push(_null_);
 190 }
 191
 192 void sq_pushstring(HSQUIRRELVM v,const SQChar *s,int len)
 193 {
 194         if(s)
 195                 v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len)));
 196         else v->Push(_null_);
 197 }
 198
 199 void sq_pushinteger(HSQUIRRELVM v,SQInteger n)
 200 {
 201         v->Push(n);
 202 }
 203
 204 void sq_pushbool(HSQUIRRELVM v,SQBool b)
 205 {
 206         v->Push(b?true:false);
 207 }
 208
 209 void sq_pushfloat(HSQUIRRELVM v,SQFloat n)
 210 {
 211         v->Push(n);
 212 }
 213
 214 void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p)
 215 {
 216         v->Push(p);
 217 }
 218
 219 SQUserPointer sq_newuserdata(HSQUIRRELVM v,unsigned int size)
 220 {
 221         SQUserData *ud = SQUserData::Create(_ss(v), size);
 222         v->Push(ud);
 223         return ud->_val;
 224 }
 225
 226 void sq_newtable(HSQUIRRELVM v)
 227 {
 228         v->Push(SQTable::Create(_ss(v), 0));
 229 }
 230
 231 void sq_newarray(HSQUIRRELVM v,int size)
 232 {
 233         v->Push(SQArray::Create(_ss(v), size));
 234 }
 235
 236 SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase)
 237 {
 238         SQClass *baseclass = NULL;
 239         if(hasbase) {
 240                 SQObjectPtr &base = stack_get(v,-1);
 241                 if(type(base) != OT_CLASS)
 242                         return sq_throwerror(v,_SC("invalid base type"));
 243                 baseclass = _class(base);
 244         }
 245         SQClass *newclass = SQClass::Create(_ss(v), baseclass);
 246         if(baseclass) v->Pop();
 247         v->Push(newclass);
 248         return SQ_OK;
 249 }
 250
 251 int sq_instanceof(HSQUIRRELVM v)
 252 {
 253         SQObjectPtr &inst = stack_get(v,-1);
 254         SQObjectPtr &cl = stack_get(v,-2);
 255         if(type(inst) != OT_INSTANCE || type(cl) != OT_CLASS)
 256                 return sq_throwerror(v,_SC("invalid param type"));
 257         return _instance(inst)->InstanceOf(_class(cl))?1:0;
 258 }
 259
 260 SQRESULT sq_arrayappend(HSQUIRRELVM v,int idx)
 261 {
 262         sq_aux_paramscheck(v,2);
 263         SQObjectPtr *arr;
 264         _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
 265         _array(*arr)->Append(v->GetUp(-1));
 266         v->Pop(1);
 267         return SQ_OK;
 268 }
 269
 270 SQRESULT sq_arraypop(HSQUIRRELVM v,int idx,SQBool pushval)
 271 {
 272         sq_aux_paramscheck(v, 1);
 273         SQObjectPtr *arr;
 274         _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
 275         if(_array(*arr)->Size() > 0) {
 276         if(pushval != 0){ v->Push(_array(*arr)->Top()); }
 277                 _array(*arr)->Pop();
 278                 return SQ_OK;
 279         }
 280         return sq_throwerror(v, _SC("empty array"));
 281 }
 282
 283 SQRESULT sq_arrayresize(HSQUIRRELVM v,int idx,int newsize)
 284 {
 285         sq_aux_paramscheck(v,1);
 286         SQObjectPtr *arr;
 287         _GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
 288         if(_array(*arr)->Size() > 0) {
 289                 _array(*arr)->Resize(newsize);
 290                 return SQ_OK;
 291         }
 292         return sq_throwerror(v, _SC("empty array"));
 293 }
 294
 295 SQRESULT sq_arrayreverse(HSQUIRRELVM v,int idx)
 296 {
 297         sq_aux_paramscheck(v, 1);
 298         SQObjectPtr *o;
 299         _GETSAFE_OBJ(v, idx, OT_ARRAY,o);
 300         SQArray *arr = _array(*o);
 301         if(arr->Size() > 0) {
 302                 SQObjectPtr t;
 303                 int size = arr->Size();
 304                 int n = size >> 1; size -= 1;
 305                 for(int i = 0; i < n; i++) {
 306                         t = arr->_values[i];
 307                         arr->_values[i] = arr->_values[size-i];
 308                         arr->_values[size-i] = t;
 309                 }
 310                 return SQ_OK;
 311         }
 312         return sq_throwerror(v, _SC("empty array"));
 313 }
 314
 315 void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,unsigned int nfreevars)
 316 {
 317         SQNativeClosure *nc = SQNativeClosure::Create(_ss(v), func);
 318         nc->_nparamscheck = 0;
 319         for(unsigned int i = 0; i < nfreevars; i++) {
 320                 nc->_outervalues.push_back(v->Top());
 321                 v->Pop();
 322         }
 323         v->Push(SQObjectPtr(nc));
 324 }
 325
 326 SQRESULT sq_getclosureinfo(HSQUIRRELVM v,int idx,unsigned int *nparams,unsigned int *nfreevars)
 327 {
 328         SQObject o = stack_get(v, idx);
 329         if(sq_isclosure(o)) {
 330                 SQClosure *c = _closure(o);
 331                 SQFunctionProto *proto = _funcproto(c->_function);
 332                 *nparams = (unsigned int)proto->_parameters.size();
 333         *nfreevars = (unsigned int)c->_outervalues.size();
 334                 return SQ_OK;
 335         }
 336         return sq_throwerror(v,_SC("the object is not a closure"));
 337 }
 338
 339 SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,int idx,const SQChar *name)
 340 {
 341         SQObject o = stack_get(v, idx);
 342         if(sq_isnativeclosure(o)) {
 343                 SQNativeClosure *nc = _nativeclosure(o);
 344                 nc->_name = SQString::Create(_ss(v),name);
 345                 return SQ_OK;
 346         }
 347         return sq_throwerror(v,_SC("the object is not a nativeclosure"));
 348 }
 349
 350 SQRESULT sq_setparamscheck(HSQUIRRELVM v,int nparamscheck,const SQChar *typemask)
 351 {
 352         SQObject o = stack_get(v, -1);
 353         if(!sq_isnativeclosure(o))
 354                 return sq_throwerror(v, _SC("native closure expected"));
 355         SQNativeClosure *nc = _nativeclosure(o);
 356         nc->_nparamscheck = nparamscheck;
 357         if(typemask) {
 358                 SQIntVec res;
 359                 if(!CompileTypemask(res, typemask))
 360                         return sq_throwerror(v, _SC("invalid typemask"));
 361                 nc->_typecheck.copy(res);
 362         }
 363         else {
 364                 nc->_typecheck.resize(0);
 365         }
 366         if(nparamscheck == SQ_MATCHTYPEMASKSTRING) {
 367                 nc->_nparamscheck = nc->_typecheck.size();
 368         }
 369         return SQ_OK;
 370 }
 371
 372 void sq_pushroottable(HSQUIRRELVM v)
 373 {
 374         v->Push(v->_roottable);
 375 }
 376
 377 void sq_pushregistrytable(HSQUIRRELVM v)
 378 {
 379         v->Push(_ss(v)->_registry);
 380 }
 381
 382 SQRESULT sq_setroottable(HSQUIRRELVM v)
 383 {
 384         SQObject o = stack_get(v, -1);
 385         if(sq_istable(o) || sq_isnull(o)) {
 386                 v->_roottable = o;
 387                 v->Pop();
 388                 return SQ_OK;
 389         }
 390         return sq_throwerror(v, _SC("ivalid type"));
 391 }
 392
 393 void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p)
 394 {
 395         v->_foreignptr = p;
 396 }
 397
 398 SQUserPointer sq_getforeignptr(HSQUIRRELVM v)
 399 {
 400         return v->_foreignptr;
 401 }
 402
 403 void sq_push(HSQUIRRELVM v,int idx)
 404 {
 405         v->Push(stack_get(v, idx));
 406 }
 407
 408 SQObjectType sq_gettype(HSQUIRRELVM v,int idx)
 409 {
 410         return type(stack_get(v, idx));
 411 }
 412
 413 SQRESULT sq_getinteger(HSQUIRRELVM v,int idx,SQInteger *i)
 414 {
 415         SQObjectPtr &o = stack_get(v, idx);
 416         if(sq_isnumeric(o)) {
 417                 *i = tointeger(o);
 418                 return SQ_OK;
 419         }
 420         return SQ_ERROR;
 421 }
 422
 423 SQRESULT sq_getfloat(HSQUIRRELVM v,int idx,SQFloat *f)
 424 {
 425         SQObjectPtr &o = stack_get(v, idx);
 426         if(sq_isnumeric(o)) {
 427                 *f = tofloat(o);
 428                 return SQ_OK;
 429         }
 430         return SQ_ERROR;
 431 }
 432
 433 SQRESULT sq_getbool(HSQUIRRELVM v,int idx,SQBool *b)
 434 {
 435         SQObjectPtr &o = stack_get(v, idx);
 436         if(sq_isbool(o)) {
 437                 *b = _integer(o);
 438                 return SQ_OK;
 439         }
 440         return SQ_ERROR;
 441 }
 442
 443 SQRESULT sq_getstring(HSQUIRRELVM v,int idx,const SQChar **c)
 444 {
 445         SQObjectPtr *o = NULL;
 446         _GETSAFE_OBJ(v, idx, OT_STRING,o);
 447         *c = _stringval(*o);
 448         return SQ_OK;
 449 }
 450
 451 SQRESULT sq_getthread(HSQUIRRELVM v,int idx,HSQUIRRELVM *thread)
 452 {
 453         SQObjectPtr *o = NULL;
 454         _GETSAFE_OBJ(v, idx, OT_THREAD,o);
 455         *thread = _thread(*o);
 456         return SQ_OK;
 457 }
 458
 459 SQRESULT sq_clone(HSQUIRRELVM v,int idx)
 460 {
 461         SQObjectPtr &o = stack_get(v,idx);
 462         v->Push(_null_);
 463         if(!v->Clone(o, stack_get(v, -1))){
 464                 v->Pop();
 465                 return sq_aux_invalidtype(v, type(o));
 466         }
 467         return SQ_OK;
 468 }
 469
 470 SQInteger sq_getsize(HSQUIRRELVM v, int idx)
 471 {
 472         SQObjectPtr &o = stack_get(v, idx);
 473         SQObjectType type = type(o);
 474         switch(type) {
 475         case OT_STRING:         return _string(o)->_len;
 476         case OT_TABLE:          return _table(o)->CountUsed();
 477         case OT_ARRAY:          return _array(o)->Size();
 478         case OT_USERDATA:       return _userdata(o)->_size;
 479         default:
 480                 return sq_aux_invalidtype(v, type);
 481         }
 482 }
 483
 484 SQRESULT sq_getuserdata(HSQUIRRELVM v,int idx,SQUserPointer *p,unsigned int *typetag)
 485 {
 486         SQObjectPtr *o = NULL;
 487         _GETSAFE_OBJ(v, idx, OT_USERDATA,o);
 488         (*p) = _userdataval(*o);
 489         if(typetag) *typetag = _userdata(*o)->_typetag;
 490         return SQ_OK;
 491 }
 492
 493 SQRESULT sq_settypetag(HSQUIRRELVM v,int idx,unsigned int typetag)
 494 {
 495         SQObjectPtr &o = stack_get(v,idx);
 496         switch(type(o)) {
 497                 case OT_USERDATA:       _userdata(o)->_typetag = typetag;       break;
 498                 case OT_CLASS:          _class(o)->_typetag = typetag;          break;
 499                 default:                        return sq_throwerror(v,_SC("invalid object type"));
 500         }
 501         return SQ_OK;
 502 }
 503
 504 SQRESULT sq_gettypetag(HSQUIRRELVM v,int idx,unsigned int *typetag)
 505 {
 506         SQObjectPtr &o = stack_get(v,idx);
 507         switch(type(o)) {
 508                 case OT_USERDATA:       *typetag = _userdata(o)->_typetag;      break;
 509                 case OT_CLASS:          *typetag = _class(o)->_typetag;         break;
 510                 default:                        return sq_throwerror(v,_SC("invalid object type"));
 511         }
 512         return SQ_OK;
 513 }
 514
 515 SQRESULT sq_getuserpointer(HSQUIRRELVM v, int idx, SQUserPointer *p)
 516 {
 517         SQObjectPtr *o = NULL;
 518         _GETSAFE_OBJ(v, idx, OT_USERPOINTER,o);
 519         (*p) = _userpointer(*o);
 520         return SQ_OK;
 521 }
 522
 523 SQRESULT sq_setinstanceup(HSQUIRRELVM v, int idx, SQUserPointer p)
 524 {
 525         SQObjectPtr &o = stack_get(v,idx);
 526         if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
 527         _instance(o)->_userpointer = p;
 528         return SQ_OK;
 529 }
 530
 531 SQRESULT sq_getinstanceup(HSQUIRRELVM v, int idx, SQUserPointer *p,unsigned int typetag)
 532 {
 533         SQObjectPtr &o = stack_get(v,idx);
 534         if(type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
 535         (*p) = _instance(o)->_userpointer;
 536         if(typetag != 0) {
 537                 SQClass *cl = _instance(o)->_class;
 538                 do{
 539                         if(cl->_typetag == typetag)
 540                                 return SQ_OK;
 541                         cl = cl->_base;
 542                 }while(cl != NULL);
 543                 return sq_throwerror(v,_SC("invalid type tag"));
 544         }
 545         return SQ_OK;
 546 }
 547
 548 int sq_gettop(HSQUIRRELVM v)
 549 {
 550         return (v->_top) - v->_stackbase;
 551 }
 552
 553 void sq_settop(HSQUIRRELVM v, int newtop)
 554 {
 555         int top = sq_gettop(v);
 556         if(top > newtop)
 557                 sq_pop(v, top - newtop);
 558         else
 559                 while(top < newtop) sq_pushnull(v);
 560 }
 561
 562 void sq_pop(HSQUIRRELVM v, int nelemstopop)
 563 {
 564         assert(v->_top >= nelemstopop);
 565         v->Pop(nelemstopop);
 566 }
 567
 568 void sq_remove(HSQUIRRELVM v, int idx)
 569 {
 570         v->Remove(idx);
 571 }
 572
 573 int sq_cmp(HSQUIRRELVM v)
 574 {
 575         int res;
 576         v->ObjCmp(stack_get(v, -1), stack_get(v, -2),res);
 577         return res;
 578 }
 579
 580 SQRESULT sq_createslot(HSQUIRRELVM v, int idx)
 581 {
 582         sq_aux_paramscheck(v, 3);
 583         SQObjectPtr &self = stack_get(v, idx);
 584         if(type(self) == OT_TABLE || type(self) == OT_CLASS) {
 585                 SQObjectPtr &key = v->GetUp(-2);
 586                 if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
 587                 v->NewSlot(self, key, v->GetUp(-1));
 588                 v->Pop(2);
 589         }
 590         return SQ_OK;
 591 }
 592
 593 SQRESULT sq_deleteslot(HSQUIRRELVM v,int idx,SQBool pushval)
 594 {
 595         sq_aux_paramscheck(v, 2);
 596         SQObjectPtr *self;
 597         _GETSAFE_OBJ(v, idx, OT_TABLE,self);
 598         SQObjectPtr &key = v->GetUp(-1);
 599         if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
 600         SQObjectPtr res;
 601         if(!v->DeleteSlot(*self, key, res)){
 602                 return SQ_ERROR;
 603         }
 604         if(pushval)     v->GetUp(-1) = res;
 605         else v->Pop(1);
 606         return SQ_OK;
 607 }
 608
 609 SQRESULT sq_set(HSQUIRRELVM v,int idx)
 610 {
 611         SQObjectPtr &self = stack_get(v, idx);
 612         if(v->Set(self, v->GetUp(-2), v->GetUp(-1),false)) {
 613                 v->Pop(2);
 614                 return SQ_OK;
 615         }
 616         v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
 617 }
 618
 619 SQRESULT sq_rawset(HSQUIRRELVM v,int idx)
 620 {
 621         SQObjectPtr &self = stack_get(v, idx);
 622         if(type(v->GetUp(-2)) == OT_NULL) return sq_throwerror(v, _SC("null key"));
 623         switch(type(self)) {
 624         case OT_TABLE:
 625                 _table(self)->NewSlot(v->GetUp(-2), v->GetUp(-1));
 626                 v->Pop(2);
 627                 return SQ_OK;
 628         break;
 629         case OT_CLASS:
 630                 _class(self)->NewSlot(v->GetUp(-2), v->GetUp(-1));
 631                 v->Pop(2);
 632                 return SQ_OK;
 633         break;
 634         case OT_INSTANCE:
 635                 if(_instance(self)->Set(v->GetUp(-2), v->GetUp(-1))) {
 636                         v->Pop(2);
 637                         return SQ_OK;
 638                 }
 639         break;
 640         case OT_ARRAY:
 641                 if(v->Set(self, v->GetUp(-2), v->GetUp(-1),false)) {
 642                         v->Pop(2);
 643                         return SQ_OK;
 644                 }
 645         break;
 646         default:
 647                 v->Pop(2);
 648                 return sq_throwerror(v, _SC("rawset works only on arrays,tables,calsses and instances"));
 649         }
 650         v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
 651 }
 652
 653 SQRESULT sq_setdelegate(HSQUIRRELVM v,int idx)
 654 {
 655         SQObjectPtr &self = stack_get(v, idx);
 656         SQObjectPtr &mt = v->GetUp(-1);
 657         SQObjectType type = type(self);
 658         switch(type) {
 659         case OT_TABLE:
 660                 if(type(mt) == OT_TABLE) {
 661                         if(!_table(self)->SetDelegate(_table(mt))) return sq_throwerror(v, _SC("delagate cycle")); v->Pop();}
 662                 else if(type(mt)==OT_NULL) {
 663                         _table(self)->SetDelegate(NULL); v->Pop(); }
 664                 else return sq_aux_invalidtype(v,type);
 665                 break;
 666         case OT_USERDATA:
 667                 if(type(mt)==OT_TABLE) {
 668                         _userdata(self)->SetDelegate(_table(mt)); v->Pop(); }
 669                 else if(type(mt)==OT_NULL) {
 670                         _userdata(self)->SetDelegate(NULL); v->Pop(); }
 671                 else return sq_aux_invalidtype(v, type);
 672                 break;
 673         default:
 674                         return sq_aux_invalidtype(v, type);
 675                 break;
 676         }
 677         return SQ_OK;
 678 }
 679
 680 SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,int idx,SQBool pushval)
 681 {
 682         sq_aux_paramscheck(v, 2);
 683         SQObjectPtr *self;
 684         _GETSAFE_OBJ(v, idx, OT_TABLE,self);
 685         SQObjectPtr &key = v->GetUp(-1);
 686         SQObjectPtr t;
 687         if(_table(*self)->Get(key,t)) {
 688                 _table(*self)->Remove(key);
 689         }
 690         if(pushval != 0)
 691                 if(pushval)     v->GetUp(-1) = t;
 692         else
 693                 v->Pop(1);
 694         return SQ_OK;
 695 }
 696
 697 SQRESULT sq_getdelegate(HSQUIRRELVM v,int idx)
 698 {
 699         SQObjectPtr &self=stack_get(v,idx);
 700         switch(type(self)){
 701         case OT_TABLE:
 702                 if(!_table(self)->_delegate)break;
 703                 v->Push(SQObjectPtr(_table(self)->_delegate));
 704                 return SQ_OK;
 705                 break;
 706         case OT_USERDATA:
 707                 if(!_userdata(self)->_delegate)break;
 708                 v->Push(SQObjectPtr(_userdata(self)->_delegate));
 709                 return SQ_OK;
 710                 break;
 711         }
 712         return sq_throwerror(v,_SC("wrong type"));
 713 }
 714
 715 SQRESULT sq_get(HSQUIRRELVM v,int idx)
 716 {
 717         SQObjectPtr &self=stack_get(v,idx);
 718         if(v->Get(self,v->GetUp(-1),v->GetUp(-1),false,false))
 719                 return SQ_OK;
 720         v->Pop(1);
 721         return sq_throwerror(v,_SC("the index doesn't exist"));
 722 }
 723
 724 SQRESULT sq_rawget(HSQUIRRELVM v,int idx)
 725 {
 726         SQObjectPtr &self=stack_get(v,idx);
 727         switch(type(self)) {
 728         case OT_TABLE:
 729                 if(_table(self)->Get(v->GetUp(-1),v->GetUp(-1)))
 730                         return SQ_OK;
 731                 break;
 732         case OT_CLASS:
 733                 if(_class(self)->Get(v->GetUp(-1),v->GetUp(-1)))
 734                         return SQ_OK;
 735                 break;
 736         case OT_INSTANCE:
 737                 if(_instance(self)->Get(v->GetUp(-1),v->GetUp(-1)))
 738                         return SQ_OK;
 739                 break;
 740         case OT_ARRAY:
 741                 if(v->Get(self,v->GetUp(-1),v->GetUp(-1),false,false))
 742                         return SQ_OK;
 743                 break;
 744         default:
 745                 v->Pop(1);
 746                 return sq_throwerror(v,_SC("rawget works only on arrays and tables"));
 747         }
 748         v->Pop(1);
 749         return sq_throwerror(v,_SC("the index doesn't exist"));
 750 }
 751
 752 SQRESULT sq_getstackobj(HSQUIRRELVM v,int idx,HSQOBJECT *po)
 753 {
 754         *po=stack_get(v,idx);
 755         return SQ_OK;
 756 }
 757
 758 const SQChar *sq_getlocal(HSQUIRRELVM v,unsigned int level,unsigned int idx)
 759 {
 760         unsigned int cstksize=v->_callsstack.size();
 761         unsigned int lvl=(cstksize-level)-1;
 762         int stackbase=v->_stackbase;
 763         if(lvl<cstksize){
 764                 for(unsigned int i=0;i<level;i++){
 765                         SQVM::CallInfo &ci=v->_callsstack[(cstksize-i)-1];
 766                         stackbase-=ci._prevstkbase;
 767                 }
 768                 SQVM::CallInfo &ci=v->_callsstack[lvl];
 769                 if(type(ci._closure)!=OT_CLOSURE)
 770                         return NULL;
 771                 SQClosure *c=_closure(ci._closure);
 772                 SQFunctionProto *func=_funcproto(c->_function);
 773                 return func->GetLocal(v,stackbase,idx,(ci._ip-func->_instructions._vals)-1);
 774         }
 775         return NULL;
 776 }
 777
 778 void sq_pushobject(HSQUIRRELVM v,HSQOBJECT obj)
 779 {
 780         v->Push(SQObjectPtr(obj));
 781 }
 782
 783 void sq_resetobject(HSQOBJECT *po)
 784 {
 785         po->_unVal.pUserPointer=NULL;po->_type=OT_NULL;
 786 }
 787
 788 SQRESULT sq_throwerror(HSQUIRRELVM v,const SQChar *err)
 789 {
 790         v->_lasterror=SQString::Create(_ss(v),err);
 791         return -1;
 792 }
 793
 794 void sq_reseterror(HSQUIRRELVM v)
 795 {
 796         v->_lasterror = _null_;
 797 }
 798
 799 void sq_getlasterror(HSQUIRRELVM v)
 800 {
 801         v->Push(v->_lasterror);
 802 }
 803
 804 void sq_reservestack(HSQUIRRELVM v,int nsize)
 805 {
 806         if (((unsigned int)v->_top + nsize) > v->_stack.size()) {
 807                 v->_stack.resize(v->_stack.size() + ((v->_top + nsize) - v->_stack.size()));
 808         }
 809 }
 810
 811 SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval)
 812 {
 813         if(type(v->GetUp(-1))==OT_GENERATOR){
 814                 v->Push(_null_); //retval
 815                 if(!v->Execute(v->GetUp(-2),v->_top,0,v->_top,v->GetUp(-1),SQVM::ET_RESUME_GENERATOR))
 816                 {v->Raise_Error(v->_lasterror); return SQ_ERROR;}
 817                 if(!retval)
 818                         v->Pop();
 819                 return SQ_OK;
 820         }
 821         return sq_throwerror(v,_SC("only generators can be resumed"));
 822 }
 823
 824 SQRESULT sq_call(HSQUIRRELVM v,int params,SQBool retval)
 825 {
 826         SQObjectPtr res;
 827         if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res)){
 828                 v->Pop(params);//pop closure and args
 829                 if(retval){
 830                         v->Push(res); return SQ_OK;
 831                 }
 832                 return SQ_OK;
 833         }
 834         else {
 835                 v->Pop(params);
 836                 return SQ_ERROR;
 837         }
 838         if(!v->_suspended)
 839                 v->Pop(params);
 840         return sq_throwerror(v,_SC("call failed"));
 841 }
 842
 843 SQRESULT sq_suspendvm(HSQUIRRELVM v)
 844 {
 845         return v->Suspend();
 846 }
 847
 848 SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool wakeupret,SQBool retval)
 849 {
 850         SQObjectPtr ret;
 851         if(!v->_suspended)
 852                 return sq_throwerror(v,_SC("cannot resume a vm that is not running any code"));
 853         if(wakeupret) {
 854                 v->GetAt(v->_stackbase+v->_suspended_target)=v->GetUp(-1); //retval
 855                 v->Pop();
 856         } else v->GetAt(v->_stackbase+v->_suspended_target)=_null_;
 857         if(!v->Execute(_null_,v->_top,-1,-1,ret,SQVM::ET_RESUME_VM))
 858                 return SQ_ERROR;
 859         if(sq_getvmstate(v) == SQ_VMSTATE_IDLE) {
 860                 while (v->_top > 1) v->_stack[--v->_top] = _null_;
 861         }
 862         if(retval)
 863                 v->Push(ret);
 864         return SQ_OK;
 865 }
 866
 867 void sq_setreleasehook(HSQUIRRELVM v,int idx,SQRELEASEHOOK hook)
 868 {
 869         if(sq_gettop(v) >= 1){
 870                 SQObjectPtr &ud=stack_get(v,idx);
 871                 switch( type(ud) ) {
 872                 case OT_USERDATA:
 873                         _userdata(ud)->_hook = hook;
 874                         break;
 875                 case OT_INSTANCE:
 876                         _instance(ud)->_hook = hook;
 877                         break;
 878                 }
 879         }
 880 }
 881
 882 void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f)
 883 {
 884         _ss(v)->_compilererrorhandler = f;
 885 }
 886
 887 SQRESULT sq_writeclosure(HSQUIRRELVM v,SQWRITEFUNC w,SQUserPointer up)
 888 {
 889         SQObjectPtr *o = NULL;
 890         _GETSAFE_OBJ(v, -1, OT_CLOSURE,o);
 891         SQClosure *c=_closure(*o);
 892         unsigned short tag = SQ_BYTECODE_STREAM_TAG;
 893         if(w(up,&tag,2) != 2)
 894                 return sq_throwerror(v,_SC("io error"));
 895         if(!_closure(*o)->Save(v,up,w))
 896                 return SQ_ERROR;
 897         return SQ_OK;
 898 }
 899
 900 SQRESULT sq_readclosure(HSQUIRRELVM v,SQREADFUNC r,SQUserPointer up)
 901 {
 902         SQObjectPtr func=SQFunctionProto::Create();
 903         SQObjectPtr closure=SQClosure::Create(_ss(v),_funcproto(func));
 904         unsigned short tag;
 905         if(r(up,&tag,2) != 2)
 906                 return sq_throwerror(v,_SC("io error"));
 907         if(tag != SQ_BYTECODE_STREAM_TAG)
 908                 return sq_throwerror(v,_SC("invalid stream"));
 909         if(!_closure(closure)->Load(v,up,r))
 910                 return SQ_ERROR;
 911         v->Push(closure);
 912         return SQ_OK;
 913 }
 914
 915 SQChar *sq_getscratchpad(HSQUIRRELVM v,int minsize)
 916 {
 917         return _ss(v)->GetScratchPad(minsize);
 918 }
 919
 920 int sq_collectgarbage(HSQUIRRELVM v)
 921 {
 922 #ifndef NO_GARBAGE_COLLECTOR
 923         return _ss(v)->CollectGarbage(v);
 924 #else
 925         return -1;
 926 #endif
 927 }
 928
 929 SQRESULT sq_setfreevariable(HSQUIRRELVM v,int idx,unsigned int nval)
 930 {
 931         SQObjectPtr &self=stack_get(v,idx);
 932         switch(type(self))
 933         {
 934         case OT_CLOSURE:
 935                 if(_closure(self)->_outervalues.size()>nval){
 936                         _closure(self)->_outervalues[nval]=stack_get(v,-1);
 937                 }
 938                 else return sq_throwerror(v,_SC("invalid free var index"));
 939                 break;
 940         case OT_NATIVECLOSURE:
 941                 if(_nativeclosure(self)->_outervalues.size()>nval){
 942                         _nativeclosure(self)->_outervalues[nval]=stack_get(v,-1);
 943                 }
 944                 else return sq_throwerror(v,_SC("invalid free var index"));
 945                 break;
 946         default:
 947                 return sq_aux_invalidtype(v,type(self));
 948         }
 949         v->Pop(1);
 950         return SQ_OK;
 951 }
 952
 953 SQRESULT sq_setattributes(HSQUIRRELVM v,int idx)
 954 {
 955         SQObjectPtr *o = NULL;
 956         _GETSAFE_OBJ(v, idx, OT_CLASS,o);
 957         SQObjectPtr &key = stack_get(v,-2);
 958         SQObjectPtr &val = stack_get(v,-1);
 959         SQObjectPtr attrs;
 960         if(type(key) == OT_NULL) {
 961                 attrs = _class(*o)->_attributes;
 962                 _class(*o)->_attributes = val;
 963                 v->Pop(2);
 964                 v->Push(attrs);
 965                 return SQ_OK;
 966         }else if(_class(*o)->GetAttributes(key,attrs)) {
 967                 _class(*o)->SetAttributes(key,val);
 968                 v->Pop(2);
 969                 v->Push(attrs);
 970                 return SQ_OK;
 971         }
 972         return sq_throwerror(v,_SC("wrong index"));
 973 }
 974
 975 SQRESULT sq_getattributes(HSQUIRRELVM v,int idx)
 976 {
 977         SQObjectPtr *o = NULL;
 978         _GETSAFE_OBJ(v, idx, OT_CLASS,o);
 979         SQObjectPtr &key = stack_get(v,-1);
 980         SQObjectPtr attrs;
 981         if(type(key) == OT_NULL) {
 982                 attrs = _class(*o)->_attributes;
 983                 v->Pop();
 984                 v->Push(attrs);
 985                 return SQ_OK;
 986         }
 987         else if(_class(*o)->GetAttributes(key,attrs)) {
 988                 v->Pop();
 989                 v->Push(attrs);
 990                 return SQ_OK;
 991         }
 992         return sq_throwerror(v,_SC("wrong index"));
 993 }
 994
 995 SQRESULT sq_getclass(HSQUIRRELVM v,int idx)
 996 {
 997         SQObjectPtr *o = NULL;
 998         _GETSAFE_OBJ(v, idx, OT_INSTANCE,o);
 999         v->Push(SQObjectPtr(_instance(*o)->_class));
1000         return SQ_OK;
1001 }
1002
1003 SQRESULT sq_createinstance(HSQUIRRELVM v,int idx)
1004 {
1005         SQObjectPtr *o = NULL;
1006         _GETSAFE_OBJ(v, idx, OT_CLASS,o);
1007         v->Push(_class(*o)->CreateInstance());
1008         return SQ_OK;
1009 }
1010
1011 SQRESULT sq_next(HSQUIRRELVM v,int idx)
1012 {
1013         SQObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val;
1014         if(type(o) == OT_GENERATOR) {
1015                 return sq_throwerror(v,_SC("cannot iterate a generator"));
1016         }
1017         bool finished;
1018         if(!v->FOREACH_OP(o,realkey,val,refpos,0,finished))
1019                 return SQ_ERROR;
1020         if(!finished) {
1021                 v->Push(realkey);
1022                 v->Push(val);
1023                 return SQ_OK;
1024         }
1025         return SQ_ERROR;
1026 }
1027
1028 struct BufState{
1029         const SQChar *buf;
1030         int ptr;
1031         int size;
1032 };
1033
1034 SQInteger buf_lexfeed(SQUserPointer file)
1035 {
1036         BufState *buf=(BufState*)file;
1037         if(buf->size<(buf->ptr+1))
1038                 return 0;
1039         return buf->buf[buf->ptr++];
1040 }
1041
1042 SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,int size,const SQChar *sourcename,SQBool raiseerror) {
1043         BufState buf;
1044         buf.buf = s;
1045         buf.size = size;
1046         buf.ptr = 0;
1047         return sq_compile(v, buf_lexfeed, &buf, sourcename, raiseerror);
1048 }
1049
1050 void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,int idx)
1051 {
1052         dest->Push(stack_get(src,idx));
1053 }
1054
1055 void sq_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc)
1056 {
1057         _ss(v)->_printfunc = printfunc;
1058 }
1059
1060 SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v)
1061 {
1062         return _ss(v)->_printfunc;
1063 }
1064
1065 void *sq_malloc(unsigned int size)
1066 {
1067         return SQ_MALLOC(size);
1068 }
1069
1070 void *sq_realloc(void* p,unsigned int oldsize,unsigned int newsize)
1071 {
1072         return SQ_REALLOC(p,oldsize,newsize);
1073 }
1074 void sq_free(void *p,unsigned int size)
1075 {
1076         SQ_FREE(p,size);
1077 }