1 /*
2 * see copyright notice in squirrel.h
3 */
4
5 #include "../../../stdafx.h"
6
7 #include <math.h>
8 #include <squirrel.h>
9 #include "sqpcheader.h"
10 #include "sqopcodes.h"
11 #include "sqfuncproto.h"
12 #include "sqvm.h"
13 #include "sqclosure.h"
14 #include "sqstring.h"
15 #include "sqtable.h"
16 #include "squserdata.h"
17 #include "sqarray.h"
18 #include "sqclass.h"
19
20 #include "../../../string_func.h"
21
22 #include "../../../safeguards.h"
23
24 #define TOP() (_stack._vals[_top-1])
25
26 #define CLEARSTACK(_last_top) { if((_last_top) >= _top) ClearStack(_last_top); }
ClearStack(SQInteger last_top)27 void SQVM::ClearStack(SQInteger last_top)
28 {
29 SQObjectType tOldType;
30 SQObjectValue unOldVal;
31 while (last_top >= _top) {
32 SQObjectPtr &o = _stack._vals[last_top--];
33 tOldType = o._type;
34 unOldVal = o._unVal;
35 o._type = OT_NULL;
36 o._unVal.pUserPointer = nullptr;
37 __Release(tOldType,unOldVal);
38 }
39 }
40
BW_OP(SQUnsignedInteger op,SQObjectPtr & trg,const SQObjectPtr & o1,const SQObjectPtr & o2)41 bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
42 {
43 SQInteger res;
44 SQInteger i1 = _integer(o1), i2 = _integer(o2);
45 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER))
46 {
47 switch(op) {
48 case BW_AND: res = i1 & i2; break;
49 case BW_OR: res = i1 | i2; break;
50 case BW_XOR: res = i1 ^ i2; break;
51 case BW_SHIFTL: res = i1 << i2; break;
52 case BW_SHIFTR: res = i1 >> i2; break;
53 case BW_USHIFTR:res = (SQInteger)(*((SQUnsignedInteger*)&i1) >> i2); break;
54 default: { Raise_Error("internal vm error bitwise op failed"); return false; }
55 }
56 }
57 else { Raise_Error("bitwise op between '%s' and '%s'",GetTypeName(o1),GetTypeName(o2)); return false;}
58 trg = res;
59 return true;
60 }
61
ARITH_OP(SQUnsignedInteger op,SQObjectPtr & trg,const SQObjectPtr & o1,const SQObjectPtr & o2)62 bool SQVM::ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
63 {
64 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
65 if((type(o1)==OT_INTEGER) && (type(o2)==OT_INTEGER)) {
66 SQInteger res, i1 = _integer(o1), i2 = _integer(o2);
67 switch(op) {
68 case '+': res = i1 + i2; break;
69 case '-': res = i1 - i2; break;
70 case '/': if(i2 == 0) { Raise_Error("division by zero"); return false; }
71 res = i1 / i2;
72 break;
73 case '*': res = i1 * i2; break;
74 case '%': if(i2 == 0) { Raise_Error("modulo by zero"); return false; }
75 res = i1 % i2;
76 break;
77 default: res = 0xDEADBEEF;
78 }
79 trg = res;
80 }else{
81 SQFloat res, f1 = tofloat(o1), f2 = tofloat(o2);
82 switch(op) {
83 case '+': res = f1 + f2; break;
84 case '-': res = f1 - f2; break;
85 case '/': res = f1 / f2; break;
86 case '*': res = f1 * f2; break;
87 case '%': res = SQFloat(fmod((double)f1,(double)f2)); break;
88 default: res = 0x0f;
89 }
90 trg = res;
91 }
92 } else {
93 if(op == '+' && (type(o1) == OT_STRING || type(o2) == OT_STRING)){
94 if(!StringCat(o1, o2, trg)) return false;
95 }
96 else if(!ArithMetaMethod(op,o1,o2,trg)) {
97 Raise_Error("arith op %c on between '%s' and '%s'",(char)op,GetTypeName(o1),GetTypeName(o2)); return false;
98 }
99 }
100 return true;
101 }
102
SQVM(SQSharedState * ss)103 SQVM::SQVM(SQSharedState *ss)
104 {
105 _sharedstate=ss;
106 _suspended = SQFalse;
107 _suspended_target=-1;
108 _suspended_root = SQFalse;
109 _suspended_traps=0;
110 _foreignptr=nullptr;
111 _nnativecalls=0;
112 _lasterror = _null_;
113 _errorhandler = _null_;
114 _debughook = _null_;
115 _can_suspend = false;
116 _in_stackoverflow = false;
117 _ops_till_suspend = 0;
118 _callsstack = nullptr;
119 _callsstacksize = 0;
120 _alloccallsstacksize = 0;
121 _top = 0;
122 _stackbase = 0;
123 ci = nullptr;
124 INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);
125 }
126
Finalize()127 void SQVM::Finalize()
128 {
129 _roottable = _null_;
130 _lasterror = _null_;
131 _errorhandler = _null_;
132 _debughook = _null_;
133 temp_reg = _null_;
134 _callstackdata.resize(0);
135 SQInteger size=_stack.size();
136 for(SQInteger i=size - 1;i>=0;i--)
137 _stack[i]=_null_;
138 }
139
~SQVM()140 SQVM::~SQVM()
141 {
142 Finalize();
143 //sq_free(_callsstack,_alloccallsstacksize*sizeof(CallInfo));
144 REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
145 }
146
ArithMetaMethod(SQInteger op,const SQObjectPtr & o1,const SQObjectPtr & o2,SQObjectPtr & dest)147 bool SQVM::ArithMetaMethod(SQInteger op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)
148 {
149 SQMetaMethod mm;
150 switch(op){
151 case '+': mm=MT_ADD; break;
152 case '-': mm=MT_SUB; break;
153 case '/': mm=MT_DIV; break;
154 case '*': mm=MT_MUL; break;
155 case '%': mm=MT_MODULO; break;
156 default: mm = MT_ADD; assert(0); break; //shutup compiler
157 }
158 if(is_delegable(o1) && _delegable(o1)->_delegate) {
159 Push(o1);Push(o2);
160 return CallMetaMethod(_delegable(o1),mm,2,dest);
161 }
162 return false;
163 }
164
NEG_OP(SQObjectPtr & trg,const SQObjectPtr & o)165 bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
166 {
167
168 switch(type(o)) {
169 case OT_INTEGER:
170 trg = -_integer(o);
171 return true;
172 case OT_FLOAT:
173 trg = -_float(o);
174 return true;
175 case OT_TABLE:
176 case OT_USERDATA:
177 case OT_INSTANCE:
178 if(_delegable(o)->_delegate) {
179 Push(o);
180 if(CallMetaMethod(_delegable(o), MT_UNM, 1, temp_reg)) {
181 trg = temp_reg;
182 return true;
183 }
184 }
185 default:break; //shutup compiler
186 }
187 Raise_Error("attempt to negate a %s", GetTypeName(o));
188 return false;
189 }
190
191 #define _RET_SUCCEED(exp) { result = (exp); return true; }
ObjCmp(const SQObjectPtr & o1,const SQObjectPtr & o2,SQInteger & result)192 bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result)
193 {
194 if(type(o1)==type(o2)){
195 if(_rawval(o1)==_rawval(o2))_RET_SUCCEED(0);
196 SQObjectPtr res;
197 switch(type(o1)){
198 case OT_STRING:
199 _RET_SUCCEED(strcmp(_stringval(o1),_stringval(o2)));
200 case OT_INTEGER:
201 /* FS#3954: wrong integer comparison */
202 _RET_SUCCEED((_integer(o1)<_integer(o2))?-1:(_integer(o1)==_integer(o2))?0:1);
203 case OT_FLOAT:
204 _RET_SUCCEED((_float(o1)<_float(o2))?-1:1);
205 case OT_TABLE:
206 case OT_USERDATA:
207 case OT_INSTANCE:
208 if(_delegable(o1)->_delegate) {
209 Push(o1);Push(o2);
210 if(CallMetaMethod(_delegable(o1),MT_CMP,2,res)) {
211 if(type(res) != OT_INTEGER) {
212 Raise_Error("_cmp must return an integer");
213 return false;
214 }
215 _RET_SUCCEED(_integer(res))
216 }
217 }
218 FALLTHROUGH;
219 default:
220 _RET_SUCCEED( _userpointer(o1) < _userpointer(o2)?-1:1 );
221 }
222 assert(0);
223
224 }
225 else{
226 if(sq_isnumeric(o1) && sq_isnumeric(o2)){
227 if((type(o1)==OT_INTEGER) && (type(o2)==OT_FLOAT)) {
228 if( _integer(o1)==_float(o2) ) { _RET_SUCCEED(0); }
229 else if( _integer(o1)<_float(o2) ) { _RET_SUCCEED(-1); }
230 _RET_SUCCEED(1);
231 }
232 else{
233 if( _float(o1)==_integer(o2) ) { _RET_SUCCEED(0); }
234 else if( _float(o1)<_integer(o2) ) { _RET_SUCCEED(-1); }
235 _RET_SUCCEED(1);
236 }
237 }
238 else if(type(o1)==OT_NULL) {_RET_SUCCEED(-1);}
239 else if(type(o2)==OT_NULL) {_RET_SUCCEED(1);}
240 else { Raise_CompareError(o1,o2); return false; }
241
242 }
243 assert(0);
244 _RET_SUCCEED(0); //cannot happen
245 }
246
CMP_OP(CmpOP op,const SQObjectPtr & o1,const SQObjectPtr & o2,SQObjectPtr & res)247 bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)
248 {
249 SQInteger r;
250 if(ObjCmp(o1,o2,r)) {
251 switch(op) {
252 case CMP_G: res = (r > 0)?_true_:_false_; return true;
253 case CMP_GE: res = (r >= 0)?_true_:_false_; return true;
254 case CMP_L: res = (r < 0)?_true_:_false_; return true;
255 case CMP_LE: res = (r <= 0)?_true_:_false_; return true;
256
257 }
258 assert(0);
259 }
260 return false;
261 }
262
ToString(const SQObjectPtr & o,SQObjectPtr & res)263 void SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res)
264 {
265 char buf[64];
266 switch(type(o)) {
267 case OT_STRING:
268 res = o;
269 return;
270 case OT_FLOAT:
271 seprintf(buf, lastof(buf),"%g",_float(o));
272 break;
273 case OT_INTEGER:
274 seprintf(buf, lastof(buf),OTTD_PRINTF64,_integer(o));
275 break;
276 case OT_BOOL:
277 seprintf(buf, lastof(buf),_integer(o)?"true":"false");
278 break;
279 case OT_TABLE:
280 case OT_USERDATA:
281 case OT_INSTANCE:
282 if(_delegable(o)->_delegate) {
283 Push(o);
284 if(CallMetaMethod(_delegable(o),MT_TOSTRING,1,res)) {
285 if(type(res) == OT_STRING)
286 return;
287 //else keeps going to the default
288 }
289 }
290 FALLTHROUGH;
291 default:
292 seprintf(buf, lastof(buf),"(%s : 0x%p)",GetTypeName(o),(void*)_rawval(o));
293 }
294 res = SQString::Create(_ss(this),buf);
295 }
296
297
StringCat(const SQObjectPtr & str,const SQObjectPtr & obj,SQObjectPtr & dest)298 bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest)
299 {
300 SQObjectPtr a, b;
301 ToString(str, a);
302 ToString(obj, b);
303 SQInteger l = _string(a)->_len , ol = _string(b)->_len;
304 SQChar *s = _sp(l + ol + 1);
305 memcpy(s, _stringval(a), (size_t)l);
306 memcpy(s + l, _stringval(b), (size_t)ol);
307 dest = SQString::Create(_ss(this), _spval, l + ol);
308 return true;
309 }
310
TypeOf(const SQObjectPtr & obj1,SQObjectPtr & dest)311 void SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
312 {
313 if(is_delegable(obj1) && _delegable(obj1)->_delegate) {
314 Push(obj1);
315 if(CallMetaMethod(_delegable(obj1),MT_TYPEOF,1,dest))
316 return;
317 }
318 dest = SQString::Create(_ss(this),GetTypeName(obj1));
319 }
320
Init(SQVM * friendvm,SQInteger stacksize)321 bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)
322 {
323 _stack.resize(stacksize);
324 _alloccallsstacksize = 4;
325 _callstackdata.resize(_alloccallsstacksize);
326 _callsstacksize = 0;
327 _callsstack = &_callstackdata[0];
328 _stackbase = 0;
329 _top = 0;
330 if(!friendvm)
331 _roottable = SQTable::Create(_ss(this), 0);
332 else {
333 _roottable = friendvm->_roottable;
334 _errorhandler = friendvm->_errorhandler;
335 _debughook = friendvm->_debughook;
336 }
337
338 sq_base_register(this);
339 return true;
340 }
341
342 extern SQInstructionDesc g_InstrDesc[];
343
StartCall(SQClosure * closure,SQInteger target,SQInteger args,SQInteger stackbase,bool tailcall)344 bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQInteger stackbase,bool tailcall)
345 {
346 SQFunctionProto *func = _funcproto(closure->_function);
347
348 const SQInteger paramssize = func->_nparameters;
349 const SQInteger newtop = stackbase + func->_stacksize;
350 SQInteger nargs = args;
351 if (paramssize != nargs) {
352 SQInteger ndef = func->_ndefaultparams;
353 SQInteger diff;
354 if(ndef && nargs < paramssize && (diff = paramssize - nargs) <= ndef) {
355 for(SQInteger n = ndef - diff; n < ndef; n++) {
356 _stack._vals[stackbase + (nargs++)] = closure->_defaultparams[n];
357 }
358 }
359 else if(func->_varparams)
360 {
361 if (nargs < paramssize) {
362 Raise_Error("wrong number of parameters");
363 return false;
364 }
365 for(SQInteger n = 0; n < nargs - paramssize; n++) {
366 _vargsstack.push_back(_stack._vals[stackbase+paramssize+n]);
367 _stack._vals[stackbase+paramssize+n] = _null_;
368 }
369 }
370 else {
371 Raise_Error("wrong number of parameters");
372 return false;
373 }
374 }
375
376 if(type(closure->_env) == OT_WEAKREF) {
377 _stack._vals[stackbase] = _weakref(closure->_env)->_obj;
378 }
379
380 if (!tailcall) {
381 CallInfo lc = {};
382 lc._generator = nullptr;
383 lc._etraps = 0;
384 lc._prevstkbase = (SQInt32) ( stackbase - _stackbase );
385 lc._target = (SQInt32) target;
386 lc._prevtop = (SQInt32) (_top - _stackbase);
387 lc._ncalls = 1;
388 lc._root = SQFalse;
389 PUSH_CALLINFO(this, lc);
390 }
391 else {
392 ci->_ncalls++;
393 }
394 ci->_vargs.size = (SQInt32)(nargs - paramssize);
395 ci->_vargs.base = (SQInt32)(_vargsstack.size()-(ci->_vargs.size));
396 ci->_closure = closure;
397 ci->_literals = func->_literals;
398 ci->_ip = func->_instructions;
399 //grows the stack if needed
400 if (((SQUnsignedInteger)newtop + (func->_stacksize<<1)) > _stack.size()) {
401 _stack.resize(_stack.size() + (func->_stacksize<<1));
402 }
403
404 _top = newtop;
405 _stackbase = stackbase;
406 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
407 CallDebugHook('c');
408 return true;
409 }
410
Return(SQInteger _arg0,SQInteger _arg1,SQObjectPtr & retval)411 bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval)
412 {
413 if (type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
414 for(SQInteger i=0;i<ci->_ncalls;i++)
415 CallDebugHook('r');
416
417 SQBool broot = ci->_root;
418 SQInteger last_top = _top;
419 SQInteger target = ci->_target;
420 SQInteger oldstackbase = _stackbase;
421 _stackbase -= ci->_prevstkbase;
422 _top = _stackbase + ci->_prevtop;
423 if(ci->_vargs.size) PopVarArgs(ci->_vargs);
424 POP_CALLINFO(this);
425 if (broot) {
426 if (_arg0 != MAX_FUNC_STACKSIZE) retval = _stack._vals[oldstackbase+_arg1];
427 else retval = _null_;
428 }
429 else {
430 if(target != -1) { //-1 is when a class contructor ret value has to be ignored
431 if (_arg0 != MAX_FUNC_STACKSIZE)
432 STK(target) = _stack._vals[oldstackbase+_arg1];
433 else
434 STK(target) = _null_;
435 }
436 }
437
438 while (last_top > oldstackbase) _stack._vals[last_top--].Null();
439 assert(oldstackbase >= _stackbase);
440 return broot != 0;
441 }
442
443 #define _RET_ON_FAIL(exp) { if(!exp) return false; }
444
LOCAL_INC(SQInteger op,SQObjectPtr & target,SQObjectPtr & a,SQObjectPtr & incr)445 bool SQVM::LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
446 {
447 _RET_ON_FAIL(ARITH_OP( op , target, a, incr));
448 a = target;
449 return true;
450 }
451
PLOCAL_INC(SQInteger op,SQObjectPtr & target,SQObjectPtr & a,SQObjectPtr & incr)452 bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
453 {
454 SQObjectPtr trg;
455 _RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
456 target = a;
457 a = trg;
458 return true;
459 }
460
DerefInc(SQInteger op,SQObjectPtr & target,SQObjectPtr & self,SQObjectPtr & key,SQObjectPtr & incr,bool postfix)461 bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix)
462 {
463 SQObjectPtr tmp, tself = self, tkey = key;
464 if (!Get(tself, tkey, tmp, false, true)) { Raise_IdxError(tkey); return false; }
465 _RET_ON_FAIL(ARITH_OP( op , target, tmp, incr))
466 Set(tself, tkey, target,true);
467 if (postfix) target = tmp;
468 return true;
469 }
470
471 #define arg0 (_i_._arg0)
472 #define arg1 (_i_._arg1)
473 #define sarg1 (*(const_cast<SQInt32 *>(&_i_._arg1)))
474 #define arg2 (_i_._arg2)
475 #define arg3 (_i_._arg3)
476 #define sarg3 ((SQInteger)*((const signed char *)&_i_._arg3))
477
Suspend()478 SQRESULT SQVM::Suspend()
479 {
480 if (_suspended)
481 return sq_throwerror(this, "cannot suspend an already suspended vm");
482 if (_nnativecalls!=2)
483 return sq_throwerror(this, "cannot suspend through native calls/metamethods");
484 return SQ_SUSPEND_FLAG;
485 }
486
PopVarArgs(VarArgs & vargs)487 void SQVM::PopVarArgs(VarArgs &vargs)
488 {
489 for(SQInteger n = 0; n< vargs.size; n++)
490 _vargsstack.pop_back();
491 }
492
493 #define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; }
FOREACH_OP(SQObjectPtr & o1,SQObjectPtr & o2,SQObjectPtr & o3,SQObjectPtr & o4,SQInteger arg_2,int exitpos,int & jump)494 bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
495 &o3,SQObjectPtr &o4,SQInteger arg_2,int exitpos,int &jump)
496 {
497 SQInteger nrefidx;
498 switch(type(o1)) {
499 case OT_TABLE:
500 if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(exitpos);
501 o4 = (SQInteger)nrefidx; _FINISH(1);
502 case OT_ARRAY:
503 if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(exitpos);
504 o4 = (SQInteger) nrefidx; _FINISH(1);
505 case OT_STRING:
506 if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
507 o4 = (SQInteger)nrefidx; _FINISH(1);
508 case OT_CLASS:
509 if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
510 o4 = (SQInteger)nrefidx; _FINISH(1);
511 case OT_USERDATA:
512 case OT_INSTANCE:
513 if(_delegable(o1)->_delegate) {
514 SQObjectPtr itr;
515 Push(o1);
516 Push(o4);
517 if(CallMetaMethod(_delegable(o1), MT_NEXTI, 2, itr)){
518 o4 = o2 = itr;
519 if(type(itr) == OT_NULL) _FINISH(exitpos);
520 if(!Get(o1, itr, o3, false,false)) {
521 Raise_Error("_nexti returned an invalid idx");
522 return false;
523 }
524 _FINISH(1);
525 }
526 Raise_Error("_nexti failed");
527 return false;
528 }
529 break;
530 case OT_GENERATOR:
531 if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(exitpos);
532 if(_generator(o1)->_state == SQGenerator::eSuspended) {
533 SQInteger idx = 0;
534 if(type(o4) == OT_INTEGER) {
535 idx = _integer(o4) + 1;
536 }
537 o2 = idx;
538 o4 = idx;
539 _generator(o1)->Resume(this, arg_2+1);
540 _FINISH(0);
541 }
542 FALLTHROUGH;
543 default:
544 Raise_Error("cannot iterate %s", GetTypeName(o1));
545 }
546 return false; //cannot be hit(just to avoid warnings)
547 }
548
DELEGATE_OP(SQObjectPtr & trg,SQObjectPtr & o1,SQObjectPtr & o2)549 bool SQVM::DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2)
550 {
551 if(type(o1) != OT_TABLE) { Raise_Error("delegating a '%s'", GetTypeName(o1)); return false; }
552 switch(type(o2)) {
553 case OT_TABLE:
554 if(!_table(o1)->SetDelegate(_table(o2))){
555 Raise_Error("delegate cycle detected");
556 return false;
557 }
558 break;
559 case OT_NULL:
560 _table(o1)->SetDelegate(nullptr);
561 break;
562 default:
563 Raise_Error("using '%s' as delegate", GetTypeName(o2));
564 return false;
565 break;
566 }
567 trg = o1;
568 return true;
569 }
570 #define COND_LITERAL (arg3!=0?ci->_literals[arg1]:STK(arg1))
571
572 #define _GUARD(exp) { if(!exp) { Raise_Error(_lasterror); SQ_THROW();} }
573
574 #define SQ_THROW() { goto exception_trap; }
575
CLOSURE_OP(SQObjectPtr & target,SQFunctionProto * func)576 bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
577 {
578 SQInteger nouters;
579 SQClosure *closure = SQClosure::Create(_ss(this), func);
580 if((nouters = func->_noutervalues)) {
581 closure->_outervalues.reserve(nouters);
582 for(SQInteger i = 0; i<nouters; i++) {
583 SQOuterVar &v = func->_outervalues[i];
584 switch(v._type){
585 case otSYMBOL:
586 closure->_outervalues.push_back(_null_);
587 if(!Get(_stack._vals[_stackbase]/*STK(0)*/, v._src, closure->_outervalues.top(), false,true))
588 {Raise_IdxError(v._src); return false; }
589 break;
590 case otLOCAL:
591 closure->_outervalues.push_back(_stack._vals[_stackbase+_integer(v._src)]);
592 break;
593 case otOUTER:
594 closure->_outervalues.push_back(_closure(ci->_closure)->_outervalues[_integer(v._src)]);
595 break;
596 }
597 }
598 }
599 SQInteger ndefparams;
600 if((ndefparams = func->_ndefaultparams)) {
601 closure->_defaultparams.reserve(ndefparams);
602 for(SQInteger i = 0; i < ndefparams; i++) {
603 SQInteger spos = func->_defaultparams[i];
604 closure->_defaultparams.push_back(_stack._vals[_stackbase + spos]);
605 }
606 }
607 target = closure;
608 return true;
609
610 }
611
GETVARGV_OP(SQObjectPtr & target,SQObjectPtr & index,CallInfo * ci)612 bool SQVM::GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &index,CallInfo *ci)
613 {
614 if(ci->_vargs.size == 0) {
615 Raise_Error("the function doesn't have var args");
616 return false;
617 }
618 if(!sq_isnumeric(index)){
619 Raise_Error("indexing 'vargv' with %s",GetTypeName(index));
620 return false;
621 }
622 SQInteger idx = tointeger(index);
623 if(idx < 0 || idx >= ci->_vargs.size){ Raise_Error("vargv index out of range"); return false; }
624 target = _vargsstack[ci->_vargs.base+idx];
625 return true;
626 }
627
CLASS_OP(SQObjectPtr & target,SQInteger baseclass,SQInteger attributes)628 bool SQVM::CLASS_OP(SQObjectPtr &target,SQInteger baseclass,SQInteger attributes)
629 {
630 SQClass *base = nullptr;
631 SQObjectPtr attrs;
632 if(baseclass != -1) {
633 if(type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { Raise_Error("trying to inherit from a %s",GetTypeName(_stack._vals[_stackbase+baseclass])); return false; }
634 base = _class(_stack._vals[_stackbase + baseclass]);
635 }
636 if(attributes != MAX_FUNC_STACKSIZE) {
637 attrs = _stack._vals[_stackbase+attributes];
638 }
639 target = SQClass::Create(_ss(this),base);
640 if(type(_class(target)->_metamethods[MT_INHERITED]) != OT_NULL) {
641 int nparams = 2;
642 SQObjectPtr ret;
643 Push(target); Push(attrs);
644 Call(_class(target)->_metamethods[MT_INHERITED],nparams,_top - nparams, ret, false, false);
645 Pop(nparams);
646 }
647 _class(target)->_attributes = attrs;
648 return true;
649 }
650
651
652
IsEqual(SQObjectPtr & o1,SQObjectPtr & o2,bool & res)653 bool SQVM::IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res)
654 {
655 if(type(o1) == type(o2)) {
656 res = ((_rawval(o1) == _rawval(o2)));
657 }
658 else {
659 if(sq_isnumeric(o1) && sq_isnumeric(o2)) {
660 SQInteger cmpres;
661 if(!ObjCmp(o1, o2,cmpres)) return false;
662 res = (cmpres == 0);
663 }
664 else {
665 res = false;
666 }
667 }
668 return true;
669 }
670
IsFalse(SQObjectPtr & o)671 bool SQVM::IsFalse(SQObjectPtr &o)
672 {
673 if(((type(o) & SQOBJECT_CANBEFALSE) && ( (type(o) == OT_FLOAT) && (_float(o) == SQFloat(0.0)) ))
674 || (_integer(o) == 0) ) { //OT_NULL|OT_INTEGER|OT_BOOL
675 return true;
676 }
677 return false;
678 }
679
GETPARENT_OP(SQObjectPtr & o,SQObjectPtr & target)680 bool SQVM::GETPARENT_OP(SQObjectPtr &o,SQObjectPtr &target)
681 {
682 switch(type(o)) {
683 case OT_TABLE: target = _table(o)->_delegate?SQObjectPtr(_table(o)->_delegate):_null_;
684 break;
685 case OT_CLASS: target = _class(o)->_base?_class(o)->_base:_null_;
686 break;
687 default:
688 Raise_Error("the %s type doesn't have a parent slot", GetTypeName(o));
689 return false;
690 }
691 return true;
692 }
693
Execute(SQObjectPtr & closure,SQInteger target,SQInteger nargs,SQInteger stackbase,SQObjectPtr & outres,SQBool raiseerror,ExecutionType et)694 bool SQVM::Execute(SQObjectPtr &closure, SQInteger target, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et)
695 {
696 if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error("Native stack overflow"); return false; }
697 _nnativecalls++;
698 AutoDec ad(&_nnativecalls);
699 SQInteger traps = 0;
700 //temp_reg vars for OP_CALL
701 SQInteger ct_target;
702 SQInteger ct_stackbase;
703 bool ct_tailcall;
704
705 switch(et) {
706 case ET_CALL: {
707 SQInteger last_top = _top;
708 temp_reg = closure;
709 if(!StartCall(_closure(temp_reg), _top - nargs, nargs, stackbase, false)) {
710 //call the handler if there are no calls in the stack, if not relies on the previous node
711 if(ci == nullptr) CallErrorHandler(_lasterror);
712 return false;
713 }
714 if (_funcproto(_closure(temp_reg)->_function)->_bgenerator) {
715 //SQFunctionProto *f = _funcproto(_closure(temp_reg)->_function);
716 SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(temp_reg));
717 _GUARD(gen->Yield(this));
718 Return(1, ci->_target, temp_reg);
719 outres = gen;
720 CLEARSTACK(last_top);
721 return true;
722 }
723 ci->_root = SQTrue;
724 }
725 break;
726 case ET_RESUME_GENERATOR: _generator(closure)->Resume(this, target); ci->_root = SQTrue; traps += ci->_etraps; break;
727 case ET_RESUME_VM:
728 case ET_RESUME_THROW_VM:
729 traps = _suspended_traps;
730 ci->_root = _suspended_root;
731 ci->_vargs = _suspend_varargs;
732 _suspended = SQFalse;
733 if(et == ET_RESUME_THROW_VM) { SQ_THROW(); }
734 break;
735 case ET_RESUME_OPENTTD:
736 traps = _suspended_traps;
737 _suspended = SQFalse;
738 break;
739 }
740
741 exception_restore:
742 //
743 {
744 for(;;)
745 {
746 DecreaseOps(1);
747 if (ShouldSuspend()) { _suspended = SQTrue; _suspended_traps = traps; return true; }
748
749 const SQInstruction &_i_ = *ci->_ip++;
750 //dumpstack(_stackbase);
751 //printf("%s %d %d %d %d\n",g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3);
752 switch(_i_.op)
753 {
754 case _OP_LINE:
755 if(type(_debughook) != OT_NULL && _rawval(_debughook) != _rawval(ci->_closure))
756 CallDebugHook('l',arg1);
757 continue;
758 case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;
759 case _OP_LOADINT: TARGET = (SQInteger)arg1; continue;
760 case _OP_LOADFLOAT: TARGET = *((const SQFloat *)&arg1); continue;
761 case _OP_DLOAD: TARGET = ci->_literals[arg1]; STK(arg2) = ci->_literals[arg3];continue;
762 case _OP_TAILCALL:
763 temp_reg = STK(arg1);
764 if (type(temp_reg) == OT_CLOSURE && !_funcproto(_closure(temp_reg)->_function)->_bgenerator){
765 ct_tailcall = true;
766 if(ci->_vargs.size) PopVarArgs(ci->_vargs);
767 for (SQInteger i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);
768 ct_target = ci->_target;
769 ct_stackbase = _stackbase;
770 goto common_call;
771 }
772 FALLTHROUGH;
773 case _OP_CALL: {
774 ct_tailcall = false;
775 ct_target = arg0;
776 temp_reg = STK(arg1);
777 ct_stackbase = _stackbase+arg2;
778
779 common_call:
780 SQObjectPtr clo = temp_reg;
781 SQInteger last_top = _top;
782 switch (type(clo)) {
783 case OT_CLOSURE:{
784 _GUARD(StartCall(_closure(clo), ct_target, arg3, ct_stackbase, ct_tailcall));
785 if (_funcproto(_closure(clo)->_function)->_bgenerator) {
786 SQGenerator *gen = SQGenerator::Create(_ss(this), _closure(clo));
787 _GUARD(gen->Yield(this));
788 Return(1, ct_target, clo);
789 STK(ct_target) = gen;
790 }
791 CLEARSTACK(last_top);
792 }
793 continue;
794 case OT_NATIVECLOSURE: {
795 bool suspend;
796 _suspended_target = ct_target;
797 try {
798 _GUARD(CallNative(_nativeclosure(clo), arg3, ct_stackbase, clo,suspend));
799 } catch (...) {
800 _suspended = SQTrue;
801 _suspended_target = ct_target;
802 _suspended_root = ci->_root;
803 _suspended_traps = traps;
804 _suspend_varargs = ci->_vargs;
805 throw;
806 }
807 if(suspend){
808 _suspended = SQTrue;
809 _suspended_target = ct_target;
810 _suspended_root = ci->_root;
811 _suspended_traps = traps;
812 _suspend_varargs = ci->_vargs;
813 outres = clo;
814 return true;
815 }
816 if(ct_target != -1) { //skip return value for constructors
817 STK(ct_target) = clo;
818 }
819 }
820 continue;
821 case OT_CLASS:{
822 SQObjectPtr inst;
823 _GUARD(CreateClassInstance(_class(clo),inst,temp_reg));
824 STK(ct_target) = inst;
825 ct_target = -1; //fakes return value target so that is not overwritten by the constructor
826 if(type(temp_reg) != OT_NULL) {
827 _stack._vals[ct_stackbase] = inst;
828 goto common_call; //hard core spaghetti code(reissues the OP_CALL to invoke the constructor)
829 }
830 }
831 break;
832 case OT_TABLE:
833 case OT_USERDATA:
834 case OT_INSTANCE:
835 {
836 Push(clo);
837 for (SQInteger i = 0; i < arg3; i++) Push(STK(arg2 + i));
838 if (_delegable(clo) && CallMetaMethod(_delegable(clo), MT_CALL, arg3+1, clo)){
839 STK(ct_target) = clo;
840 break;
841 }
842 Raise_Error("attempt to call '%s'", GetTypeName(clo));
843 SQ_THROW();
844 }
845 default:
846 Raise_Error("attempt to call '%s'", GetTypeName(clo));
847 SQ_THROW();
848 }
849 }
850 continue;
851 case _OP_PREPCALL:
852 case _OP_PREPCALLK:
853 {
854 SQObjectPtr &key = _i_.op == _OP_PREPCALLK?(ci->_literals)[arg1]:STK(arg1);
855 SQObjectPtr &o = STK(arg2);
856 if (!Get(o, key, temp_reg,false,true)) {
857 if(type(o) == OT_CLASS) { //hack?
858 if(_class_ddel->Get(key,temp_reg)) {
859 STK(arg3) = o;
860 TARGET = temp_reg;
861 continue;
862 }
863 }
864 { Raise_IdxError(key); SQ_THROW();}
865 }
866
867 STK(arg3) = type(o) == OT_CLASS?STK(0):o;
868 TARGET = temp_reg;
869 }
870 continue;
871 case _OP_SCOPE_END:
872 {
873 SQInteger from = arg0;
874 SQInteger count = arg1 - arg0 + 2;
875 /* When 'return' is executed, it happens that the stack is already cleaned
876 * (by Return()), but this OP-code is still executed. So check for this
877 * situation, and ignore the cleanup */
878 if (_stackbase + count + from <= _top) {
879 while (--count >= 0) _stack._vals[_stackbase + count + from].Null();
880 }
881 } continue;
882 case _OP_GETK:
883 if (!Get(STK(arg2), ci->_literals[arg1], temp_reg, false,true)) { Raise_IdxError(ci->_literals[arg1]); SQ_THROW();}
884 TARGET = temp_reg;
885 continue;
886 case _OP_MOVE: TARGET = STK(arg1); continue;
887 case _OP_NEWSLOT:
888 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),false));
889 if(arg0 != arg3) TARGET = STK(arg3);
890 continue;
891 case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue;
892 case _OP_SET:
893 if (!Set(STK(arg1), STK(arg2), STK(arg3),true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
894 if (arg0 != arg3) TARGET = STK(arg3);
895 continue;
896 case _OP_GET:
897 if (!Get(STK(arg1), STK(arg2), temp_reg, false,true)) { Raise_IdxError(STK(arg2)); SQ_THROW(); }
898 TARGET = temp_reg;
899 continue;
900 case _OP_EQ:{
901 bool res;
902 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
903 TARGET = res?_true_:_false_;
904 }continue;
905 case _OP_NE:{
906 bool res;
907 if(!IsEqual(STK(arg2),COND_LITERAL,res)) { SQ_THROW(); }
908 TARGET = (!res)?_true_:_false_;
909 } continue;
910 case _OP_ARITH: _GUARD(ARITH_OP( arg3 , temp_reg, STK(arg2), STK(arg1))); TARGET = temp_reg; continue;
911 case _OP_BITW: _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;
912 case _OP_RETURN:
913 if(ci->_generator) {
914 ci->_generator->Kill();
915 }
916 if(Return(arg0, arg1, temp_reg)){
917 assert(traps==0);
918 outres = temp_reg;
919 return true;
920 }
921 continue;
922 case _OP_LOADNULLS:{ for(SQInt32 n=0; n < arg1; n++) STK(arg0+n) = _null_; }continue;
923 case _OP_LOADROOTTABLE: TARGET = _roottable; continue;
924 case _OP_LOADBOOL: TARGET = arg1?_true_:_false_; continue;
925 case _OP_DMOVE: STK(arg0) = STK(arg1); STK(arg2) = STK(arg3); continue;
926 case _OP_JMP: ci->_ip += (sarg1); continue;
927 case _OP_JNZ: if(!IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
928 case _OP_JZ: if(IsFalse(STK(arg0))) ci->_ip+=(sarg1); continue;
929 case _OP_LOADFREEVAR: TARGET = _closure(ci->_closure)->_outervalues[arg1]; continue;
930 case _OP_VARGC: TARGET = SQInteger(ci->_vargs.size); continue;
931 case _OP_GETVARGV:
932 if(!GETVARGV_OP(TARGET,STK(arg1),ci)) { SQ_THROW(); }
933 continue;
934 case _OP_NEWTABLE: TARGET = SQTable::Create(_ss(this), arg1); continue;
935 case _OP_NEWARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue;
936 case _OP_APPENDARRAY: _array(STK(arg0))->Append(COND_LITERAL); continue;
937 case _OP_GETPARENT: _GUARD(GETPARENT_OP(STK(arg1),TARGET)); continue;
938 case _OP_COMPARITH: _GUARD(DerefInc(arg3, TARGET, STK((((SQUnsignedInteger)arg1&0xFFFF0000)>>16)), STK(arg2), STK(arg1&0x0000FFFF), false)); continue;
939 case _OP_COMPARITHL: _GUARD(LOCAL_INC(arg3, TARGET, STK(arg1), STK(arg2))); continue;
940 case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, false));} continue;
941 case _OP_INCL: {SQObjectPtr o(sarg3); _GUARD(LOCAL_INC('+',TARGET, STK(arg1), o));} continue;
942 case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(DerefInc('+',TARGET, STK(arg1), STK(arg2), o, true));} continue;
943 case _OP_PINCL: {SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o));} continue;
944 case _OP_CMP: _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET)) continue;
945 case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, true,false)?_true_:_false_;continue;
946 case _OP_INSTANCEOF:
947 if(type(STK(arg1)) != OT_CLASS || type(STK(arg2)) != OT_INSTANCE)
948 {Raise_Error("cannot apply instanceof between a %s and a %s",GetTypeName(STK(arg1)),GetTypeName(STK(arg2))); SQ_THROW();}
949 TARGET = _instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?_true_:_false_;
950 continue;
951 case _OP_AND:
952 if(IsFalse(STK(arg2))) {
953 TARGET = STK(arg2);
954 ci->_ip += (sarg1);
955 }
956 continue;
957 case _OP_OR:
958 if(!IsFalse(STK(arg2))) {
959 TARGET = STK(arg2);
960 ci->_ip += (sarg1);
961 }
962 continue;
963 case _OP_NEG: _GUARD(NEG_OP(TARGET,STK(arg1))); continue;
964 case _OP_NOT: TARGET = (IsFalse(STK(arg1))?_true_:_false_); continue;
965 case _OP_BWNOT:
966 if(type(STK(arg1)) == OT_INTEGER) {
967 SQInteger t = _integer(STK(arg1));
968 TARGET = SQInteger(~t);
969 continue;
970 }
971 Raise_Error("attempt to perform a bitwise op on a %s", GetTypeName(STK(arg1)));
972 SQ_THROW();
973 case _OP_CLOSURE: {
974 SQClosure *c = ci->_closure._unVal.pClosure;
975 SQFunctionProto *fp = c->_function._unVal.pFunctionProto;
976 if(!CLOSURE_OP(TARGET,fp->_functions[arg1]._unVal.pFunctionProto)) { SQ_THROW(); }
977 continue;
978 }
979 case _OP_YIELD:{
980 if(ci->_generator) {
981 if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1);
982 _GUARD(ci->_generator->Yield(this));
983 traps -= ci->_etraps;
984 if(sarg1 != MAX_FUNC_STACKSIZE) STK(arg1) = temp_reg;
985 }
986 else { Raise_Error("trying to yield a '%s',only genenerator can be yielded", GetTypeName(ci->_closure)); SQ_THROW();}
987 if(Return(arg0, arg1, temp_reg)){
988 assert(traps == 0);
989 outres = temp_reg;
990 return true;
991 }
992
993 }
994 continue;
995 case _OP_RESUME:
996 if(type(STK(arg1)) != OT_GENERATOR){ Raise_Error("trying to resume a '%s',only genenerator can be resumed", GetTypeName(STK(arg1))); SQ_THROW();}
997 _GUARD(_generator(STK(arg1))->Resume(this, arg0));
998 traps += ci->_etraps;
999 continue;
1000 case _OP_FOREACH:{ int tojump;
1001 _GUARD(FOREACH_OP(STK(arg0),STK(arg2),STK(arg2+1),STK(arg2+2),arg2,sarg1,tojump));
1002 ci->_ip += tojump; }
1003 continue;
1004 case _OP_POSTFOREACH:
1005 assert(type(STK(arg0)) == OT_GENERATOR);
1006 if(_generator(STK(arg0))->_state == SQGenerator::eDead)
1007 ci->_ip += (sarg1 - 1);
1008 continue;
1009 case _OP_DELEGATE: _GUARD(DELEGATE_OP(TARGET,STK(arg1),STK(arg2))); continue;
1010 case _OP_CLONE:
1011 if(!Clone(STK(arg1), TARGET))
1012 { Raise_Error("cloning a %s", GetTypeName(STK(arg1))); SQ_THROW();}
1013 continue;
1014 case _OP_TYPEOF: TypeOf(STK(arg1), TARGET); continue;
1015 case _OP_PUSHTRAP:{
1016 SQInstruction *_iv = _funcproto(_closure(ci->_closure)->_function)->_instructions;
1017 _etraps.push_back(SQExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++;
1018 ci->_etraps++;
1019 }
1020 continue;
1021 case _OP_POPTRAP: {
1022 for(SQInteger i = 0; i < arg0; i++) {
1023 _etraps.pop_back(); traps--;
1024 ci->_etraps--;
1025 }
1026 }
1027 continue;
1028 case _OP_THROW: Raise_Error(TARGET); SQ_THROW();
1029 case _OP_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;
1030 case _OP_NEWSLOTA:
1031 bool bstatic = (arg0&NEW_SLOT_STATIC_FLAG) != 0;
1032 if(type(STK(arg1)) == OT_CLASS) {
1033 if(type(_class(STK(arg1))->_metamethods[MT_NEWMEMBER]) != OT_NULL ) {
1034 Push(STK(arg1)); Push(STK(arg2)); Push(STK(arg3));
1035 Push((arg0&NEW_SLOT_ATTRIBUTES_FLAG) ? STK(arg2-1) : _null_);
1036 Push(bstatic);
1037 int nparams = 5;
1038 if(Call(_class(STK(arg1))->_metamethods[MT_NEWMEMBER], nparams, _top - nparams, temp_reg,SQFalse,SQFalse)) {
1039 Pop(nparams);
1040 continue;
1041 }
1042 }
1043 }
1044 _GUARD(NewSlot(STK(arg1), STK(arg2), STK(arg3),bstatic));
1045 if((arg0&NEW_SLOT_ATTRIBUTES_FLAG)) {
1046 _class(STK(arg1))->SetAttributes(STK(arg2),STK(arg2-1));
1047 }
1048 continue;
1049 }
1050
1051 }
1052 }
1053 exception_trap:
1054 {
1055 SQObjectPtr currerror = _lasterror;
1056 // dumpstack(_stackbase);
1057 SQInteger n = 0;
1058 SQInteger last_top = _top;
1059 if(ci) {
1060 if(_ss(this)->_notifyallexceptions) CallErrorHandler(currerror);
1061
1062 if(traps) {
1063 do {
1064 if(ci->_etraps > 0) {
1065 SQExceptionTrap &et = _etraps.top();
1066 ci->_ip = et._ip;
1067 _top = et._stacksize;
1068 _stackbase = et._stackbase;
1069 _stack._vals[_stackbase+et._extarget] = currerror;
1070 _etraps.pop_back(); traps--; ci->_etraps--;
1071 CLEARSTACK(last_top);
1072 goto exception_restore;
1073 }
1074 //if is a native closure
1075 if(type(ci->_closure) != OT_CLOSURE && n)
1076 break;
1077 if(ci->_generator) ci->_generator->Kill();
1078 PopVarArgs(ci->_vargs);
1079 POP_CALLINFO(this);
1080 n++;
1081 } while(_callsstacksize);
1082 }
1083 else {
1084 //call the hook
1085 if(raiseerror && !_ss(this)->_notifyallexceptions)
1086 CallErrorHandler(currerror);
1087 }
1088 //remove call stack until a C function is found or the cstack is empty
1089 if(ci) do {
1090 SQBool exitafterthisone = ci->_root;
1091 if(ci->_generator) ci->_generator->Kill();
1092 _stackbase -= ci->_prevstkbase;
1093 _top = _stackbase + ci->_prevtop;
1094 PopVarArgs(ci->_vargs);
1095 POP_CALLINFO(this);
1096 if( (ci && type(ci->_closure) != OT_CLOSURE) || exitafterthisone) break;
1097 } while(_callsstacksize);
1098
1099 CLEARSTACK(last_top);
1100 }
1101 _lasterror = currerror;
1102 return false;
1103 }
1104 NOT_REACHED();
1105 }
1106
CreateClassInstance(SQClass * theclass,SQObjectPtr & inst,SQObjectPtr & constructor)1107 bool SQVM::CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor)
1108 {
1109 inst = theclass->CreateInstance();
1110 if(!theclass->Get(_ss(this)->_constructoridx,constructor)) {
1111 constructor = _null_;
1112 }
1113 return true;
1114 }
1115
CallErrorHandler(SQObjectPtr & error)1116 void SQVM::CallErrorHandler(SQObjectPtr &error)
1117 {
1118 if(type(_errorhandler) != OT_NULL) {
1119 SQObjectPtr out;
1120 Push(_roottable); Push(error);
1121 Call(_errorhandler, 2, _top-2, out,SQFalse,SQFalse);
1122 Pop(2);
1123 }
1124 }
1125
CallDebugHook(SQInteger type,SQInteger forcedline)1126 void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)
1127 {
1128 SQObjectPtr temp_reg;
1129 SQInteger nparams=5;
1130 SQFunctionProto *func=_funcproto(_closure(ci->_closure)->_function);
1131 Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);
1132 Call(_debughook,nparams,_top-nparams,temp_reg,SQFalse,SQFalse);
1133 Pop(nparams);
1134 }
1135
CallNative(SQNativeClosure * nclosure,SQInteger nargs,SQInteger stackbase,SQObjectPtr & retval,bool & suspend)1136 bool SQVM::CallNative(SQNativeClosure *nclosure,SQInteger nargs,SQInteger stackbase,SQObjectPtr &retval,bool &suspend)
1137 {
1138 if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { Raise_Error("Native stack overflow"); return false; }
1139 SQInteger nparamscheck = nclosure->_nparamscheck;
1140 if(((nparamscheck > 0) && (nparamscheck != nargs))
1141 || ((nparamscheck < 0) && (nargs < (-nparamscheck)))) {
1142 Raise_Error("wrong number of parameters");
1143 return false;
1144 }
1145
1146 SQInteger tcs;
1147 if((tcs = nclosure->_typecheck.size())) {
1148 for(SQInteger i = 0; i < nargs && i < tcs; i++)
1149 if((nclosure->_typecheck._vals[i] != -1) && !(type(_stack._vals[stackbase+i]) & nclosure->_typecheck[i])) {
1150 Raise_ParamTypeError(i,nclosure->_typecheck._vals[i],type(_stack._vals[stackbase+i]));
1151 return false;
1152 }
1153 }
1154 _nnativecalls++;
1155 if ((_top + MIN_STACK_OVERHEAD) > (SQInteger)_stack.size()) {
1156 _stack.resize(_stack.size() + (MIN_STACK_OVERHEAD<<1));
1157 }
1158 SQInteger oldtop = _top;
1159 SQInteger oldstackbase = _stackbase;
1160 _top = stackbase + nargs;
1161 CallInfo lci = {};
1162 lci._closure = nclosure;
1163 lci._generator = nullptr;
1164 lci._etraps = 0;
1165 lci._prevstkbase = (SQInt32) (stackbase - _stackbase);
1166 lci._ncalls = 1;
1167 lci._prevtop = (SQInt32) (oldtop - oldstackbase);
1168 PUSH_CALLINFO(this, lci);
1169 _stackbase = stackbase;
1170 //push free variables
1171 SQInteger outers = nclosure->_outervalues.size();
1172 for (SQInteger i = 0; i < outers; i++) {
1173 Push(nclosure->_outervalues[i]);
1174 }
1175
1176 if(type(nclosure->_env) == OT_WEAKREF) {
1177 _stack[stackbase] = _weakref(nclosure->_env)->_obj;
1178 }
1179
1180
1181 /* Store the call stack size, so we can restore that */
1182 SQInteger cstksize = _callsstacksize;
1183 SQInteger ret;
1184 try {
1185 SQBool can_suspend = this->_can_suspend;
1186 this->_can_suspend = false;
1187 ret = (nclosure->_function)(this);
1188 this->_can_suspend = can_suspend;
1189 } catch (...) {
1190 _nnativecalls--;
1191 suspend = false;
1192
1193 _callsstacksize = cstksize;
1194 _stackbase = oldstackbase;
1195 _top = oldtop;
1196
1197 POP_CALLINFO(this);
1198
1199 while(oldtop > _stackbase + stackbase) _stack._vals[oldtop--].Null();
1200 throw;
1201 }
1202
1203 _callsstacksize = cstksize;
1204
1205 _nnativecalls--;
1206 suspend = false;
1207 if( ret == SQ_SUSPEND_FLAG) suspend = true;
1208 else if (ret < 0) {
1209 _stackbase = oldstackbase;
1210 _top = oldtop;
1211 POP_CALLINFO(this);
1212 while(oldtop > _stackbase + stackbase) _stack._vals[oldtop--].Null();
1213 Raise_Error(_lasterror);
1214 return false;
1215 }
1216
1217 if (ret != 0){ retval = TOP(); TOP().Null(); }
1218 else { retval = _null_; }
1219 _stackbase = oldstackbase;
1220 _top = oldtop;
1221 POP_CALLINFO(this);
1222 while(oldtop > _stackbase + stackbase) _stack._vals[oldtop--].Null();
1223 return true;
1224 }
1225
Get(const SQObjectPtr & self,const SQObjectPtr & key,SQObjectPtr & dest,bool raw,bool fetchroot)1226 bool SQVM::Get(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw, bool fetchroot)
1227 {
1228 switch(type(self)){
1229 case OT_TABLE:
1230 if(_table(self)->Get(key,dest))return true;
1231 break;
1232 case OT_ARRAY:
1233 if(sq_isnumeric(key)){
1234 return _array(self)->Get(tointeger(key),dest);
1235 }
1236 break;
1237 case OT_INSTANCE:
1238 if(_instance(self)->Get(key,dest)) return true;
1239 break;
1240 default:break; //shut up compiler
1241 }
1242 if(FallBackGet(self,key,dest,raw)) return true;
1243
1244 if(fetchroot) {
1245 if(_rawval(STK(0)) == _rawval(self) &&
1246 type(STK(0)) == type(self)) {
1247 return _table(_roottable)->Get(key,dest);
1248 }
1249 }
1250 return false;
1251 }
1252
FallBackGet(const SQObjectPtr & self,const SQObjectPtr & key,SQObjectPtr & dest,bool raw)1253 bool SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw)
1254 {
1255 switch(type(self)){
1256 case OT_CLASS:
1257 return _class(self)->Get(key,dest);
1258 break;
1259 case OT_TABLE:
1260 case OT_USERDATA:
1261 //delegation
1262 if(_delegable(self)->_delegate) {
1263 if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,raw,false))
1264 return true;
1265 if(raw)return false;
1266 Push(self);Push(key);
1267 if(CallMetaMethod(_delegable(self),MT_GET,2,dest))
1268 return true;
1269 }
1270 if(type(self) == OT_TABLE) {
1271 if(raw) return false;
1272 return _table_ddel->Get(key,dest);
1273 }
1274 return false;
1275 break;
1276 case OT_ARRAY:
1277 if(raw)return false;
1278 return _array_ddel->Get(key,dest);
1279 case OT_STRING:
1280 if(sq_isnumeric(key)){
1281 SQInteger n=tointeger(key);
1282 if(abs((int)n)<_string(self)->_len){
1283 if(n<0)n=_string(self)->_len-n;
1284 dest=SQInteger(_stringval(self)[n]);
1285 return true;
1286 }
1287 return false;
1288 }
1289 else {
1290 if(raw)return false;
1291 return _string_ddel->Get(key,dest);
1292 }
1293 break;
1294 case OT_INSTANCE:
1295 if(raw)return false;
1296 Push(self);Push(key);
1297 if(!CallMetaMethod(_delegable(self),MT_GET,2,dest)) {
1298 return _instance_ddel->Get(key,dest);
1299 }
1300 return true;
1301 case OT_INTEGER:case OT_FLOAT:case OT_BOOL:
1302 if(raw)return false;
1303 return _number_ddel->Get(key,dest);
1304 case OT_GENERATOR:
1305 if(raw)return false;
1306 return _generator_ddel->Get(key,dest);
1307 case OT_CLOSURE: case OT_NATIVECLOSURE:
1308 if(raw)return false;
1309 return _closure_ddel->Get(key,dest);
1310 case OT_THREAD:
1311 if(raw)return false;
1312 return _thread_ddel->Get(key,dest);
1313 case OT_WEAKREF:
1314 if(raw)return false;
1315 return _weakref_ddel->Get(key,dest);
1316 default:return false;
1317 }
1318 return false;
1319 }
1320
Set(const SQObjectPtr & self,const SQObjectPtr & key,const SQObjectPtr & val,bool fetchroot)1321 bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool fetchroot)
1322 {
1323 switch(type(self)){
1324 case OT_TABLE:
1325 if(_table(self)->Set(key,val))
1326 return true;
1327 if(_table(self)->_delegate) {
1328 if(Set(_table(self)->_delegate,key,val,false)) {
1329 return true;
1330 }
1331 }
1332 FALLTHROUGH;
1333 case OT_USERDATA:
1334 if(_delegable(self)->_delegate) {
1335 SQObjectPtr t;
1336 Push(self);Push(key);Push(val);
1337 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1338 }
1339 break;
1340 case OT_INSTANCE:{
1341 if(_instance(self)->Set(key,val))
1342 return true;
1343 SQObjectPtr t;
1344 Push(self);Push(key);Push(val);
1345 if(CallMetaMethod(_delegable(self),MT_SET,3,t)) return true;
1346 }
1347 break;
1348 case OT_ARRAY:
1349 if(!sq_isnumeric(key)) {Raise_Error("indexing %s with %s",GetTypeName(self),GetTypeName(key)); return false; }
1350 return _array(self)->Set(tointeger(key),val);
1351 default:
1352 Raise_Error("trying to set '%s'",GetTypeName(self));
1353 return false;
1354 }
1355 if(fetchroot) {
1356 if(_rawval(STK(0)) == _rawval(self) &&
1357 type(STK(0)) == type(self)) {
1358 return _table(_roottable)->Set(key,val);
1359 }
1360 }
1361 return false;
1362 }
1363
Clone(const SQObjectPtr & self,SQObjectPtr & target)1364 bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target)
1365 {
1366 SQObjectPtr temp_reg;
1367 SQObjectPtr newobj;
1368 switch(type(self)){
1369 case OT_TABLE:
1370 newobj = _table(self)->Clone();
1371 goto cloned_mt;
1372 case OT_INSTANCE:
1373 newobj = _instance(self)->Clone(_ss(this));
1374 cloned_mt:
1375 if(_delegable(newobj)->_delegate){
1376 Push(newobj);
1377 Push(self);
1378 CallMetaMethod(_delegable(newobj),MT_CLONED,2,temp_reg);
1379 }
1380 target = newobj;
1381 return true;
1382 case OT_ARRAY:
1383 target = _array(self)->Clone();
1384 return true;
1385 default: return false;
1386 }
1387 }
1388
NewSlot(const SQObjectPtr & self,const SQObjectPtr & key,const SQObjectPtr & val,bool bstatic)1389 bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic)
1390 {
1391 if(type(key) == OT_NULL) { Raise_Error("null cannot be used as index"); return false; }
1392 switch(type(self)) {
1393 case OT_TABLE: {
1394 bool rawcall = true;
1395 if(_table(self)->_delegate) {
1396 SQObjectPtr res;
1397 if(!_table(self)->Get(key,res)) {
1398 Push(self);Push(key);Push(val);
1399 rawcall = !CallMetaMethod(_table(self),MT_NEWSLOT,3,res);
1400 }
1401 }
1402 if(rawcall) _table(self)->NewSlot(key,val); //cannot fail
1403
1404 break;}
1405 case OT_INSTANCE: {
1406 SQObjectPtr res;
1407 Push(self);Push(key);Push(val);
1408 if(!CallMetaMethod(_instance(self),MT_NEWSLOT,3,res)) {
1409 Raise_Error("class instances do not support the new slot operator");
1410 return false;
1411 }
1412 break;}
1413 case OT_CLASS:
1414 if(!_class(self)->NewSlot(_ss(this),key,val,bstatic)) {
1415 if(_class(self)->_locked) {
1416 Raise_Error("trying to modify a class that has already been instantiated");
1417 return false;
1418 }
1419 else {
1420 SQObjectPtr oval = PrintObjVal(key);
1421 Raise_Error("the property '%s' already exists",_stringval(oval));
1422 return false;
1423 }
1424 }
1425 break;
1426 default:
1427 Raise_Error("indexing %s with %s",GetTypeName(self),GetTypeName(key));
1428 return false;
1429 break;
1430 }
1431 return true;
1432 }
1433
DeleteSlot(const SQObjectPtr & self,const SQObjectPtr & key,SQObjectPtr & res)1434 bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res)
1435 {
1436 switch(type(self)) {
1437 case OT_TABLE:
1438 case OT_INSTANCE:
1439 case OT_USERDATA: {
1440 SQObjectPtr t;
1441 bool handled = false;
1442 if(_delegable(self)->_delegate) {
1443 Push(self);Push(key);
1444 handled = CallMetaMethod(_delegable(self),MT_DELSLOT,2,t);
1445 }
1446
1447 if(!handled) {
1448 if(type(self) == OT_TABLE) {
1449 if(_table(self)->Get(key,t)) {
1450 _table(self)->Remove(key);
1451 }
1452 else {
1453 Raise_IdxError((const SQObject &)key);
1454 return false;
1455 }
1456 }
1457 else {
1458 Raise_Error("cannot delete a slot from %s",GetTypeName(self));
1459 return false;
1460 }
1461 }
1462 res = t;
1463 }
1464 break;
1465 default:
1466 Raise_Error("attempt to delete a slot from a %s",GetTypeName(self));
1467 return false;
1468 }
1469 return true;
1470 }
1471
Call(SQObjectPtr & closure,SQInteger nparams,SQInteger stackbase,SQObjectPtr & outres,SQBool raiseerror,SQBool can_suspend)1472 bool SQVM::Call(SQObjectPtr &closure,SQInteger nparams,SQInteger stackbase,SQObjectPtr &outres,SQBool raiseerror,SQBool can_suspend)
1473 {
1474 [[maybe_unused]] SQInteger prevstackbase = _stackbase;
1475 switch(type(closure)) {
1476 case OT_CLOSURE: {
1477 assert(!can_suspend || this->_can_suspend);
1478 SQBool backup_suspend = this->_can_suspend;
1479 this->_can_suspend = can_suspend;
1480 bool ret = Execute(closure, _top - nparams, nparams, stackbase,outres,raiseerror);
1481 this->_can_suspend = backup_suspend;
1482 return ret;
1483 }
1484 break;
1485 case OT_NATIVECLOSURE: {
1486 bool suspend;
1487 return CallNative(_nativeclosure(closure), nparams, stackbase, outres,suspend);
1488
1489 }
1490 break;
1491 case OT_CLASS: {
1492 SQObjectPtr constr;
1493 SQObjectPtr temp;
1494 CreateClassInstance(_class(closure),outres,constr);
1495 if(type(constr) != OT_NULL) {
1496 _stack[stackbase] = outres;
1497 return Call(constr,nparams,stackbase,temp,raiseerror,false);
1498 }
1499 return true;
1500 }
1501 break;
1502 default:
1503 return false;
1504 }
1505 if(!_suspended) {
1506 assert(_stackbase == prevstackbase);
1507 }
1508 return true;
1509 }
1510
CallMetaMethod(SQDelegable * del,SQMetaMethod mm,SQInteger nparams,SQObjectPtr & outres)1511 bool SQVM::CallMetaMethod(SQDelegable *del,SQMetaMethod mm,SQInteger nparams,SQObjectPtr &outres)
1512 {
1513 SQObjectPtr closure;
1514 if(del->GetMetaMethod(this, mm, closure)) {
1515 if(Call(closure, nparams, _top - nparams, outres, SQFalse, SQFalse)) {
1516 Pop(nparams);
1517 return true;
1518 }
1519 }
1520 Pop(nparams);
1521 return false;
1522 }
1523
Remove(SQInteger n)1524 void SQVM::Remove(SQInteger n) {
1525 n = (n >= 0)?n + _stackbase - 1:_top + n;
1526 for(SQInteger i = n; i < _top; i++){
1527 _stack[i] = _stack[i+1];
1528 }
1529 _stack[_top] = _null_;
1530 _top--;
1531 }
1532
Pop()1533 void SQVM::Pop() {
1534 _stack[--_top] = _null_;
1535 }
1536
Pop(SQInteger n)1537 void SQVM::Pop(SQInteger n) {
1538 for(SQInteger i = 0; i < n; i++){
1539 _stack[--_top] = _null_;
1540 }
1541 }
1542
Push(const SQObjectPtr & o)1543 void SQVM::Push(const SQObjectPtr &o) {
1544 /* Normally the stack shouldn't get this full, sometimes it might. As of now
1545 * all cases have been bugs in "our" (OpenTTD) code. Trigger an assert for
1546 * all debug builds and for the release builds just increase the stack size.
1547 * This way getting a false positive isn't that bad (releases work fine) and
1548 * if there is something fishy it can be caught in RCs/nightlies. */
1549 #ifdef NDEBUG
1550 if (_top >= (int)_stack.capacity()) _stack.resize(2 * _stack.capacity());
1551 #else
1552 assert(_top < (int)_stack.capacity());
1553 #endif
1554 _stack[_top++] = o;
1555 }
Top()1556 SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }
PopGet()1557 SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }
GetUp(SQInteger n)1558 SQObjectPtr &SQVM::GetUp(SQInteger n) { return _stack[_top+n]; }
GetAt(SQInteger n)1559 SQObjectPtr &SQVM::GetAt(SQInteger n) { return _stack[n]; }
1560
1561 #ifdef _DEBUG_DUMP
dumpstack(SQInteger stackbase,bool dumpall)1562 void SQVM::dumpstack(SQInteger stackbase,bool dumpall)
1563 {
1564 SQInteger size=dumpall?_stack.size():_top;
1565 SQInteger n=0;
1566 printf("\n>>>>stack dump<<<<\n");
1567 CallInfo &ci=_callsstack[_callsstacksize-1];
1568 printf("IP: %p\n",ci._ip);
1569 printf("prev stack base: %d\n",ci._prevstkbase);
1570 printf("prev top: %d\n",ci._prevtop);
1571 for(SQInteger i=0;i<size;i++){
1572 SQObjectPtr &obj=_stack[i];
1573 if(stackbase==i)printf(">");else printf(" ");
1574 printf("[%d]:",n);
1575 switch(type(obj)){
1576 case OT_FLOAT: printf("FLOAT %.3f",_float(obj));break;
1577 case OT_INTEGER: printf("INTEGER %d",_integer(obj));break;
1578 case OT_BOOL: printf("BOOL %s",_integer(obj)?"true":"false");break;
1579 case OT_STRING: printf("STRING %s",_stringval(obj));break;
1580 case OT_NULL: printf("NULL"); break;
1581 case OT_TABLE: printf("TABLE %p[%p]",_table(obj),_table(obj)->_delegate);break;
1582 case OT_ARRAY: printf("ARRAY %p",_array(obj));break;
1583 case OT_CLOSURE: printf("CLOSURE [%p]",_closure(obj));break;
1584 case OT_NATIVECLOSURE: printf("NATIVECLOSURE");break;
1585 case OT_USERDATA: printf("USERDATA %p[%p]",_userdataval(obj),_userdata(obj)->_delegate);break;
1586 case OT_GENERATOR: printf("GENERATOR %p",_generator(obj));break;
1587 case OT_THREAD: printf("THREAD [%p]",_thread(obj));break;
1588 case OT_USERPOINTER: printf("USERPOINTER %p",_userpointer(obj));break;
1589 case OT_CLASS: printf("CLASS %p",_class(obj));break;
1590 case OT_INSTANCE: printf("INSTANCE %p",_instance(obj));break;
1591 case OT_WEAKREF: printf("WEAKERF %p",_weakref(obj));break;
1592 default:
1593 assert(0);
1594 break;
1595 };
1596 printf("\n");
1597 ++n;
1598 }
1599 }
1600
1601
1602
1603 #endif
1604