sqrat  0.9
sqrat
 All Classes Functions Variables Enumerations Enumerator Pages
sqratGlobalMethods.h
1 //
2 // SqratGlobalMethods: Global Methods
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_GLOBAL_METHODS_H_)
30 #define _SCRAT_GLOBAL_METHODS_H_
31 
32 #include <squirrel.h>
33 #include "sqratTypes.h"
34 
35 namespace Sqrat {
36 
38 
39 
40 //
41 // Squirrel Global Functions
42 //
43 template <class R>
44 class SqGlobal {
45 public:
46  // Arg Count 0
47  template <bool overloaded /* = false */ >
48  static SQInteger Func0(HSQUIRRELVM vm) {
49 
50 #if !defined (SCRAT_NO_ERROR_CHECKING)
51  if (!overloaded && sq_gettop(vm) != 2) {
52  return sq_throwerror(vm, _SC("wrong number of parameters"));
53  }
54 #endif
55 
56  typedef R (*M)();
57  M* method;
58  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
59 
60  R ret = (*method)();
61 
62 #if !defined (SCRAT_NO_ERROR_CHECKING)
63  if (!overloaded && Error::Instance().Occurred(vm)) {
64  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
65  }
66 #endif
67 
68  PushVar(vm, ret);
69  return 1;
70  }
71 
72  // Arg Count 1
73  template <class A1, SQInteger startIdx, bool overloaded /*= false*/>
74  static SQInteger Func1(HSQUIRRELVM vm) {
75 
76 #if !defined (SCRAT_NO_ERROR_CHECKING)
77  if (!overloaded && sq_gettop(vm) != startIdx + 1) {
78  return sq_throwerror(vm, _SC("wrong number of parameters"));
79  }
80 #endif
81 
82  typedef R (*M)(A1);
83  M* method;
84  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
85 
86  Var<A1> a1(vm, startIdx);
87 
88 #if !defined (SCRAT_NO_ERROR_CHECKING)
89  if (Error::Instance().Occurred(vm)) {
90  if (overloaded)
91  return 0;
92  else
93  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
94  }
95 #endif
96 
97  R ret = (*method)(
98  a1.value
99  );
100 
101 #if !defined (SCRAT_NO_ERROR_CHECKING)
102  if (!overloaded && Error::Instance().Occurred(vm)) {
103  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
104  }
105 #endif
106 
107  PushVar(vm, ret);
108  return 1;
109  }
110 
111  // Arg Count 2
112  template <class A1, class A2, SQInteger startIdx, bool overloaded /*= false*/>
113  static SQInteger Func2(HSQUIRRELVM vm) {
114 
115 #if !defined (SCRAT_NO_ERROR_CHECKING)
116  if (!overloaded && sq_gettop(vm) != startIdx + 2) {
117  return sq_throwerror(vm, _SC("wrong number of parameters"));
118  }
119 #endif
120 
121  typedef R (*M)(A1, A2);
122  M* method;
123  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
124 
125  Var<A1> a1(vm, startIdx);
126  Var<A2> a2(vm, startIdx + 1);
127 
128 #if !defined (SCRAT_NO_ERROR_CHECKING)
129  if (Error::Instance().Occurred(vm)) {
130  if (overloaded)
131  return 0;
132  else
133  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
134  }
135 #endif
136 
137  R ret = (*method)(
138  a1.value,
139  a2.value
140  );
141 
142 #if !defined (SCRAT_NO_ERROR_CHECKING)
143  if (!overloaded && Error::Instance().Occurred(vm)) {
144  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
145  }
146 #endif
147 
148  PushVar(vm, ret);
149  return 1;
150  }
151 
152  // Arg Count 3
153  template <class A1, class A2, class A3, SQInteger startIdx, bool overloaded /*= false*/>
154  static SQInteger Func3(HSQUIRRELVM vm) {
155 
156 #if !defined (SCRAT_NO_ERROR_CHECKING)
157  if (!overloaded && sq_gettop(vm) != startIdx + 3) {
158  return sq_throwerror(vm, _SC("wrong number of parameters"));
159  }
160 #endif
161 
162  typedef R (*M)(A1, A2, A3);
163  M* method;
164  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
165 
166  Var<A1> a1(vm, startIdx);
167  Var<A2> a2(vm, startIdx + 1);
168  Var<A3> a3(vm, startIdx + 2);
169 
170 #if !defined (SCRAT_NO_ERROR_CHECKING)
171  if (Error::Instance().Occurred(vm)) {
172  if (overloaded)
173  return 0;
174  else
175  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
176  }
177 #endif
178 
179  R ret = (*method)(
180  a1.value,
181  a2.value,
182  a3.value
183  );
184 
185 #if !defined (SCRAT_NO_ERROR_CHECKING)
186  if (!overloaded && Error::Instance().Occurred(vm)) {
187  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
188  }
189 #endif
190 
191  PushVar(vm, ret);
192  return 1;
193  }
194 
195  // Arg Count 4
196  template <class A1, class A2, class A3, class A4, SQInteger startIdx, bool overloaded /*= false*/>
197  static SQInteger Func4(HSQUIRRELVM vm) {
198 
199 #if !defined (SCRAT_NO_ERROR_CHECKING)
200  if (!overloaded && sq_gettop(vm) != startIdx + 4) {
201  return sq_throwerror(vm, _SC("wrong number of parameters"));
202  }
203 #endif
204 
205  typedef R (*M)(A1, A2, A3, A4);
206  M* method;
207  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
208 
209  Var<A1> a1(vm, startIdx);
210  Var<A2> a2(vm, startIdx + 1);
211  Var<A3> a3(vm, startIdx + 2);
212  Var<A4> a4(vm, startIdx + 3);
213 
214 #if !defined (SCRAT_NO_ERROR_CHECKING)
215  if (Error::Instance().Occurred(vm)) {
216  if (overloaded)
217  return 0;
218  else
219  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
220  }
221 #endif
222 
223  R ret = (*method)(
224  a1.value,
225  a2.value,
226  a3.value,
227  a4.value
228  );
229 
230 #if !defined (SCRAT_NO_ERROR_CHECKING)
231  if (!overloaded && Error::Instance().Occurred(vm)) {
232  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
233  }
234 #endif
235 
236  PushVar(vm, ret);
237  return 1;
238  }
239 
240  // Arg Count 5
241  template <class A1, class A2, class A3, class A4, class A5, SQInteger startIdx, bool overloaded /*= false*/>
242  static SQInteger Func5(HSQUIRRELVM vm) {
243 
244 #if !defined (SCRAT_NO_ERROR_CHECKING)
245  if (!overloaded && sq_gettop(vm) != startIdx + 5) {
246  return sq_throwerror(vm, _SC("wrong number of parameters"));
247  }
248 #endif
249 
250  typedef R (*M)(A1, A2, A3, A4, A5);
251  M* method;
252  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
253 
254  Var<A1> a1(vm, startIdx);
255  Var<A2> a2(vm, startIdx + 1);
256  Var<A3> a3(vm, startIdx + 2);
257  Var<A4> a4(vm, startIdx + 3);
258  Var<A5> a5(vm, startIdx + 4);
259 
260 #if !defined (SCRAT_NO_ERROR_CHECKING)
261  if (Error::Instance().Occurred(vm)) {
262  if (overloaded)
263  return 0;
264  else
265  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
266  }
267 #endif
268 
269  R ret = (*method)(
270  a1.value,
271  a2.value,
272  a3.value,
273  a4.value,
274  a5.value
275  );
276 
277 #if !defined (SCRAT_NO_ERROR_CHECKING)
278  if (!overloaded && Error::Instance().Occurred(vm)) {
279  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
280  }
281 #endif
282 
283  PushVar(vm, ret);
284  return 1;
285  }
286 
287  // Arg Count 6
288  template <class A1, class A2, class A3, class A4, class A5, class A6, SQInteger startIdx, bool overloaded /*= false*/>
289  static SQInteger Func6(HSQUIRRELVM vm) {
290 
291 #if !defined (SCRAT_NO_ERROR_CHECKING)
292  if (!overloaded && sq_gettop(vm) != startIdx + 6) {
293  return sq_throwerror(vm, _SC("wrong number of parameters"));
294  }
295 #endif
296 
297  typedef R (*M)(A1, A2, A3, A4, A5, A6);
298  M* method;
299  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
300 
301  Var<A1> a1(vm, startIdx);
302  Var<A2> a2(vm, startIdx + 1);
303  Var<A3> a3(vm, startIdx + 2);
304  Var<A4> a4(vm, startIdx + 3);
305  Var<A5> a5(vm, startIdx + 4);
306  Var<A6> a6(vm, startIdx + 5);
307 
308 #if !defined (SCRAT_NO_ERROR_CHECKING)
309  if (Error::Instance().Occurred(vm)) {
310  if (overloaded)
311  return 0;
312  else
313  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
314  }
315 #endif
316 
317  R ret = (*method)(
318  a1.value,
319  a2.value,
320  a3.value,
321  a4.value,
322  a5.value,
323  a6.value
324  );
325 
326 #if !defined (SCRAT_NO_ERROR_CHECKING)
327  if (!overloaded && Error::Instance().Occurred(vm)) {
328  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
329  }
330 #endif
331 
332  PushVar(vm, ret);
333  return 1;
334  }
335 
336  // Arg Count 7
337  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, SQInteger startIdx, bool overloaded /*= false*/>
338  static SQInteger Func7(HSQUIRRELVM vm) {
339 
340 #if !defined (SCRAT_NO_ERROR_CHECKING)
341  if (!overloaded && sq_gettop(vm) != startIdx + 7) {
342  return sq_throwerror(vm, _SC("wrong number of parameters"));
343  }
344 #endif
345 
346  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7);
347  M* method;
348  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
349 
350  Var<A1> a1(vm, startIdx);
351  Var<A2> a2(vm, startIdx + 1);
352  Var<A3> a3(vm, startIdx + 2);
353  Var<A4> a4(vm, startIdx + 3);
354  Var<A5> a5(vm, startIdx + 4);
355  Var<A6> a6(vm, startIdx + 5);
356  Var<A7> a7(vm, startIdx + 6);
357 
358 #if !defined (SCRAT_NO_ERROR_CHECKING)
359  if (Error::Instance().Occurred(vm)) {
360  if (overloaded)
361  return 0;
362  else
363  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
364  }
365 #endif
366 
367  R ret = (*method)(
368  a1.value,
369  a2.value,
370  a3.value,
371  a4.value,
372  a5.value,
373  a6.value,
374  a7.value
375  );
376 
377 #if !defined (SCRAT_NO_ERROR_CHECKING)
378  if (!overloaded && Error::Instance().Occurred(vm)) {
379  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
380  }
381 #endif
382 
383  PushVar(vm, ret);
384  return 1;
385  }
386 
387  // Arg Count 8
388  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, SQInteger startIdx, bool overloaded /*= false*/>
389  static SQInteger Func8(HSQUIRRELVM vm) {
390 
391 #if !defined (SCRAT_NO_ERROR_CHECKING)
392  if (!overloaded && sq_gettop(vm) != startIdx + 8) {
393  return sq_throwerror(vm, _SC("wrong number of parameters"));
394  }
395 #endif
396 
397  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7, A8);
398  M* method;
399  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
400 
401  Var<A1> a1(vm, startIdx);
402  Var<A2> a2(vm, startIdx + 1);
403  Var<A3> a3(vm, startIdx + 2);
404  Var<A4> a4(vm, startIdx + 3);
405  Var<A5> a5(vm, startIdx + 4);
406  Var<A6> a6(vm, startIdx + 5);
407  Var<A7> a7(vm, startIdx + 6);
408  Var<A8> a8(vm, startIdx + 7);
409 
410 #if !defined (SCRAT_NO_ERROR_CHECKING)
411  if (Error::Instance().Occurred(vm)) {
412  if (overloaded)
413  return 0;
414  else
415  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
416  }
417 #endif
418 
419  R ret = (*method)(
420  a1.value,
421  a2.value,
422  a3.value,
423  a4.value,
424  a5.value,
425  a6.value,
426  a7.value,
427  a8.value
428  );
429 
430 #if !defined (SCRAT_NO_ERROR_CHECKING)
431  if (!overloaded && Error::Instance().Occurred(vm)) {
432  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
433  }
434 #endif
435 
436  PushVar(vm, ret);
437  return 1;
438  }
439 
440  // Arg Count 9
441  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, SQInteger startIdx, bool overloaded /*= false*/>
442  static SQInteger Func9(HSQUIRRELVM vm) {
443 
444 #if !defined (SCRAT_NO_ERROR_CHECKING)
445  if (!overloaded && sq_gettop(vm) != startIdx + 9) {
446  return sq_throwerror(vm, _SC("wrong number of parameters"));
447  }
448 #endif
449 
450  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
451  M* method;
452  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
453 
454  Var<A1> a1(vm, startIdx);
455  Var<A2> a2(vm, startIdx + 1);
456  Var<A3> a3(vm, startIdx + 2);
457  Var<A4> a4(vm, startIdx + 3);
458  Var<A5> a5(vm, startIdx + 4);
459  Var<A6> a6(vm, startIdx + 5);
460  Var<A7> a7(vm, startIdx + 6);
461  Var<A8> a8(vm, startIdx + 7);
462  Var<A9> a9(vm, startIdx + 8);
463 
464 #if !defined (SCRAT_NO_ERROR_CHECKING)
465  if (Error::Instance().Occurred(vm)) {
466  if (overloaded)
467  return 0;
468  else
469  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
470  }
471 #endif
472 
473  R ret = (*method)(
474  a1.value,
475  a2.value,
476  a3.value,
477  a4.value,
478  a5.value,
479  a6.value,
480  a7.value,
481  a8.value,
482  a9.value
483  );
484 
485 #if !defined (SCRAT_NO_ERROR_CHECKING)
486  if (!overloaded && Error::Instance().Occurred(vm)) {
487  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
488  }
489 #endif
490 
491  PushVar(vm, ret);
492  return 1;
493  }
494 
495  // Arg Count 10
496  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, SQInteger startIdx, bool overloaded /*= false*/>
497  static SQInteger Func10(HSQUIRRELVM vm) {
498 
499 #if !defined (SCRAT_NO_ERROR_CHECKING)
500  if (!overloaded && sq_gettop(vm) != startIdx + 10) {
501  return sq_throwerror(vm, _SC("wrong number of parameters"));
502  }
503 #endif
504 
505  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
506  M* method;
507  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
508 
509  Var<A1> a1(vm, startIdx);
510  Var<A2> a2(vm, startIdx + 1);
511  Var<A3> a3(vm, startIdx + 2);
512  Var<A4> a4(vm, startIdx + 3);
513  Var<A5> a5(vm, startIdx + 4);
514  Var<A6> a6(vm, startIdx + 5);
515  Var<A7> a7(vm, startIdx + 6);
516  Var<A8> a8(vm, startIdx + 7);
517  Var<A9> a9(vm, startIdx + 8);
518  Var<A10> a10(vm, startIdx + 9);
519 
520 #if !defined (SCRAT_NO_ERROR_CHECKING)
521  if (Error::Instance().Occurred(vm)) {
522  if (overloaded)
523  return 0;
524  else
525  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
526  }
527 #endif
528 
529  R ret = (*method)(
530  a1.value,
531  a2.value,
532  a3.value,
533  a4.value,
534  a5.value,
535  a6.value,
536  a7.value,
537  a8.value,
538  a9.value,
539  a10.value
540  );
541 
542 #if !defined (SCRAT_NO_ERROR_CHECKING)
543  if (!overloaded && Error::Instance().Occurred(vm)) {
544  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
545  }
546 #endif
547 
548  PushVar(vm, ret);
549  return 1;
550  }
551 
552  // Arg Count 11
553  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, SQInteger startIdx, bool overloaded /*= false*/>
554  static SQInteger Func11(HSQUIRRELVM vm) {
555 
556 #if !defined (SCRAT_NO_ERROR_CHECKING)
557  if (!overloaded && sq_gettop(vm) != startIdx + 11) {
558  return sq_throwerror(vm, _SC("wrong number of parameters"));
559  }
560 #endif
561 
562  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
563  M* method;
564  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
565 
566  Var<A1> a1(vm, startIdx);
567  Var<A2> a2(vm, startIdx + 1);
568  Var<A3> a3(vm, startIdx + 2);
569  Var<A4> a4(vm, startIdx + 3);
570  Var<A5> a5(vm, startIdx + 4);
571  Var<A6> a6(vm, startIdx + 5);
572  Var<A7> a7(vm, startIdx + 6);
573  Var<A8> a8(vm, startIdx + 7);
574  Var<A9> a9(vm, startIdx + 8);
575  Var<A10> a10(vm, startIdx + 9);
576  Var<A11> a11(vm, startIdx + 10);
577 
578 #if !defined (SCRAT_NO_ERROR_CHECKING)
579  if (Error::Instance().Occurred(vm)) {
580  if (overloaded)
581  return 0;
582  else
583  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
584  }
585 #endif
586 
587  R ret = (*method)(
588  a1.value,
589  a2.value,
590  a3.value,
591  a4.value,
592  a5.value,
593  a6.value,
594  a7.value,
595  a8.value,
596  a9.value,
597  a10.value,
598  a11.value
599  );
600 
601 #if !defined (SCRAT_NO_ERROR_CHECKING)
602  if (!overloaded && Error::Instance().Occurred(vm)) {
603  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
604  }
605 #endif
606 
607  PushVar(vm, ret);
608  return 1;
609  }
610 
611  // Arg Count 12
612  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, SQInteger startIdx, bool overloaded /*= false*/>
613  static SQInteger Func12(HSQUIRRELVM vm) {
614 
615 #if !defined (SCRAT_NO_ERROR_CHECKING)
616  if (!overloaded && sq_gettop(vm) != startIdx + 12) {
617  return sq_throwerror(vm, _SC("wrong number of parameters"));
618  }
619 #endif
620 
621  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
622  M* method;
623  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
624 
625  Var<A1> a1(vm, startIdx);
626  Var<A2> a2(vm, startIdx + 1);
627  Var<A3> a3(vm, startIdx + 2);
628  Var<A4> a4(vm, startIdx + 3);
629  Var<A5> a5(vm, startIdx + 4);
630  Var<A6> a6(vm, startIdx + 5);
631  Var<A7> a7(vm, startIdx + 6);
632  Var<A8> a8(vm, startIdx + 7);
633  Var<A9> a9(vm, startIdx + 8);
634  Var<A10> a10(vm, startIdx + 9);
635  Var<A11> a11(vm, startIdx + 10);
636  Var<A12> a12(vm, startIdx + 11);
637 
638 #if !defined (SCRAT_NO_ERROR_CHECKING)
639  if (Error::Instance().Occurred(vm)) {
640  if (overloaded)
641  return 0;
642  else
643  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
644  }
645 #endif
646 
647  R ret = (*method)(
648  a1.value,
649  a2.value,
650  a3.value,
651  a4.value,
652  a5.value,
653  a6.value,
654  a7.value,
655  a8.value,
656  a9.value,
657  a10.value,
658  a11.value,
659  a12.value
660  );
661 
662 #if !defined (SCRAT_NO_ERROR_CHECKING)
663  if (!overloaded && Error::Instance().Occurred(vm)) {
664  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
665  }
666 #endif
667 
668  PushVar(vm, ret);
669  return 1;
670  }
671 
672  // Arg Count 13
673  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, SQInteger startIdx, bool overloaded /*= false*/>
674  static SQInteger Func13(HSQUIRRELVM vm) {
675 
676 #if !defined (SCRAT_NO_ERROR_CHECKING)
677  if (!overloaded && sq_gettop(vm) != startIdx + 13) {
678  return sq_throwerror(vm, _SC("wrong number of parameters"));
679  }
680 #endif
681 
682  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
683  M* method;
684  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
685 
686  Var<A1> a1(vm, startIdx);
687  Var<A2> a2(vm, startIdx + 1);
688  Var<A3> a3(vm, startIdx + 2);
689  Var<A4> a4(vm, startIdx + 3);
690  Var<A5> a5(vm, startIdx + 4);
691  Var<A6> a6(vm, startIdx + 5);
692  Var<A7> a7(vm, startIdx + 6);
693  Var<A8> a8(vm, startIdx + 7);
694  Var<A9> a9(vm, startIdx + 8);
695  Var<A10> a10(vm, startIdx + 9);
696  Var<A11> a11(vm, startIdx + 10);
697  Var<A12> a12(vm, startIdx + 11);
698  Var<A13> a13(vm, startIdx + 12);
699 
700 #if !defined (SCRAT_NO_ERROR_CHECKING)
701  if (Error::Instance().Occurred(vm)) {
702  if (overloaded)
703  return 0;
704  else
705  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
706  }
707 #endif
708 
709  R ret = (*method)(
710  a1.value,
711  a2.value,
712  a3.value,
713  a4.value,
714  a5.value,
715  a6.value,
716  a7.value,
717  a8.value,
718  a9.value,
719  a10.value,
720  a11.value,
721  a12.value,
722  a13.value
723  );
724 
725 #if !defined (SCRAT_NO_ERROR_CHECKING)
726  if (!overloaded && Error::Instance().Occurred(vm)) {
727  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
728  }
729 #endif
730 
731  PushVar(vm, ret);
732  return 1;
733  }
734 
735  // Arg Count 14
736  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, SQInteger startIdx, bool overloaded /*= false*/>
737  static SQInteger Func14(HSQUIRRELVM vm) {
738 
739 #if !defined (SCRAT_NO_ERROR_CHECKING)
740  if (!overloaded && sq_gettop(vm) != startIdx + 14) {
741  return sq_throwerror(vm, _SC("wrong number of parameters"));
742  }
743 #endif
744 
745  typedef R (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
746  M* method;
747  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
748 
749  Var<A1> a1(vm, startIdx);
750  Var<A2> a2(vm, startIdx + 1);
751  Var<A3> a3(vm, startIdx + 2);
752  Var<A4> a4(vm, startIdx + 3);
753  Var<A5> a5(vm, startIdx + 4);
754  Var<A6> a6(vm, startIdx + 5);
755  Var<A7> a7(vm, startIdx + 6);
756  Var<A8> a8(vm, startIdx + 7);
757  Var<A9> a9(vm, startIdx + 8);
758  Var<A10> a10(vm, startIdx + 9);
759  Var<A11> a11(vm, startIdx + 10);
760  Var<A12> a12(vm, startIdx + 11);
761  Var<A13> a13(vm, startIdx + 12);
762  Var<A14> a14(vm, startIdx + 13);
763 
764 #if !defined (SCRAT_NO_ERROR_CHECKING)
765  if (Error::Instance().Occurred(vm)) {
766  if (overloaded)
767  return 0;
768  else
769  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
770  }
771 #endif
772 
773  R ret = (*method)(
774  a1.value,
775  a2.value,
776  a3.value,
777  a4.value,
778  a5.value,
779  a6.value,
780  a7.value,
781  a8.value,
782  a9.value,
783  a10.value,
784  a11.value,
785  a12.value,
786  a13.value,
787  a14.value
788  );
789 
790 #if !defined (SCRAT_NO_ERROR_CHECKING)
791  if (!overloaded && Error::Instance().Occurred(vm)) {
792  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
793  }
794 #endif
795 
796  PushVar(vm, ret);
797  return 1;
798  }
799 };
800 
801 
802 //
803 // reference return specialization
804 //
805 
806 template <class R>
807 class SqGlobal<R& > {
808 public:
809  // Arg Count 0
810  template <bool overloaded /* = false */ >
811  static SQInteger Func0(HSQUIRRELVM vm) {
812 
813 #if !defined (SCRAT_NO_ERROR_CHECKING)
814  if (!overloaded && sq_gettop(vm) != 2) {
815  return sq_throwerror(vm, _SC("wrong number of parameters"));
816  }
817 #endif
818 
819  typedef R & (*M)();
820  M* method;
821  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
822 
823  R & ret = (*method)();
824 
825 #if !defined (SCRAT_NO_ERROR_CHECKING)
826  if (!overloaded && Error::Instance().Occurred(vm)) {
827  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
828  }
829 #endif
830 
831  PushVarR(vm, ret);
832  return 1;
833  }
834 
835  // Arg Count 1
836  template <class A1, SQInteger startIdx, bool overloaded /*= false*/>
837  static SQInteger Func1(HSQUIRRELVM vm) {
838 
839 #if !defined (SCRAT_NO_ERROR_CHECKING)
840  if (!overloaded && sq_gettop(vm) != startIdx + 1) {
841  return sq_throwerror(vm, _SC("wrong number of parameters"));
842  }
843 #endif
844 
845  typedef R & (*M)(A1);
846  M* method;
847  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
848 
849  Var<A1> a1(vm, startIdx);
850 
851 #if !defined (SCRAT_NO_ERROR_CHECKING)
852  if (Error::Instance().Occurred(vm)) {
853  if (overloaded)
854  return 0;
855  else
856  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
857  }
858 #endif
859 
860  R & ret = (*method)(
861  a1.value
862  );
863 
864 #if !defined (SCRAT_NO_ERROR_CHECKING)
865  if (!overloaded && Error::Instance().Occurred(vm)) {
866  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
867  }
868 #endif
869 
870  PushVarR(vm, ret);
871  return 1;
872  }
873 
874  // Arg Count 2
875  template <class A1, class A2, SQInteger startIdx, bool overloaded /*= false*/>
876  static SQInteger Func2(HSQUIRRELVM vm) {
877 
878 #if !defined (SCRAT_NO_ERROR_CHECKING)
879  if (!overloaded && sq_gettop(vm) != startIdx + 2) {
880  return sq_throwerror(vm, _SC("wrong number of parameters"));
881  }
882 #endif
883 
884  typedef R & (*M)(A1, A2);
885  M* method;
886  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
887 
888  Var<A1> a1(vm, startIdx);
889  Var<A2> a2(vm, startIdx + 1);
890 
891 #if !defined (SCRAT_NO_ERROR_CHECKING)
892  if (Error::Instance().Occurred(vm)) {
893  if (overloaded)
894  return 0;
895  else
896  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
897  }
898 #endif
899 
900  R & ret = (*method)(
901  a1.value,
902  a2.value
903  );
904 
905 #if !defined (SCRAT_NO_ERROR_CHECKING)
906  if (!overloaded && Error::Instance().Occurred(vm)) {
907  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
908  }
909 #endif
910 
911  PushVarR(vm, ret);
912  return 1;
913  }
914 
915  // Arg Count 3
916  template <class A1, class A2, class A3, SQInteger startIdx, bool overloaded /*= false*/>
917  static SQInteger Func3(HSQUIRRELVM vm) {
918 
919 #if !defined (SCRAT_NO_ERROR_CHECKING)
920  if (!overloaded && sq_gettop(vm) != startIdx + 3) {
921  return sq_throwerror(vm, _SC("wrong number of parameters"));
922  }
923 #endif
924 
925  typedef R & (*M)(A1, A2, A3);
926  M* method;
927  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
928 
929  Var<A1> a1(vm, startIdx);
930  Var<A2> a2(vm, startIdx + 1);
931  Var<A3> a3(vm, startIdx + 2);
932 
933 #if !defined (SCRAT_NO_ERROR_CHECKING)
934  if (Error::Instance().Occurred(vm)) {
935  if (overloaded)
936  return 0;
937  else
938  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
939  }
940 #endif
941 
942  R & ret = (*method)(
943  a1.value,
944  a2.value,
945  a3.value
946  );
947 
948 #if !defined (SCRAT_NO_ERROR_CHECKING)
949  if (!overloaded && Error::Instance().Occurred(vm)) {
950  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
951  }
952 #endif
953 
954  PushVarR(vm, ret);
955  return 1;
956  }
957 
958  // Arg Count 4
959  template <class A1, class A2, class A3, class A4, SQInteger startIdx, bool overloaded /*= false*/>
960  static SQInteger Func4(HSQUIRRELVM vm) {
961 
962 #if !defined (SCRAT_NO_ERROR_CHECKING)
963  if (!overloaded && sq_gettop(vm) != startIdx + 4) {
964  return sq_throwerror(vm, _SC("wrong number of parameters"));
965  }
966 #endif
967 
968  typedef R & (*M)(A1, A2, A3, A4);
969  M* method;
970  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
971 
972  Var<A1> a1(vm, startIdx);
973  Var<A2> a2(vm, startIdx + 1);
974  Var<A3> a3(vm, startIdx + 2);
975  Var<A4> a4(vm, startIdx + 3);
976 
977 #if !defined (SCRAT_NO_ERROR_CHECKING)
978  if (Error::Instance().Occurred(vm)) {
979  if (overloaded)
980  return 0;
981  else
982  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
983  }
984 #endif
985 
986  R & ret = (*method)(
987  a1.value,
988  a2.value,
989  a3.value,
990  a4.value
991  );
992 
993 #if !defined (SCRAT_NO_ERROR_CHECKING)
994  if (!overloaded && Error::Instance().Occurred(vm)) {
995  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
996  }
997 #endif
998 
999  PushVarR(vm, ret);
1000  return 1;
1001  }
1002 
1003  // Arg Count 5
1004  template <class A1, class A2, class A3, class A4, class A5, SQInteger startIdx, bool overloaded /*= false*/>
1005  static SQInteger Func5(HSQUIRRELVM vm) {
1006 
1007 #if !defined (SCRAT_NO_ERROR_CHECKING)
1008  if (!overloaded && sq_gettop(vm) != startIdx + 5) {
1009  return sq_throwerror(vm, _SC("wrong number of parameters"));
1010  }
1011 #endif
1012 
1013  typedef R & (*M)(A1, A2, A3, A4, A5);
1014  M* method;
1015  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1016 
1017  Var<A1> a1(vm, startIdx);
1018  Var<A2> a2(vm, startIdx + 1);
1019  Var<A3> a3(vm, startIdx + 2);
1020  Var<A4> a4(vm, startIdx + 3);
1021  Var<A5> a5(vm, startIdx + 4);
1022 
1023 #if !defined (SCRAT_NO_ERROR_CHECKING)
1024  if (Error::Instance().Occurred(vm)) {
1025  if (overloaded)
1026  return 0;
1027  else
1028  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1029  }
1030 #endif
1031 
1032  R & ret = (*method)(
1033  a1.value,
1034  a2.value,
1035  a3.value,
1036  a4.value,
1037  a5.value
1038  );
1039 
1040 #if !defined (SCRAT_NO_ERROR_CHECKING)
1041  if (!overloaded && Error::Instance().Occurred(vm)) {
1042  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1043  }
1044 #endif
1045 
1046  PushVarR(vm, ret);
1047  return 1;
1048  }
1049 
1050  // Arg Count 6
1051  template <class A1, class A2, class A3, class A4, class A5, class A6, SQInteger startIdx, bool overloaded /*= false*/>
1052  static SQInteger Func6(HSQUIRRELVM vm) {
1053 
1054 #if !defined (SCRAT_NO_ERROR_CHECKING)
1055  if (!overloaded && sq_gettop(vm) != startIdx + 6) {
1056  return sq_throwerror(vm, _SC("wrong number of parameters"));
1057  }
1058 #endif
1059 
1060  typedef R & (*M)(A1, A2, A3, A4, A5, A6);
1061  M* method;
1062  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1063 
1064  Var<A1> a1(vm, startIdx);
1065  Var<A2> a2(vm, startIdx + 1);
1066  Var<A3> a3(vm, startIdx + 2);
1067  Var<A4> a4(vm, startIdx + 3);
1068  Var<A5> a5(vm, startIdx + 4);
1069  Var<A6> a6(vm, startIdx + 5);
1070 
1071 #if !defined (SCRAT_NO_ERROR_CHECKING)
1072  if (Error::Instance().Occurred(vm)) {
1073  if (overloaded)
1074  return 0;
1075  else
1076  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1077  }
1078 #endif
1079 
1080  R & ret = (*method)(
1081  a1.value,
1082  a2.value,
1083  a3.value,
1084  a4.value,
1085  a5.value,
1086  a6.value
1087  );
1088 
1089 #if !defined (SCRAT_NO_ERROR_CHECKING)
1090  if (!overloaded && Error::Instance().Occurred(vm)) {
1091  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1092  }
1093 #endif
1094 
1095  PushVarR(vm, ret);
1096  return 1;
1097  }
1098 
1099  // Arg Count 7
1100  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, SQInteger startIdx, bool overloaded /*= false*/>
1101  static SQInteger Func7(HSQUIRRELVM vm) {
1102 
1103 #if !defined (SCRAT_NO_ERROR_CHECKING)
1104  if (!overloaded && sq_gettop(vm) != startIdx + 7) {
1105  return sq_throwerror(vm, _SC("wrong number of parameters"));
1106  }
1107 #endif
1108 
1109  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7);
1110  M* method;
1111  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1112 
1113  Var<A1> a1(vm, startIdx);
1114  Var<A2> a2(vm, startIdx + 1);
1115  Var<A3> a3(vm, startIdx + 2);
1116  Var<A4> a4(vm, startIdx + 3);
1117  Var<A5> a5(vm, startIdx + 4);
1118  Var<A6> a6(vm, startIdx + 5);
1119  Var<A7> a7(vm, startIdx + 6);
1120 
1121 #if !defined (SCRAT_NO_ERROR_CHECKING)
1122  if (Error::Instance().Occurred(vm)) {
1123  if (overloaded)
1124  return 0;
1125  else
1126  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1127  }
1128 #endif
1129 
1130  R & ret = (*method)(
1131  a1.value,
1132  a2.value,
1133  a3.value,
1134  a4.value,
1135  a5.value,
1136  a6.value,
1137  a7.value
1138  );
1139 
1140 #if !defined (SCRAT_NO_ERROR_CHECKING)
1141  if (!overloaded && Error::Instance().Occurred(vm)) {
1142  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1143  }
1144 #endif
1145 
1146  PushVarR(vm, ret);
1147  return 1;
1148  }
1149 
1150  // Arg Count 8
1151  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, SQInteger startIdx, bool overloaded /*= false*/>
1152  static SQInteger Func8(HSQUIRRELVM vm) {
1153 
1154 #if !defined (SCRAT_NO_ERROR_CHECKING)
1155  if (!overloaded && sq_gettop(vm) != startIdx + 8) {
1156  return sq_throwerror(vm, _SC("wrong number of parameters"));
1157  }
1158 #endif
1159 
1160  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7, A8);
1161  M* method;
1162  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1163 
1164  Var<A1> a1(vm, startIdx);
1165  Var<A2> a2(vm, startIdx + 1);
1166  Var<A3> a3(vm, startIdx + 2);
1167  Var<A4> a4(vm, startIdx + 3);
1168  Var<A5> a5(vm, startIdx + 4);
1169  Var<A6> a6(vm, startIdx + 5);
1170  Var<A7> a7(vm, startIdx + 6);
1171  Var<A8> a8(vm, startIdx + 7);
1172 
1173 #if !defined (SCRAT_NO_ERROR_CHECKING)
1174  if (Error::Instance().Occurred(vm)) {
1175  if (overloaded)
1176  return 0;
1177  else
1178  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1179  }
1180 #endif
1181 
1182  R & ret = (*method)(
1183  a1.value,
1184  a2.value,
1185  a3.value,
1186  a4.value,
1187  a5.value,
1188  a6.value,
1189  a7.value,
1190  a8.value
1191  );
1192 
1193 #if !defined (SCRAT_NO_ERROR_CHECKING)
1194  if (!overloaded && Error::Instance().Occurred(vm)) {
1195  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1196  }
1197 #endif
1198 
1199  PushVarR(vm, ret);
1200  return 1;
1201  }
1202 
1203  // Arg Count 9
1204  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, SQInteger startIdx, bool overloaded /*= false*/>
1205  static SQInteger Func9(HSQUIRRELVM vm) {
1206 
1207 #if !defined (SCRAT_NO_ERROR_CHECKING)
1208  if (!overloaded && sq_gettop(vm) != startIdx + 9) {
1209  return sq_throwerror(vm, _SC("wrong number of parameters"));
1210  }
1211 #endif
1212 
1213  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
1214  M* method;
1215  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1216 
1217  Var<A1> a1(vm, startIdx);
1218  Var<A2> a2(vm, startIdx + 1);
1219  Var<A3> a3(vm, startIdx + 2);
1220  Var<A4> a4(vm, startIdx + 3);
1221  Var<A5> a5(vm, startIdx + 4);
1222  Var<A6> a6(vm, startIdx + 5);
1223  Var<A7> a7(vm, startIdx + 6);
1224  Var<A8> a8(vm, startIdx + 7);
1225  Var<A9> a9(vm, startIdx + 8);
1226 
1227 #if !defined (SCRAT_NO_ERROR_CHECKING)
1228  if (Error::Instance().Occurred(vm)) {
1229  if (overloaded)
1230  return 0;
1231  else
1232  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1233  }
1234 #endif
1235 
1236  R & ret = (*method)(
1237  a1.value,
1238  a2.value,
1239  a3.value,
1240  a4.value,
1241  a5.value,
1242  a6.value,
1243  a7.value,
1244  a8.value,
1245  a9.value
1246  );
1247 
1248 #if !defined (SCRAT_NO_ERROR_CHECKING)
1249  if (!overloaded && Error::Instance().Occurred(vm)) {
1250  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1251  }
1252 #endif
1253 
1254  PushVarR(vm, ret);
1255  return 1;
1256  }
1257 
1258  // Arg Count 10
1259  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, SQInteger startIdx, bool overloaded /*= false*/>
1260  static SQInteger Func10(HSQUIRRELVM vm) {
1261 
1262 #if !defined (SCRAT_NO_ERROR_CHECKING)
1263  if (!overloaded && sq_gettop(vm) != startIdx + 10) {
1264  return sq_throwerror(vm, _SC("wrong number of parameters"));
1265  }
1266 #endif
1267 
1268  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
1269  M* method;
1270  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1271 
1272  Var<A1> a1(vm, startIdx);
1273  Var<A2> a2(vm, startIdx + 1);
1274  Var<A3> a3(vm, startIdx + 2);
1275  Var<A4> a4(vm, startIdx + 3);
1276  Var<A5> a5(vm, startIdx + 4);
1277  Var<A6> a6(vm, startIdx + 5);
1278  Var<A7> a7(vm, startIdx + 6);
1279  Var<A8> a8(vm, startIdx + 7);
1280  Var<A9> a9(vm, startIdx + 8);
1281  Var<A10> a10(vm, startIdx + 9);
1282 
1283 #if !defined (SCRAT_NO_ERROR_CHECKING)
1284  if (Error::Instance().Occurred(vm)) {
1285  if (overloaded)
1286  return 0;
1287  else
1288  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1289  }
1290 #endif
1291 
1292  R & ret = (*method)(
1293  a1.value,
1294  a2.value,
1295  a3.value,
1296  a4.value,
1297  a5.value,
1298  a6.value,
1299  a7.value,
1300  a8.value,
1301  a9.value,
1302  a10.value
1303  );
1304 
1305 #if !defined (SCRAT_NO_ERROR_CHECKING)
1306  if (!overloaded && Error::Instance().Occurred(vm)) {
1307  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1308  }
1309 #endif
1310 
1311  PushVarR(vm, ret);
1312  return 1;
1313  }
1314 
1315  // Arg Count 11
1316  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, SQInteger startIdx, bool overloaded /*= false*/>
1317  static SQInteger Func11(HSQUIRRELVM vm) {
1318 
1319 #if !defined (SCRAT_NO_ERROR_CHECKING)
1320  if (!overloaded && sq_gettop(vm) != startIdx + 11) {
1321  return sq_throwerror(vm, _SC("wrong number of parameters"));
1322  }
1323 #endif
1324 
1325  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
1326  M* method;
1327  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1328 
1329  Var<A1> a1(vm, startIdx);
1330  Var<A2> a2(vm, startIdx + 1);
1331  Var<A3> a3(vm, startIdx + 2);
1332  Var<A4> a4(vm, startIdx + 3);
1333  Var<A5> a5(vm, startIdx + 4);
1334  Var<A6> a6(vm, startIdx + 5);
1335  Var<A7> a7(vm, startIdx + 6);
1336  Var<A8> a8(vm, startIdx + 7);
1337  Var<A9> a9(vm, startIdx + 8);
1338  Var<A10> a10(vm, startIdx + 9);
1339  Var<A11> a11(vm, startIdx + 10);
1340 
1341 #if !defined (SCRAT_NO_ERROR_CHECKING)
1342  if (Error::Instance().Occurred(vm)) {
1343  if (overloaded)
1344  return 0;
1345  else
1346  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1347  }
1348 #endif
1349 
1350  R & ret = (*method)(
1351  a1.value,
1352  a2.value,
1353  a3.value,
1354  a4.value,
1355  a5.value,
1356  a6.value,
1357  a7.value,
1358  a8.value,
1359  a9.value,
1360  a10.value,
1361  a11.value
1362  );
1363 
1364 #if !defined (SCRAT_NO_ERROR_CHECKING)
1365  if (!overloaded && Error::Instance().Occurred(vm)) {
1366  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1367  }
1368 #endif
1369 
1370  PushVarR(vm, ret);
1371  return 1;
1372  }
1373 
1374  // Arg Count 12
1375  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, SQInteger startIdx, bool overloaded /*= false*/>
1376  static SQInteger Func12(HSQUIRRELVM vm) {
1377 
1378 #if !defined (SCRAT_NO_ERROR_CHECKING)
1379  if (!overloaded && sq_gettop(vm) != startIdx + 12) {
1380  return sq_throwerror(vm, _SC("wrong number of parameters"));
1381  }
1382 #endif
1383 
1384  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
1385  M* method;
1386  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1387 
1388  Var<A1> a1(vm, startIdx);
1389  Var<A2> a2(vm, startIdx + 1);
1390  Var<A3> a3(vm, startIdx + 2);
1391  Var<A4> a4(vm, startIdx + 3);
1392  Var<A5> a5(vm, startIdx + 4);
1393  Var<A6> a6(vm, startIdx + 5);
1394  Var<A7> a7(vm, startIdx + 6);
1395  Var<A8> a8(vm, startIdx + 7);
1396  Var<A9> a9(vm, startIdx + 8);
1397  Var<A10> a10(vm, startIdx + 9);
1398  Var<A11> a11(vm, startIdx + 10);
1399  Var<A12> a12(vm, startIdx + 11);
1400 
1401 #if !defined (SCRAT_NO_ERROR_CHECKING)
1402  if (Error::Instance().Occurred(vm)) {
1403  if (overloaded)
1404  return 0;
1405  else
1406  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1407  }
1408 #endif
1409 
1410  R & ret = (*method)(
1411  a1.value,
1412  a2.value,
1413  a3.value,
1414  a4.value,
1415  a5.value,
1416  a6.value,
1417  a7.value,
1418  a8.value,
1419  a9.value,
1420  a10.value,
1421  a11.value,
1422  a12.value
1423  );
1424 
1425 #if !defined (SCRAT_NO_ERROR_CHECKING)
1426  if (!overloaded && Error::Instance().Occurred(vm)) {
1427  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1428  }
1429 #endif
1430 
1431  PushVarR(vm, ret);
1432  return 1;
1433  }
1434 
1435  // Arg Count 13
1436  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, SQInteger startIdx, bool overloaded /*= false*/>
1437  static SQInteger Func13(HSQUIRRELVM vm) {
1438 
1439 #if !defined (SCRAT_NO_ERROR_CHECKING)
1440  if (!overloaded && sq_gettop(vm) != startIdx + 13) {
1441  return sq_throwerror(vm, _SC("wrong number of parameters"));
1442  }
1443 #endif
1444 
1445  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
1446  M* method;
1447  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1448 
1449  Var<A1> a1(vm, startIdx);
1450  Var<A2> a2(vm, startIdx + 1);
1451  Var<A3> a3(vm, startIdx + 2);
1452  Var<A4> a4(vm, startIdx + 3);
1453  Var<A5> a5(vm, startIdx + 4);
1454  Var<A6> a6(vm, startIdx + 5);
1455  Var<A7> a7(vm, startIdx + 6);
1456  Var<A8> a8(vm, startIdx + 7);
1457  Var<A9> a9(vm, startIdx + 8);
1458  Var<A10> a10(vm, startIdx + 9);
1459  Var<A11> a11(vm, startIdx + 10);
1460  Var<A12> a12(vm, startIdx + 11);
1461  Var<A13> a13(vm, startIdx + 12);
1462 
1463 #if !defined (SCRAT_NO_ERROR_CHECKING)
1464  if (Error::Instance().Occurred(vm)) {
1465  if (overloaded)
1466  return 0;
1467  else
1468  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1469  }
1470 #endif
1471 
1472  R & ret = (*method)(
1473  a1.value,
1474  a2.value,
1475  a3.value,
1476  a4.value,
1477  a5.value,
1478  a6.value,
1479  a7.value,
1480  a8.value,
1481  a9.value,
1482  a10.value,
1483  a11.value,
1484  a12.value,
1485  a13.value
1486  );
1487 
1488 #if !defined (SCRAT_NO_ERROR_CHECKING)
1489  if (!overloaded && Error::Instance().Occurred(vm)) {
1490  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1491  }
1492 #endif
1493 
1494  PushVarR(vm, ret);
1495  return 1;
1496  }
1497 
1498  // Arg Count 14
1499  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, SQInteger startIdx, bool overloaded /*= false*/>
1500  static SQInteger Func14(HSQUIRRELVM vm) {
1501 
1502 #if !defined (SCRAT_NO_ERROR_CHECKING)
1503  if (!overloaded && sq_gettop(vm) != startIdx + 14) {
1504  return sq_throwerror(vm, _SC("wrong number of parameters"));
1505  }
1506 #endif
1507 
1508  typedef R & (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
1509  M* method;
1510  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1511 
1512  Var<A1> a1(vm, startIdx);
1513  Var<A2> a2(vm, startIdx + 1);
1514  Var<A3> a3(vm, startIdx + 2);
1515  Var<A4> a4(vm, startIdx + 3);
1516  Var<A5> a5(vm, startIdx + 4);
1517  Var<A6> a6(vm, startIdx + 5);
1518  Var<A7> a7(vm, startIdx + 6);
1519  Var<A8> a8(vm, startIdx + 7);
1520  Var<A9> a9(vm, startIdx + 8);
1521  Var<A10> a10(vm, startIdx + 9);
1522  Var<A11> a11(vm, startIdx + 10);
1523  Var<A12> a12(vm, startIdx + 11);
1524  Var<A13> a13(vm, startIdx + 12);
1525  Var<A14> a14(vm, startIdx + 13);
1526 
1527 #if !defined (SCRAT_NO_ERROR_CHECKING)
1528  if (Error::Instance().Occurred(vm)) {
1529  if (overloaded)
1530  return 0;
1531  else
1532  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1533  }
1534 #endif
1535 
1536  R & ret = (*method)(
1537  a1.value,
1538  a2.value,
1539  a3.value,
1540  a4.value,
1541  a5.value,
1542  a6.value,
1543  a7.value,
1544  a8.value,
1545  a9.value,
1546  a10.value,
1547  a11.value,
1548  a12.value,
1549  a13.value,
1550  a14.value
1551  );
1552 
1553 #if !defined (SCRAT_NO_ERROR_CHECKING)
1554  if (!overloaded && Error::Instance().Occurred(vm)) {
1555  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1556  }
1557 #endif
1558 
1559  PushVarR(vm, ret);
1560  return 1;
1561  }
1562 };
1563 
1564 
1565 //
1566 // void return specialization
1567 //
1568 
1569 template <>
1570 class SqGlobal<void> {
1571 public:
1572  // Arg Count 0
1573  template <bool overloaded /* = false */>
1574  static SQInteger Func0(HSQUIRRELVM vm) {
1575 
1576 #if !defined (SCRAT_NO_ERROR_CHECKING)
1577  if (!overloaded && sq_gettop(vm) != 2) {
1578  return sq_throwerror(vm, _SC("wrong number of parameters"));
1579  }
1580 #endif
1581 
1582  typedef void (*M)();
1583  M* method;
1584  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1585  (*method)();
1586 #if !defined (SCRAT_NO_ERROR_CHECKING)
1587  if (!overloaded && Error::Instance().Occurred(vm)) {
1588  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1589  }
1590 #endif
1591  return 0;
1592  }
1593 
1594  // Arg Count 1
1595  template <class A1, SQInteger startIdx, bool overloaded /*= false*/>
1596  static SQInteger Func1(HSQUIRRELVM vm) {
1597 
1598 #if !defined (SCRAT_NO_ERROR_CHECKING)
1599  if (!overloaded && sq_gettop(vm) != startIdx + 1) {
1600  return sq_throwerror(vm, _SC("wrong number of parameters"));
1601  }
1602 #endif
1603 
1604  typedef void (*M)(A1);
1605  M* method;
1606  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1607 
1608  Var<A1> a1(vm, startIdx);
1609 
1610 #if !defined (SCRAT_NO_ERROR_CHECKING)
1611  if (Error::Instance().Occurred(vm)) {
1612  if (overloaded)
1613  return 0;
1614  else
1615  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1616  }
1617 #endif
1618 
1619  (*method)(
1620  a1.value
1621  );
1622 #if !defined (SCRAT_NO_ERROR_CHECKING)
1623  if (!overloaded && Error::Instance().Occurred(vm)) {
1624  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1625  }
1626 #endif
1627  return 0;
1628  }
1629 
1630  // Arg Count 2
1631  template <class A1, class A2, SQInteger startIdx, bool overloaded /*= false*/>
1632  static SQInteger Func2(HSQUIRRELVM vm) {
1633 
1634 #if !defined (SCRAT_NO_ERROR_CHECKING)
1635  if (!overloaded && sq_gettop(vm) != startIdx + 2) {
1636  return sq_throwerror(vm, _SC("wrong number of parameters"));
1637  }
1638 #endif
1639 
1640  typedef void (*M)(A1, A2);
1641  M* method;
1642  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1643 
1644  Var<A1> a1(vm, startIdx);
1645  Var<A2> a2(vm, startIdx + 1);
1646 
1647 #if !defined (SCRAT_NO_ERROR_CHECKING)
1648  if (Error::Instance().Occurred(vm)) {
1649  if (overloaded)
1650  return 0;
1651  else
1652  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1653  }
1654 #endif
1655 
1656  (*method)(
1657  a1.value,
1658  a2.value
1659  );
1660 #if !defined (SCRAT_NO_ERROR_CHECKING)
1661  if (!overloaded && Error::Instance().Occurred(vm)) {
1662  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1663  }
1664 #endif
1665  return 0;
1666  }
1667 
1668  // Arg Count 3
1669  template <class A1, class A2, class A3, SQInteger startIdx, bool overloaded /*= false*/>
1670  static SQInteger Func3(HSQUIRRELVM vm) {
1671 
1672 #if !defined (SCRAT_NO_ERROR_CHECKING)
1673  if (!overloaded && sq_gettop(vm) != startIdx + 3) {
1674  return sq_throwerror(vm, _SC("wrong number of parameters"));
1675  }
1676 #endif
1677 
1678  typedef void (*M)(A1, A2, A3);
1679  M* method;
1680  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1681 
1682  Var<A1> a1(vm, startIdx);
1683  Var<A2> a2(vm, startIdx + 1);
1684  Var<A3> a3(vm, startIdx + 2);
1685 
1686 #if !defined (SCRAT_NO_ERROR_CHECKING)
1687  if (Error::Instance().Occurred(vm)) {
1688  if (overloaded)
1689  return 0;
1690  else
1691  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1692  }
1693 #endif
1694 
1695  (*method)(
1696  a1.value,
1697  a2.value,
1698  a3.value
1699  );
1700 #if !defined (SCRAT_NO_ERROR_CHECKING)
1701  if (!overloaded && Error::Instance().Occurred(vm)) {
1702  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1703  }
1704 #endif
1705  return 0;
1706  }
1707 
1708  // Arg Count 4
1709  template <class A1, class A2, class A3, class A4, SQInteger startIdx, bool overloaded /*= false*/>
1710  static SQInteger Func4(HSQUIRRELVM vm) {
1711 
1712 #if !defined (SCRAT_NO_ERROR_CHECKING)
1713  if (!overloaded && sq_gettop(vm) != startIdx + 4) {
1714  return sq_throwerror(vm, _SC("wrong number of parameters"));
1715  }
1716 #endif
1717 
1718  typedef void (*M)(A1, A2, A3, A4);
1719  M* method;
1720  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1721 
1722  Var<A1> a1(vm, startIdx);
1723  Var<A2> a2(vm, startIdx + 1);
1724  Var<A3> a3(vm, startIdx + 2);
1725  Var<A4> a4(vm, startIdx + 3);
1726 
1727 #if !defined (SCRAT_NO_ERROR_CHECKING)
1728  if (Error::Instance().Occurred(vm)) {
1729  if (overloaded)
1730  return 0;
1731  else
1732  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1733  }
1734 #endif
1735 
1736  (*method)(
1737  a1.value,
1738  a2.value,
1739  a3.value,
1740  a4.value
1741  );
1742 #if !defined (SCRAT_NO_ERROR_CHECKING)
1743  if (!overloaded && Error::Instance().Occurred(vm)) {
1744  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1745  }
1746 #endif
1747  return 0;
1748  }
1749 
1750  // Arg Count 5
1751  template <class A1, class A2, class A3, class A4, class A5, SQInteger startIdx, bool overloaded /*= false*/>
1752  static SQInteger Func5(HSQUIRRELVM vm) {
1753 
1754 #if !defined (SCRAT_NO_ERROR_CHECKING)
1755  if (!overloaded && sq_gettop(vm) != startIdx + 5) {
1756  return sq_throwerror(vm, _SC("wrong number of parameters"));
1757  }
1758 #endif
1759 
1760  typedef void (*M)(A1, A2, A3, A4, A5);
1761  M* method;
1762  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1763 
1764  Var<A1> a1(vm, startIdx);
1765  Var<A2> a2(vm, startIdx + 1);
1766  Var<A3> a3(vm, startIdx + 2);
1767  Var<A4> a4(vm, startIdx + 3);
1768  Var<A5> a5(vm, startIdx + 4);
1769 
1770 #if !defined (SCRAT_NO_ERROR_CHECKING)
1771  if (Error::Instance().Occurred(vm)) {
1772  if (overloaded)
1773  return 0;
1774  else
1775  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1776  }
1777 #endif
1778 
1779  (*method)(
1780  a1.value,
1781  a2.value,
1782  a3.value,
1783  a4.value,
1784  a5.value
1785  );
1786 #if !defined (SCRAT_NO_ERROR_CHECKING)
1787  if (!overloaded && Error::Instance().Occurred(vm)) {
1788  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1789  }
1790 #endif
1791  return 0;
1792  }
1793 
1794  // Arg Count 6
1795  template <class A1, class A2, class A3, class A4, class A5, class A6, SQInteger startIdx, bool overloaded /*= false*/>
1796  static SQInteger Func6(HSQUIRRELVM vm) {
1797 
1798 #if !defined (SCRAT_NO_ERROR_CHECKING)
1799  if (!overloaded && sq_gettop(vm) != startIdx + 6) {
1800  return sq_throwerror(vm, _SC("wrong number of parameters"));
1801  }
1802 #endif
1803 
1804  typedef void (*M)(A1, A2, A3, A4, A5, A6);
1805  M* method;
1806  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1807 
1808  Var<A1> a1(vm, startIdx);
1809  Var<A2> a2(vm, startIdx + 1);
1810  Var<A3> a3(vm, startIdx + 2);
1811  Var<A4> a4(vm, startIdx + 3);
1812  Var<A5> a5(vm, startIdx + 4);
1813  Var<A6> a6(vm, startIdx + 5);
1814 
1815 #if !defined (SCRAT_NO_ERROR_CHECKING)
1816  if (Error::Instance().Occurred(vm)) {
1817  if (overloaded)
1818  return 0;
1819  else
1820  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1821  }
1822 #endif
1823 
1824  (*method)(
1825  a1.value,
1826  a2.value,
1827  a3.value,
1828  a4.value,
1829  a5.value,
1830  a6.value
1831  );
1832 #if !defined (SCRAT_NO_ERROR_CHECKING)
1833  if (!overloaded && Error::Instance().Occurred(vm)) {
1834  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1835  }
1836 #endif
1837  return 0;
1838  }
1839 
1840  // Arg Count 7
1841  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, SQInteger startIdx, bool overloaded /*= false*/>
1842  static SQInteger Func7(HSQUIRRELVM vm) {
1843 
1844 #if !defined (SCRAT_NO_ERROR_CHECKING)
1845  if (!overloaded && sq_gettop(vm) != startIdx + 7) {
1846  return sq_throwerror(vm, _SC("wrong number of parameters"));
1847  }
1848 #endif
1849 
1850  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7);
1851  M* method;
1852  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1853 
1854  Var<A1> a1(vm, startIdx);
1855  Var<A2> a2(vm, startIdx + 1);
1856  Var<A3> a3(vm, startIdx + 2);
1857  Var<A4> a4(vm, startIdx + 3);
1858  Var<A5> a5(vm, startIdx + 4);
1859  Var<A6> a6(vm, startIdx + 5);
1860  Var<A7> a7(vm, startIdx + 6);
1861 
1862 #if !defined (SCRAT_NO_ERROR_CHECKING)
1863  if (Error::Instance().Occurred(vm)) {
1864  if (overloaded)
1865  return 0;
1866  else
1867  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1868  }
1869 #endif
1870 
1871  (*method)(
1872  a1.value,
1873  a2.value,
1874  a3.value,
1875  a4.value,
1876  a5.value,
1877  a6.value,
1878  a7.value
1879  );
1880 #if !defined (SCRAT_NO_ERROR_CHECKING)
1881  if (!overloaded && Error::Instance().Occurred(vm)) {
1882  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1883  }
1884 #endif
1885  return 0;
1886  }
1887 
1888  // Arg Count 8
1889  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, SQInteger startIdx, bool overloaded /*= false*/>
1890  static SQInteger Func8(HSQUIRRELVM vm) {
1891 
1892 #if !defined (SCRAT_NO_ERROR_CHECKING)
1893  if (!overloaded && sq_gettop(vm) != startIdx + 8) {
1894  return sq_throwerror(vm, _SC("wrong number of parameters"));
1895  }
1896 #endif
1897 
1898  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7, A8);
1899  M* method;
1900  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1901 
1902  Var<A1> a1(vm, startIdx);
1903  Var<A2> a2(vm, startIdx + 1);
1904  Var<A3> a3(vm, startIdx + 2);
1905  Var<A4> a4(vm, startIdx + 3);
1906  Var<A5> a5(vm, startIdx + 4);
1907  Var<A6> a6(vm, startIdx + 5);
1908  Var<A7> a7(vm, startIdx + 6);
1909  Var<A8> a8(vm, startIdx + 7);
1910 
1911 #if !defined (SCRAT_NO_ERROR_CHECKING)
1912  if (Error::Instance().Occurred(vm)) {
1913  if (overloaded)
1914  return 0;
1915  else
1916  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1917  }
1918 #endif
1919 
1920  (*method)(
1921  a1.value,
1922  a2.value,
1923  a3.value,
1924  a4.value,
1925  a5.value,
1926  a6.value,
1927  a7.value,
1928  a8.value
1929  );
1930 #if !defined (SCRAT_NO_ERROR_CHECKING)
1931  if (!overloaded && Error::Instance().Occurred(vm)) {
1932  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1933  }
1934 #endif
1935  return 0;
1936  }
1937 
1938  // Arg Count 9
1939  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, SQInteger startIdx, bool overloaded /*= false*/>
1940  static SQInteger Func9(HSQUIRRELVM vm) {
1941 
1942 #if !defined (SCRAT_NO_ERROR_CHECKING)
1943  if (!overloaded && sq_gettop(vm) != startIdx + 9) {
1944  return sq_throwerror(vm, _SC("wrong number of parameters"));
1945  }
1946 #endif
1947 
1948  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
1949  M* method;
1950  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
1951 
1952  Var<A1> a1(vm, startIdx);
1953  Var<A2> a2(vm, startIdx + 1);
1954  Var<A3> a3(vm, startIdx + 2);
1955  Var<A4> a4(vm, startIdx + 3);
1956  Var<A5> a5(vm, startIdx + 4);
1957  Var<A6> a6(vm, startIdx + 5);
1958  Var<A7> a7(vm, startIdx + 6);
1959  Var<A8> a8(vm, startIdx + 7);
1960  Var<A9> a9(vm, startIdx + 8);
1961 
1962 #if !defined (SCRAT_NO_ERROR_CHECKING)
1963  if (Error::Instance().Occurred(vm)) {
1964  if (overloaded)
1965  return 0;
1966  else
1967  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1968  }
1969 #endif
1970 
1971  (*method)(
1972  a1.value,
1973  a2.value,
1974  a3.value,
1975  a4.value,
1976  a5.value,
1977  a6.value,
1978  a7.value,
1979  a8.value,
1980  a9.value
1981  );
1982 #if !defined (SCRAT_NO_ERROR_CHECKING)
1983  if (!overloaded && Error::Instance().Occurred(vm)) {
1984  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1985  }
1986 #endif
1987  return 0;
1988  }
1989 
1990  // Arg Count 10
1991  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, SQInteger startIdx, bool overloaded /*= false*/>
1992  static SQInteger Func10(HSQUIRRELVM vm) {
1993 
1994 #if !defined (SCRAT_NO_ERROR_CHECKING)
1995  if (!overloaded && sq_gettop(vm) != startIdx + 10) {
1996  return sq_throwerror(vm, _SC("wrong number of parameters"));
1997  }
1998 #endif
1999 
2000  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
2001  M* method;
2002  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
2003 
2004  Var<A1> a1(vm, startIdx);
2005  Var<A2> a2(vm, startIdx + 1);
2006  Var<A3> a3(vm, startIdx + 2);
2007  Var<A4> a4(vm, startIdx + 3);
2008  Var<A5> a5(vm, startIdx + 4);
2009  Var<A6> a6(vm, startIdx + 5);
2010  Var<A7> a7(vm, startIdx + 6);
2011  Var<A8> a8(vm, startIdx + 7);
2012  Var<A9> a9(vm, startIdx + 8);
2013  Var<A10> a10(vm, startIdx + 9);
2014 
2015 #if !defined (SCRAT_NO_ERROR_CHECKING)
2016  if (Error::Instance().Occurred(vm)) {
2017  if (overloaded)
2018  return 0;
2019  else
2020  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2021  }
2022 #endif
2023 
2024  (*method)(
2025  a1.value,
2026  a2.value,
2027  a3.value,
2028  a4.value,
2029  a5.value,
2030  a6.value,
2031  a7.value,
2032  a8.value,
2033  a9.value,
2034  a10.value
2035  );
2036 #if !defined (SCRAT_NO_ERROR_CHECKING)
2037  if (!overloaded && Error::Instance().Occurred(vm)) {
2038  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2039  }
2040 #endif
2041  return 0;
2042  }
2043 
2044  // Arg Count 11
2045  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, SQInteger startIdx, bool overloaded /*= false*/>
2046  static SQInteger Func11(HSQUIRRELVM vm) {
2047 
2048 #if !defined (SCRAT_NO_ERROR_CHECKING)
2049  if (!overloaded && sq_gettop(vm) != startIdx + 11) {
2050  return sq_throwerror(vm, _SC("wrong number of parameters"));
2051  }
2052 #endif
2053 
2054  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
2055  M* method;
2056  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
2057 
2058  Var<A1> a1(vm, startIdx);
2059  Var<A2> a2(vm, startIdx + 1);
2060  Var<A3> a3(vm, startIdx + 2);
2061  Var<A4> a4(vm, startIdx + 3);
2062  Var<A5> a5(vm, startIdx + 4);
2063  Var<A6> a6(vm, startIdx + 5);
2064  Var<A7> a7(vm, startIdx + 6);
2065  Var<A8> a8(vm, startIdx + 7);
2066  Var<A9> a9(vm, startIdx + 8);
2067  Var<A10> a10(vm, startIdx + 9);
2068  Var<A11> a11(vm, startIdx + 10);
2069 
2070 #if !defined (SCRAT_NO_ERROR_CHECKING)
2071  if (Error::Instance().Occurred(vm)) {
2072  if (overloaded)
2073  return 0;
2074  else
2075  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2076  }
2077 #endif
2078 
2079  (*method)(
2080  a1.value,
2081  a2.value,
2082  a3.value,
2083  a4.value,
2084  a5.value,
2085  a6.value,
2086  a7.value,
2087  a8.value,
2088  a9.value,
2089  a10.value,
2090  a11.value
2091  );
2092 #if !defined (SCRAT_NO_ERROR_CHECKING)
2093  if (!overloaded && Error::Instance().Occurred(vm)) {
2094  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2095  }
2096 #endif
2097  return 0;
2098  }
2099 
2100  // Arg Count 12
2101  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, SQInteger startIdx, bool overloaded /*= false*/>
2102  static SQInteger Func12(HSQUIRRELVM vm) {
2103 
2104 #if !defined (SCRAT_NO_ERROR_CHECKING)
2105  if (!overloaded && sq_gettop(vm) != startIdx + 12) {
2106  return sq_throwerror(vm, _SC("wrong number of parameters"));
2107  }
2108 #endif
2109 
2110  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
2111  M* method;
2112  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
2113 
2114  Var<A1> a1(vm, startIdx);
2115  Var<A2> a2(vm, startIdx + 1);
2116  Var<A3> a3(vm, startIdx + 2);
2117  Var<A4> a4(vm, startIdx + 3);
2118  Var<A5> a5(vm, startIdx + 4);
2119  Var<A6> a6(vm, startIdx + 5);
2120  Var<A7> a7(vm, startIdx + 6);
2121  Var<A8> a8(vm, startIdx + 7);
2122  Var<A9> a9(vm, startIdx + 8);
2123  Var<A10> a10(vm, startIdx + 9);
2124  Var<A11> a11(vm, startIdx + 10);
2125  Var<A12> a12(vm, startIdx + 11);
2126 
2127 #if !defined (SCRAT_NO_ERROR_CHECKING)
2128  if (Error::Instance().Occurred(vm)) {
2129  if (overloaded)
2130  return 0;
2131  else
2132  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2133  }
2134 #endif
2135 
2136  (*method)(
2137  a1.value,
2138  a2.value,
2139  a3.value,
2140  a4.value,
2141  a5.value,
2142  a6.value,
2143  a7.value,
2144  a8.value,
2145  a9.value,
2146  a10.value,
2147  a11.value,
2148  a12.value
2149  );
2150 #if !defined (SCRAT_NO_ERROR_CHECKING)
2151  if (!overloaded && Error::Instance().Occurred(vm)) {
2152  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2153  }
2154 #endif
2155  return 0;
2156  }
2157 
2158  // Arg Count 13
2159  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, SQInteger startIdx, bool overloaded /*= false*/>
2160  static SQInteger Func13(HSQUIRRELVM vm) {
2161 
2162 #if !defined (SCRAT_NO_ERROR_CHECKING)
2163  if (!overloaded && sq_gettop(vm) != startIdx + 13) {
2164  return sq_throwerror(vm, _SC("wrong number of parameters"));
2165  }
2166 #endif
2167 
2168  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
2169  M* method;
2170  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
2171 
2172  Var<A1> a1(vm, startIdx);
2173  Var<A2> a2(vm, startIdx + 1);
2174  Var<A3> a3(vm, startIdx + 2);
2175  Var<A4> a4(vm, startIdx + 3);
2176  Var<A5> a5(vm, startIdx + 4);
2177  Var<A6> a6(vm, startIdx + 5);
2178  Var<A7> a7(vm, startIdx + 6);
2179  Var<A8> a8(vm, startIdx + 7);
2180  Var<A9> a9(vm, startIdx + 8);
2181  Var<A10> a10(vm, startIdx + 9);
2182  Var<A11> a11(vm, startIdx + 10);
2183  Var<A12> a12(vm, startIdx + 11);
2184  Var<A13> a13(vm, startIdx + 12);
2185 
2186 #if !defined (SCRAT_NO_ERROR_CHECKING)
2187  if (Error::Instance().Occurred(vm)) {
2188  if (overloaded)
2189  return 0;
2190  else
2191  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2192  }
2193 #endif
2194 
2195  (*method)(
2196  a1.value,
2197  a2.value,
2198  a3.value,
2199  a4.value,
2200  a5.value,
2201  a6.value,
2202  a7.value,
2203  a8.value,
2204  a9.value,
2205  a10.value,
2206  a11.value,
2207  a12.value,
2208  a13.value
2209  );
2210 #if !defined (SCRAT_NO_ERROR_CHECKING)
2211  if (!overloaded && Error::Instance().Occurred(vm)) {
2212  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2213  }
2214 #endif
2215  return 0;
2216  }
2217 
2218  // Arg Count 14
2219  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, SQInteger startIdx, bool overloaded /*= false*/>
2220  static SQInteger Func14(HSQUIRRELVM vm) {
2221 
2222 #if !defined (SCRAT_NO_ERROR_CHECKING)
2223  if (!overloaded && sq_gettop(vm) != startIdx + 14) {
2224  return sq_throwerror(vm, _SC("wrong number of parameters"));
2225  }
2226 #endif
2227 
2228  typedef void (*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
2229  M* method;
2230  sq_getuserdata(vm, -1, (SQUserPointer*)&method, NULL);
2231 
2232  Var<A1> a1(vm, startIdx);
2233  Var<A2> a2(vm, startIdx + 1);
2234  Var<A3> a3(vm, startIdx + 2);
2235  Var<A4> a4(vm, startIdx + 3);
2236  Var<A5> a5(vm, startIdx + 4);
2237  Var<A6> a6(vm, startIdx + 5);
2238  Var<A7> a7(vm, startIdx + 6);
2239  Var<A8> a8(vm, startIdx + 7);
2240  Var<A9> a9(vm, startIdx + 8);
2241  Var<A10> a10(vm, startIdx + 9);
2242  Var<A11> a11(vm, startIdx + 10);
2243  Var<A12> a12(vm, startIdx + 11);
2244  Var<A13> a13(vm, startIdx + 12);
2245  Var<A14> a14(vm, startIdx + 13);
2246 
2247 #if !defined (SCRAT_NO_ERROR_CHECKING)
2248  if (Error::Instance().Occurred(vm)) {
2249  if (overloaded)
2250  return 0;
2251  else
2252  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2253  }
2254 #endif
2255 
2256  (*method)(
2257  a1.value,
2258  a2.value,
2259  a3.value,
2260  a4.value,
2261  a5.value,
2262  a6.value,
2263  a7.value,
2264  a8.value,
2265  a9.value,
2266  a10.value,
2267  a11.value,
2268  a12.value,
2269  a13.value,
2270  a14.value
2271  );
2272 #if !defined (SCRAT_NO_ERROR_CHECKING)
2273  if (!overloaded && Error::Instance().Occurred(vm)) {
2274  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2275  }
2276 #endif
2277  return 0;
2278  }
2279 };
2280 
2281 
2282 //
2283 // Global Function Resolvers
2284 //
2285 
2286 // Arg Count 0
2287 template <class R>
2288 SQFUNCTION SqGlobalFunc(R (*/*method*/)()) {
2289  return &SqGlobal<R>::template Func0<false>;
2290 }
2291 
2292 // Arg Count 0
2293 template <class R>
2294 SQFUNCTION SqGlobalFunc(R & (*/*method*/)()) {
2295  return &SqGlobal<R& >::template Func0<false>;
2296 }
2297 
2298 // Arg Count 1
2299 template <class R, class A1>
2300 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1)) {
2301  return &SqGlobal<R>::template Func1<A1, 2, false>;
2302 }
2303 
2304 // Arg Count 1
2305 template <class R, class A1>
2306 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1)) {
2307  return &SqGlobal<R&>::template Func1<A1, 2, false>;
2308 }
2309 
2310 // Arg Count 2
2311 template <class R, class A1, class A2>
2312 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2)) {
2313  return &SqGlobal<R>::template Func2<A1, A2, 2, false>;
2314 }
2315 
2316 // Arg Count 2
2317 template <class R, class A1, class A2>
2318 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2)) {
2319  return &SqGlobal<R& >::template Func2<A1, A2, 2, false>;
2320 }
2321 
2322 // Arg Count 3
2323 template <class R, class A1, class A2, class A3>
2324 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3)) {
2325  return &SqGlobal<R>::template Func3<A1, A2, A3, 2, false>;
2326 }
2327 
2328 // Arg Count 3
2329 template <class R, class A1, class A2, class A3>
2330 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3)) {
2331  return &SqGlobal<R& >::template Func3<A1, A2, A3, 2, false>;
2332 }
2333 
2334 // Arg Count 4
2335 template <class R, class A1, class A2, class A3, class A4>
2336 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4)) {
2337  return &SqGlobal<R>::template Func4<A1, A2, A3, A4, 2, false>;
2338 }
2339 
2340 // Arg Count 4
2341 template <class R, class A1, class A2, class A3, class A4>
2342 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4)) {
2343  return &SqGlobal<R& >::template Func4<A1, A2, A3, A4, 2, false>;
2344 }
2345 
2346 // Arg Count 5
2347 template <class R, class A1, class A2, class A3, class A4, class A5>
2348 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5)) {
2349  return &SqGlobal<R>::template Func5<A1, A2, A3, A4, A5, 2, false>;
2350 }
2351 
2352 // Arg Count 5
2353 template <class R, class A1, class A2, class A3, class A4, class A5>
2354 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5)) {
2355  return &SqGlobal<R&>::template Func5<A1, A2, A3, A4, A5, 2, false>;
2356 }
2357 
2358 // Arg Count 6
2359 template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
2360 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6)) {
2361  return &SqGlobal<R>::template Func6<A1, A2, A3, A4, A5, A6, 2, false>;
2362 }
2363 
2364 // Arg Count 6
2365 template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
2366 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6)) {
2367  return &SqGlobal<R& >::template Func6<A1, A2, A3, A4, A5, A6, 2, false>;
2368 }
2369 
2370 // Arg Count 7
2371 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2372 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7)) {
2373  return &SqGlobal<R>::template Func7<A1, A2, A3, A4, A5, A6, A7, 2, false>;
2374 }
2375 
2376 // Arg Count 7
2377 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2378 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7)) {
2379  return &SqGlobal<R &>::template Func7<A1, A2, A3, A4, A5, A6, A7, 2, false>;
2380 }
2381 
2382 // Arg Count 8
2383 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2384 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8)) {
2385  return &SqGlobal<R>::template Func8<A1, A2, A3, A4, A5, A6, A7, A8, 2, false>;
2386 }
2387 
2388 // Arg Count 8
2389 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2390 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8)) {
2391  return &SqGlobal<R& >::template Func8<A1, A2, A3, A4, A5, A6, A7, A8, 2, false>;
2392 }
2393 
2394 // Arg Count 9
2395 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2396 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) {
2397  return &SqGlobal<R>::template Func9<A1, A2, A3, A4, A5, A6, A7, A8, A9, 2, false>;
2398 }
2399 
2400 // Arg Count 9
2401 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2402 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) {
2403  return &SqGlobal<R& >::template Func9<A1, A2, A3, A4, A5, A6, A7, A8, A9, 2, false>;
2404 }
2405 
2406 // Arg Count 10
2407 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
2408 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) {
2409  return &SqGlobal<R>::template Func10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, 2, false>;
2410 }
2411 
2412 // Arg Count 10
2413 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
2414 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) {
2415  return &SqGlobal<R& >::template Func10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, 2, false>;
2416 }
2417 
2418 // Arg Count 11
2419 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>
2420 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) {
2421  return &SqGlobal<R>::template Func11<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, 2, false>;
2422 }
2423 
2424 // Arg Count 11
2425 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>
2426 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) {
2427  return &SqGlobal<R& >::template Func11<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, 2, false>;
2428 }
2429 
2430 // Arg Count 12
2431 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>
2432 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) {
2433  return &SqGlobal<R>::template Func12<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, 2, false>;
2434 }
2435 
2436 // Arg Count 12
2437 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>
2438 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) {
2439  return &SqGlobal<R& >::template Func12<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, 2, false>;
2440 }
2441 
2442 // Arg Count 13
2443 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>
2444 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) {
2445  return &SqGlobal<R>::template Func13<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, 2, false>;
2446 }
2447 
2448 // Arg Count 13
2449 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>
2450 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) {
2451  return &SqGlobal<R& >::template Func13<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, 2, false>;
2452 }
2453 
2454 // Arg Count 14
2455 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>
2456 SQFUNCTION SqGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) {
2457  return &SqGlobal<R>::template Func14<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, 2, false>;
2458 }
2459 
2460 // Arg Count 14
2461 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>
2462 SQFUNCTION SqGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) {
2463  return &SqGlobal<R& >::template Func14<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, 2, false>;
2464 }
2465 
2466 
2467 //
2468 // Member Global Function Resolvers
2469 //
2470 
2471 // Arg Count 1
2472 template <class R, class A1>
2473 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1)) {
2474  return &SqGlobal<R>::template Func1<A1, 1, false>;
2475 }
2476 
2477 // Arg Count 1
2478 template <class R, class A1>
2479 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1)) {
2480  return &SqGlobal<R& >::template Func1<A1, 1, false>;
2481 }
2482 
2483 // Arg Count 2
2484 template <class R, class A1, class A2>
2485 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2)) {
2486  return &SqGlobal<R>::template Func2<A1, A2, 1, false>;
2487 }
2488 
2489 // Arg Count 2
2490 template <class R, class A1, class A2>
2491 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2)) {
2492  return &SqGlobal<R& >::template Func2<A1, A2, 1, false>;
2493 }
2494 
2495 // Arg Count 3
2496 template <class R, class A1, class A2, class A3>
2497 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3)) {
2498  return &SqGlobal<R>::template Func3<A1, A2, A3, 1, false>;
2499 }
2500 
2501 // Arg Count 3
2502 template <class R, class A1, class A2, class A3>
2503 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3)) {
2504  return &SqGlobal<R& >::template Func3<A1, A2, A3, 1, false>;
2505 }
2506 
2507 // Arg Count 4
2508 template <class R, class A1, class A2, class A3, class A4>
2509 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4)) {
2510  return &SqGlobal<R>::template Func4<A1, A2, A3, A4, 1, false>;
2511 }
2512 
2513 // Arg Count 4
2514 template <class R, class A1, class A2, class A3, class A4>
2515 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4)) {
2516  return &SqGlobal<R& >::template Func4<A1, A2, A3, A4, 1, false>;
2517 }
2518 
2519 // Arg Count 5
2520 template <class R, class A1, class A2, class A3, class A4, class A5>
2521 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5)) {
2522  return &SqGlobal<R>::template Func5<A1, A2, A3, A4, A5, 1, false>;
2523 }
2524 
2525 // Arg Count 5
2526 template <class R, class A1, class A2, class A3, class A4, class A5>
2527 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5)) {
2528  return &SqGlobal<R& >::template Func5<A1, A2, A3, A4, A5, 1, false>;
2529 }
2530 
2531 // Arg Count 6
2532 template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
2533 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6)) {
2534  return &SqGlobal<R>::template Func6<A1, A2, A3, A4, A5, A6, 1, false>;
2535 }
2536 
2537 // Arg Count 6
2538 template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
2539 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6)) {
2540  return &SqGlobal<R& >::template Func6<A1, A2, A3, A4, A5, A6, 1, false>;
2541 }
2542 
2543 // Arg Count 7
2544 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2545 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7)) {
2546  return &SqGlobal<R>::template Func7<A1, A2, A3, A4, A5, A6, A7, 1, false>;
2547 }
2548 
2549 // Arg Count 7
2550 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
2551 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7)) {
2552  return &SqGlobal<R& >::template Func7<A1, A2, A3, A4, A5, A6, A7, 1, false>;
2553 }
2554 
2555 // Arg Count 8
2556 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2557 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8)) {
2558  return &SqGlobal<R>::template Func8<A1, A2, A3, A4, A5, A6, A7, A8, 1, false>;
2559 }
2560 
2561 // Arg Count 8
2562 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
2563 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8)) {
2564  return &SqGlobal<R& >::template Func8<A1, A2, A3, A4, A5, A6, A7, A8, 1, false>;
2565 }
2566 
2567 // Arg Count 9
2568 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2569 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) {
2570  return &SqGlobal<R>::template Func9<A1, A2, A3, A4, A5, A6, A7, A8, A9, 1, false>;
2571 }
2572 
2573 // Arg Count 9
2574 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
2575 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) {
2576  return &SqGlobal<R& >::template Func9<A1, A2, A3, A4, A5, A6, A7, A8, A9, 1, false>;
2577 }
2578 
2579 // Arg Count 10
2580 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
2581 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) {
2582  return &SqGlobal<R>::template Func10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, 1, false>;
2583 }
2584 
2585 // Arg Count 10
2586 template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
2587 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) {
2588  return &SqGlobal<R& >::template Func10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, 1, false>;
2589 }
2590 
2591 // Arg Count 11
2592 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>
2593 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) {
2594  return &SqGlobal<R>::template Func11<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, 1, false>;
2595 }
2596 
2597 // Arg Count 11
2598 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>
2599 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) {
2600  return &SqGlobal<R& >::template Func11<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, 1, false>;
2601 }
2602 
2603 // Arg Count 12
2604 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>
2605 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) {
2606  return &SqGlobal<R>::template Func12<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, 1, false>;
2607 }
2608 
2609 // Arg Count 12
2610 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>
2611 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) {
2612  return &SqGlobal<R& >::template Func12<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, 1, false>;
2613 }
2614 
2615 // Arg Count 13
2616 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>
2617 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) {
2618  return &SqGlobal<R>::template Func13<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, 1, false>;
2619 }
2620 
2621 // Arg Count 13
2622 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>
2623 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) {
2624  return &SqGlobal<R& >::template Func13<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, 1, false>;
2625 }
2626 
2627 // Arg Count 14
2628 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>
2629 SQFUNCTION SqMemberGlobalFunc(R (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) {
2630  return &SqGlobal<R>::template Func14<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, 1, false>;
2631 }
2632 
2633 // Arg Count 14
2634 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>
2635 SQFUNCTION SqMemberGlobalFunc(R & (*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) {
2636  return &SqGlobal<R& >::template Func14<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, 1, false>;
2637 }
2638 
2640 
2641 }
2642 
2643 #endif
Sqrat::Error::Instance
static Error & Instance()
Definition: sqratUtil.h:134
Sqrat::Error::Occurred
bool Occurred(HSQUIRRELVM vm)
Definition: sqratUtil.h:198
Generated by   doxygen 1.8.6