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