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