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