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