sqrat  0.9
sqrat
 All Classes Functions Variables Enumerations Enumerator Pages
sqratFunction.h
1 //
2 // sqratFunction: Squirrel Function Wrapper
3 //
4 
5 //
6 // Copyright (c) 2009 Brandon Jones
7 // Copyirght 2011 Li-Cheng (Andy) Tai
8 //
9 // This software is provided 'as-is', without any express or implied
10 // warranty. In no event will the authors be held liable for any damages
11 // arising from the use of this software.
12 //
13 // Permission is granted to anyone to use this software for any purpose,
14 // including commercial applications, and to alter it and redistribute it
15 // freely, subject to the following restrictions:
16 //
17 // 1. The origin of this software must not be misrepresented; you must not
18 // claim that you wrote the original software. If you use this software
19 // in a product, an acknowledgment in the product documentation would be
20 // appreciated but is not required.
21 //
22 // 2. Altered source versions must be plainly marked as such, and must not be
23 // misrepresented as being the original software.
24 //
25 // 3. This notice may not be removed or altered from any source
26 // distribution.
27 //
28 
29 #if !defined(_SCRAT_SQFUNC_H_)
30 #define _SCRAT_SQFUNC_H_
31 
32 #include <squirrel.h>
33 #include "sqratObject.h"
34 
35 namespace Sqrat {
36 
40 class Function {
41  friend class TableBase;
42  friend class Table;
43  friend class ArrayBase;
44  friend struct Var<Function>;
45 private:
46  HSQUIRRELVM vm;
47  HSQOBJECT env, obj;
48 
49 public:
54  Function() {
55  sq_resetobject(&env);
56  sq_resetobject(&obj);
57  }
58 
65  Function(const Function& sf) : vm(sf.vm), env(sf.env), obj(sf.obj) {
66  sq_addref(vm, &env);
67  sq_addref(vm, &obj);
68  }
69 
80  Function(const Object& e, const SQChar* slot) : vm(e.GetVM()), env(e.GetObject()) {
81  sq_addref(vm, &env);
82  Object so = e.GetSlot(slot);
83  obj = so.GetObject();
84  sq_addref(vm, &obj);
85 #if !defined (SCRAT_NO_ERROR_CHECKING)
86  SQObjectType value_type = so.GetType();
87  if (value_type != OT_CLOSURE && value_type != OT_NATIVECLOSURE) {
88  Error::Instance().Throw(vm, _SC("function not found in slot"));
89  }
90 #endif
91  }
92 
101  Function(HSQUIRRELVM v, HSQOBJECT e, HSQOBJECT o) : vm(v), env(e), obj(o) {
102  sq_addref(vm, &env);
103  sq_addref(vm, &obj);
104  }
105 
110  ~Function() {
111  Release();
112  }
113 
122  Function& operator=(const Function& sf) {
123  Release();
124  vm = sf.vm;
125  env = sf.env;
126  obj = sf.obj;
127  sq_addref(vm, &env);
128  sq_addref(vm, &obj);
129  return *this;
130  }
131 
138  bool IsNull() {
139  return sq_isnull(obj);
140  }
141 
148  HSQOBJECT& GetEnv() {
149  return env;
150  }
151 
158  HSQOBJECT& GetFunc() {
159  return obj;
160  }
161 
168  HSQUIRRELVM& GetVM() {
169  return vm;
170  }
171 
176  void Release() {
177  if(!IsNull()) {
178  sq_release(vm, &env);
179  sq_release(vm, &obj);
180  sq_resetobject(&env);
181  sq_resetobject(&obj);
182  }
183  }
184 
196  template <class R>
197  SharedPtr<R> Evaluate() {
198  sq_pushobject(vm, obj);
199  sq_pushobject(vm, env);
200 
201 #if !defined (SCRAT_NO_ERROR_CHECKING)
202  SQUnsignedInteger nparams;
203  SQUnsignedInteger nfreevars;
204 
205  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 1)) {
206  sq_pop(vm, 2);
207  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
208  return SharedPtr<R>();
209  }
210 
211  SQRESULT result = sq_call(vm, 1, true, ErrorHandling::IsEnabled());
212 
213  //handle an error: pop the stack and throw the exception
214  if(SQ_FAILED(result)) {
215  sq_pop(vm, 2);
216  Error::Instance().Throw(vm, LastErrorString(vm));
217  return SharedPtr<R>();
218  }
219 #else
220  sq_call(vm, 1, true, ErrorHandling::IsEnabled());
221 #endif
222 
223  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
224  sq_pop(vm, 2);
225  return ret;
226  }
227 
242  template <class R, class A1>
243  SharedPtr<R> Evaluate(A1 a1) {
244  sq_pushobject(vm, obj);
245  sq_pushobject(vm, env);
246 
247 #if !defined (SCRAT_NO_ERROR_CHECKING)
248  SQUnsignedInteger nparams;
249  SQUnsignedInteger nfreevars;
250 
251  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 2)) {
252  sq_pop(vm, 2);
253  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
254  return SharedPtr<R>();
255  }
256 #endif
257 
258  PushVar(vm, a1);
259 
260 #if !defined (SCRAT_NO_ERROR_CHECKING)
261  SQRESULT result = sq_call(vm, 2, true, ErrorHandling::IsEnabled());
262 
263  //handle an error: pop the stack and throw the exception
264  if(SQ_FAILED(result)) {
265  sq_pop(vm, 2);
266  Error::Instance().Throw(vm, LastErrorString(vm));
267  return SharedPtr<R>();
268  }
269 #else
270  sq_call(vm, 2, true, ErrorHandling::IsEnabled());
271 #endif
272 
273  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
274  sq_pop(vm, 2);
275  return ret;
276  }
277 
294  template <class R, class A1, class A2>
295  SharedPtr<R> Evaluate(A1 a1, A2 a2) {
296  sq_pushobject(vm, obj);
297  sq_pushobject(vm, env);
298 
299 #if !defined (SCRAT_NO_ERROR_CHECKING)
300  SQUnsignedInteger nparams;
301  SQUnsignedInteger nfreevars;
302 
303  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 3)) {
304  sq_pop(vm, 2);
305  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
306  return SharedPtr<R>();
307  }
308 #endif
309 
310  PushVar(vm, a1);
311  PushVar(vm, a2);
312 
313 #if !defined (SCRAT_NO_ERROR_CHECKING)
314  SQRESULT result = sq_call(vm, 3, true, ErrorHandling::IsEnabled());
315 
316  //handle an error: pop the stack and throw the exception
317  if(SQ_FAILED(result)) {
318  sq_pop(vm, 2);
319  Error::Instance().Throw(vm, LastErrorString(vm));
320  return SharedPtr<R>();
321  }
322 #else
323  sq_call(vm, 3, true, ErrorHandling::IsEnabled());
324 #endif
325 
326  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
327  sq_pop(vm, 2);
328  return ret;
329  }
330 
349  template <class R, class A1, class A2, class A3>
350  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3) {
351  sq_pushobject(vm, obj);
352  sq_pushobject(vm, env);
353 
354 #if !defined (SCRAT_NO_ERROR_CHECKING)
355  SQUnsignedInteger nparams;
356  SQUnsignedInteger nfreevars;
357  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 4)) {
358  sq_pop(vm, 2);
359  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
360  return SharedPtr<R>();
361  }
362 #endif
363 
364  PushVar(vm, a1);
365  PushVar(vm, a2);
366  PushVar(vm, a3);
367 
368 #if !defined (SCRAT_NO_ERROR_CHECKING)
369  SQRESULT result = sq_call(vm, 4, true, ErrorHandling::IsEnabled());
370 
371  //handle an error: pop the stack and throw the exception
372  if(SQ_FAILED(result)) {
373  sq_pop(vm, 2);
374  Error::Instance().Throw(vm, LastErrorString(vm));
375  return SharedPtr<R>();
376  }
377 #else
378  sq_call(vm, 4, true, ErrorHandling::IsEnabled());
379 #endif
380 
381  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
382  sq_pop(vm, 2);
383  return ret;
384  }
385 
406  template <class R, class A1, class A2, class A3, class A4>
407  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4) {
408  sq_pushobject(vm, obj);
409  sq_pushobject(vm, env);
410 
411 #if !defined (SCRAT_NO_ERROR_CHECKING)
412  SQUnsignedInteger nparams;
413  SQUnsignedInteger nfreevars;
414  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 5)) {
415  sq_pop(vm, 2);
416  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
417  return SharedPtr<R>();
418  }
419 #endif
420 
421  PushVar(vm, a1);
422  PushVar(vm, a2);
423  PushVar(vm, a3);
424  PushVar(vm, a4);
425 
426 #if !defined (SCRAT_NO_ERROR_CHECKING)
427  SQRESULT result = sq_call(vm, 5, true, ErrorHandling::IsEnabled());
428 
429  //handle an error: pop the stack and throw the exception
430  if(SQ_FAILED(result)) {
431  sq_pop(vm, 2);
432  Error::Instance().Throw(vm, LastErrorString(vm));
433  return SharedPtr<R>();
434  }
435 #else
436  sq_call(vm, 5, true, ErrorHandling::IsEnabled());
437 #endif
438 
439  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
440  sq_pop(vm, 2);
441  return ret;
442  }
443 
466  template <class R, class A1, class A2, class A3, class A4, class A5>
467  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
468  sq_pushobject(vm, obj);
469  sq_pushobject(vm, env);
470 
471 #if !defined (SCRAT_NO_ERROR_CHECKING)
472  SQUnsignedInteger nparams;
473  SQUnsignedInteger nfreevars;
474  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 6)) {
475  sq_pop(vm, 2);
476  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
477  return SharedPtr<R>();
478  }
479 #endif
480 
481  PushVar(vm, a1);
482  PushVar(vm, a2);
483  PushVar(vm, a3);
484  PushVar(vm, a4);
485  PushVar(vm, a5);
486 
487 #if !defined (SCRAT_NO_ERROR_CHECKING)
488  SQRESULT result = sq_call(vm, 6, true, ErrorHandling::IsEnabled());
489 
490  //handle an error: pop the stack and throw the exception
491  if(SQ_FAILED(result)) {
492  sq_pop(vm, 2);
493  Error::Instance().Throw(vm, LastErrorString(vm));
494  return SharedPtr<R>();
495  }
496 #else
497  sq_call(vm, 6, true, ErrorHandling::IsEnabled());
498 #endif
499 
500  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
501  sq_pop(vm, 2);
502  return ret;
503  }
504 
529  template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
530  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
531  sq_pushobject(vm, obj);
532  sq_pushobject(vm, env);
533 
534 #if !defined (SCRAT_NO_ERROR_CHECKING)
535 
536  SQUnsignedInteger nparams;
537  SQUnsignedInteger nfreevars;
538  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 7)) {
539  sq_pop(vm, 2);
540  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
541  return SharedPtr<R>();
542  }
543 #endif
544 
545  PushVar(vm, a1);
546  PushVar(vm, a2);
547  PushVar(vm, a3);
548  PushVar(vm, a4);
549  PushVar(vm, a5);
550  PushVar(vm, a6);
551 
552 #if !defined (SCRAT_NO_ERROR_CHECKING)
553  SQRESULT result = sq_call(vm, 7, true, ErrorHandling::IsEnabled());
554 
555  //handle an error: pop the stack and throw the exception
556  if(SQ_FAILED(result)) {
557  sq_pop(vm, 2);
558  Error::Instance().Throw(vm, LastErrorString(vm));
559  return SharedPtr<R>();
560  }
561 #else
562  sq_call(vm, 7, true, ErrorHandling::IsEnabled());
563 #endif
564 
565  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
566  sq_pop(vm, 2);
567  return ret;
568  }
569 
596  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
597  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
598  sq_pushobject(vm, obj);
599  sq_pushobject(vm, env);
600 
601 #if !defined (SCRAT_NO_ERROR_CHECKING)
602  SQUnsignedInteger nparams;
603  SQUnsignedInteger nfreevars;
604  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 8)) {
605  sq_pop(vm, 2);
606  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
607  return SharedPtr<R>();
608  }
609 #endif
610 
611  PushVar(vm, a1);
612  PushVar(vm, a2);
613  PushVar(vm, a3);
614  PushVar(vm, a4);
615  PushVar(vm, a5);
616  PushVar(vm, a6);
617  PushVar(vm, a7);
618 
619 #if !defined (SCRAT_NO_ERROR_CHECKING)
620  SQRESULT result = sq_call(vm, 8, true, ErrorHandling::IsEnabled());
621 
622  //handle an error: pop the stack and throw the exception
623  if(SQ_FAILED(result)) {
624  sq_pop(vm, 2);
625  Error::Instance().Throw(vm, LastErrorString(vm));
626  return SharedPtr<R>();
627  }
628 #else
629  sq_call(vm, 8, true, ErrorHandling::IsEnabled());
630 #endif
631 
632  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
633  sq_pop(vm, 2);
634  return ret;
635  }
636 
665  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
666  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
667  sq_pushobject(vm, obj);
668  sq_pushobject(vm, env);
669 
670 #if !defined (SCRAT_NO_ERROR_CHECKING)
671  SQUnsignedInteger nparams;
672  SQUnsignedInteger nfreevars;
673  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 9)) {
674  sq_pop(vm, 2);
675  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
676  return SharedPtr<R>();
677  }
678 #endif
679 
680  PushVar(vm, a1);
681  PushVar(vm, a2);
682  PushVar(vm, a3);
683  PushVar(vm, a4);
684  PushVar(vm, a5);
685  PushVar(vm, a6);
686  PushVar(vm, a7);
687  PushVar(vm, a8);
688 
689 #if !defined (SCRAT_NO_ERROR_CHECKING)
690  SQRESULT result = sq_call(vm, 9, true, ErrorHandling::IsEnabled());
691 
692  //handle an error: pop the stack and throw the exception
693  if(SQ_FAILED(result)) {
694  sq_pop(vm, 2);
695  Error::Instance().Throw(vm, LastErrorString(vm));
696  return SharedPtr<R>();
697  }
698 #else
699  sq_call(vm, 9, true, ErrorHandling::IsEnabled());
700 #endif
701 
702  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
703  sq_pop(vm, 2);
704  return ret;
705  }
706 
737  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
738  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
739  sq_pushobject(vm, obj);
740  sq_pushobject(vm, env);
741 
742 #if !defined (SCRAT_NO_ERROR_CHECKING)
743  SQUnsignedInteger nparams;
744  SQUnsignedInteger nfreevars;
745  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 10)) {
746  sq_pop(vm, 2);
747  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
748  return SharedPtr<R>();
749  }
750 #endif
751 
752  PushVar(vm, a1);
753  PushVar(vm, a2);
754  PushVar(vm, a3);
755  PushVar(vm, a4);
756  PushVar(vm, a5);
757  PushVar(vm, a6);
758  PushVar(vm, a7);
759  PushVar(vm, a8);
760  PushVar(vm, a9);
761 
762 #if !defined (SCRAT_NO_ERROR_CHECKING)
763  SQRESULT result = sq_call(vm, 10, true, ErrorHandling::IsEnabled());
764 
765  //handle an error: pop the stack and throw the exception
766  if(SQ_FAILED(result)) {
767  sq_pop(vm, 2);
768  Error::Instance().Throw(vm, LastErrorString(vm));
769  return SharedPtr<R>();
770  }
771 #else
772  sq_call(vm, 10, true, ErrorHandling::IsEnabled());
773 #endif
774 
775  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
776  sq_pop(vm, 2);
777  return ret;
778  }
779 
812  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
813  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
814  sq_pushobject(vm, obj);
815  sq_pushobject(vm, env);
816 
817 #if !defined (SCRAT_NO_ERROR_CHECKING)
818  SQUnsignedInteger nparams;
819  SQUnsignedInteger nfreevars;
820  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 11)) {
821  sq_pop(vm, 2);
822  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
823  return SharedPtr<R>();
824  }
825 #endif
826 
827  PushVar(vm, a1);
828  PushVar(vm, a2);
829  PushVar(vm, a3);
830  PushVar(vm, a4);
831  PushVar(vm, a5);
832  PushVar(vm, a6);
833  PushVar(vm, a7);
834  PushVar(vm, a8);
835  PushVar(vm, a9);
836  PushVar(vm, a10);
837 
838 #if !defined (SCRAT_NO_ERROR_CHECKING)
839  SQRESULT result = sq_call(vm, 11, true, ErrorHandling::IsEnabled());
840 
841  //handle an error: pop the stack and throw the exception
842  if(SQ_FAILED(result)) {
843  sq_pop(vm, 2);
844  Error::Instance().Throw(vm, LastErrorString(vm));
845  return SharedPtr<R>();
846  }
847 #else
848  sq_call(vm, 11, true, ErrorHandling::IsEnabled());
849 #endif
850 
851  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
852  sq_pop(vm, 2);
853  return ret;
854  }
855 
890  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
891  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
892  sq_pushobject(vm, obj);
893  sq_pushobject(vm, env);
894 
895 #if !defined (SCRAT_NO_ERROR_CHECKING)
896  SQUnsignedInteger nparams;
897  SQUnsignedInteger nfreevars;
898  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 12)) {
899  sq_pop(vm, 2);
900  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
901  return SharedPtr<R>();
902  }
903 #endif
904 
905  PushVar(vm, a1);
906  PushVar(vm, a2);
907  PushVar(vm, a3);
908  PushVar(vm, a4);
909  PushVar(vm, a5);
910  PushVar(vm, a6);
911  PushVar(vm, a7);
912  PushVar(vm, a8);
913  PushVar(vm, a9);
914  PushVar(vm, a10);
915  PushVar(vm, a11);
916 
917 #if !defined (SCRAT_NO_ERROR_CHECKING)
918  SQRESULT result = sq_call(vm, 12, true, ErrorHandling::IsEnabled());
919 
920  //handle an error: pop the stack and throw the exception
921  if(SQ_FAILED(result)) {
922  sq_pop(vm, 2);
923  Error::Instance().Throw(vm, LastErrorString(vm));
924  return SharedPtr<R>();
925  }
926 #else
927  sq_call(vm, 12, true, ErrorHandling::IsEnabled());
928 #endif
929 
930  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
931  sq_pop(vm, 2);
932  return ret;
933  }
934 
971  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
972  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
973  sq_pushobject(vm, obj);
974  sq_pushobject(vm, env);
975 
976 #if !defined (SCRAT_NO_ERROR_CHECKING)
977  SQUnsignedInteger nparams;
978  SQUnsignedInteger nfreevars;
979  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 13)) {
980  sq_pop(vm, 2);
981  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
982  return SharedPtr<R>();
983  }
984 #endif
985 
986  PushVar(vm, a1);
987  PushVar(vm, a2);
988  PushVar(vm, a3);
989  PushVar(vm, a4);
990  PushVar(vm, a5);
991  PushVar(vm, a6);
992  PushVar(vm, a7);
993  PushVar(vm, a8);
994  PushVar(vm, a9);
995  PushVar(vm, a10);
996  PushVar(vm, a11);
997  PushVar(vm, a12);
998 
999 #if !defined (SCRAT_NO_ERROR_CHECKING)
1000  SQRESULT result = sq_call(vm, 13, true, ErrorHandling::IsEnabled());
1001 
1002  //handle an error: pop the stack and throw the exception
1003  if(SQ_FAILED(result)) {
1004  sq_pop(vm, 2);
1005  Error::Instance().Throw(vm, LastErrorString(vm));
1006  return SharedPtr<R>();
1007  }
1008 #else
1009  sq_call(vm, 13, true, ErrorHandling::IsEnabled());
1010 #endif
1011 
1012  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
1013  sq_pop(vm, 2);
1014  return ret;
1015  }
1016 
1055  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
1056  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
1057  sq_pushobject(vm, obj);
1058  sq_pushobject(vm, env);
1059 
1060 #if !defined (SCRAT_NO_ERROR_CHECKING)
1061  SQUnsignedInteger nparams;
1062  SQUnsignedInteger nfreevars;
1063  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 14)) {
1064  sq_pop(vm, 2);
1065  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1066  return SharedPtr<R>();
1067  }
1068 #endif
1069 
1070  PushVar(vm, a1);
1071  PushVar(vm, a2);
1072  PushVar(vm, a3);
1073  PushVar(vm, a4);
1074  PushVar(vm, a5);
1075  PushVar(vm, a6);
1076  PushVar(vm, a7);
1077  PushVar(vm, a8);
1078  PushVar(vm, a9);
1079  PushVar(vm, a10);
1080  PushVar(vm, a11);
1081  PushVar(vm, a12);
1082  PushVar(vm, a13);
1083 
1084 #if !defined (SCRAT_NO_ERROR_CHECKING)
1085  SQRESULT result = sq_call(vm, 14, true, ErrorHandling::IsEnabled());
1086 
1087  //handle an error: pop the stack and throw the exception
1088  if(SQ_FAILED(result)) {
1089  sq_pop(vm, 2);
1090  Error::Instance().Throw(vm, LastErrorString(vm));
1091  return SharedPtr<R>();
1092  }
1093 #else
1094  sq_call(vm, 14, true, ErrorHandling::IsEnabled());
1095 #endif
1096 
1097  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
1098  sq_pop(vm, 2);
1099  return ret;
1100  }
1101 
1142  template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
1143  SharedPtr<R> Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
1144  sq_pushobject(vm, obj);
1145  sq_pushobject(vm, env);
1146 
1147 #if !defined (SCRAT_NO_ERROR_CHECKING)
1148  SQUnsignedInteger nparams;
1149  SQUnsignedInteger nfreevars;
1150  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 15)) {
1151  sq_pop(vm, 2);
1152  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1153  return SharedPtr<R>();
1154  }
1155 #endif
1156 
1157  PushVar(vm, a1);
1158  PushVar(vm, a2);
1159  PushVar(vm, a3);
1160  PushVar(vm, a4);
1161  PushVar(vm, a5);
1162  PushVar(vm, a6);
1163  PushVar(vm, a7);
1164  PushVar(vm, a8);
1165  PushVar(vm, a9);
1166  PushVar(vm, a10);
1167  PushVar(vm, a11);
1168  PushVar(vm, a12);
1169  PushVar(vm, a13);
1170  PushVar(vm, a14);
1171 
1172 #if !defined (SCRAT_NO_ERROR_CHECKING)
1173  SQRESULT result = sq_call(vm, 15, true, ErrorHandling::IsEnabled());
1174 
1175  //handle an error: pop the stack and throw the exception
1176  if(SQ_FAILED(result)) {
1177  sq_pop(vm, 2);
1178  Error::Instance().Throw(vm, LastErrorString(vm));
1179  return SharedPtr<R>();
1180  }
1181 #else
1182  sq_call(vm, 15, true, ErrorHandling::IsEnabled());
1183 #endif
1184 
1185  SharedPtr<R> ret = Var<SharedPtr<R> >(vm, -1).value;
1186  sq_pop(vm, 2);
1187  return ret;
1188  }
1189 
1197  void Execute() {
1198  sq_pushobject(vm, obj);
1199  sq_pushobject(vm, env);
1200 
1201 #if !defined (SCRAT_NO_ERROR_CHECKING)
1202  SQUnsignedInteger nparams;
1203  SQUnsignedInteger nfreevars;
1204  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 1)) {
1205  sq_pop(vm, 2);
1206  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1207  return;
1208  }
1209 
1210  SQRESULT result = sq_call(vm, 1, false, ErrorHandling::IsEnabled());
1211  sq_pop(vm, 2);
1212 
1213  //handle an error: throw the exception
1214  if(SQ_FAILED(result)) {
1215  Error::Instance().Throw(vm, LastErrorString(vm));
1216  return;
1217  }
1218 #else
1219  sq_call(vm, 1, false, ErrorHandling::IsEnabled());
1220  sq_pop(vm, 2);
1221 #endif
1222  }
1223 
1235  template <class A1>
1236  void Execute(A1 a1) {
1237  sq_pushobject(vm, obj);
1238  sq_pushobject(vm, env);
1239 
1240 #if !defined (SCRAT_NO_ERROR_CHECKING)
1241  SQUnsignedInteger nparams;
1242  SQUnsignedInteger nfreevars;
1243  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 2)) {
1244  sq_pop(vm, 2);
1245  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1246  return;
1247  }
1248 #endif
1249 
1250  PushVar(vm, a1);
1251 
1252 #if !defined (SCRAT_NO_ERROR_CHECKING)
1253  SQRESULT result = sq_call(vm, 2, false, ErrorHandling::IsEnabled());
1254  sq_pop(vm, 2);
1255 
1256  //handle an error: throw the exception
1257  if(SQ_FAILED(result)) {
1258  Error::Instance().Throw(vm, LastErrorString(vm));
1259  return;
1260  }
1261 #else
1262  sq_call(vm, 2, false, ErrorHandling::IsEnabled());
1263  sq_pop(vm, 2);
1264 #endif
1265  }
1266 
1280  template <class A1, class A2>
1281  void Execute(A1 a1, A2 a2) {
1282  sq_pushobject(vm, obj);
1283  sq_pushobject(vm, env);
1284 
1285 #if !defined (SCRAT_NO_ERROR_CHECKING)
1286  SQUnsignedInteger nparams;
1287  SQUnsignedInteger nfreevars;
1288  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 3)) {
1289  sq_pop(vm, 2);
1290  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1291  return;
1292  }
1293 #endif
1294 
1295  PushVar(vm, a1);
1296  PushVar(vm, a2);
1297 
1298 #if !defined (SCRAT_NO_ERROR_CHECKING)
1299  SQRESULT result = sq_call(vm, 3, false, ErrorHandling::IsEnabled());
1300  sq_pop(vm, 2);
1301 
1302  //handle an error: throw the exception
1303  if(SQ_FAILED(result)) {
1304  Error::Instance().Throw(vm, LastErrorString(vm));
1305  return;
1306  }
1307 #else
1308  sq_call(vm, 3, false, ErrorHandling::IsEnabled());
1309  sq_pop(vm, 2);
1310 #endif
1311  }
1312 
1328  template <class A1, class A2, class A3>
1329  void Execute(A1 a1, A2 a2, A3 a3) {
1330  sq_pushobject(vm, obj);
1331  sq_pushobject(vm, env);
1332 
1333 #if !defined (SCRAT_NO_ERROR_CHECKING)
1334  SQUnsignedInteger nparams;
1335  SQUnsignedInteger nfreevars;
1336  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 4)) {
1337  sq_pop(vm, 2);
1338  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1339  return;
1340  }
1341 #endif
1342 
1343  PushVar(vm, a1);
1344  PushVar(vm, a2);
1345  PushVar(vm, a3);
1346 
1347 #if !defined (SCRAT_NO_ERROR_CHECKING)
1348  SQRESULT result = sq_call(vm, 4, false, ErrorHandling::IsEnabled());
1349  sq_pop(vm, 2);
1350 
1351  //handle an error: throw the exception
1352  if(SQ_FAILED(result)) {
1353  Error::Instance().Throw(vm, LastErrorString(vm));
1354  return;
1355  }
1356 #else
1357  sq_call(vm, 4, false, ErrorHandling::IsEnabled());
1358  sq_pop(vm, 2);
1359 #endif
1360  }
1361 
1379  template <class A1, class A2, class A3, class A4>
1380  void Execute(A1 a1, A2 a2, A3 a3, A4 a4) {
1381  sq_pushobject(vm, obj);
1382  sq_pushobject(vm, env);
1383 
1384 #if !defined (SCRAT_NO_ERROR_CHECKING)
1385  SQUnsignedInteger nparams;
1386  SQUnsignedInteger nfreevars;
1387  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 5)) {
1388  sq_pop(vm, 2);
1389  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1390  return;
1391  }
1392 #endif
1393 
1394  PushVar(vm, a1);
1395  PushVar(vm, a2);
1396  PushVar(vm, a3);
1397  PushVar(vm, a4);
1398 
1399 #if !defined (SCRAT_NO_ERROR_CHECKING)
1400  SQRESULT result = sq_call(vm, 5, false, ErrorHandling::IsEnabled());
1401  sq_pop(vm, 2);
1402 
1403  //handle an error: throw the exception
1404  if(SQ_FAILED(result)) {
1405  Error::Instance().Throw(vm, LastErrorString(vm));
1406  return;
1407  }
1408 #else
1409  sq_call(vm, 5, false, ErrorHandling::IsEnabled());
1410  sq_pop(vm, 2);
1411 #endif
1412  }
1413 
1433  template <class A1, class A2, class A3, class A4, class A5>
1434  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
1435  sq_pushobject(vm, obj);
1436  sq_pushobject(vm, env);
1437 
1438 #if !defined (SCRAT_NO_ERROR_CHECKING)
1439  SQUnsignedInteger nparams;
1440  SQUnsignedInteger nfreevars;
1441  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 6)) {
1442  sq_pop(vm, 2);
1443  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1444  return;
1445  }
1446 #endif
1447 
1448  PushVar(vm, a1);
1449  PushVar(vm, a2);
1450  PushVar(vm, a3);
1451  PushVar(vm, a4);
1452  PushVar(vm, a5);
1453 
1454 #if !defined (SCRAT_NO_ERROR_CHECKING)
1455  SQRESULT result = sq_call(vm, 6, false, ErrorHandling::IsEnabled());
1456  sq_pop(vm, 2);
1457 
1458  //handle an error: throw the exception
1459  if(SQ_FAILED(result)) {
1460  Error::Instance().Throw(vm, LastErrorString(vm));
1461  return;
1462  }
1463 #else
1464  sq_call(vm, 6, false, ErrorHandling::IsEnabled());
1465  sq_pop(vm, 2);
1466 #endif
1467  }
1468 
1490  template <class A1, class A2, class A3, class A4, class A5, class A6>
1491  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
1492  sq_pushobject(vm, obj);
1493  sq_pushobject(vm, env);
1494 
1495 #if !defined (SCRAT_NO_ERROR_CHECKING)
1496  SQUnsignedInteger nparams;
1497  SQUnsignedInteger nfreevars;
1498  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 7)) {
1499  sq_pop(vm, 2);
1500  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1501  return;
1502  }
1503 #endif
1504 
1505  PushVar(vm, a1);
1506  PushVar(vm, a2);
1507  PushVar(vm, a3);
1508  PushVar(vm, a4);
1509  PushVar(vm, a5);
1510  PushVar(vm, a6);
1511 
1512 #if !defined (SCRAT_NO_ERROR_CHECKING)
1513  SQRESULT result = sq_call(vm, 7, false, ErrorHandling::IsEnabled());
1514  sq_pop(vm, 2);
1515 
1516  //handle an error: throw the exception
1517  if(SQ_FAILED(result)) {
1518  Error::Instance().Throw(vm, LastErrorString(vm));
1519  return;
1520  }
1521 #else
1522  sq_call(vm, 7, false, ErrorHandling::IsEnabled());
1523  sq_pop(vm, 2);
1524 #endif
1525  }
1526 
1550  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1551  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
1552  sq_pushobject(vm, obj);
1553  sq_pushobject(vm, env);
1554 
1555 #if !defined (SCRAT_NO_ERROR_CHECKING)
1556  SQUnsignedInteger nparams;
1557  SQUnsignedInteger nfreevars;
1558  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 8)) {
1559  sq_pop(vm, 2);
1560  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1561  return;
1562  }
1563 #endif
1564 
1565  PushVar(vm, a1);
1566  PushVar(vm, a2);
1567  PushVar(vm, a3);
1568  PushVar(vm, a4);
1569  PushVar(vm, a5);
1570  PushVar(vm, a6);
1571  PushVar(vm, a7);
1572 
1573 #if !defined (SCRAT_NO_ERROR_CHECKING)
1574  SQRESULT result = sq_call(vm, 8, false, ErrorHandling::IsEnabled());
1575  sq_pop(vm, 2);
1576 
1577  //handle an error: throw the exception
1578  if(SQ_FAILED(result)) {
1579  Error::Instance().Throw(vm, LastErrorString(vm));
1580  return;
1581  }
1582 #else
1583  sq_call(vm, 8, false, ErrorHandling::IsEnabled());
1584  sq_pop(vm, 2);
1585 #endif
1586  }
1587 
1613  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
1614  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
1615  sq_pushobject(vm, obj);
1616  sq_pushobject(vm, env);
1617 
1618 #if !defined (SCRAT_NO_ERROR_CHECKING)
1619  SQUnsignedInteger nparams;
1620  SQUnsignedInteger nfreevars;
1621  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 9)) {
1622  sq_pop(vm, 2);
1623  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1624  return;
1625  }
1626 #endif
1627 
1628  PushVar(vm, a1);
1629  PushVar(vm, a2);
1630  PushVar(vm, a3);
1631  PushVar(vm, a4);
1632  PushVar(vm, a5);
1633  PushVar(vm, a6);
1634  PushVar(vm, a7);
1635  PushVar(vm, a8);
1636 
1637 #if !defined (SCRAT_NO_ERROR_CHECKING)
1638  SQRESULT result = sq_call(vm, 9, false, ErrorHandling::IsEnabled());
1639  sq_pop(vm, 2);
1640 
1641  //handle an error: throw the exception
1642  if(SQ_FAILED(result)) {
1643  Error::Instance().Throw(vm, LastErrorString(vm));
1644  return;
1645  }
1646 #else
1647  sq_call(vm, 9, false, ErrorHandling::IsEnabled());
1648  sq_pop(vm, 2);
1649 #endif
1650  }
1651 
1679  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
1680  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
1681  sq_pushobject(vm, obj);
1682  sq_pushobject(vm, env);
1683 
1684 #if !defined (SCRAT_NO_ERROR_CHECKING)
1685  SQUnsignedInteger nparams;
1686  SQUnsignedInteger nfreevars;
1687  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 10)) {
1688  sq_pop(vm, 2);
1689  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1690  return;
1691  }
1692 #endif
1693 
1694  PushVar(vm, a1);
1695  PushVar(vm, a2);
1696  PushVar(vm, a3);
1697  PushVar(vm, a4);
1698  PushVar(vm, a5);
1699  PushVar(vm, a6);
1700  PushVar(vm, a7);
1701  PushVar(vm, a8);
1702  PushVar(vm, a9);
1703 
1704 #if !defined (SCRAT_NO_ERROR_CHECKING)
1705  SQRESULT result = sq_call(vm, 10, false, ErrorHandling::IsEnabled());
1706  sq_pop(vm, 2);
1707 
1708  //handle an error: throw the exception
1709  if(SQ_FAILED(result)) {
1710  Error::Instance().Throw(vm, LastErrorString(vm));
1711  return;
1712  }
1713 #else
1714  sq_call(vm, 10, false, ErrorHandling::IsEnabled());
1715  sq_pop(vm, 2);
1716 #endif
1717  }
1718 
1748  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
1749  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
1750  sq_pushobject(vm, obj);
1751  sq_pushobject(vm, env);
1752 
1753 #if !defined (SCRAT_NO_ERROR_CHECKING)
1754  SQUnsignedInteger nparams;
1755  SQUnsignedInteger nfreevars;
1756  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 11)) {
1757  sq_pop(vm, 2);
1758  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1759  return;
1760  }
1761 #endif
1762 
1763  PushVar(vm, a1);
1764  PushVar(vm, a2);
1765  PushVar(vm, a3);
1766  PushVar(vm, a4);
1767  PushVar(vm, a5);
1768  PushVar(vm, a6);
1769  PushVar(vm, a7);
1770  PushVar(vm, a8);
1771  PushVar(vm, a9);
1772  PushVar(vm, a10);
1773 
1774 #if !defined (SCRAT_NO_ERROR_CHECKING)
1775  SQRESULT result = sq_call(vm, 11, false, ErrorHandling::IsEnabled());
1776  sq_pop(vm, 2);
1777 
1778  //handle an error: throw the exception
1779  if(SQ_FAILED(result)) {
1780  Error::Instance().Throw(vm, LastErrorString(vm));
1781  return;
1782  }
1783 #else
1784  sq_call(vm, 11, false, ErrorHandling::IsEnabled());
1785  sq_pop(vm, 2);
1786 #endif
1787  }
1788 
1820  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
1821  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
1822  sq_pushobject(vm, obj);
1823  sq_pushobject(vm, env);
1824 
1825 #if !defined (SCRAT_NO_ERROR_CHECKING)
1826  SQUnsignedInteger nparams;
1827  SQUnsignedInteger nfreevars;
1828  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 12)) {
1829  sq_pop(vm, 2);
1830  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1831  return;
1832  }
1833 #endif
1834 
1835  PushVar(vm, a1);
1836  PushVar(vm, a2);
1837  PushVar(vm, a3);
1838  PushVar(vm, a4);
1839  PushVar(vm, a5);
1840  PushVar(vm, a6);
1841  PushVar(vm, a7);
1842  PushVar(vm, a8);
1843  PushVar(vm, a9);
1844  PushVar(vm, a10);
1845  PushVar(vm, a11);
1846 
1847 #if !defined (SCRAT_NO_ERROR_CHECKING)
1848  SQRESULT result = sq_call(vm, 12, false, ErrorHandling::IsEnabled());
1849  sq_pop(vm, 2);
1850 
1851  //handle an error: throw the exception
1852  if(SQ_FAILED(result)) {
1853  Error::Instance().Throw(vm, LastErrorString(vm));
1854  return;
1855  }
1856 #else
1857  sq_call(vm, 12, false, ErrorHandling::IsEnabled());
1858  sq_pop(vm, 2);
1859 #endif
1860  }
1861 
1895  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
1896  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
1897  sq_pushobject(vm, obj);
1898  sq_pushobject(vm, env);
1899 
1900 
1901 #if !defined (SCRAT_NO_ERROR_CHECKING)
1902  SQUnsignedInteger nparams;
1903  SQUnsignedInteger nfreevars;
1904  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 13)) {
1905  sq_pop(vm, 2);
1906  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1907  return;
1908  }
1909 #endif
1910 
1911  PushVar(vm, a1);
1912  PushVar(vm, a2);
1913  PushVar(vm, a3);
1914  PushVar(vm, a4);
1915  PushVar(vm, a5);
1916  PushVar(vm, a6);
1917  PushVar(vm, a7);
1918  PushVar(vm, a8);
1919  PushVar(vm, a9);
1920  PushVar(vm, a10);
1921  PushVar(vm, a11);
1922  PushVar(vm, a12);
1923 
1924 #if !defined (SCRAT_NO_ERROR_CHECKING)
1925  SQRESULT result = sq_call(vm, 13, false, ErrorHandling::IsEnabled());
1926  sq_pop(vm, 2);
1927 
1928  //handle an error: throw the exception
1929  if(SQ_FAILED(result)) {
1930  Error::Instance().Throw(vm, LastErrorString(vm));
1931  return;
1932  }
1933 #else
1934  sq_call(vm, 13, false, ErrorHandling::IsEnabled());
1935  sq_pop(vm, 2);
1936 #endif
1937  }
1938 
1974  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
1975  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
1976  sq_pushobject(vm, obj);
1977  sq_pushobject(vm, env);
1978 
1979 #if !defined (SCRAT_NO_ERROR_CHECKING)
1980  SQUnsignedInteger nparams;
1981  SQUnsignedInteger nfreevars;
1982  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 14)) {
1983  sq_pop(vm, 2);
1984  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
1985  return;
1986  }
1987 #endif
1988 
1989  PushVar(vm, a1);
1990  PushVar(vm, a2);
1991  PushVar(vm, a3);
1992  PushVar(vm, a4);
1993  PushVar(vm, a5);
1994  PushVar(vm, a6);
1995  PushVar(vm, a7);
1996  PushVar(vm, a8);
1997  PushVar(vm, a9);
1998  PushVar(vm, a10);
1999  PushVar(vm, a11);
2000  PushVar(vm, a12);
2001  PushVar(vm, a13);
2002 
2003 #if !defined (SCRAT_NO_ERROR_CHECKING)
2004  SQRESULT result = sq_call(vm, 14, false, ErrorHandling::IsEnabled());
2005  sq_pop(vm, 2);
2006 
2007  //handle an error: throw the exception
2008  if(SQ_FAILED(result)) {
2009  Error::Instance().Throw(vm, LastErrorString(vm));
2010  return;
2011  }
2012 #else
2013  sq_call(vm, 14, false, ErrorHandling::IsEnabled());
2014  sq_pop(vm, 2);
2015 #endif
2016  }
2017 
2055  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
2056  void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
2057  sq_pushobject(vm, obj);
2058  sq_pushobject(vm, env);
2059 
2060 #if !defined (SCRAT_NO_ERROR_CHECKING)
2061  SQUnsignedInteger nparams;
2062  SQUnsignedInteger nfreevars;
2063  if (SQ_SUCCEEDED(sq_getclosureinfo(vm, -2, &nparams, &nfreevars)) && (nparams != 15)) {
2064  sq_pop(vm, 2);
2065  Error::Instance().Throw(vm, _SC("wrong number of parameters"));
2066  return;
2067  }
2068 #endif
2069 
2070  PushVar(vm, a1);
2071  PushVar(vm, a2);
2072  PushVar(vm, a3);
2073  PushVar(vm, a4);
2074  PushVar(vm, a5);
2075  PushVar(vm, a6);
2076  PushVar(vm, a7);
2077  PushVar(vm, a8);
2078  PushVar(vm, a9);
2079  PushVar(vm, a10);
2080  PushVar(vm, a11);
2081  PushVar(vm, a12);
2082  PushVar(vm, a13);
2083  PushVar(vm, a14);
2084 
2085 #if !defined (SCRAT_NO_ERROR_CHECKING)
2086  SQRESULT result = sq_call(vm, 15, false, ErrorHandling::IsEnabled());
2087  sq_pop(vm, 2);
2088 
2089  //handle an error: throw the exception
2090  if(SQ_FAILED(result)) {
2091  Error::Instance().Throw(vm, LastErrorString(vm));
2092  return;
2093  }
2094 #else
2095  sq_call(vm, 15, false, ErrorHandling::IsEnabled());
2096  sq_pop(vm, 2);
2097 #endif
2098  }
2099 
2107  void operator()() {
2108  Execute();
2109  }
2110 
2122  template <class A1>
2123  void operator()(A1 a1) {
2124  Execute(a1);
2125  }
2126 
2140  template <class A1, class A2>
2141  void operator()(A1 a1, A2 a2) {
2142  Execute(a1, a2);
2143  }
2144 
2160  template <class A1, class A2, class A3>
2161  void operator()(A1 a1, A2 a2, A3 a3) {
2162  Execute(a1, a2, a3);
2163  }
2164 
2182  template <class A1, class A2, class A3, class A4>
2183  void operator()(A1 a1, A2 a2, A3 a3, A4 a4) {
2184  Execute(a1, a2, a3, a4);
2185  }
2186 
2206  template <class A1, class A2, class A3, class A4, class A5>
2207  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
2208  Execute(a1, a2, a3, a4, a5);
2209  }
2210 
2232  template <class A1, class A2, class A3, class A4, class A5, class A6>
2233  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
2234  Execute(a1, a2, a3, a4, a5, a6);
2235  }
2236 
2260  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2261  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
2262  Execute(a1, a2, a3, a4, a5, a6, a7);
2263  }
2264 
2290  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2291  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
2292  Execute(a1, a2, a3, a4, a5, a6, a7, a8);
2293  }
2294 
2322  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2323  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
2324  Execute(a1, a2, a3, a4, a5, a6, a7, a8, a9);
2325  }
2326 
2356  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
2357  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
2358  Execute(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2359  }
2360 
2392  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
2393  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
2394  Execute(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
2395  }
2396 
2430  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
2431  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
2432  Execute(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
2433  }
2434 
2470  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
2471  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
2472  Execute(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
2473  }
2474 
2512  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
2513  void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
2514  Execute(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
2515  }
2516 };
2517 
2521 template<>
2522 struct Var<Function> {
2523 
2524  Function value;
2525 
2539  Var(HSQUIRRELVM vm, SQInteger idx) {
2540  HSQOBJECT sqEnv;
2541  HSQOBJECT sqValue;
2542  sq_getstackobj(vm, 1, &sqEnv);
2543  sq_getstackobj(vm, idx, &sqValue);
2544  value = Function(vm, sqEnv, sqValue);
2545 #if !defined (SCRAT_NO_ERROR_CHECKING)
2546  SQObjectType value_type = sq_gettype(vm, idx);
2547  if (value_type != OT_CLOSURE && value_type != OT_NATIVECLOSURE) {
2548  Error::Instance().Throw(vm, Sqrat::Error::FormatTypeError(vm, idx, _SC("closure")));
2549  }
2550 #endif
2551  }
2552 
2560  static void push(HSQUIRRELVM vm, Function& value) {
2561  sq_pushobject(vm, value.GetFunc());
2562  }
2563 };
2564 
2568 template<>
2569 struct Var<Function&> {
2570 
2571  Function value;
2572 
2586  Var(HSQUIRRELVM vm, SQInteger idx) {
2587  HSQOBJECT sqEnv;
2588  HSQOBJECT sqValue;
2589  sq_getstackobj(vm, 1, &sqEnv);
2590  sq_getstackobj(vm, idx, &sqValue);
2591  value = Function(vm, sqEnv, sqValue);
2592 #if !defined (SCRAT_NO_ERROR_CHECKING)
2593  SQObjectType value_type = sq_gettype(vm, idx);
2594  if (value_type != OT_CLOSURE && value_type != OT_NATIVECLOSURE) {
2595  Error::Instance().Throw(vm, Sqrat::Error::FormatTypeError(vm, idx, _SC("closure")));
2596  }
2597 #endif
2598  }
2599 
2607  static void push(HSQUIRRELVM vm, Function& value) {
2608  sq_pushobject(vm, value.GetFunc());
2609  }
2610 };
2611 
2612 }
2613 
2614 #endif
Sqrat::Function::Function
Function(HSQUIRRELVM v, HSQOBJECT e, HSQOBJECT o)
Definition: sqratFunction.h:101
Sqrat::Var< Function & >::push
static void push(HSQUIRRELVM vm, Function &value)
Definition: sqratFunction.h:2607
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
Definition: sqratFunction.h:1434
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2)
Definition: sqratFunction.h:295
Sqrat::Object::GetType
SQObjectType GetType() const
Definition: sqratObject.h:162
Sqrat::Var::value
T value
The actual value of get operations.
Definition: sqratTypes.h:152
Sqrat::Function::~Function
~Function()
Definition: sqratFunction.h:110
Sqrat::Var< Function >::value
Function value
The actual value of get operations.
Definition: sqratFunction.h:2524
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4)
Definition: sqratFunction.h:407
Sqrat::Var
Definition: sqratTypes.h:150
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14)
Definition: sqratFunction.h:1143
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3)
Definition: sqratFunction.h:1329
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14)
Definition: sqratFunction.h:2056
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
Definition: sqratFunction.h:597
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2)
Definition: sqratFunction.h:1281
Sqrat::ErrorHandling::IsEnabled
static bool IsEnabled()
Definition: sqratUtil.h:244
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4)
Definition: sqratFunction.h:2183
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3)
Definition: sqratFunction.h:2161
Sqrat::Var< Function >::Var
Var(HSQUIRRELVM vm, SQInteger idx)
Definition: sqratFunction.h:2539
Sqrat::Function::operator()
void operator()(A1 a1)
Definition: sqratFunction.h:2123
Sqrat::Function::Release
void Release()
Definition: sqratFunction.h:176
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
Definition: sqratFunction.h:1614
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
Definition: sqratFunction.h:1551
Sqrat::Error::FormatTypeError
static string FormatTypeError(HSQUIRRELVM vm, SQInteger idx, const string &expectedType)
Definition: sqratUtil.h:149
Sqrat::Function::IsNull
bool IsNull()
Definition: sqratFunction.h:138
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2)
Definition: sqratFunction.h:2141
Sqrat::Function::operator()
void operator()()
Definition: sqratFunction.h:2107
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3)
Definition: sqratFunction.h:350
Sqrat::Function::GetEnv
HSQOBJECT & GetEnv()
Definition: sqratFunction.h:148
Sqrat::Var< Function & >::value
Function value
The actual value of get operations.
Definition: sqratFunction.h:2571
Sqrat::Object::GetSlot
Object GetSlot(const SQChar *slot) const
Definition: sqratObject.h:221
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
Definition: sqratFunction.h:2323
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
Definition: sqratFunction.h:1680
Sqrat::Function
Represents a function in Squirrel.
Definition: sqratFunction.h:40
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
Definition: sqratFunction.h:2207
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12)
Definition: sqratFunction.h:972
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Definition: sqratFunction.h:2357
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4)
Definition: sqratFunction.h:1380
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12)
Definition: sqratFunction.h:1896
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
Definition: sqratFunction.h:2233
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12)
Definition: sqratFunction.h:2431
Sqrat::SharedPtr
Definition: sqratUtil.h:291
Sqrat::Object::GetObject
virtual HSQOBJECT GetObject() const
Definition: sqratObject.h:182
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
Definition: sqratFunction.h:467
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
Definition: sqratFunction.h:738
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11)
Definition: sqratFunction.h:1821
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13)
Definition: sqratFunction.h:1056
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13)
Definition: sqratFunction.h:1975
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate()
Definition: sqratFunction.h:197
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
Definition: sqratFunction.h:666
Sqrat::Object
Definition: sqratObject.h:48
Sqrat::Error::Instance
static Error & Instance()
Definition: sqratUtil.h:134
Sqrat::ArrayBase
The base class for Array that implements almost all of its functionality.
Definition: sqratArray.h:43
Sqrat::Error::Throw
void Throw(HSQUIRRELVM vm, const string &err)
Definition: sqratUtil.h:210
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
Definition: sqratFunction.h:530
Sqrat::Function::GetFunc
HSQOBJECT & GetFunc()
Definition: sqratFunction.h:158
Sqrat::TableBase
The base class for Table that implements almost all of its functionality.
Definition: sqratTable.h:43
Sqrat::Var< Function & >::Var
Var(HSQUIRRELVM vm, SQInteger idx)
Definition: sqratFunction.h:2586
Sqrat::Function::Function
Function(const Function &sf)
Definition: sqratFunction.h:65
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11)
Definition: sqratFunction.h:891
Sqrat::Table
Represents a table in Squirrel.
Definition: sqratTable.h:357
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Definition: sqratFunction.h:1749
Sqrat::Var< Function >::push
static void push(HSQUIRRELVM vm, Function &value)
Definition: sqratFunction.h:2560
Sqrat::Function::GetVM
HSQUIRRELVM & GetVM()
Definition: sqratFunction.h:168
Sqrat::Function::Function
Function()
Definition: sqratFunction.h:54
Sqrat::Function::Execute
void Execute()
Definition: sqratFunction.h:1197
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
Definition: sqratFunction.h:2261
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14)
Definition: sqratFunction.h:2513
Sqrat::Function::Execute
void Execute(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
Definition: sqratFunction.h:1491
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1)
Definition: sqratFunction.h:243
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13)
Definition: sqratFunction.h:2471
Sqrat::Function::operator=
Function & operator=(const Function &sf)
Definition: sqratFunction.h:122
Sqrat::Function::Execute
void Execute(A1 a1)
Definition: sqratFunction.h:1236
Sqrat::Function::Evaluate
SharedPtr< R > Evaluate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
Definition: sqratFunction.h:813
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
Definition: sqratFunction.h:2291
Sqrat::Function::Function
Function(const Object &e, const SQChar *slot)
Definition: sqratFunction.h:80
Sqrat::Function::operator()
void operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11)
Definition: sqratFunction.h:2393
Generated by   doxygen 1.8.6