sqrat  0.9
sqrat
 All Classes Functions Variables Enumerations Enumerator Pages
sqratMemberMethods.h
1 //
2 // SqratMemberMethods: Member Methods
3 //
4 
5 //
6 // Copyright (c) 2009 Brandon Jones
7 // Copyright 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_MEMBER_METHODS_H_)
30 #define _SCRAT_MEMBER_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 
44 template <class C, class R>
45 class SqMember {
46 #if !defined (SCRAT_NO_ERROR_CHECKING)
47  static const SQChar STATICCALLERROR[] ;
48 #endif
49 public:
50  // Arg Count 0
51  template <bool overloaded /* = false */>
52  static SQInteger Func0(HSQUIRRELVM vm) {
53 
54 #if !defined (SCRAT_NO_ERROR_CHECKING)
55  if (!overloaded && sq_gettop(vm) != 2) {
56  return sq_throwerror(vm, _SC("wrong number of parameters"));
57  }
58 #endif
59 
60  typedef R (C::*M)();
61  M* methodPtr;
62  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
63  M method = *methodPtr;
64 
65  C* ptr = ClassType<C>::GetInstance(vm, 1);
66 
67 #if !defined (SCRAT_NO_ERROR_CHECKING)
68  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
69 #endif
70 
71  R ret = (ptr->*method)();
72 
73 #if !defined (SCRAT_NO_ERROR_CHECKING)
74  if (!overloaded && Error::Instance().Occurred(vm)) {
75  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
76  }
77 #endif
78 
79  PushVar(vm, ret);
80  return 1;
81  }
82 
83  template <bool overloaded /* = false */ >
84  static SQInteger Func0C(HSQUIRRELVM vm) {
85 
86 #if !defined (SCRAT_NO_ERROR_CHECKING)
87  if (!overloaded && sq_gettop(vm) != 2) {
88  return sq_throwerror(vm, _SC("wrong number of parameters"));
89  }
90 #endif
91  typedef R (C::*M)() const;
92  M* methodPtr;
93  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
94  M method = *methodPtr;
95 
96  C* ptr = ClassType<C>::GetInstance(vm, 1);
97 
98 #if !defined (SCRAT_NO_ERROR_CHECKING)
99  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
100 #endif
101 
102  R ret = (ptr->*method)();
103 
104 #if !defined (SCRAT_NO_ERROR_CHECKING)
105  if (!overloaded && Error::Instance().Occurred(vm)) {
106  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
107  }
108 #endif
109 
110  PushVar(vm, ret);
111  return 1;
112  }
113 
114  // Arg Count 1
115  template <class A1, bool overloaded /*= false*/ >
116  static SQInteger Func1(HSQUIRRELVM vm) {
117 
118 #if !defined (SCRAT_NO_ERROR_CHECKING)
119  if (!overloaded && sq_gettop(vm) != 3) {
120  return sq_throwerror(vm, _SC("wrong number of parameters"));
121  }
122 #endif
123  typedef R (C::*M)(A1);
124  M* methodPtr;
125  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
126  M method = *methodPtr;
127 
128  C* ptr = ClassType<C>::GetInstance(vm, 1);
129 
130 #if !defined (SCRAT_NO_ERROR_CHECKING)
131  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
132 #endif
133 
134  Var<A1> a1(vm, 2);
135 
136 #if !defined (SCRAT_NO_ERROR_CHECKING)
137  if (Error::Instance().Occurred(vm)) {
138  if (overloaded)
139  return 0;
140  else
141  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
142  }
143 #endif
144 
145  R ret = (ptr->*method)(
146  a1.value
147  );
148 
149 #if !defined (SCRAT_NO_ERROR_CHECKING)
150  if (!overloaded && Error::Instance().Occurred(vm)) {
151  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
152  }
153 #endif
154 
155  PushVar(vm, ret);
156  return 1;
157  }
158 
159  template <class A1, bool overloaded /*= false*/ >
160  static SQInteger Func1C(HSQUIRRELVM vm) {
161 
162 #if !defined (SCRAT_NO_ERROR_CHECKING)
163  if (!overloaded && sq_gettop(vm) != 3) {
164  return sq_throwerror(vm, _SC("wrong number of parameters"));
165  }
166 #endif
167  typedef R (C::*M)(A1) const;
168  M* methodPtr;
169  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
170  M method = *methodPtr;
171 
172  C* ptr = ClassType<C>::GetInstance(vm, 1);
173 
174 #if !defined (SCRAT_NO_ERROR_CHECKING)
175  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
176 #endif
177 
178  Var<A1> a1(vm, 2);
179 
180 #if !defined (SCRAT_NO_ERROR_CHECKING)
181  if (Error::Instance().Occurred(vm)) {
182  if (overloaded)
183  return 0;
184  else
185  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
186  }
187 #endif
188 
189  R ret = (ptr->*method)(
190  a1.value
191  );
192 
193 #if !defined (SCRAT_NO_ERROR_CHECKING)
194  if (!overloaded && Error::Instance().Occurred(vm)) {
195  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
196  }
197 #endif
198 
199  PushVar(vm, ret);
200  return 1;
201  }
202 
203  // Arg Count 2
204  template <class A1, class A2, bool overloaded /*= false*/ >
205  static SQInteger Func2(HSQUIRRELVM vm) {
206 
207 #if !defined (SCRAT_NO_ERROR_CHECKING)
208  if (!overloaded && sq_gettop(vm) != 4) {
209  return sq_throwerror(vm, _SC("wrong number of parameters"));
210  }
211 #endif
212  typedef R (C::*M)(A1, A2);
213  M* methodPtr;
214  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
215  M method = *methodPtr;
216 
217  C* ptr = ClassType<C>::GetInstance(vm, 1);
218 
219 #if !defined (SCRAT_NO_ERROR_CHECKING)
220  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
221 #endif
222 
223  Var<A1> a1(vm, 2);
224  Var<A2> a2(vm, 3);
225 
226 #if !defined (SCRAT_NO_ERROR_CHECKING)
227  if (Error::Instance().Occurred(vm)) {
228  if (overloaded)
229  return 0;
230  else
231  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
232  }
233 #endif
234 
235  R ret = (ptr->*method)(
236  a1.value,
237  a2.value
238  );
239 
240 #if !defined (SCRAT_NO_ERROR_CHECKING)
241  if (!overloaded && Error::Instance().Occurred(vm)) {
242  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
243  }
244 #endif
245 
246  PushVar(vm, ret);
247  return 1;
248  }
249 
250  template <class A1, class A2, bool overloaded /*= false*/ >
251  static SQInteger Func2C(HSQUIRRELVM vm) {
252 
253 #if !defined (SCRAT_NO_ERROR_CHECKING)
254  if (!overloaded && sq_gettop(vm) != 4) {
255  return sq_throwerror(vm, _SC("wrong number of parameters"));
256  }
257 #endif
258  typedef R (C::*M)(A1, A2) const;
259  M* methodPtr;
260  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
261  M method = *methodPtr;
262 
263  C* ptr = ClassType<C>::GetInstance(vm, 1);
264 
265 #if !defined (SCRAT_NO_ERROR_CHECKING)
266  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
267 #endif
268 
269  Var<A1> a1(vm, 2);
270  Var<A2> a2(vm, 3);
271 
272 #if !defined (SCRAT_NO_ERROR_CHECKING)
273  if (Error::Instance().Occurred(vm)) {
274  if (overloaded)
275  return 0;
276  else
277  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
278  }
279 #endif
280 
281  R ret = (ptr->*method)(
282  a1.value,
283  a2.value
284  );
285 
286 #if !defined (SCRAT_NO_ERROR_CHECKING)
287  if (!overloaded && Error::Instance().Occurred(vm)) {
288  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
289  }
290 #endif
291 
292  PushVar(vm, ret);
293  return 1;
294  }
295 
296  // Arg Count 3
297  template <class A1, class A2, class A3, bool overloaded /*= false*/ >
298  static SQInteger Func3(HSQUIRRELVM vm) {
299 
300 #if !defined (SCRAT_NO_ERROR_CHECKING)
301  if (!overloaded && sq_gettop(vm) != 5) {
302  return sq_throwerror(vm, _SC("wrong number of parameters"));
303  }
304 #endif
305  typedef R (C::*M)(A1, A2, A3);
306  M* methodPtr;
307  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
308  M method = *methodPtr;
309 
310  C* ptr = ClassType<C>::GetInstance(vm, 1);
311 
312 #if !defined (SCRAT_NO_ERROR_CHECKING)
313  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
314 #endif
315 
316  Var<A1> a1(vm, 2);
317  Var<A2> a2(vm, 3);
318  Var<A3> a3(vm, 4);
319 
320 #if !defined (SCRAT_NO_ERROR_CHECKING)
321  if (Error::Instance().Occurred(vm)) {
322  if (overloaded)
323  return 0;
324  else
325  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
326  }
327 #endif
328 
329  R ret = (ptr->*method)(
330  a1.value,
331  a2.value,
332  a3.value
333  );
334 
335 #if !defined (SCRAT_NO_ERROR_CHECKING)
336  if (!overloaded && Error::Instance().Occurred(vm)) {
337  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
338  }
339 #endif
340 
341  PushVar(vm, ret);
342  return 1;
343  }
344 
345  template <class A1, class A2, class A3, bool overloaded /*= false*/ >
346  static SQInteger Func3C(HSQUIRRELVM vm) {
347 
348 #if !defined (SCRAT_NO_ERROR_CHECKING)
349  if (!overloaded && sq_gettop(vm) != 5) {
350  return sq_throwerror(vm, _SC("wrong number of parameters"));
351  }
352 #endif
353  typedef R (C::*M)(A1, A2, A3) const;
354  M* methodPtr;
355  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
356  M method = *methodPtr;
357 
358  C* ptr = ClassType<C>::GetInstance(vm, 1);
359 
360 #if !defined (SCRAT_NO_ERROR_CHECKING)
361  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
362 #endif
363 
364  Var<A1> a1(vm, 2);
365  Var<A2> a2(vm, 3);
366  Var<A3> a3(vm, 4);
367 
368 #if !defined (SCRAT_NO_ERROR_CHECKING)
369  if (Error::Instance().Occurred(vm)) {
370  if (overloaded)
371  return 0;
372  else
373  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
374  }
375 #endif
376 
377  R ret = (ptr->*method)(
378  a1.value,
379  a2.value,
380  a3.value
381  );
382 
383 #if !defined (SCRAT_NO_ERROR_CHECKING)
384  if (!overloaded && Error::Instance().Occurred(vm)) {
385  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
386  }
387 #endif
388 
389  PushVar(vm, ret);
390  return 1;
391  }
392 
393  // Arg Count 4
394  template <class A1, class A2, class A3, class A4, bool overloaded /*= false*/ >
395  static SQInteger Func4(HSQUIRRELVM vm) {
396 
397 #if !defined (SCRAT_NO_ERROR_CHECKING)
398  if (!overloaded && sq_gettop(vm) != 6) {
399  return sq_throwerror(vm, _SC("wrong number of parameters"));
400  }
401 #endif
402  typedef R (C::*M)(A1, A2, A3, A4);
403  M* methodPtr;
404  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
405  M method = *methodPtr;
406 
407  C* ptr = ClassType<C>::GetInstance(vm, 1);
408 
409 #if !defined (SCRAT_NO_ERROR_CHECKING)
410  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
411 #endif
412 
413  Var<A1> a1(vm, 2);
414  Var<A2> a2(vm, 3);
415  Var<A3> a3(vm, 4);
416  Var<A4> a4(vm, 5);
417 
418 #if !defined (SCRAT_NO_ERROR_CHECKING)
419  if (Error::Instance().Occurred(vm)) {
420  if (overloaded)
421  return 0;
422  else
423  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
424  }
425 #endif
426 
427  R ret = (ptr->*method)(
428  a1.value,
429  a2.value,
430  a3.value,
431  a4.value
432  );
433 
434 #if !defined (SCRAT_NO_ERROR_CHECKING)
435  if (!overloaded && Error::Instance().Occurred(vm)) {
436  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
437  }
438 #endif
439 
440  PushVar(vm, ret);
441  return 1;
442  }
443 
444  template <class A1, class A2, class A3, class A4, bool overloaded /*= false*/ >
445  static SQInteger Func4C(HSQUIRRELVM vm) {
446 
447 #if !defined (SCRAT_NO_ERROR_CHECKING)
448  if (!overloaded && sq_gettop(vm) != 6) {
449  return sq_throwerror(vm, _SC("wrong number of parameters"));
450  }
451 #endif
452  typedef R (C::*M)(A1, A2, A3, A4) const;
453  M* methodPtr;
454  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
455  M method = *methodPtr;
456 
457  C* ptr = ClassType<C>::GetInstance(vm, 1);
458 
459 #if !defined (SCRAT_NO_ERROR_CHECKING)
460  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
461 #endif
462 
463  Var<A1> a1(vm, 2);
464  Var<A2> a2(vm, 3);
465  Var<A3> a3(vm, 4);
466  Var<A4> a4(vm, 5);
467 
468 #if !defined (SCRAT_NO_ERROR_CHECKING)
469  if (Error::Instance().Occurred(vm)) {
470  if (overloaded)
471  return 0;
472  else
473  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
474  }
475 #endif
476 
477  R ret = (ptr->*method)(
478  a1.value,
479  a2.value,
480  a3.value,
481  a4.value
482  );
483 
484 #if !defined (SCRAT_NO_ERROR_CHECKING)
485  if (!overloaded && Error::Instance().Occurred(vm)) {
486  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
487  }
488 #endif
489 
490  PushVar(vm, ret);
491  return 1;
492  }
493 
494  // Arg Count 5
495  template <class A1, class A2, class A3, class A4, class A5, bool overloaded /*= false*/ >
496  static SQInteger Func5(HSQUIRRELVM vm) {
497 
498 #if !defined (SCRAT_NO_ERROR_CHECKING)
499  if (!overloaded && sq_gettop(vm) != 7) {
500  return sq_throwerror(vm, _SC("wrong number of parameters"));
501  }
502 #endif
503  typedef R (C::*M)(A1, A2, A3, A4, A5);
504  M* methodPtr;
505  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
506  M method = *methodPtr;
507 
508  C* ptr = ClassType<C>::GetInstance(vm, 1);
509 
510 #if !defined (SCRAT_NO_ERROR_CHECKING)
511  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
512 #endif
513 
514  Var<A1> a1(vm, 2);
515  Var<A2> a2(vm, 3);
516  Var<A3> a3(vm, 4);
517  Var<A4> a4(vm, 5);
518  Var<A5> a5(vm, 6);
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 = (ptr->*method)(
530  a1.value,
531  a2.value,
532  a3.value,
533  a4.value,
534  a5.value
535  );
536 
537 #if !defined (SCRAT_NO_ERROR_CHECKING)
538  if (!overloaded && Error::Instance().Occurred(vm)) {
539  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
540  }
541 #endif
542 
543  PushVar(vm, ret);
544  return 1;
545  }
546 
547  template <class A1, class A2, class A3, class A4, class A5, bool overloaded /*= false*/ >
548  static SQInteger Func5C(HSQUIRRELVM vm) {
549 
550 #if !defined (SCRAT_NO_ERROR_CHECKING)
551  if (!overloaded && sq_gettop(vm) != 7) {
552  return sq_throwerror(vm, _SC("wrong number of parameters"));
553  }
554 #endif
555  typedef R (C::*M)(A1, A2, A3, A4, A5) const;
556  M* methodPtr;
557  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
558  M method = *methodPtr;
559 
560  C* ptr = ClassType<C>::GetInstance(vm, 1);
561 
562 #if !defined (SCRAT_NO_ERROR_CHECKING)
563  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
564 #endif
565 
566  Var<A1> a1(vm, 2);
567  Var<A2> a2(vm, 3);
568  Var<A3> a3(vm, 4);
569  Var<A4> a4(vm, 5);
570  Var<A5> a5(vm, 6);
571 
572 #if !defined (SCRAT_NO_ERROR_CHECKING)
573  if (Error::Instance().Occurred(vm)) {
574  if (overloaded)
575  return 0;
576  else
577  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
578  }
579 #endif
580 
581  R ret = (ptr->*method)(
582  a1.value,
583  a2.value,
584  a3.value,
585  a4.value,
586  a5.value
587  );
588 
589 #if !defined (SCRAT_NO_ERROR_CHECKING)
590  if (!overloaded && Error::Instance().Occurred(vm)) {
591  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
592  }
593 #endif
594 
595  PushVar(vm, ret);
596  return 1;
597  }
598 
599  // Arg Count 6
600  template <class A1, class A2, class A3, class A4, class A5, class A6, bool overloaded /*= false*/ >
601  static SQInteger Func6(HSQUIRRELVM vm) {
602 
603 #if !defined (SCRAT_NO_ERROR_CHECKING)
604  if (!overloaded && sq_gettop(vm) != 8) {
605  return sq_throwerror(vm, _SC("wrong number of parameters"));
606  }
607 #endif
608  typedef R (C::*M)(A1, A2, A3, A4, A5, A6);
609  M* methodPtr;
610  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
611  M method = *methodPtr;
612 
613  C* ptr = ClassType<C>::GetInstance(vm, 1);
614 
615 #if !defined (SCRAT_NO_ERROR_CHECKING)
616  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
617 #endif
618 
619  Var<A1> a1(vm, 2);
620  Var<A2> a2(vm, 3);
621  Var<A3> a3(vm, 4);
622  Var<A4> a4(vm, 5);
623  Var<A5> a5(vm, 6);
624  Var<A6> a6(vm, 7);
625 
626 #if !defined (SCRAT_NO_ERROR_CHECKING)
627  if (Error::Instance().Occurred(vm)) {
628  if (overloaded)
629  return 0;
630  else
631  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
632  }
633 #endif
634 
635  R ret = (ptr->*method)(
636  a1.value,
637  a2.value,
638  a3.value,
639  a4.value,
640  a5.value,
641  a6.value
642  );
643 
644 #if !defined (SCRAT_NO_ERROR_CHECKING)
645  if (!overloaded && Error::Instance().Occurred(vm)) {
646  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
647  }
648 #endif
649 
650  PushVar(vm, ret);
651  return 1;
652  }
653 
654  template <class A1, class A2, class A3, class A4, class A5, class A6, bool overloaded /*= false*/ >
655  static SQInteger Func6C(HSQUIRRELVM vm) {
656 
657 #if !defined (SCRAT_NO_ERROR_CHECKING)
658  if (!overloaded && sq_gettop(vm) != 8) {
659  return sq_throwerror(vm, _SC("wrong number of parameters"));
660  }
661 #endif
662  typedef R (C::*M)(A1, A2, A3, A4, A5, A6) const;
663  M* methodPtr;
664  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
665  M method = *methodPtr;
666 
667  C* ptr = ClassType<C>::GetInstance(vm, 1);
668 
669 #if !defined (SCRAT_NO_ERROR_CHECKING)
670  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
671 #endif
672 
673  Var<A1> a1(vm, 2);
674  Var<A2> a2(vm, 3);
675  Var<A3> a3(vm, 4);
676  Var<A4> a4(vm, 5);
677  Var<A5> a5(vm, 6);
678  Var<A6> a6(vm, 7);
679 
680 #if !defined (SCRAT_NO_ERROR_CHECKING)
681  if (Error::Instance().Occurred(vm)) {
682  if (overloaded)
683  return 0;
684  else
685  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
686  }
687 #endif
688 
689  R ret = (ptr->*method)(
690  a1.value,
691  a2.value,
692  a3.value,
693  a4.value,
694  a5.value,
695  a6.value
696  );
697 
698 #if !defined (SCRAT_NO_ERROR_CHECKING)
699  if (!overloaded && Error::Instance().Occurred(vm)) {
700  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
701  }
702 #endif
703 
704  PushVar(vm, ret);
705  return 1;
706  }
707 
708  // Arg Count 7
709  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool overloaded /*= false*/ >
710  static SQInteger Func7(HSQUIRRELVM vm) {
711 
712 #if !defined (SCRAT_NO_ERROR_CHECKING)
713  if (!overloaded && sq_gettop(vm) != 9) {
714  return sq_throwerror(vm, _SC("wrong number of parameters"));
715  }
716 #endif
717  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7);
718  M* methodPtr;
719  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
720  M method = *methodPtr;
721 
722  C* ptr = ClassType<C>::GetInstance(vm, 1);
723 
724 #if !defined (SCRAT_NO_ERROR_CHECKING)
725  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
726 #endif
727 
728  Var<A1> a1(vm, 2);
729  Var<A2> a2(vm, 3);
730  Var<A3> a3(vm, 4);
731  Var<A4> a4(vm, 5);
732  Var<A5> a5(vm, 6);
733  Var<A6> a6(vm, 7);
734  Var<A7> a7(vm, 8);
735 
736 #if !defined (SCRAT_NO_ERROR_CHECKING)
737  if (Error::Instance().Occurred(vm)) {
738  if (overloaded)
739  return 0;
740  else
741  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
742  }
743 #endif
744 
745  R ret = (ptr->*method)(
746  a1.value,
747  a2.value,
748  a3.value,
749  a4.value,
750  a5.value,
751  a6.value,
752  a7.value
753  );
754 
755 #if !defined (SCRAT_NO_ERROR_CHECKING)
756  if (!overloaded && Error::Instance().Occurred(vm)) {
757  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
758  }
759 #endif
760 
761  PushVar(vm, ret);
762  return 1;
763  }
764 
765  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool overloaded /*= false*/ >
766  static SQInteger Func7C(HSQUIRRELVM vm) {
767 
768 #if !defined (SCRAT_NO_ERROR_CHECKING)
769  if (!overloaded && sq_gettop(vm) != 9) {
770  return sq_throwerror(vm, _SC("wrong number of parameters"));
771  }
772 #endif
773  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7) const;
774  M* methodPtr;
775  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
776  M method = *methodPtr;
777 
778  C* ptr = ClassType<C>::GetInstance(vm, 1);
779 
780 #if !defined (SCRAT_NO_ERROR_CHECKING)
781  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
782 #endif
783 
784  Var<A1> a1(vm, 2);
785  Var<A2> a2(vm, 3);
786  Var<A3> a3(vm, 4);
787  Var<A4> a4(vm, 5);
788  Var<A5> a5(vm, 6);
789  Var<A6> a6(vm, 7);
790  Var<A7> a7(vm, 8);
791 
792 #if !defined (SCRAT_NO_ERROR_CHECKING)
793  if (Error::Instance().Occurred(vm)) {
794  if (overloaded)
795  return 0;
796  else
797  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
798  }
799 #endif
800 
801  R ret = (ptr->*method)(
802  a1.value,
803  a2.value,
804  a3.value,
805  a4.value,
806  a5.value,
807  a6.value,
808  a7.value
809  );
810 
811 #if !defined (SCRAT_NO_ERROR_CHECKING)
812  if (!overloaded && Error::Instance().Occurred(vm)) {
813  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
814  }
815 #endif
816 
817  PushVar(vm, ret);
818  return 1;
819  }
820 
821  // Arg Count 8
822  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool overloaded /*= false*/ >
823  static SQInteger Func8(HSQUIRRELVM vm) {
824 
825 #if !defined (SCRAT_NO_ERROR_CHECKING)
826  if (!overloaded && sq_gettop(vm) != 10) {
827  return sq_throwerror(vm, _SC("wrong number of parameters"));
828  }
829 #endif
830  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8);
831  M* methodPtr;
832  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
833  M method = *methodPtr;
834 
835  C* ptr = ClassType<C>::GetInstance(vm, 1);
836 
837 #if !defined (SCRAT_NO_ERROR_CHECKING)
838  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
839 #endif
840 
841  Var<A1> a1(vm, 2);
842  Var<A2> a2(vm, 3);
843  Var<A3> a3(vm, 4);
844  Var<A4> a4(vm, 5);
845  Var<A5> a5(vm, 6);
846  Var<A6> a6(vm, 7);
847  Var<A7> a7(vm, 8);
848  Var<A8> a8(vm, 9);
849 
850 #if !defined (SCRAT_NO_ERROR_CHECKING)
851  if (Error::Instance().Occurred(vm)) {
852  if (overloaded)
853  return 0;
854  else
855  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
856  }
857 #endif
858 
859  R ret = (ptr->*method)(
860  a1.value,
861  a2.value,
862  a3.value,
863  a4.value,
864  a5.value,
865  a6.value,
866  a7.value,
867  a8.value
868  );
869 
870 #if !defined (SCRAT_NO_ERROR_CHECKING)
871  if (!overloaded && Error::Instance().Occurred(vm)) {
872  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
873  }
874 #endif
875 
876  PushVar(vm, ret);
877  return 1;
878  }
879 
880  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool overloaded /*= false*/ >
881  static SQInteger Func8C(HSQUIRRELVM vm) {
882 
883 #if !defined (SCRAT_NO_ERROR_CHECKING)
884  if (!overloaded && sq_gettop(vm) != 10) {
885  return sq_throwerror(vm, _SC("wrong number of parameters"));
886  }
887 #endif
888  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8) const;
889  M* methodPtr;
890  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
891  M method = *methodPtr;
892 
893  C* ptr = ClassType<C>::GetInstance(vm, 1);
894 
895 #if !defined (SCRAT_NO_ERROR_CHECKING)
896  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
897 #endif
898 
899  Var<A1> a1(vm, 2);
900  Var<A2> a2(vm, 3);
901  Var<A3> a3(vm, 4);
902  Var<A4> a4(vm, 5);
903  Var<A5> a5(vm, 6);
904  Var<A6> a6(vm, 7);
905  Var<A7> a7(vm, 8);
906  Var<A8> a8(vm, 9);
907 
908 #if !defined (SCRAT_NO_ERROR_CHECKING)
909  if (Error::Instance().Occurred(vm)) {
910  if (overloaded)
911  return 0;
912  else
913  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
914  }
915 #endif
916 
917  R ret = (ptr->*method)(
918  a1.value,
919  a2.value,
920  a3.value,
921  a4.value,
922  a5.value,
923  a6.value,
924  a7.value,
925  a8.value
926  );
927 
928 #if !defined (SCRAT_NO_ERROR_CHECKING)
929  if (!overloaded && Error::Instance().Occurred(vm)) {
930  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
931  }
932 #endif
933 
934  PushVar(vm, ret);
935  return 1;
936  }
937 
938  // Arg Count 9
939  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool overloaded /*= false*/ >
940  static SQInteger Func9(HSQUIRRELVM vm) {
941 
942 #if !defined (SCRAT_NO_ERROR_CHECKING)
943  if (!overloaded && sq_gettop(vm) != 11) {
944  return sq_throwerror(vm, _SC("wrong number of parameters"));
945  }
946 #endif
947  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
948  M* methodPtr;
949  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
950  M method = *methodPtr;
951 
952  C* ptr = ClassType<C>::GetInstance(vm, 1);
953 
954 #if !defined (SCRAT_NO_ERROR_CHECKING)
955  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
956 #endif
957 
958  Var<A1> a1(vm, 2);
959  Var<A2> a2(vm, 3);
960  Var<A3> a3(vm, 4);
961  Var<A4> a4(vm, 5);
962  Var<A5> a5(vm, 6);
963  Var<A6> a6(vm, 7);
964  Var<A7> a7(vm, 8);
965  Var<A8> a8(vm, 9);
966  Var<A9> a9(vm, 10);
967 
968 #if !defined (SCRAT_NO_ERROR_CHECKING)
969  if (Error::Instance().Occurred(vm)) {
970  if (overloaded)
971  return 0;
972  else
973  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
974  }
975 #endif
976 
977  R ret = (ptr->*method)(
978  a1.value,
979  a2.value,
980  a3.value,
981  a4.value,
982  a5.value,
983  a6.value,
984  a7.value,
985  a8.value,
986  a9.value
987  );
988 
989 #if !defined (SCRAT_NO_ERROR_CHECKING)
990  if (!overloaded && Error::Instance().Occurred(vm)) {
991  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
992  }
993 #endif
994 
995  PushVar(vm, ret);
996  return 1;
997  }
998 
999  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool overloaded /*= false*/ >
1000  static SQInteger Func9C(HSQUIRRELVM vm) {
1001 
1002 #if !defined (SCRAT_NO_ERROR_CHECKING)
1003  if (!overloaded && sq_gettop(vm) != 11) {
1004  return sq_throwerror(vm, _SC("wrong number of parameters"));
1005  }
1006 #endif
1007  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const;
1008  M* methodPtr;
1009  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1010  M method = *methodPtr;
1011 
1012  C* ptr = ClassType<C>::GetInstance(vm, 1);
1013 
1014 #if !defined (SCRAT_NO_ERROR_CHECKING)
1015  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1016 #endif
1017 
1018  Var<A1> a1(vm, 2);
1019  Var<A2> a2(vm, 3);
1020  Var<A3> a3(vm, 4);
1021  Var<A4> a4(vm, 5);
1022  Var<A5> a5(vm, 6);
1023  Var<A6> a6(vm, 7);
1024  Var<A7> a7(vm, 8);
1025  Var<A8> a8(vm, 9);
1026  Var<A9> a9(vm, 10);
1027 
1028 #if !defined (SCRAT_NO_ERROR_CHECKING)
1029  if (Error::Instance().Occurred(vm)) {
1030  if (overloaded)
1031  return 0;
1032  else
1033  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1034  }
1035 #endif
1036 
1037  R ret = (ptr->*method)(
1038  a1.value,
1039  a2.value,
1040  a3.value,
1041  a4.value,
1042  a5.value,
1043  a6.value,
1044  a7.value,
1045  a8.value,
1046  a9.value
1047  );
1048 
1049 #if !defined (SCRAT_NO_ERROR_CHECKING)
1050  if (!overloaded && Error::Instance().Occurred(vm)) {
1051  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1052  }
1053 #endif
1054 
1055  PushVar(vm, ret);
1056  return 1;
1057  }
1058 
1059 
1060  // Arg Count 10
1061  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool overloaded /*= false*/ >
1062  static SQInteger Func10(HSQUIRRELVM vm) {
1063 
1064 #if !defined (SCRAT_NO_ERROR_CHECKING)
1065  if (!overloaded && sq_gettop(vm) != 12) {
1066  return sq_throwerror(vm, _SC("wrong number of parameters"));
1067  }
1068 #endif
1069  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
1070  M* methodPtr;
1071  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1072  M method = *methodPtr;
1073 
1074  C* ptr = ClassType<C>::GetInstance(vm, 1);
1075 
1076 #if !defined (SCRAT_NO_ERROR_CHECKING)
1077  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1078 #endif
1079 
1080  Var<A1> a1(vm, 2);
1081  Var<A2> a2(vm, 3);
1082  Var<A3> a3(vm, 4);
1083  Var<A4> a4(vm, 5);
1084  Var<A5> a5(vm, 6);
1085  Var<A6> a6(vm, 7);
1086  Var<A7> a7(vm, 8);
1087  Var<A8> a8(vm, 9);
1088  Var<A9> a9(vm, 10);
1089  Var<A10> a10(vm, 11);
1090 
1091 #if !defined (SCRAT_NO_ERROR_CHECKING)
1092  if (Error::Instance().Occurred(vm)) {
1093  if (overloaded)
1094  return 0;
1095  else
1096  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1097  }
1098 #endif
1099 
1100  R ret = (ptr->*method)(
1101  a1.value,
1102  a2.value,
1103  a3.value,
1104  a4.value,
1105  a5.value,
1106  a6.value,
1107  a7.value,
1108  a8.value,
1109  a9.value,
1110  a10.value
1111  );
1112 
1113 #if !defined (SCRAT_NO_ERROR_CHECKING)
1114  if (!overloaded && Error::Instance().Occurred(vm)) {
1115  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1116  }
1117 #endif
1118 
1119  PushVar(vm, ret);
1120  return 1;
1121  }
1122 
1123  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool overloaded /*= false*/ >
1124  static SQInteger Func10C(HSQUIRRELVM vm) {
1125 
1126 #if !defined (SCRAT_NO_ERROR_CHECKING)
1127  if (!overloaded && sq_gettop(vm) != 12) {
1128  return sq_throwerror(vm, _SC("wrong number of parameters"));
1129  }
1130 #endif
1131  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const;
1132  M* methodPtr;
1133  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1134  M method = *methodPtr;
1135 
1136  C* ptr = ClassType<C>::GetInstance(vm, 1);
1137 
1138 #if !defined (SCRAT_NO_ERROR_CHECKING)
1139  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1140 #endif
1141 
1142  Var<A1> a1(vm, 2);
1143  Var<A2> a2(vm, 3);
1144  Var<A3> a3(vm, 4);
1145  Var<A4> a4(vm, 5);
1146  Var<A5> a5(vm, 6);
1147  Var<A6> a6(vm, 7);
1148  Var<A7> a7(vm, 8);
1149  Var<A8> a8(vm, 9);
1150  Var<A9> a9(vm, 10);
1151  Var<A10> a10(vm, 11);
1152 
1153 #if !defined (SCRAT_NO_ERROR_CHECKING)
1154  if (Error::Instance().Occurred(vm)) {
1155  if (overloaded)
1156  return 0;
1157  else
1158  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1159  }
1160 #endif
1161 
1162  R ret = (ptr->*method)(
1163  a1.value,
1164  a2.value,
1165  a3.value,
1166  a4.value,
1167  a5.value,
1168  a6.value,
1169  a7.value,
1170  a8.value,
1171  a9.value,
1172  a10.value
1173  );
1174 
1175 #if !defined (SCRAT_NO_ERROR_CHECKING)
1176  if (!overloaded && Error::Instance().Occurred(vm)) {
1177  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1178  }
1179 #endif
1180 
1181  PushVar(vm, ret);
1182  return 1;
1183  }
1184 
1185 
1186  // Arg Count 11
1187  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool overloaded /*= false*/>
1188  static SQInteger Func11(HSQUIRRELVM vm) {
1189 
1190 #if !defined (SCRAT_NO_ERROR_CHECKING)
1191  if (!overloaded && sq_gettop(vm) != 13) {
1192  return sq_throwerror(vm, _SC("wrong number of parameters"));
1193  }
1194 #endif
1195  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
1196  M* methodPtr;
1197  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1198  M method = *methodPtr;
1199 
1200  C* ptr = ClassType<C>::GetInstance(vm, 1);
1201 
1202 #if !defined (SCRAT_NO_ERROR_CHECKING)
1203  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1204 #endif
1205 
1206  Var<A1> a1(vm, 2);
1207  Var<A2> a2(vm, 3);
1208  Var<A3> a3(vm, 4);
1209  Var<A4> a4(vm, 5);
1210  Var<A5> a5(vm, 6);
1211  Var<A6> a6(vm, 7);
1212  Var<A7> a7(vm, 8);
1213  Var<A8> a8(vm, 9);
1214  Var<A9> a9(vm, 10);
1215  Var<A10> a10(vm, 11);
1216  Var<A11> a11(vm, 12);
1217 
1218 #if !defined (SCRAT_NO_ERROR_CHECKING)
1219  if (Error::Instance().Occurred(vm)) {
1220  if (overloaded)
1221  return 0;
1222  else
1223  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1224  }
1225 #endif
1226 
1227  R ret = (ptr->*method)(
1228  a1.value,
1229  a2.value,
1230  a3.value,
1231  a4.value,
1232  a5.value,
1233  a6.value,
1234  a7.value,
1235  a8.value,
1236  a9.value,
1237  a10.value,
1238  a11.value
1239  );
1240 
1241 #if !defined (SCRAT_NO_ERROR_CHECKING)
1242  if (!overloaded && Error::Instance().Occurred(vm)) {
1243  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1244  }
1245 #endif
1246 
1247  PushVar(vm, ret);
1248  return 1;
1249  }
1250 
1251  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool overloaded /*= false*/>
1252  static SQInteger Func11C(HSQUIRRELVM vm) {
1253 
1254 #if !defined (SCRAT_NO_ERROR_CHECKING)
1255  if (!overloaded && sq_gettop(vm) != 13) {
1256  return sq_throwerror(vm, _SC("wrong number of parameters"));
1257  }
1258 #endif
1259  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const;
1260  M* methodPtr;
1261  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1262  M method = *methodPtr;
1263 
1264  C* ptr = ClassType<C>::GetInstance(vm, 1);
1265 
1266 #if !defined (SCRAT_NO_ERROR_CHECKING)
1267  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1268 #endif
1269 
1270  Var<A1> a1(vm, 2);
1271  Var<A2> a2(vm, 3);
1272  Var<A3> a3(vm, 4);
1273  Var<A4> a4(vm, 5);
1274  Var<A5> a5(vm, 6);
1275  Var<A6> a6(vm, 7);
1276  Var<A7> a7(vm, 8);
1277  Var<A8> a8(vm, 9);
1278  Var<A9> a9(vm, 10);
1279  Var<A10> a10(vm, 11);
1280  Var<A11> a11(vm, 12);
1281 
1282 #if !defined (SCRAT_NO_ERROR_CHECKING)
1283  if (Error::Instance().Occurred(vm)) {
1284  if (overloaded)
1285  return 0;
1286  else
1287  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1288  }
1289 #endif
1290 
1291  R ret = (ptr->*method)(
1292  a1.value,
1293  a2.value,
1294  a3.value,
1295  a4.value,
1296  a5.value,
1297  a6.value,
1298  a7.value,
1299  a8.value,
1300  a9.value,
1301  a10.value,
1302  a11.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  PushVar(vm, ret);
1312  return 1;
1313  }
1314 
1315 
1316  // Arg Count 12
1317  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, bool overloaded /*= false*/ >
1318  static SQInteger Func12(HSQUIRRELVM vm) {
1319 
1320 #if !defined (SCRAT_NO_ERROR_CHECKING)
1321  if (!overloaded && sq_gettop(vm) != 14) {
1322  return sq_throwerror(vm, _SC("wrong number of parameters"));
1323  }
1324 #endif
1325  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
1326  M* methodPtr;
1327  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1328  M method = *methodPtr;
1329 
1330  C* ptr = ClassType<C>::GetInstance(vm, 1);
1331 
1332 #if !defined (SCRAT_NO_ERROR_CHECKING)
1333  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1334 #endif
1335 
1336  Var<A1> a1(vm, 2);
1337  Var<A2> a2(vm, 3);
1338  Var<A3> a3(vm, 4);
1339  Var<A4> a4(vm, 5);
1340  Var<A5> a5(vm, 6);
1341  Var<A6> a6(vm, 7);
1342  Var<A7> a7(vm, 8);
1343  Var<A8> a8(vm, 9);
1344  Var<A9> a9(vm, 10);
1345  Var<A10> a10(vm, 11);
1346  Var<A11> a11(vm, 12);
1347  Var<A12> a12(vm, 13);
1348 
1349 #if !defined (SCRAT_NO_ERROR_CHECKING)
1350  if (Error::Instance().Occurred(vm)) {
1351  if (overloaded)
1352  return 0;
1353  else
1354  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1355  }
1356 #endif
1357 
1358  R ret = (ptr->*method)(
1359  a1.value,
1360  a2.value,
1361  a3.value,
1362  a4.value,
1363  a5.value,
1364  a6.value,
1365  a7.value,
1366  a8.value,
1367  a9.value,
1368  a10.value,
1369  a11.value,
1370  a12.value
1371  );
1372 
1373 #if !defined (SCRAT_NO_ERROR_CHECKING)
1374  if (!overloaded && Error::Instance().Occurred(vm)) {
1375  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1376  }
1377 #endif
1378 
1379  PushVar(vm, ret);
1380  return 1;
1381  }
1382 
1383  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, bool overloaded /*= false*/ >
1384  static SQInteger Func12C(HSQUIRRELVM vm) {
1385 
1386 #if !defined (SCRAT_NO_ERROR_CHECKING)
1387  if (!overloaded && sq_gettop(vm) != 14) {
1388  return sq_throwerror(vm, _SC("wrong number of parameters"));
1389  }
1390 #endif
1391  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const;
1392  M* methodPtr;
1393  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1394  M method = *methodPtr;
1395 
1396  C* ptr = ClassType<C>::GetInstance(vm, 1);
1397 
1398 #if !defined (SCRAT_NO_ERROR_CHECKING)
1399  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1400 #endif
1401 
1402  Var<A1> a1(vm, 2);
1403  Var<A2> a2(vm, 3);
1404  Var<A3> a3(vm, 4);
1405  Var<A4> a4(vm, 5);
1406  Var<A5> a5(vm, 6);
1407  Var<A6> a6(vm, 7);
1408  Var<A7> a7(vm, 8);
1409  Var<A8> a8(vm, 9);
1410  Var<A9> a9(vm, 10);
1411  Var<A10> a10(vm, 11);
1412  Var<A11> a11(vm, 12);
1413  Var<A12> a12(vm, 13);
1414 
1415 #if !defined (SCRAT_NO_ERROR_CHECKING)
1416  if (Error::Instance().Occurred(vm)) {
1417  if (overloaded)
1418  return 0;
1419  else
1420  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1421  }
1422 #endif
1423 
1424  R ret = (ptr->*method)(
1425  a1.value,
1426  a2.value,
1427  a3.value,
1428  a4.value,
1429  a5.value,
1430  a6.value,
1431  a7.value,
1432  a8.value,
1433  a9.value,
1434  a10.value,
1435  a11.value,
1436  a12.value
1437  );
1438 
1439 #if !defined (SCRAT_NO_ERROR_CHECKING)
1440  if (!overloaded && Error::Instance().Occurred(vm)) {
1441  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1442  }
1443 #endif
1444 
1445  PushVar(vm, ret);
1446  return 1;
1447  }
1448 
1449  // Arg Count 13
1450  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, bool overloaded /*= false*/ >
1451  static SQInteger Func13(HSQUIRRELVM vm) {
1452 
1453 #if !defined (SCRAT_NO_ERROR_CHECKING)
1454  if (!overloaded && sq_gettop(vm) != 15) {
1455  return sq_throwerror(vm, _SC("wrong number of parameters"));
1456  }
1457 #endif
1458  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
1459  M* methodPtr;
1460  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1461  M method = *methodPtr;
1462 
1463  C* ptr = ClassType<C>::GetInstance(vm, 1);
1464 
1465 #if !defined (SCRAT_NO_ERROR_CHECKING)
1466  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1467 #endif
1468 
1469  Var<A1> a1(vm, 2);
1470  Var<A2> a2(vm, 3);
1471  Var<A3> a3(vm, 4);
1472  Var<A4> a4(vm, 5);
1473  Var<A5> a5(vm, 6);
1474  Var<A6> a6(vm, 7);
1475  Var<A7> a7(vm, 8);
1476  Var<A8> a8(vm, 9);
1477  Var<A9> a9(vm, 10);
1478  Var<A10> a10(vm, 11);
1479  Var<A11> a11(vm, 12);
1480  Var<A12> a12(vm, 13);
1481  Var<A13> a13(vm, 14);
1482 
1483 #if !defined (SCRAT_NO_ERROR_CHECKING)
1484  if (Error::Instance().Occurred(vm)) {
1485  if (overloaded)
1486  return 0;
1487  else
1488  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1489  }
1490 #endif
1491 
1492  R ret = (ptr->*method)(
1493  a1.value,
1494  a2.value,
1495  a3.value,
1496  a4.value,
1497  a5.value,
1498  a6.value,
1499  a7.value,
1500  a8.value,
1501  a9.value,
1502  a10.value,
1503  a11.value,
1504  a12.value,
1505  a13.value
1506  );
1507 
1508 #if !defined (SCRAT_NO_ERROR_CHECKING)
1509  if (!overloaded && Error::Instance().Occurred(vm)) {
1510  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1511  }
1512 #endif
1513 
1514  PushVar(vm, ret);
1515  return 1;
1516  }
1517 
1518  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, bool overloaded /*= false*/ >
1519  static SQInteger Func13C(HSQUIRRELVM vm) {
1520 
1521 #if !defined (SCRAT_NO_ERROR_CHECKING)
1522  if (!overloaded && sq_gettop(vm) != 15) {
1523  return sq_throwerror(vm, _SC("wrong number of parameters"));
1524  }
1525 #endif
1526  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const;
1527  M* methodPtr;
1528  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1529  M method = *methodPtr;
1530 
1531  C* ptr = ClassType<C>::GetInstance(vm, 1);
1532 
1533 #if !defined (SCRAT_NO_ERROR_CHECKING)
1534  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1535 #endif
1536 
1537  Var<A1> a1(vm, 2);
1538  Var<A2> a2(vm, 3);
1539  Var<A3> a3(vm, 4);
1540  Var<A4> a4(vm, 5);
1541  Var<A5> a5(vm, 6);
1542  Var<A6> a6(vm, 7);
1543  Var<A7> a7(vm, 8);
1544  Var<A8> a8(vm, 9);
1545  Var<A9> a9(vm, 10);
1546  Var<A10> a10(vm, 11);
1547  Var<A11> a11(vm, 12);
1548  Var<A12> a12(vm, 13);
1549  Var<A13> a13(vm, 14);
1550 
1551 #if !defined (SCRAT_NO_ERROR_CHECKING)
1552  if (Error::Instance().Occurred(vm)) {
1553  if (overloaded)
1554  return 0;
1555  else
1556  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1557  }
1558 #endif
1559 
1560  R ret = (ptr->*method)(
1561  a1.value,
1562  a2.value,
1563  a3.value,
1564  a4.value,
1565  a5.value,
1566  a6.value,
1567  a7.value,
1568  a8.value,
1569  a9.value,
1570  a10.value,
1571  a11.value,
1572  a12.value,
1573  a13.value
1574  );
1575 
1576 #if !defined (SCRAT_NO_ERROR_CHECKING)
1577  if (!overloaded && Error::Instance().Occurred(vm)) {
1578  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1579  }
1580 #endif
1581 
1582  PushVar(vm, ret);
1583  return 1;
1584  }
1585 
1586  // Arg Count 14
1587  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, bool overloaded /*= false*/ >
1588  static SQInteger Func14(HSQUIRRELVM vm) {
1589 
1590 #if !defined (SCRAT_NO_ERROR_CHECKING)
1591  if (!overloaded && sq_gettop(vm) != 16) {
1592  return sq_throwerror(vm, _SC("wrong number of parameters"));
1593  }
1594 #endif
1595  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
1596  M* methodPtr;
1597  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1598  M method = *methodPtr;
1599 
1600  C* ptr = ClassType<C>::GetInstance(vm, 1);
1601 
1602 #if !defined (SCRAT_NO_ERROR_CHECKING)
1603  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1604 #endif
1605 
1606  Var<A1> a1(vm, 2);
1607  Var<A2> a2(vm, 3);
1608  Var<A3> a3(vm, 4);
1609  Var<A4> a4(vm, 5);
1610  Var<A5> a5(vm, 6);
1611  Var<A6> a6(vm, 7);
1612  Var<A7> a7(vm, 8);
1613  Var<A8> a8(vm, 9);
1614  Var<A9> a9(vm, 10);
1615  Var<A10> a10(vm, 11);
1616  Var<A11> a11(vm, 12);
1617  Var<A12> a12(vm, 13);
1618  Var<A13> a13(vm, 14);
1619  Var<A14> a14(vm, 15);
1620 
1621 #if !defined (SCRAT_NO_ERROR_CHECKING)
1622  if (Error::Instance().Occurred(vm)) {
1623  if (overloaded)
1624  return 0;
1625  else
1626  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1627  }
1628 #endif
1629 
1630  R ret = (ptr->*method)(
1631  a1.value,
1632  a2.value,
1633  a3.value,
1634  a4.value,
1635  a5.value,
1636  a6.value,
1637  a7.value,
1638  a8.value,
1639  a9.value,
1640  a10.value,
1641  a11.value,
1642  a12.value,
1643  a13.value,
1644  a14.value
1645  );
1646 
1647 #if !defined (SCRAT_NO_ERROR_CHECKING)
1648  if (!overloaded && Error::Instance().Occurred(vm)) {
1649  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1650  }
1651 #endif
1652 
1653  PushVar(vm, ret);
1654  return 1;
1655  }
1656 
1657  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, bool overloaded /*= false*/ >
1658  static SQInteger Func14C(HSQUIRRELVM vm) {
1659 
1660 #if !defined (SCRAT_NO_ERROR_CHECKING)
1661  if (!overloaded && sq_gettop(vm) != 16) {
1662  return sq_throwerror(vm, _SC("wrong number of parameters"));
1663  }
1664 #endif
1665  typedef R (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const;
1666  M* methodPtr;
1667  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1668  M method = *methodPtr;
1669 
1670  C* ptr = ClassType<C>::GetInstance(vm, 1);
1671 
1672 #if !defined (SCRAT_NO_ERROR_CHECKING)
1673  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1674 #endif
1675 
1676  Var<A1> a1(vm, 2);
1677  Var<A2> a2(vm, 3);
1678  Var<A3> a3(vm, 4);
1679  Var<A4> a4(vm, 5);
1680  Var<A5> a5(vm, 6);
1681  Var<A6> a6(vm, 7);
1682  Var<A7> a7(vm, 8);
1683  Var<A8> a8(vm, 9);
1684  Var<A9> a9(vm, 10);
1685  Var<A10> a10(vm, 11);
1686  Var<A11> a11(vm, 12);
1687  Var<A12> a12(vm, 13);
1688  Var<A13> a13(vm, 14);
1689  Var<A14> a14(vm, 15);
1690 
1691 #if !defined (SCRAT_NO_ERROR_CHECKING)
1692  if (Error::Instance().Occurred(vm)) {
1693  if (overloaded)
1694  return 0;
1695  else
1696  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1697  }
1698 #endif
1699 
1700  R ret = (ptr->*method)(
1701  a1.value,
1702  a2.value,
1703  a3.value,
1704  a4.value,
1705  a5.value,
1706  a6.value,
1707  a7.value,
1708  a8.value,
1709  a9.value,
1710  a10.value,
1711  a11.value,
1712  a12.value,
1713  a13.value,
1714  a14.value
1715  );
1716 
1717 #if !defined (SCRAT_NO_ERROR_CHECKING)
1718  if (!overloaded && Error::Instance().Occurred(vm)) {
1719  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1720  }
1721 #endif
1722 
1723  PushVar(vm, ret);
1724  return 1;
1725  }
1726 };
1727 
1728 
1729 //
1730 // reference return specialization
1731 //
1732 
1733 template <class C, class R>
1734 class SqMember<C, R&> {
1735 #if !defined (SCRAT_NO_ERROR_CHECKING)
1736  static const SQChar STATICCALLERROR[] ;
1737 #endif
1738 public:
1739  // Arg Count 0
1740  template <bool overloaded /* = false */>
1741  static SQInteger Func0(HSQUIRRELVM vm) {
1742 
1743 #if !defined (SCRAT_NO_ERROR_CHECKING)
1744  if (!overloaded && sq_gettop(vm) != 2) {
1745  return sq_throwerror(vm, _SC("wrong number of parameters"));
1746  }
1747 #endif
1748  typedef R & (C::*M)();
1749  M* methodPtr;
1750  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1751  M method = *methodPtr;
1752 
1753  C* ptr = ClassType<C>::GetInstance(vm, 1);
1754 
1755 #if !defined (SCRAT_NO_ERROR_CHECKING)
1756  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1757 #endif
1758 
1759  R & ret = (ptr->*method)();
1760 
1761 #if !defined (SCRAT_NO_ERROR_CHECKING)
1762  if (!overloaded && Error::Instance().Occurred(vm)) {
1763  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1764  }
1765 #endif
1766 
1767  PushVarR(vm, ret);
1768  return 1;
1769  }
1770 
1771  template <bool overloaded /* = false */ >
1772  static SQInteger Func0C(HSQUIRRELVM vm) {
1773 
1774 #if !defined (SCRAT_NO_ERROR_CHECKING)
1775  if (!overloaded && sq_gettop(vm) != 2) {
1776  return sq_throwerror(vm, _SC("wrong number of parameters"));
1777  }
1778 #endif
1779  typedef R & (C::*M)() const;
1780  M* methodPtr;
1781  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1782  M method = *methodPtr;
1783 
1784  C* ptr = ClassType<C>::GetInstance(vm, 1);
1785 
1786 #if !defined (SCRAT_NO_ERROR_CHECKING)
1787  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1788 #endif
1789 
1790  R & ret = (ptr->*method)();
1791 
1792 #if !defined (SCRAT_NO_ERROR_CHECKING)
1793  if (!overloaded && Error::Instance().Occurred(vm)) {
1794  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1795  }
1796 #endif
1797 
1798  PushVarR(vm, ret);
1799  return 1;
1800  }
1801 
1802  // Arg Count 1
1803  template <class A1, bool overloaded /*= false*/ >
1804  static SQInteger Func1(HSQUIRRELVM vm) {
1805 
1806 #if !defined (SCRAT_NO_ERROR_CHECKING)
1807  if (!overloaded && sq_gettop(vm) != 3) {
1808  return sq_throwerror(vm, _SC("wrong number of parameters"));
1809  }
1810 #endif
1811  typedef R & (C::*M)(A1);
1812  M* methodPtr;
1813  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1814  M method = *methodPtr;
1815 
1816  C* ptr = ClassType<C>::GetInstance(vm, 1);
1817 
1818 #if !defined (SCRAT_NO_ERROR_CHECKING)
1819  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1820 #endif
1821 
1822  Var<A1> a1(vm, 2);
1823 
1824 #if !defined (SCRAT_NO_ERROR_CHECKING)
1825  if (Error::Instance().Occurred(vm)) {
1826  if (overloaded)
1827  return 0;
1828  else
1829  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1830  }
1831 #endif
1832 
1833  R & ret = (ptr->*method)(
1834  a1.value
1835  );
1836 
1837 #if !defined (SCRAT_NO_ERROR_CHECKING)
1838  if (!overloaded && Error::Instance().Occurred(vm)) {
1839  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1840  }
1841 #endif
1842 
1843  PushVarR(vm, ret);
1844  return 1;
1845  }
1846 
1847  template <class A1, bool overloaded /*= false*/ >
1848  static SQInteger Func1C(HSQUIRRELVM vm) {
1849 
1850 #if !defined (SCRAT_NO_ERROR_CHECKING)
1851  if (!overloaded && sq_gettop(vm) != 3) {
1852  return sq_throwerror(vm, _SC("wrong number of parameters"));
1853  }
1854 #endif
1855  typedef R & (C::*M)(A1) const;
1856  M* methodPtr;
1857  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1858  M method = *methodPtr;
1859 
1860  C* ptr = ClassType<C>::GetInstance(vm, 1);
1861 
1862 #if !defined (SCRAT_NO_ERROR_CHECKING)
1863  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1864 #endif
1865 
1866  Var<A1> a1(vm, 2);
1867 
1868 #if !defined (SCRAT_NO_ERROR_CHECKING)
1869  if (Error::Instance().Occurred(vm)) {
1870  if (overloaded)
1871  return 0;
1872  else
1873  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1874  }
1875 #endif
1876 
1877  R & ret = (ptr->*method)(
1878  a1.value
1879  );
1880 
1881 #if !defined (SCRAT_NO_ERROR_CHECKING)
1882  if (!overloaded && Error::Instance().Occurred(vm)) {
1883  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1884  }
1885 #endif
1886 
1887  PushVarR(vm, ret);
1888  return 1;
1889  }
1890 
1891  // Arg Count 2
1892  template <class A1, class A2, bool overloaded /*= false*/ >
1893  static SQInteger Func2(HSQUIRRELVM vm) {
1894 
1895 #if !defined (SCRAT_NO_ERROR_CHECKING)
1896  if (!overloaded && sq_gettop(vm) != 4) {
1897  return sq_throwerror(vm, _SC("wrong number of parameters"));
1898  }
1899 #endif
1900  typedef R & (C::*M)(A1, A2);
1901  M* methodPtr;
1902  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1903  M method = *methodPtr;
1904 
1905  C* ptr = ClassType<C>::GetInstance(vm, 1);
1906 
1907 #if !defined (SCRAT_NO_ERROR_CHECKING)
1908  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1909 #endif
1910 
1911  Var<A1> a1(vm, 2);
1912  Var<A2> a2(vm, 3);
1913 
1914 #if !defined (SCRAT_NO_ERROR_CHECKING)
1915  if (Error::Instance().Occurred(vm)) {
1916  if (overloaded)
1917  return 0;
1918  else
1919  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1920  }
1921 #endif
1922 
1923  R & ret = (ptr->*method)(
1924  a1.value,
1925  a2.value
1926  );
1927 
1928 #if !defined (SCRAT_NO_ERROR_CHECKING)
1929  if (!overloaded && Error::Instance().Occurred(vm)) {
1930  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
1931  }
1932 #endif
1933 
1934  PushVarR(vm, ret);
1935  return 1;
1936  }
1937 
1938  template <class A1, class A2, bool overloaded /*= false*/ >
1939  static SQInteger Func2C(HSQUIRRELVM vm) {
1940 
1941 #if !defined (SCRAT_NO_ERROR_CHECKING)
1942  if (!overloaded && sq_gettop(vm) != 4) {
1943  return sq_throwerror(vm, _SC("wrong number of parameters"));
1944  }
1945 #endif
1946  typedef R & (C::*M)(A1, A2) const;
1947  M* methodPtr;
1948  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1949  M method = *methodPtr;
1950 
1951  C* ptr = ClassType<C>::GetInstance(vm, 1);
1952 
1953 #if !defined (SCRAT_NO_ERROR_CHECKING)
1954  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1955 #endif
1956 
1957  Var<A1> a1(vm, 2);
1958  Var<A2> a2(vm, 3);
1959 
1960 #if !defined (SCRAT_NO_ERROR_CHECKING)
1961  if (Error::Instance().Occurred(vm)) {
1962  if (overloaded)
1963  return 0;
1964  else
1965  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
1966  }
1967 #endif
1968 
1969  R & ret = (ptr->*method)(
1970  a1.value,
1971  a2.value
1972  );
1973 
1974  PushVarR (vm, ret);
1975  return 1;
1976  }
1977 
1978  // Arg Count 3
1979  template <class A1, class A2, class A3, bool overloaded /*= false*/ >
1980  static SQInteger Func3(HSQUIRRELVM vm) {
1981 
1982 #if !defined (SCRAT_NO_ERROR_CHECKING)
1983  if (!overloaded && sq_gettop(vm) != 5) {
1984  return sq_throwerror(vm, _SC("wrong number of parameters"));
1985  }
1986 #endif
1987  typedef R & (C::*M)(A1, A2, A3);
1988  M* methodPtr;
1989  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
1990  M method = *methodPtr;
1991 
1992  C* ptr = ClassType<C>::GetInstance(vm, 1);
1993 
1994 #if !defined (SCRAT_NO_ERROR_CHECKING)
1995  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
1996 #endif
1997 
1998  Var<A1> a1(vm, 2);
1999  Var<A2> a2(vm, 3);
2000  Var<A3> a3(vm, 4);
2001 
2002 #if !defined (SCRAT_NO_ERROR_CHECKING)
2003  if (Error::Instance().Occurred(vm)) {
2004  if (overloaded)
2005  return 0;
2006  else
2007  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2008  }
2009 #endif
2010 
2011  R & ret = (ptr->*method)(
2012  a1.value,
2013  a2.value,
2014  a3.value
2015  );
2016 
2017 #if !defined (SCRAT_NO_ERROR_CHECKING)
2018  if (!overloaded && Error::Instance().Occurred(vm)) {
2019  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2020  }
2021 #endif
2022 
2023  PushVarR(vm, ret);
2024  return 1;
2025  }
2026 
2027  template <class A1, class A2, class A3, bool overloaded /*= false*/ >
2028  static SQInteger Func3C(HSQUIRRELVM vm) {
2029 
2030 #if !defined (SCRAT_NO_ERROR_CHECKING)
2031  if (!overloaded && sq_gettop(vm) != 5) {
2032  return sq_throwerror(vm, _SC("wrong number of parameters"));
2033  }
2034 #endif
2035  typedef R & (C::*M)(A1, A2, A3) const;
2036  M* methodPtr;
2037  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2038  M method = *methodPtr;
2039 
2040  C* ptr = ClassType<C>::GetInstance(vm, 1);
2041 
2042 #if !defined (SCRAT_NO_ERROR_CHECKING)
2043  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2044 #endif
2045 
2046  Var<A1> a1(vm, 2);
2047  Var<A2> a2(vm, 3);
2048  Var<A3> a3(vm, 4);
2049 
2050 #if !defined (SCRAT_NO_ERROR_CHECKING)
2051  if (Error::Instance().Occurred(vm)) {
2052  if (overloaded)
2053  return 0;
2054  else
2055  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2056  }
2057 #endif
2058 
2059  R & ret = (ptr->*method)(
2060  a1.value,
2061  a2.value,
2062  a3.value
2063  );
2064 
2065 #if !defined (SCRAT_NO_ERROR_CHECKING)
2066  if (!overloaded && Error::Instance().Occurred(vm)) {
2067  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2068  }
2069 #endif
2070 
2071  PushVarR(vm, ret);
2072  return 1;
2073  }
2074 
2075  // Arg Count 4
2076  template <class A1, class A2, class A3, class A4, bool overloaded /*= false*/ >
2077  static SQInteger Func4(HSQUIRRELVM vm) {
2078 
2079 #if !defined (SCRAT_NO_ERROR_CHECKING)
2080  if (!overloaded && sq_gettop(vm) != 6) {
2081  return sq_throwerror(vm, _SC("wrong number of parameters"));
2082  }
2083 #endif
2084  typedef R & (C::*M)(A1, A2, A3, A4);
2085  M* methodPtr;
2086  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2087  M method = *methodPtr;
2088 
2089  C* ptr = ClassType<C>::GetInstance(vm, 1);
2090 
2091 #if !defined (SCRAT_NO_ERROR_CHECKING)
2092  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2093 #endif
2094 
2095  Var<A1> a1(vm, 2);
2096  Var<A2> a2(vm, 3);
2097  Var<A3> a3(vm, 4);
2098  Var<A4> a4(vm, 5);
2099 
2100 #if !defined (SCRAT_NO_ERROR_CHECKING)
2101  if (Error::Instance().Occurred(vm)) {
2102  if (overloaded)
2103  return 0;
2104  else
2105  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2106  }
2107 #endif
2108 
2109  R & ret = (ptr->*method)(
2110  a1.value,
2111  a2.value,
2112  a3.value,
2113  a4.value
2114  );
2115 
2116 #if !defined (SCRAT_NO_ERROR_CHECKING)
2117  if (!overloaded && Error::Instance().Occurred(vm)) {
2118  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2119  }
2120 #endif
2121 
2122  PushVarR(vm, ret);
2123  return 1;
2124  }
2125 
2126  template <class A1, class A2, class A3, class A4, bool overloaded /*= false*/ >
2127  static SQInteger Func4C(HSQUIRRELVM vm) {
2128 
2129 #if !defined (SCRAT_NO_ERROR_CHECKING)
2130  if (!overloaded && sq_gettop(vm) != 6) {
2131  return sq_throwerror(vm, _SC("wrong number of parameters"));
2132  }
2133 #endif
2134  typedef R & (C::*M)(A1, A2, A3, A4) const;
2135  M* methodPtr;
2136  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2137  M method = *methodPtr;
2138 
2139  C* ptr = ClassType<C>::GetInstance(vm, 1);
2140 
2141 #if !defined (SCRAT_NO_ERROR_CHECKING)
2142  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2143 #endif
2144 
2145  Var<A1> a1(vm, 2);
2146  Var<A2> a2(vm, 3);
2147  Var<A3> a3(vm, 4);
2148  Var<A4> a4(vm, 5);
2149 
2150 #if !defined (SCRAT_NO_ERROR_CHECKING)
2151  if (Error::Instance().Occurred(vm)) {
2152  if (overloaded)
2153  return 0;
2154  else
2155  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2156  }
2157 #endif
2158 
2159  R & ret = (ptr->*method)(
2160  a1.value,
2161  a2.value,
2162  a3.value,
2163  a4.value
2164  );
2165 
2166 #if !defined (SCRAT_NO_ERROR_CHECKING)
2167  if (!overloaded && Error::Instance().Occurred(vm)) {
2168  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2169  }
2170 #endif
2171 
2172  PushVarR(vm, ret);
2173  return 1;
2174  }
2175 
2176  // Arg Count 5
2177  template <class A1, class A2, class A3, class A4, class A5, bool overloaded /*= false*/ >
2178  static SQInteger Func5(HSQUIRRELVM vm) {
2179 
2180 #if !defined (SCRAT_NO_ERROR_CHECKING)
2181  if (!overloaded && sq_gettop(vm) != 7) {
2182  return sq_throwerror(vm, _SC("wrong number of parameters"));
2183  }
2184 #endif
2185  typedef R & (C::*M)(A1, A2, A3, A4, A5);
2186  M* methodPtr;
2187  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2188  M method = *methodPtr;
2189 
2190  C* ptr = ClassType<C>::GetInstance(vm, 1);
2191 
2192 #if !defined (SCRAT_NO_ERROR_CHECKING)
2193  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2194 #endif
2195 
2196  Var<A1> a1(vm, 2);
2197  Var<A2> a2(vm, 3);
2198  Var<A3> a3(vm, 4);
2199  Var<A4> a4(vm, 5);
2200  Var<A5> a5(vm, 6);
2201 
2202 #if !defined (SCRAT_NO_ERROR_CHECKING)
2203  if (Error::Instance().Occurred(vm)) {
2204  if (overloaded)
2205  return 0;
2206  else
2207  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2208  }
2209 #endif
2210 
2211  R & ret = (ptr->*method)(
2212  a1.value,
2213  a2.value,
2214  a3.value,
2215  a4.value,
2216  a5.value
2217  );
2218 
2219 #if !defined (SCRAT_NO_ERROR_CHECKING)
2220  if (!overloaded && Error::Instance().Occurred(vm)) {
2221  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2222  }
2223 #endif
2224 
2225  PushVarR(vm, ret);
2226  return 1;
2227  }
2228 
2229  template <class A1, class A2, class A3, class A4, class A5, bool overloaded /*= false*/ >
2230  static SQInteger Func5C(HSQUIRRELVM vm) {
2231 
2232 #if !defined (SCRAT_NO_ERROR_CHECKING)
2233  if (!overloaded && sq_gettop(vm) != 7) {
2234  return sq_throwerror(vm, _SC("wrong number of parameters"));
2235  }
2236 #endif
2237  typedef R & (C::*M)(A1, A2, A3, A4, A5) const;
2238  M* methodPtr;
2239  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2240  M method = *methodPtr;
2241 
2242  C* ptr = ClassType<C>::GetInstance(vm, 1);
2243 
2244 #if !defined (SCRAT_NO_ERROR_CHECKING)
2245  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2246 #endif
2247 
2248  Var<A1> a1(vm, 2);
2249  Var<A2> a2(vm, 3);
2250  Var<A3> a3(vm, 4);
2251  Var<A4> a4(vm, 5);
2252  Var<A5> a5(vm, 6);
2253 
2254 #if !defined (SCRAT_NO_ERROR_CHECKING)
2255  if (Error::Instance().Occurred(vm)) {
2256  if (overloaded)
2257  return 0;
2258  else
2259  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2260  }
2261 #endif
2262 
2263  R & ret = (ptr->*method)(
2264  a1.value,
2265  a2.value,
2266  a3.value,
2267  a4.value,
2268  a5.value
2269  );
2270 
2271 #if !defined (SCRAT_NO_ERROR_CHECKING)
2272  if (!overloaded && Error::Instance().Occurred(vm)) {
2273  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2274  }
2275 #endif
2276 
2277  PushVarR(vm, ret);
2278  return 1;
2279  }
2280 
2281  // Arg Count 6
2282  template <class A1, class A2, class A3, class A4, class A5, class A6, bool overloaded /*= false*/ >
2283  static SQInteger Func6(HSQUIRRELVM vm) {
2284 
2285 #if !defined (SCRAT_NO_ERROR_CHECKING)
2286  if (!overloaded && sq_gettop(vm) != 8) {
2287  return sq_throwerror(vm, _SC("wrong number of parameters"));
2288  }
2289 #endif
2290  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6);
2291  M* methodPtr;
2292  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2293  M method = *methodPtr;
2294 
2295  C* ptr = ClassType<C>::GetInstance(vm, 1);
2296 
2297 #if !defined (SCRAT_NO_ERROR_CHECKING)
2298  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2299 #endif
2300 
2301  Var<A1> a1(vm, 2);
2302  Var<A2> a2(vm, 3);
2303  Var<A3> a3(vm, 4);
2304  Var<A4> a4(vm, 5);
2305  Var<A5> a5(vm, 6);
2306  Var<A6> a6(vm, 7);
2307 
2308 #if !defined (SCRAT_NO_ERROR_CHECKING)
2309  if (Error::Instance().Occurred(vm)) {
2310  if (overloaded)
2311  return 0;
2312  else
2313  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2314  }
2315 #endif
2316 
2317  R & ret = (ptr->*method)(
2318  a1.value,
2319  a2.value,
2320  a3.value,
2321  a4.value,
2322  a5.value,
2323  a6.value
2324  );
2325 
2326 #if !defined (SCRAT_NO_ERROR_CHECKING)
2327  if (!overloaded && Error::Instance().Occurred(vm)) {
2328  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2329  }
2330 #endif
2331 
2332  PushVarR(vm, ret);
2333  return 1;
2334  }
2335 
2336  template <class A1, class A2, class A3, class A4, class A5, class A6, bool overloaded /*= false*/ >
2337  static SQInteger Func6C(HSQUIRRELVM vm) {
2338 
2339 #if !defined (SCRAT_NO_ERROR_CHECKING)
2340  if (!overloaded && sq_gettop(vm) != 8) {
2341  return sq_throwerror(vm, _SC("wrong number of parameters"));
2342  }
2343 #endif
2344  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6) const;
2345  M* methodPtr;
2346  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2347  M method = *methodPtr;
2348 
2349  C* ptr = ClassType<C>::GetInstance(vm, 1);
2350 
2351 #if !defined (SCRAT_NO_ERROR_CHECKING)
2352  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2353 #endif
2354 
2355  Var<A1> a1(vm, 2);
2356  Var<A2> a2(vm, 3);
2357  Var<A3> a3(vm, 4);
2358  Var<A4> a4(vm, 5);
2359  Var<A5> a5(vm, 6);
2360  Var<A6> a6(vm, 7);
2361 
2362 #if !defined (SCRAT_NO_ERROR_CHECKING)
2363  if (Error::Instance().Occurred(vm)) {
2364  if (overloaded)
2365  return 0;
2366  else
2367  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2368  }
2369 #endif
2370 
2371  R & ret = (ptr->*method)(
2372  a1.value,
2373  a2.value,
2374  a3.value,
2375  a4.value,
2376  a5.value,
2377  a6.value
2378  );
2379 
2380 #if !defined (SCRAT_NO_ERROR_CHECKING)
2381  if (!overloaded && Error::Instance().Occurred(vm)) {
2382  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2383  }
2384 #endif
2385 
2386  PushVarR(vm, ret);
2387  return 1;
2388  }
2389 
2390  // Arg Count 7
2391  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool overloaded /*= false*/ >
2392  static SQInteger Func7(HSQUIRRELVM vm) {
2393 
2394 #if !defined (SCRAT_NO_ERROR_CHECKING)
2395  if (!overloaded && sq_gettop(vm) != 9) {
2396  return sq_throwerror(vm, _SC("wrong number of parameters"));
2397  }
2398 #endif
2399  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7);
2400  M* methodPtr;
2401  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2402  M method = *methodPtr;
2403 
2404  C* ptr = ClassType<C>::GetInstance(vm, 1);
2405 
2406 #if !defined (SCRAT_NO_ERROR_CHECKING)
2407  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2408 #endif
2409 
2410  Var<A1> a1(vm, 2);
2411  Var<A2> a2(vm, 3);
2412  Var<A3> a3(vm, 4);
2413  Var<A4> a4(vm, 5);
2414  Var<A5> a5(vm, 6);
2415  Var<A6> a6(vm, 7);
2416  Var<A7> a7(vm, 8);
2417 
2418 #if !defined (SCRAT_NO_ERROR_CHECKING)
2419  if (Error::Instance().Occurred(vm)) {
2420  if (overloaded)
2421  return 0;
2422  else
2423  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2424  }
2425 #endif
2426 
2427  R & ret = (ptr->*method)(
2428  a1.value,
2429  a2.value,
2430  a3.value,
2431  a4.value,
2432  a5.value,
2433  a6.value,
2434  a7.value
2435  );
2436 
2437 #if !defined (SCRAT_NO_ERROR_CHECKING)
2438  if (!overloaded && Error::Instance().Occurred(vm)) {
2439  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2440  }
2441 #endif
2442 
2443  PushVarR(vm, ret);
2444  return 1;
2445  }
2446 
2447  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool overloaded /*= false*/ >
2448  static SQInteger Func7C(HSQUIRRELVM vm) {
2449 
2450 #if !defined (SCRAT_NO_ERROR_CHECKING)
2451  if (!overloaded && sq_gettop(vm) != 9) {
2452  return sq_throwerror(vm, _SC("wrong number of parameters"));
2453  }
2454 #endif
2455  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7) const;
2456  M* methodPtr;
2457  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2458  M method = *methodPtr;
2459 
2460  C* ptr = ClassType<C>::GetInstance(vm, 1);
2461 
2462 #if !defined (SCRAT_NO_ERROR_CHECKING)
2463  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2464 #endif
2465 
2466  Var<A1> a1(vm, 2);
2467  Var<A2> a2(vm, 3);
2468  Var<A3> a3(vm, 4);
2469  Var<A4> a4(vm, 5);
2470  Var<A5> a5(vm, 6);
2471  Var<A6> a6(vm, 7);
2472  Var<A7> a7(vm, 8);
2473 
2474 #if !defined (SCRAT_NO_ERROR_CHECKING)
2475  if (Error::Instance().Occurred(vm)) {
2476  if (overloaded)
2477  return 0;
2478  else
2479  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2480  }
2481 #endif
2482 
2483  R & ret = (ptr->*method)(
2484  a1.value,
2485  a2.value,
2486  a3.value,
2487  a4.value,
2488  a5.value,
2489  a6.value,
2490  a7.value
2491  );
2492 
2493 #if !defined (SCRAT_NO_ERROR_CHECKING)
2494  if (!overloaded && Error::Instance().Occurred(vm)) {
2495  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2496  }
2497 #endif
2498 
2499  PushVarR(vm, ret);
2500  return 1;
2501  }
2502 
2503  // Arg Count 8
2504  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool overloaded /*= false*/ >
2505  static SQInteger Func8(HSQUIRRELVM vm) {
2506 
2507 #if !defined (SCRAT_NO_ERROR_CHECKING)
2508  if (!overloaded && sq_gettop(vm) != 10) {
2509  return sq_throwerror(vm, _SC("wrong number of parameters"));
2510  }
2511 #endif
2512  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8);
2513  M* methodPtr;
2514  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2515  M method = *methodPtr;
2516 
2517  C* ptr = ClassType<C>::GetInstance(vm, 1);
2518 
2519 #if !defined (SCRAT_NO_ERROR_CHECKING)
2520  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2521 #endif
2522 
2523  Var<A1> a1(vm, 2);
2524  Var<A2> a2(vm, 3);
2525  Var<A3> a3(vm, 4);
2526  Var<A4> a4(vm, 5);
2527  Var<A5> a5(vm, 6);
2528  Var<A6> a6(vm, 7);
2529  Var<A7> a7(vm, 8);
2530  Var<A8> a8(vm, 9);
2531 
2532 #if !defined (SCRAT_NO_ERROR_CHECKING)
2533  if (Error::Instance().Occurred(vm)) {
2534  if (overloaded)
2535  return 0;
2536  else
2537  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2538  }
2539 #endif
2540 
2541  R & ret = (ptr->*method)(
2542  a1.value,
2543  a2.value,
2544  a3.value,
2545  a4.value,
2546  a5.value,
2547  a6.value,
2548  a7.value,
2549  a8.value
2550  );
2551 
2552 #if !defined (SCRAT_NO_ERROR_CHECKING)
2553  if (!overloaded && Error::Instance().Occurred(vm)) {
2554  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2555  }
2556 #endif
2557 
2558  PushVarR(vm, ret);
2559  return 1;
2560  }
2561 
2562  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool overloaded /*= false*/ >
2563  static SQInteger Func8C(HSQUIRRELVM vm) {
2564 
2565 #if !defined (SCRAT_NO_ERROR_CHECKING)
2566  if (!overloaded && sq_gettop(vm) != 10) {
2567  return sq_throwerror(vm, _SC("wrong number of parameters"));
2568  }
2569 #endif
2570  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8) const;
2571  M* methodPtr;
2572  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2573  M method = *methodPtr;
2574 
2575  C* ptr = ClassType<C>::GetInstance(vm, 1);
2576 
2577 #if !defined (SCRAT_NO_ERROR_CHECKING)
2578  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2579 #endif
2580 
2581  Var<A1> a1(vm, 2);
2582  Var<A2> a2(vm, 3);
2583  Var<A3> a3(vm, 4);
2584  Var<A4> a4(vm, 5);
2585  Var<A5> a5(vm, 6);
2586  Var<A6> a6(vm, 7);
2587  Var<A7> a7(vm, 8);
2588  Var<A8> a8(vm, 9);
2589 
2590 #if !defined (SCRAT_NO_ERROR_CHECKING)
2591  if (Error::Instance().Occurred(vm)) {
2592  if (overloaded)
2593  return 0;
2594  else
2595  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2596  }
2597 #endif
2598 
2599  R & ret = (ptr->*method)(
2600  a1.value,
2601  a2.value,
2602  a3.value,
2603  a4.value,
2604  a5.value,
2605  a6.value,
2606  a7.value,
2607  a8.value
2608  );
2609 
2610 #if !defined (SCRAT_NO_ERROR_CHECKING)
2611  if (!overloaded && Error::Instance().Occurred(vm)) {
2612  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2613  }
2614 #endif
2615 
2616  PushVarR(vm, ret);
2617  return 1;
2618  }
2619 
2620  // Arg Count 9
2621  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool overloaded /*= false*/ >
2622  static SQInteger Func9(HSQUIRRELVM vm) {
2623 
2624 #if !defined (SCRAT_NO_ERROR_CHECKING)
2625  if (!overloaded && sq_gettop(vm) != 11) {
2626  return sq_throwerror(vm, _SC("wrong number of parameters"));
2627  }
2628 #endif
2629  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
2630  M* methodPtr;
2631  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2632  M method = *methodPtr;
2633 
2634  C* ptr = ClassType<C>::GetInstance(vm, 1);
2635 
2636 #if !defined (SCRAT_NO_ERROR_CHECKING)
2637  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2638 #endif
2639 
2640  Var<A1> a1(vm, 2);
2641  Var<A2> a2(vm, 3);
2642  Var<A3> a3(vm, 4);
2643  Var<A4> a4(vm, 5);
2644  Var<A5> a5(vm, 6);
2645  Var<A6> a6(vm, 7);
2646  Var<A7> a7(vm, 8);
2647  Var<A8> a8(vm, 9);
2648  Var<A9> a9(vm, 10);
2649 
2650 #if !defined (SCRAT_NO_ERROR_CHECKING)
2651  if (Error::Instance().Occurred(vm)) {
2652  if (overloaded)
2653  return 0;
2654  else
2655  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2656  }
2657 #endif
2658 
2659  R & ret = (ptr->*method)(
2660  a1.value,
2661  a2.value,
2662  a3.value,
2663  a4.value,
2664  a5.value,
2665  a6.value,
2666  a7.value,
2667  a8.value,
2668  a9.value
2669  );
2670 
2671 #if !defined (SCRAT_NO_ERROR_CHECKING)
2672  if (!overloaded && Error::Instance().Occurred(vm)) {
2673  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2674  }
2675 #endif
2676 
2677  PushVarR(vm, ret);
2678  return 1;
2679  }
2680 
2681  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool overloaded /*= false*/ >
2682  static SQInteger Func9C(HSQUIRRELVM vm) {
2683 
2684 #if !defined (SCRAT_NO_ERROR_CHECKING)
2685  if (!overloaded && sq_gettop(vm) != 11) {
2686  return sq_throwerror(vm, _SC("wrong number of parameters"));
2687  }
2688 #endif
2689  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const;
2690  M* methodPtr;
2691  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2692  M method = *methodPtr;
2693 
2694  C* ptr = ClassType<C>::GetInstance(vm, 1);
2695 
2696 #if !defined (SCRAT_NO_ERROR_CHECKING)
2697  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2698 #endif
2699 
2700  Var<A1> a1(vm, 2);
2701  Var<A2> a2(vm, 3);
2702  Var<A3> a3(vm, 4);
2703  Var<A4> a4(vm, 5);
2704  Var<A5> a5(vm, 6);
2705  Var<A6> a6(vm, 7);
2706  Var<A7> a7(vm, 8);
2707  Var<A8> a8(vm, 9);
2708  Var<A9> a9(vm, 10);
2709 
2710 #if !defined (SCRAT_NO_ERROR_CHECKING)
2711  if (Error::Instance().Occurred(vm)) {
2712  if (overloaded)
2713  return 0;
2714  else
2715  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2716  }
2717 #endif
2718 
2719  R & ret = (ptr->*method)(
2720  a1.value,
2721  a2.value,
2722  a3.value,
2723  a4.value,
2724  a5.value,
2725  a6.value,
2726  a7.value,
2727  a8.value,
2728  a9.value
2729  );
2730 
2731 #if !defined (SCRAT_NO_ERROR_CHECKING)
2732  if (!overloaded && Error::Instance().Occurred(vm)) {
2733  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2734  }
2735 #endif
2736 
2737  PushVarR(vm, ret);
2738  return 1;
2739  }
2740 
2741 
2742  // Arg Count 10
2743  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool overloaded /*= false*/ >
2744  static SQInteger Func10(HSQUIRRELVM vm) {
2745 
2746 #if !defined (SCRAT_NO_ERROR_CHECKING)
2747  if (!overloaded && sq_gettop(vm) != 12) {
2748  return sq_throwerror(vm, _SC("wrong number of parameters"));
2749  }
2750 #endif
2751  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
2752  M* methodPtr;
2753  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2754  M method = *methodPtr;
2755 
2756  C* ptr = ClassType<C>::GetInstance(vm, 1);
2757 
2758 #if !defined (SCRAT_NO_ERROR_CHECKING)
2759  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2760 #endif
2761 
2762  Var<A1> a1(vm, 2);
2763  Var<A2> a2(vm, 3);
2764  Var<A3> a3(vm, 4);
2765  Var<A4> a4(vm, 5);
2766  Var<A5> a5(vm, 6);
2767  Var<A6> a6(vm, 7);
2768  Var<A7> a7(vm, 8);
2769  Var<A8> a8(vm, 9);
2770  Var<A9> a9(vm, 10);
2771  Var<A10> a10(vm, 11);
2772 
2773 #if !defined (SCRAT_NO_ERROR_CHECKING)
2774  if (Error::Instance().Occurred(vm)) {
2775  if (overloaded)
2776  return 0;
2777  else
2778  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2779  }
2780 #endif
2781 
2782  R & ret = (ptr->*method)(
2783  a1.value,
2784  a2.value,
2785  a3.value,
2786  a4.value,
2787  a5.value,
2788  a6.value,
2789  a7.value,
2790  a8.value,
2791  a9.value,
2792  a10.value
2793  );
2794 
2795 #if !defined (SCRAT_NO_ERROR_CHECKING)
2796  if (!overloaded && Error::Instance().Occurred(vm)) {
2797  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2798  }
2799 #endif
2800 
2801  PushVarR(vm, ret);
2802  return 1;
2803  }
2804 
2805  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool overloaded /*= false*/ >
2806  static SQInteger Func10C(HSQUIRRELVM vm) {
2807 
2808 #if !defined (SCRAT_NO_ERROR_CHECKING)
2809  if (!overloaded && sq_gettop(vm) != 12) {
2810  return sq_throwerror(vm, _SC("wrong number of parameters"));
2811  }
2812 #endif
2813  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const;
2814  M* methodPtr;
2815  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2816  M method = *methodPtr;
2817 
2818  C* ptr = ClassType<C>::GetInstance(vm, 1);
2819 
2820 #if !defined (SCRAT_NO_ERROR_CHECKING)
2821  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2822 #endif
2823 
2824  Var<A1> a1(vm, 2);
2825  Var<A2> a2(vm, 3);
2826  Var<A3> a3(vm, 4);
2827  Var<A4> a4(vm, 5);
2828  Var<A5> a5(vm, 6);
2829  Var<A6> a6(vm, 7);
2830  Var<A7> a7(vm, 8);
2831  Var<A8> a8(vm, 9);
2832  Var<A9> a9(vm, 10);
2833  Var<A10> a10(vm, 11);
2834 
2835 #if !defined (SCRAT_NO_ERROR_CHECKING)
2836  if (Error::Instance().Occurred(vm)) {
2837  if (overloaded)
2838  return 0;
2839  else
2840  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2841  }
2842 #endif
2843 
2844  R & ret = (ptr->*method)(
2845  a1.value,
2846  a2.value,
2847  a3.value,
2848  a4.value,
2849  a5.value,
2850  a6.value,
2851  a7.value,
2852  a8.value,
2853  a9.value,
2854  a10.value
2855  );
2856 
2857 #if !defined (SCRAT_NO_ERROR_CHECKING)
2858  if (!overloaded && Error::Instance().Occurred(vm)) {
2859  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2860  }
2861 #endif
2862 
2863  PushVarR(vm, ret);
2864  return 1;
2865  }
2866 
2867 
2868  // Arg Count 11
2869  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool overloaded /*= false*/>
2870  static SQInteger Func11(HSQUIRRELVM vm) {
2871 
2872 #if !defined (SCRAT_NO_ERROR_CHECKING)
2873  if (!overloaded && sq_gettop(vm) != 13) {
2874  return sq_throwerror(vm, _SC("wrong number of parameters"));
2875  }
2876 #endif
2877  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
2878  M* methodPtr;
2879  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2880  M method = *methodPtr;
2881 
2882  C* ptr = ClassType<C>::GetInstance(vm, 1);
2883 
2884 #if !defined (SCRAT_NO_ERROR_CHECKING)
2885  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2886 #endif
2887 
2888  Var<A1> a1(vm, 2);
2889  Var<A2> a2(vm, 3);
2890  Var<A3> a3(vm, 4);
2891  Var<A4> a4(vm, 5);
2892  Var<A5> a5(vm, 6);
2893  Var<A6> a6(vm, 7);
2894  Var<A7> a7(vm, 8);
2895  Var<A8> a8(vm, 9);
2896  Var<A9> a9(vm, 10);
2897  Var<A10> a10(vm, 11);
2898  Var<A11> a11(vm, 12);
2899 
2900 #if !defined (SCRAT_NO_ERROR_CHECKING)
2901  if (Error::Instance().Occurred(vm)) {
2902  if (overloaded)
2903  return 0;
2904  else
2905  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2906  }
2907 #endif
2908 
2909  R & ret = (ptr->*method)(
2910  a1.value,
2911  a2.value,
2912  a3.value,
2913  a4.value,
2914  a5.value,
2915  a6.value,
2916  a7.value,
2917  a8.value,
2918  a9.value,
2919  a10.value,
2920  a11.value
2921  );
2922 
2923 #if !defined (SCRAT_NO_ERROR_CHECKING)
2924  if (!overloaded && Error::Instance().Occurred(vm)) {
2925  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2926  }
2927 #endif
2928 
2929  PushVarR(vm, ret);
2930  return 1;
2931  }
2932 
2933  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool overloaded /*= false*/>
2934  static SQInteger Func11C(HSQUIRRELVM vm) {
2935 
2936 #if !defined (SCRAT_NO_ERROR_CHECKING)
2937  if (!overloaded && sq_gettop(vm) != 13) {
2938  return sq_throwerror(vm, _SC("wrong number of parameters"));
2939  }
2940 #endif
2941  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const;
2942  M* methodPtr;
2943  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
2944  M method = *methodPtr;
2945 
2946  C* ptr = ClassType<C>::GetInstance(vm, 1);
2947 
2948 #if !defined (SCRAT_NO_ERROR_CHECKING)
2949  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
2950 #endif
2951 
2952  Var<A1> a1(vm, 2);
2953  Var<A2> a2(vm, 3);
2954  Var<A3> a3(vm, 4);
2955  Var<A4> a4(vm, 5);
2956  Var<A5> a5(vm, 6);
2957  Var<A6> a6(vm, 7);
2958  Var<A7> a7(vm, 8);
2959  Var<A8> a8(vm, 9);
2960  Var<A9> a9(vm, 10);
2961  Var<A10> a10(vm, 11);
2962  Var<A11> a11(vm, 12);
2963 
2964 #if !defined (SCRAT_NO_ERROR_CHECKING)
2965  if (Error::Instance().Occurred(vm)) {
2966  if (overloaded)
2967  return 0;
2968  else
2969  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
2970  }
2971 #endif
2972 
2973  R & ret = (ptr->*method)(
2974  a1.value,
2975  a2.value,
2976  a3.value,
2977  a4.value,
2978  a5.value,
2979  a6.value,
2980  a7.value,
2981  a8.value,
2982  a9.value,
2983  a10.value,
2984  a11.value
2985  );
2986 
2987 #if !defined (SCRAT_NO_ERROR_CHECKING)
2988  if (!overloaded && Error::Instance().Occurred(vm)) {
2989  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
2990  }
2991 #endif
2992 
2993  PushVarR(vm, ret);
2994  return 1;
2995  }
2996 
2997 
2998  // Arg Count 12
2999  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, bool overloaded /*= false*/ >
3000  static SQInteger Func12(HSQUIRRELVM vm) {
3001 
3002 #if !defined (SCRAT_NO_ERROR_CHECKING)
3003  if (!overloaded && sq_gettop(vm) != 14) {
3004  return sq_throwerror(vm, _SC("wrong number of parameters"));
3005  }
3006 #endif
3007  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
3008  M* methodPtr;
3009  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3010  M method = *methodPtr;
3011 
3012  C* ptr = ClassType<C>::GetInstance(vm, 1);
3013 
3014 #if !defined (SCRAT_NO_ERROR_CHECKING)
3015  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
3016 #endif
3017 
3018  Var<A1> a1(vm, 2);
3019  Var<A2> a2(vm, 3);
3020  Var<A3> a3(vm, 4);
3021  Var<A4> a4(vm, 5);
3022  Var<A5> a5(vm, 6);
3023  Var<A6> a6(vm, 7);
3024  Var<A7> a7(vm, 8);
3025  Var<A8> a8(vm, 9);
3026  Var<A9> a9(vm, 10);
3027  Var<A10> a10(vm, 11);
3028  Var<A11> a11(vm, 12);
3029  Var<A12> a12(vm, 13);
3030 
3031 #if !defined (SCRAT_NO_ERROR_CHECKING)
3032  if (Error::Instance().Occurred(vm)) {
3033  if (overloaded)
3034  return 0;
3035  else
3036  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3037  }
3038 #endif
3039 
3040  R & ret = (ptr->*method)(
3041  a1.value,
3042  a2.value,
3043  a3.value,
3044  a4.value,
3045  a5.value,
3046  a6.value,
3047  a7.value,
3048  a8.value,
3049  a9.value,
3050  a10.value,
3051  a11.value,
3052  a12.value
3053  );
3054 
3055 #if !defined (SCRAT_NO_ERROR_CHECKING)
3056  if (!overloaded && Error::Instance().Occurred(vm)) {
3057  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3058  }
3059 #endif
3060 
3061  PushVarR(vm, ret);
3062  return 1;
3063  }
3064 
3065  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, bool overloaded /*= false*/ >
3066  static SQInteger Func12C(HSQUIRRELVM vm) {
3067 
3068 #if !defined (SCRAT_NO_ERROR_CHECKING)
3069  if (!overloaded && sq_gettop(vm) != 14) {
3070  return sq_throwerror(vm, _SC("wrong number of parameters"));
3071  }
3072 #endif
3073  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const;
3074  M* methodPtr;
3075  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3076  M method = *methodPtr;
3077 
3078  C* ptr = ClassType<C>::GetInstance(vm, 1);
3079 
3080 #if !defined (SCRAT_NO_ERROR_CHECKING)
3081  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
3082 #endif
3083 
3084  Var<A1> a1(vm, 2);
3085  Var<A2> a2(vm, 3);
3086  Var<A3> a3(vm, 4);
3087  Var<A4> a4(vm, 5);
3088  Var<A5> a5(vm, 6);
3089  Var<A6> a6(vm, 7);
3090  Var<A7> a7(vm, 8);
3091  Var<A8> a8(vm, 9);
3092  Var<A9> a9(vm, 10);
3093  Var<A10> a10(vm, 11);
3094  Var<A11> a11(vm, 12);
3095  Var<A12> a12(vm, 13);
3096 
3097 #if !defined (SCRAT_NO_ERROR_CHECKING)
3098  if (Error::Instance().Occurred(vm)) {
3099  if (overloaded)
3100  return 0;
3101  else
3102  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3103  }
3104 #endif
3105 
3106  R & ret = (ptr->*method)(
3107  a1.value,
3108  a2.value,
3109  a3.value,
3110  a4.value,
3111  a5.value,
3112  a6.value,
3113  a7.value,
3114  a8.value,
3115  a9.value,
3116  a10.value,
3117  a11.value,
3118  a12.value
3119  );
3120 
3121 #if !defined (SCRAT_NO_ERROR_CHECKING)
3122  if (!overloaded && Error::Instance().Occurred(vm)) {
3123  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3124  }
3125 #endif
3126 
3127  PushVarR(vm, ret);
3128  return 1;
3129  }
3130 
3131  // Arg Count 13
3132  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, bool overloaded /*= false*/ >
3133  static SQInteger Func13(HSQUIRRELVM vm) {
3134 
3135 #if !defined (SCRAT_NO_ERROR_CHECKING)
3136  if (!overloaded && sq_gettop(vm) != 15) {
3137  return sq_throwerror(vm, _SC("wrong number of parameters"));
3138  }
3139 #endif
3140  typedef R &(C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
3141  M* methodPtr;
3142  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3143  M method = *methodPtr;
3144 
3145  C* ptr = ClassType<C>::GetInstance(vm, 1);
3146 
3147 #if !defined (SCRAT_NO_ERROR_CHECKING)
3148  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
3149 #endif
3150 
3151  Var<A1> a1(vm, 2);
3152  Var<A2> a2(vm, 3);
3153  Var<A3> a3(vm, 4);
3154  Var<A4> a4(vm, 5);
3155  Var<A5> a5(vm, 6);
3156  Var<A6> a6(vm, 7);
3157  Var<A7> a7(vm, 8);
3158  Var<A8> a8(vm, 9);
3159  Var<A9> a9(vm, 10);
3160  Var<A10> a10(vm, 11);
3161  Var<A11> a11(vm, 12);
3162  Var<A12> a12(vm, 13);
3163  Var<A13> a13(vm, 14);
3164 
3165 #if !defined (SCRAT_NO_ERROR_CHECKING)
3166  if (Error::Instance().Occurred(vm)) {
3167  if (overloaded)
3168  return 0;
3169  else
3170  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3171  }
3172 #endif
3173 
3174  R & ret = (ptr->*method)(
3175  a1.value,
3176  a2.value,
3177  a3.value,
3178  a4.value,
3179  a5.value,
3180  a6.value,
3181  a7.value,
3182  a8.value,
3183  a9.value,
3184  a10.value,
3185  a11.value,
3186  a12.value,
3187  a13.value
3188  );
3189 
3190 #if !defined (SCRAT_NO_ERROR_CHECKING)
3191  if (!overloaded && Error::Instance().Occurred(vm)) {
3192  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3193  }
3194 #endif
3195 
3196  PushVarR(vm, ret);
3197  return 1;
3198  }
3199 
3200  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, bool overloaded /*= false*/ >
3201  static SQInteger Func13C(HSQUIRRELVM vm) {
3202 
3203 #if !defined (SCRAT_NO_ERROR_CHECKING)
3204  if (!overloaded && sq_gettop(vm) != 15) {
3205  return sq_throwerror(vm, _SC("wrong number of parameters"));
3206  }
3207 #endif
3208  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const;
3209  M* methodPtr;
3210  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3211  M method = *methodPtr;
3212 
3213  C* ptr = ClassType<C>::GetInstance(vm, 1);
3214 
3215 #if !defined (SCRAT_NO_ERROR_CHECKING)
3216  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
3217 #endif
3218 
3219  Var<A1> a1(vm, 2);
3220  Var<A2> a2(vm, 3);
3221  Var<A3> a3(vm, 4);
3222  Var<A4> a4(vm, 5);
3223  Var<A5> a5(vm, 6);
3224  Var<A6> a6(vm, 7);
3225  Var<A7> a7(vm, 8);
3226  Var<A8> a8(vm, 9);
3227  Var<A9> a9(vm, 10);
3228  Var<A10> a10(vm, 11);
3229  Var<A11> a11(vm, 12);
3230  Var<A12> a12(vm, 13);
3231  Var<A13> a13(vm, 14);
3232 
3233 #if !defined (SCRAT_NO_ERROR_CHECKING)
3234  if (Error::Instance().Occurred(vm)) {
3235  if (overloaded)
3236  return 0;
3237  else
3238  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3239  }
3240 #endif
3241 
3242  R & ret = (ptr->*method)(
3243  a1.value,
3244  a2.value,
3245  a3.value,
3246  a4.value,
3247  a5.value,
3248  a6.value,
3249  a7.value,
3250  a8.value,
3251  a9.value,
3252  a10.value,
3253  a11.value,
3254  a12.value,
3255  a13.value
3256  );
3257 
3258 #if !defined (SCRAT_NO_ERROR_CHECKING)
3259  if (!overloaded && Error::Instance().Occurred(vm)) {
3260  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3261  }
3262 #endif
3263 
3264  PushVarR(vm, ret);
3265  return 1;
3266  }
3267 
3268  // Arg Count 14
3269  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, bool overloaded /*= false*/ >
3270  static SQInteger Func14(HSQUIRRELVM vm) {
3271 
3272 #if !defined (SCRAT_NO_ERROR_CHECKING)
3273  if (!overloaded && sq_gettop(vm) != 16) {
3274  return sq_throwerror(vm, _SC("wrong number of parameters"));
3275  }
3276 #endif
3277  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
3278  M* methodPtr;
3279  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3280  M method = *methodPtr;
3281 
3282  C* ptr = ClassType<C>::GetInstance(vm, 1);
3283 
3284 #if !defined (SCRAT_NO_ERROR_CHECKING)
3285  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
3286 #endif
3287 
3288  Var<A1> a1(vm, 2);
3289  Var<A2> a2(vm, 3);
3290  Var<A3> a3(vm, 4);
3291  Var<A4> a4(vm, 5);
3292  Var<A5> a5(vm, 6);
3293  Var<A6> a6(vm, 7);
3294  Var<A7> a7(vm, 8);
3295  Var<A8> a8(vm, 9);
3296  Var<A9> a9(vm, 10);
3297  Var<A10> a10(vm, 11);
3298  Var<A11> a11(vm, 12);
3299  Var<A12> a12(vm, 13);
3300  Var<A13> a13(vm, 14);
3301  Var<A14> a14(vm, 15);
3302 
3303 #if !defined (SCRAT_NO_ERROR_CHECKING)
3304  if (Error::Instance().Occurred(vm)) {
3305  if (overloaded)
3306  return 0;
3307  else
3308  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3309  }
3310 #endif
3311 
3312  R & ret = (ptr->*method)(
3313  a1.value,
3314  a2.value,
3315  a3.value,
3316  a4.value,
3317  a5.value,
3318  a6.value,
3319  a7.value,
3320  a8.value,
3321  a9.value,
3322  a10.value,
3323  a11.value,
3324  a12.value,
3325  a13.value,
3326  a14.value
3327  );
3328 
3329 #if !defined (SCRAT_NO_ERROR_CHECKING)
3330  if (!overloaded && Error::Instance().Occurred(vm)) {
3331  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3332  }
3333 #endif
3334 
3335  PushVarR(vm, ret);
3336  return 1;
3337  }
3338 
3339  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, bool overloaded /*= false*/ >
3340  static SQInteger Func14C(HSQUIRRELVM vm) {
3341 
3342 #if !defined (SCRAT_NO_ERROR_CHECKING)
3343  if (!overloaded && sq_gettop(vm) != 16) {
3344  return sq_throwerror(vm, _SC("wrong number of parameters"));
3345  }
3346 #endif
3347  typedef R & (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const;
3348  M* methodPtr;
3349  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3350  M method = *methodPtr;
3351 
3352  C* ptr = ClassType<C>::GetInstance(vm, 1);
3353 
3354 #if !defined (SCRAT_NO_ERROR_CHECKING)
3355  if (ptr == NULL) return sq_throwerror(vm, STATICCALLERROR);
3356 #endif
3357 
3358  Var<A1> a1(vm, 2);
3359  Var<A2> a2(vm, 3);
3360  Var<A3> a3(vm, 4);
3361  Var<A4> a4(vm, 5);
3362  Var<A5> a5(vm, 6);
3363  Var<A6> a6(vm, 7);
3364  Var<A7> a7(vm, 8);
3365  Var<A8> a8(vm, 9);
3366  Var<A9> a9(vm, 10);
3367  Var<A10> a10(vm, 11);
3368  Var<A11> a11(vm, 12);
3369  Var<A12> a12(vm, 13);
3370  Var<A13> a13(vm, 14);
3371  Var<A14> a14(vm, 15);
3372 
3373 #if !defined (SCRAT_NO_ERROR_CHECKING)
3374  if (Error::Instance().Occurred(vm)) {
3375  if (overloaded)
3376  return 0;
3377  else
3378  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3379  }
3380 #endif
3381 
3382  R & ret = (ptr->*method)(
3383  a1.value,
3384  a2.value,
3385  a3.value,
3386  a4.value,
3387  a5.value,
3388  a6.value,
3389  a7.value,
3390  a8.value,
3391  a9.value,
3392  a10.value,
3393  a11.value,
3394  a12.value,
3395  a13.value,
3396  a14.value
3397  );
3398 
3399 #if !defined (SCRAT_NO_ERROR_CHECKING)
3400  if (!overloaded && Error::Instance().Occurred(vm)) {
3401  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3402  }
3403 #endif
3404 
3405  PushVarR(vm, ret);
3406  return 1;
3407  }
3408 
3409 };
3410 
3411 
3412 //
3413 // void return specialization
3414 //
3415 
3416 template <class C>
3417 class SqMember<C, void> {
3418 public:
3419  // Arg Count 0
3420  template <bool overloaded /* = false */ >
3421  static SQInteger Func0(HSQUIRRELVM vm) {
3422 
3423 #if !defined (SCRAT_NO_ERROR_CHECKING)
3424  if (!overloaded && sq_gettop(vm) != 2) {
3425  return sq_throwerror(vm, _SC("wrong number of parameters"));
3426  }
3427 #endif
3428  typedef void (C::*M)();
3429  M* methodPtr;
3430  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3431  M method = *methodPtr;
3432 
3433  C* ptr = ClassType<C>::GetInstance(vm, 1);
3434 
3435  (ptr->*method)();
3436 #if !defined (SCRAT_NO_ERROR_CHECKING)
3437  if (!overloaded && Error::Instance().Occurred(vm)) {
3438  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3439  }
3440 #endif
3441  return 0;
3442  }
3443 
3444  template <bool overloaded /* = false */ >
3445  static SQInteger Func0C(HSQUIRRELVM vm) {
3446 
3447 #if !defined (SCRAT_NO_ERROR_CHECKING)
3448  if (!overloaded && sq_gettop(vm) != 2) {
3449  return sq_throwerror(vm, _SC("wrong number of parameters"));
3450  }
3451 #endif
3452  typedef void (C::*M)() const;
3453  M* methodPtr;
3454  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3455  M method = *methodPtr;
3456 
3457  C* ptr = ClassType<C>::GetInstance(vm, 1);
3458 
3459  (ptr->*method)();
3460 #if !defined (SCRAT_NO_ERROR_CHECKING)
3461  if (!overloaded && Error::Instance().Occurred(vm)) {
3462  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3463  }
3464 #endif
3465  return 0;
3466  }
3467 
3468  // Arg Count 1
3469  template <class A1, bool overloaded /*= false*/>
3470  static SQInteger Func1(HSQUIRRELVM vm) {
3471 
3472 #if !defined (SCRAT_NO_ERROR_CHECKING)
3473  if (!overloaded && sq_gettop(vm) != 3) {
3474  return sq_throwerror(vm, _SC("wrong number of parameters"));
3475  }
3476 #endif
3477  typedef void (C::*M)(A1);
3478  M* methodPtr;
3479  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3480  M method = *methodPtr;
3481 
3482  C* ptr = ClassType<C>::GetInstance(vm, 1);
3483 
3484  Var<A1> a1(vm, 2);
3485 
3486 #if !defined (SCRAT_NO_ERROR_CHECKING)
3487  if (Error::Instance().Occurred(vm)) {
3488  if (overloaded)
3489  return 0;
3490  else
3491  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3492  }
3493 #endif
3494 
3495  (ptr->*method)(
3496  a1.value
3497  );
3498 #if !defined (SCRAT_NO_ERROR_CHECKING)
3499  if (!overloaded && Error::Instance().Occurred(vm)) {
3500  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3501  }
3502 #endif
3503  return 0;
3504  }
3505 
3506  template <class A1, bool overloaded /*= false*/ >
3507  static SQInteger Func1C(HSQUIRRELVM vm) {
3508 
3509 #if !defined (SCRAT_NO_ERROR_CHECKING)
3510  if (!overloaded && sq_gettop(vm) != 3) {
3511  return sq_throwerror(vm, _SC("wrong number of parameters"));
3512  }
3513 #endif
3514  typedef void (C::*M)(A1) const;
3515  M* methodPtr;
3516  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3517  M method = *methodPtr;
3518 
3519  C* ptr = ClassType<C>::GetInstance(vm, 1);
3520 
3521  Var<A1> a1(vm, 2);
3522 
3523 #if !defined (SCRAT_NO_ERROR_CHECKING)
3524  if (Error::Instance().Occurred(vm)) {
3525  if (overloaded)
3526  return 0;
3527  else
3528  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3529  }
3530 #endif
3531 
3532  (ptr->*method)(
3533  a1.value
3534  );
3535 #if !defined (SCRAT_NO_ERROR_CHECKING)
3536  if (!overloaded && Error::Instance().Occurred(vm)) {
3537  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3538  }
3539 #endif
3540  return 0;
3541  }
3542 
3543  // Arg Count 2
3544  template <class A1, class A2, bool overloaded /*= false*/>
3545  static SQInteger Func2(HSQUIRRELVM vm) {
3546 
3547 #if !defined (SCRAT_NO_ERROR_CHECKING)
3548  if (!overloaded && sq_gettop(vm) != 4) {
3549  return sq_throwerror(vm, _SC("wrong number of parameters"));
3550  }
3551 #endif
3552  typedef void (C::*M)(A1, A2);
3553  M* methodPtr;
3554  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3555  M method = *methodPtr;
3556 
3557  C* ptr = ClassType<C>::GetInstance(vm, 1);
3558 
3559  Var<A1> a1(vm, 2);
3560  Var<A2> a2(vm, 3);
3561 
3562 #if !defined (SCRAT_NO_ERROR_CHECKING)
3563  if (Error::Instance().Occurred(vm)) {
3564  if (overloaded)
3565  return 0;
3566  else
3567  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3568  }
3569 #endif
3570 
3571  (ptr->*method)(
3572  a1.value,
3573  a2.value
3574  );
3575 #if !defined (SCRAT_NO_ERROR_CHECKING)
3576  if (!overloaded && Error::Instance().Occurred(vm)) {
3577  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3578  }
3579 #endif
3580  return 0;
3581  }
3582 
3583  template <class A1, class A2, bool overloaded /*= false*/>
3584  static SQInteger Func2C(HSQUIRRELVM vm) {
3585 
3586 #if !defined (SCRAT_NO_ERROR_CHECKING)
3587  if (!overloaded && sq_gettop(vm) != 4) {
3588  return sq_throwerror(vm, _SC("wrong number of parameters"));
3589  }
3590 #endif
3591  typedef void (C::*M)(A1, A2) const;
3592  M* methodPtr;
3593  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3594  M method = *methodPtr;
3595 
3596  C* ptr = ClassType<C>::GetInstance(vm, 1);
3597 
3598  Var<A1> a1(vm, 2);
3599  Var<A2> a2(vm, 3);
3600 
3601 #if !defined (SCRAT_NO_ERROR_CHECKING)
3602  if (Error::Instance().Occurred(vm)) {
3603  if (overloaded)
3604  return 0;
3605  else
3606  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3607  }
3608 #endif
3609 
3610  (ptr->*method)(
3611  a1.value,
3612  a2.value
3613  );
3614 #if !defined (SCRAT_NO_ERROR_CHECKING)
3615  if (!overloaded && Error::Instance().Occurred(vm)) {
3616  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3617  }
3618 #endif
3619  return 0;
3620  }
3621 
3622  // Arg Count 3
3623  template <class A1, class A2, class A3, bool overloaded /*= false*/ >
3624  static SQInteger Func3(HSQUIRRELVM vm) {
3625 
3626 #if !defined (SCRAT_NO_ERROR_CHECKING)
3627  if (!overloaded && sq_gettop(vm) != 5) {
3628  return sq_throwerror(vm, _SC("wrong number of parameters"));
3629  }
3630 #endif
3631  typedef void (C::*M)(A1, A2, A3);
3632  M* methodPtr;
3633  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3634  M method = *methodPtr;
3635 
3636  C* ptr = ClassType<C>::GetInstance(vm, 1);
3637 
3638  Var<A1> a1(vm, 2);
3639  Var<A2> a2(vm, 3);
3640  Var<A3> a3(vm, 4);
3641 
3642 #if !defined (SCRAT_NO_ERROR_CHECKING)
3643  if (Error::Instance().Occurred(vm)) {
3644  if (overloaded)
3645  return 0;
3646  else
3647  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3648  }
3649 #endif
3650 
3651  (ptr->*method)(
3652  a1.value,
3653  a2.value,
3654  a3.value
3655  );
3656 #if !defined (SCRAT_NO_ERROR_CHECKING)
3657  if (!overloaded && Error::Instance().Occurred(vm)) {
3658  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3659  }
3660 #endif
3661  return 0;
3662  }
3663 
3664  template <class A1, class A2, class A3, bool overloaded /*= false*/ >
3665  static SQInteger Func3C(HSQUIRRELVM vm) {
3666 
3667 #if !defined (SCRAT_NO_ERROR_CHECKING)
3668  if (!overloaded && sq_gettop(vm) != 5) {
3669  return sq_throwerror(vm, _SC("wrong number of parameters"));
3670  }
3671 #endif
3672  typedef void (C::*M)(A1, A2, A3) const;
3673  M* methodPtr;
3674  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3675  M method = *methodPtr;
3676 
3677  C* ptr = ClassType<C>::GetInstance(vm, 1);
3678 
3679  Var<A1> a1(vm, 2);
3680  Var<A2> a2(vm, 3);
3681  Var<A3> a3(vm, 4);
3682 
3683 #if !defined (SCRAT_NO_ERROR_CHECKING)
3684  if (Error::Instance().Occurred(vm)) {
3685  if (overloaded)
3686  return 0;
3687  else
3688  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3689  }
3690 #endif
3691 
3692  (ptr->*method)(
3693  a1.value,
3694  a2.value,
3695  a3.value
3696  );
3697 #if !defined (SCRAT_NO_ERROR_CHECKING)
3698  if (!overloaded && Error::Instance().Occurred(vm)) {
3699  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3700  }
3701 #endif
3702  return 0;
3703  }
3704 
3705  // Arg Count 4
3706  template <class A1, class A2, class A3, class A4, bool overloaded /*= false*/ >
3707  static SQInteger Func4(HSQUIRRELVM vm) {
3708 
3709 #if !defined (SCRAT_NO_ERROR_CHECKING)
3710  if (!overloaded && sq_gettop(vm) != 6) {
3711  return sq_throwerror(vm, _SC("wrong number of parameters"));
3712  }
3713 #endif
3714  typedef void (C::*M)(A1, A2, A3, A4);
3715  M* methodPtr;
3716  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3717  M method = *methodPtr;
3718 
3719  C* ptr = ClassType<C>::GetInstance(vm, 1);
3720 
3721  Var<A1> a1(vm, 2);
3722  Var<A2> a2(vm, 3);
3723  Var<A3> a3(vm, 4);
3724  Var<A4> a4(vm, 5);
3725 
3726 #if !defined (SCRAT_NO_ERROR_CHECKING)
3727  if (Error::Instance().Occurred(vm)) {
3728  if (overloaded)
3729  return 0;
3730  else
3731  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3732  }
3733 #endif
3734 
3735  (ptr->*method)(
3736  a1.value,
3737  a2.value,
3738  a3.value,
3739  a4.value
3740  );
3741 #if !defined (SCRAT_NO_ERROR_CHECKING)
3742  if (!overloaded && Error::Instance().Occurred(vm)) {
3743  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3744  }
3745 #endif
3746  return 0;
3747  }
3748 
3749  template <class A1, class A2, class A3, class A4, bool overloaded /*= false*/ >
3750  static SQInteger Func4C(HSQUIRRELVM vm) {
3751 
3752 #if !defined (SCRAT_NO_ERROR_CHECKING)
3753  if (!overloaded && sq_gettop(vm) != 6) {
3754  return sq_throwerror(vm, _SC("wrong number of parameters"));
3755  }
3756 #endif
3757  typedef void (C::*M)(A1, A2, A3, A4) const;
3758  M* methodPtr;
3759  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3760  M method = *methodPtr;
3761 
3762  C* ptr = ClassType<C>::GetInstance(vm, 1);
3763 
3764  Var<A1> a1(vm, 2);
3765  Var<A2> a2(vm, 3);
3766  Var<A3> a3(vm, 4);
3767  Var<A4> a4(vm, 5);
3768 
3769 #if !defined (SCRAT_NO_ERROR_CHECKING)
3770  if (Error::Instance().Occurred(vm)) {
3771  if (overloaded)
3772  return 0;
3773  else
3774  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3775  }
3776 #endif
3777 
3778  (ptr->*method)(
3779  a1.value,
3780  a2.value,
3781  a3.value,
3782  a4.value
3783  );
3784 #if !defined (SCRAT_NO_ERROR_CHECKING)
3785  if (!overloaded && Error::Instance().Occurred(vm)) {
3786  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3787  }
3788 #endif
3789  return 0;
3790  }
3791 
3792  // Arg Count 5
3793  template <class A1, class A2, class A3, class A4, class A5, bool overloaded /*= false*/ >
3794  static SQInteger Func5(HSQUIRRELVM vm) {
3795 
3796 #if !defined (SCRAT_NO_ERROR_CHECKING)
3797  if (!overloaded && sq_gettop(vm) != 7) {
3798  return sq_throwerror(vm, _SC("wrong number of parameters"));
3799  }
3800 #endif
3801  typedef void (C::*M)(A1, A2, A3, A4, A5);
3802  M* methodPtr;
3803  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3804  M method = *methodPtr;
3805 
3806  C* ptr = ClassType<C>::GetInstance(vm, 1);
3807 
3808  Var<A1> a1(vm, 2);
3809  Var<A2> a2(vm, 3);
3810  Var<A3> a3(vm, 4);
3811  Var<A4> a4(vm, 5);
3812  Var<A5> a5(vm, 6);
3813 
3814 #if !defined (SCRAT_NO_ERROR_CHECKING)
3815  if (Error::Instance().Occurred(vm)) {
3816  if (overloaded)
3817  return 0;
3818  else
3819  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3820  }
3821 #endif
3822 
3823  (ptr->*method)(
3824  a1.value,
3825  a2.value,
3826  a3.value,
3827  a4.value,
3828  a5.value
3829  );
3830 #if !defined (SCRAT_NO_ERROR_CHECKING)
3831  if (!overloaded && Error::Instance().Occurred(vm)) {
3832  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3833  }
3834 #endif
3835  return 0;
3836  }
3837 
3838  template <class A1, class A2, class A3, class A4, class A5, bool overloaded /*= false*/ >
3839  static SQInteger Func5C(HSQUIRRELVM vm) {
3840 
3841 #if !defined (SCRAT_NO_ERROR_CHECKING)
3842  if (!overloaded && sq_gettop(vm) != 7) {
3843  return sq_throwerror(vm, _SC("wrong number of parameters"));
3844  }
3845 #endif
3846  typedef void (C::*M)(A1, A2, A3, A4, A5) const;
3847  M* methodPtr;
3848  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3849  M method = *methodPtr;
3850 
3851  C* ptr = ClassType<C>::GetInstance(vm, 1);
3852 
3853  Var<A1> a1(vm, 2);
3854  Var<A2> a2(vm, 3);
3855  Var<A3> a3(vm, 4);
3856  Var<A4> a4(vm, 5);
3857  Var<A5> a5(vm, 6);
3858 
3859 #if !defined (SCRAT_NO_ERROR_CHECKING)
3860  if (Error::Instance().Occurred(vm)) {
3861  if (overloaded)
3862  return 0;
3863  else
3864  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3865  }
3866 #endif
3867 
3868  (ptr->*method)(
3869  a1.value,
3870  a2.value,
3871  a3.value,
3872  a4.value,
3873  a5.value
3874  );
3875 #if !defined (SCRAT_NO_ERROR_CHECKING)
3876  if (!overloaded && Error::Instance().Occurred(vm)) {
3877  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3878  }
3879 #endif
3880  return 0;
3881  }
3882 
3883  // Arg Count 6
3884  template <class A1, class A2, class A3, class A4, class A5, class A6, bool overloaded /*= false*/ >
3885  static SQInteger Func6(HSQUIRRELVM vm) {
3886 
3887 #if !defined (SCRAT_NO_ERROR_CHECKING)
3888  if (!overloaded && sq_gettop(vm) != 8) {
3889  return sq_throwerror(vm, _SC("wrong number of parameters"));
3890  }
3891 #endif
3892  typedef void (C::*M)(A1, A2, A3, A4, A5, A6);
3893  M* methodPtr;
3894  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3895  M method = *methodPtr;
3896 
3897  C* ptr = ClassType<C>::GetInstance(vm, 1);
3898 
3899  Var<A1> a1(vm, 2);
3900  Var<A2> a2(vm, 3);
3901  Var<A3> a3(vm, 4);
3902  Var<A4> a4(vm, 5);
3903  Var<A5> a5(vm, 6);
3904  Var<A6> a6(vm, 7);
3905 
3906 #if !defined (SCRAT_NO_ERROR_CHECKING)
3907  if (Error::Instance().Occurred(vm)) {
3908  if (overloaded)
3909  return 0;
3910  else
3911  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3912  }
3913 #endif
3914 
3915  (ptr->*method)(
3916  a1.value,
3917  a2.value,
3918  a3.value,
3919  a4.value,
3920  a5.value,
3921  a6.value
3922  );
3923 #if !defined (SCRAT_NO_ERROR_CHECKING)
3924  if (!overloaded && Error::Instance().Occurred(vm)) {
3925  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3926  }
3927 #endif
3928  return 0;
3929  }
3930 
3931  template <class A1, class A2, class A3, class A4, class A5, class A6, bool overloaded /*= false*/ >
3932  static SQInteger Func6C(HSQUIRRELVM vm) {
3933 
3934 #if !defined (SCRAT_NO_ERROR_CHECKING)
3935  if (!overloaded && sq_gettop(vm) != 8) {
3936  return sq_throwerror(vm, _SC("wrong number of parameters"));
3937  }
3938 #endif
3939  typedef void (C::*M)(A1, A2, A3, A4, A5, A6) const;
3940  M* methodPtr;
3941  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3942  M method = *methodPtr;
3943 
3944  C* ptr = ClassType<C>::GetInstance(vm, 1);
3945 
3946  Var<A1> a1(vm, 2);
3947  Var<A2> a2(vm, 3);
3948  Var<A3> a3(vm, 4);
3949  Var<A4> a4(vm, 5);
3950  Var<A5> a5(vm, 6);
3951  Var<A6> a6(vm, 7);
3952 
3953 #if !defined (SCRAT_NO_ERROR_CHECKING)
3954  if (Error::Instance().Occurred(vm)) {
3955  if (overloaded)
3956  return 0;
3957  else
3958  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
3959  }
3960 #endif
3961 
3962  (ptr->*method)(
3963  a1.value,
3964  a2.value,
3965  a3.value,
3966  a4.value,
3967  a5.value,
3968  a6.value
3969  );
3970 #if !defined (SCRAT_NO_ERROR_CHECKING)
3971  if (!overloaded && Error::Instance().Occurred(vm)) {
3972  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
3973  }
3974 #endif
3975  return 0;
3976  }
3977 
3978  // Arg Count 7
3979  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool overloaded /*= false*/ >
3980  static SQInteger Func7(HSQUIRRELVM vm) {
3981 
3982 #if !defined (SCRAT_NO_ERROR_CHECKING)
3983  if (!overloaded && sq_gettop(vm) != 9) {
3984  return sq_throwerror(vm, _SC("wrong number of parameters"));
3985  }
3986 #endif
3987  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7);
3988  M* methodPtr;
3989  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
3990  M method = *methodPtr;
3991 
3992  C* ptr = ClassType<C>::GetInstance(vm, 1);
3993 
3994  Var<A1> a1(vm, 2);
3995  Var<A2> a2(vm, 3);
3996  Var<A3> a3(vm, 4);
3997  Var<A4> a4(vm, 5);
3998  Var<A5> a5(vm, 6);
3999  Var<A6> a6(vm, 7);
4000  Var<A7> a7(vm, 8);
4001 
4002 #if !defined (SCRAT_NO_ERROR_CHECKING)
4003  if (Error::Instance().Occurred(vm)) {
4004  if (overloaded)
4005  return 0;
4006  else
4007  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4008  }
4009 #endif
4010 
4011  (ptr->*method)(
4012  a1.value,
4013  a2.value,
4014  a3.value,
4015  a4.value,
4016  a5.value,
4017  a6.value,
4018  a7.value
4019  );
4020 #if !defined (SCRAT_NO_ERROR_CHECKING)
4021  if (!overloaded && Error::Instance().Occurred(vm)) {
4022  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4023  }
4024 #endif
4025  return 0;
4026  }
4027 
4028  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool overloaded /*= false*/ >
4029  static SQInteger Func7C(HSQUIRRELVM vm) {
4030 
4031 #if !defined (SCRAT_NO_ERROR_CHECKING)
4032  if (!overloaded && sq_gettop(vm) != 9) {
4033  return sq_throwerror(vm, _SC("wrong number of parameters"));
4034  }
4035 #endif
4036  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7) const;
4037  M* methodPtr;
4038  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4039  M method = *methodPtr;
4040 
4041  C* ptr = ClassType<C>::GetInstance(vm, 1);
4042 
4043  Var<A1> a1(vm, 2);
4044  Var<A2> a2(vm, 3);
4045  Var<A3> a3(vm, 4);
4046  Var<A4> a4(vm, 5);
4047  Var<A5> a5(vm, 6);
4048  Var<A6> a6(vm, 7);
4049  Var<A7> a7(vm, 8);
4050 
4051 #if !defined (SCRAT_NO_ERROR_CHECKING)
4052  if (Error::Instance().Occurred(vm)) {
4053  if (overloaded)
4054  return 0;
4055  else
4056  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4057  }
4058 #endif
4059 
4060  (ptr->*method)(
4061  a1.value,
4062  a2.value,
4063  a3.value,
4064  a4.value,
4065  a5.value,
4066  a6.value,
4067  a7.value
4068  );
4069 #if !defined (SCRAT_NO_ERROR_CHECKING)
4070  if (!overloaded && Error::Instance().Occurred(vm)) {
4071  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4072  }
4073 #endif
4074  return 0;
4075  }
4076 
4077  // Arg Count 8
4078  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool overloaded /*= false*/ >
4079  static SQInteger Func8(HSQUIRRELVM vm) {
4080 
4081 #if !defined (SCRAT_NO_ERROR_CHECKING)
4082  if (!overloaded && sq_gettop(vm) != 10) {
4083  return sq_throwerror(vm, _SC("wrong number of parameters"));
4084  }
4085 #endif
4086  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8);
4087  M* methodPtr;
4088  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4089  M method = *methodPtr;
4090 
4091  C* ptr = ClassType<C>::GetInstance(vm, 1);
4092 
4093  Var<A1> a1(vm, 2);
4094  Var<A2> a2(vm, 3);
4095  Var<A3> a3(vm, 4);
4096  Var<A4> a4(vm, 5);
4097  Var<A5> a5(vm, 6);
4098  Var<A6> a6(vm, 7);
4099  Var<A7> a7(vm, 8);
4100  Var<A8> a8(vm, 9);
4101 
4102 #if !defined (SCRAT_NO_ERROR_CHECKING)
4103  if (Error::Instance().Occurred(vm)) {
4104  if (overloaded)
4105  return 0;
4106  else
4107  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4108  }
4109 #endif
4110 
4111  (ptr->*method)(
4112  a1.value,
4113  a2.value,
4114  a3.value,
4115  a4.value,
4116  a5.value,
4117  a6.value,
4118  a7.value,
4119  a8.value
4120  );
4121 #if !defined (SCRAT_NO_ERROR_CHECKING)
4122  if (!overloaded && Error::Instance().Occurred(vm)) {
4123  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4124  }
4125 #endif
4126  return 0;
4127  }
4128 
4129  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool overloaded /*= false*/ >
4130  static SQInteger Func8C(HSQUIRRELVM vm) {
4131 
4132 #if !defined (SCRAT_NO_ERROR_CHECKING)
4133  if (!overloaded && sq_gettop(vm) != 10) {
4134  return sq_throwerror(vm, _SC("wrong number of parameters"));
4135  }
4136 #endif
4137  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8) const;
4138  M* methodPtr;
4139  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4140  M method = *methodPtr;
4141 
4142  C* ptr = ClassType<C>::GetInstance(vm, 1);
4143 
4144  Var<A1> a1(vm, 2);
4145  Var<A2> a2(vm, 3);
4146  Var<A3> a3(vm, 4);
4147  Var<A4> a4(vm, 5);
4148  Var<A5> a5(vm, 6);
4149  Var<A6> a6(vm, 7);
4150  Var<A7> a7(vm, 8);
4151  Var<A8> a8(vm, 9);
4152 
4153 #if !defined (SCRAT_NO_ERROR_CHECKING)
4154  if (Error::Instance().Occurred(vm)) {
4155  if (overloaded)
4156  return 0;
4157  else
4158  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4159  }
4160 #endif
4161 
4162  (ptr->*method)(
4163  a1.value,
4164  a2.value,
4165  a3.value,
4166  a4.value,
4167  a5.value,
4168  a6.value,
4169  a7.value,
4170  a8.value
4171  );
4172 #if !defined (SCRAT_NO_ERROR_CHECKING)
4173  if (!overloaded && Error::Instance().Occurred(vm)) {
4174  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4175  }
4176 #endif
4177  return 0;
4178  }
4179 
4180  // Arg Count 9
4181  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool overloaded /*= false*/ >
4182  static SQInteger Func9(HSQUIRRELVM vm) {
4183 
4184 #if !defined (SCRAT_NO_ERROR_CHECKING)
4185  if (!overloaded && sq_gettop(vm) != 11) {
4186  return sq_throwerror(vm, _SC("wrong number of parameters"));
4187  }
4188 #endif
4189  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
4190  M* methodPtr;
4191  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4192  M method = *methodPtr;
4193 
4194  C* ptr = ClassType<C>::GetInstance(vm, 1);
4195 
4196  Var<A1> a1(vm, 2);
4197  Var<A2> a2(vm, 3);
4198  Var<A3> a3(vm, 4);
4199  Var<A4> a4(vm, 5);
4200  Var<A5> a5(vm, 6);
4201  Var<A6> a6(vm, 7);
4202  Var<A7> a7(vm, 8);
4203  Var<A8> a8(vm, 9);
4204  Var<A9> a9(vm, 10);
4205 
4206 #if !defined (SCRAT_NO_ERROR_CHECKING)
4207  if (Error::Instance().Occurred(vm)) {
4208  if (overloaded)
4209  return 0;
4210  else
4211  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4212  }
4213 #endif
4214 
4215  (ptr->*method)(
4216  a1.value,
4217  a2.value,
4218  a3.value,
4219  a4.value,
4220  a5.value,
4221  a6.value,
4222  a7.value,
4223  a8.value,
4224  a9.value
4225  );
4226 #if !defined (SCRAT_NO_ERROR_CHECKING)
4227  if (!overloaded && Error::Instance().Occurred(vm)) {
4228  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4229  }
4230 #endif
4231  return 0;
4232  }
4233 
4234  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool overloaded /*= false*/ >
4235  static SQInteger Func9C(HSQUIRRELVM vm) {
4236 
4237 #if !defined (SCRAT_NO_ERROR_CHECKING)
4238  if (!overloaded && sq_gettop(vm) != 11) {
4239  return sq_throwerror(vm, _SC("wrong number of parameters"));
4240  }
4241 #endif
4242  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const;
4243  M* methodPtr;
4244  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4245  M method = *methodPtr;
4246 
4247  C* ptr = ClassType<C>::GetInstance(vm, 1);
4248 
4249  Var<A1> a1(vm, 2);
4250  Var<A2> a2(vm, 3);
4251  Var<A3> a3(vm, 4);
4252  Var<A4> a4(vm, 5);
4253  Var<A5> a5(vm, 6);
4254  Var<A6> a6(vm, 7);
4255  Var<A7> a7(vm, 8);
4256  Var<A8> a8(vm, 9);
4257  Var<A9> a9(vm, 10);
4258 
4259 #if !defined (SCRAT_NO_ERROR_CHECKING)
4260  if (Error::Instance().Occurred(vm)) {
4261  if (overloaded)
4262  return 0;
4263  else
4264  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4265  }
4266 #endif
4267 
4268  (ptr->*method)(
4269  a1.value,
4270  a2.value,
4271  a3.value,
4272  a4.value,
4273  a5.value,
4274  a6.value,
4275  a7.value,
4276  a8.value,
4277  a9.value
4278  );
4279 #if !defined (SCRAT_NO_ERROR_CHECKING)
4280  if (!overloaded && Error::Instance().Occurred(vm)) {
4281  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4282  }
4283 #endif
4284  return 0;
4285  }
4286 
4287  // Arg Count 10
4288  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool overloaded /*= false*/ >
4289  static SQInteger Func10(HSQUIRRELVM vm) {
4290 
4291 #if !defined (SCRAT_NO_ERROR_CHECKING)
4292  if (!overloaded && sq_gettop(vm) != 12) {
4293  return sq_throwerror(vm, _SC("wrong number of parameters"));
4294  }
4295 #endif
4296  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
4297  M* methodPtr;
4298  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4299  M method = *methodPtr;
4300 
4301  C* ptr = ClassType<C>::GetInstance(vm, 1);
4302 
4303  Var<A1> a1(vm, 2);
4304  Var<A2> a2(vm, 3);
4305  Var<A3> a3(vm, 4);
4306  Var<A4> a4(vm, 5);
4307  Var<A5> a5(vm, 6);
4308  Var<A6> a6(vm, 7);
4309  Var<A7> a7(vm, 8);
4310  Var<A8> a8(vm, 9);
4311  Var<A9> a9(vm, 10);
4312  Var<A10> a10(vm, 11);
4313 
4314 #if !defined (SCRAT_NO_ERROR_CHECKING)
4315  if (Error::Instance().Occurred(vm)) {
4316  if (overloaded)
4317  return 0;
4318  else
4319  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4320  }
4321 #endif
4322 
4323  (ptr->*method)(
4324  a1.value,
4325  a2.value,
4326  a3.value,
4327  a4.value,
4328  a5.value,
4329  a6.value,
4330  a7.value,
4331  a8.value,
4332  a9.value,
4333  a10.value
4334  );
4335 #if !defined (SCRAT_NO_ERROR_CHECKING)
4336  if (!overloaded && Error::Instance().Occurred(vm)) {
4337  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4338  }
4339 #endif
4340  return 0;
4341  }
4342 
4343  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool overloaded /*= false*/ >
4344  static SQInteger Func10C(HSQUIRRELVM vm) {
4345 
4346 #if !defined (SCRAT_NO_ERROR_CHECKING)
4347  if (!overloaded && sq_gettop(vm) != 12) {
4348  return sq_throwerror(vm, _SC("wrong number of parameters"));
4349  }
4350 #endif
4351  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const;
4352  M* methodPtr;
4353  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4354  M method = *methodPtr;
4355 
4356  C* ptr = ClassType<C>::GetInstance(vm, 1);
4357 
4358  Var<A1> a1(vm, 2);
4359  Var<A2> a2(vm, 3);
4360  Var<A3> a3(vm, 4);
4361  Var<A4> a4(vm, 5);
4362  Var<A5> a5(vm, 6);
4363  Var<A6> a6(vm, 7);
4364  Var<A7> a7(vm, 8);
4365  Var<A8> a8(vm, 9);
4366  Var<A9> a9(vm, 10);
4367  Var<A10> a10(vm, 11);
4368 
4369 #if !defined (SCRAT_NO_ERROR_CHECKING)
4370  if (Error::Instance().Occurred(vm)) {
4371  if (overloaded)
4372  return 0;
4373  else
4374  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4375  }
4376 #endif
4377 
4378  (ptr->*method)(
4379  a1.value,
4380  a2.value,
4381  a3.value,
4382  a4.value,
4383  a5.value,
4384  a6.value,
4385  a7.value,
4386  a8.value,
4387  a9.value,
4388  a10.value
4389  );
4390 #if !defined (SCRAT_NO_ERROR_CHECKING)
4391  if (!overloaded && Error::Instance().Occurred(vm)) {
4392  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4393  }
4394 #endif
4395  return 0;
4396  }
4397 
4398  // Arg Count 11
4399  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool overloaded /*= false*/ >
4400  static SQInteger Func11(HSQUIRRELVM vm) {
4401 
4402 #if !defined (SCRAT_NO_ERROR_CHECKING)
4403  if (!overloaded && sq_gettop(vm) != 13) {
4404  return sq_throwerror(vm, _SC("wrong number of parameters"));
4405  }
4406 #endif
4407  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
4408  M* methodPtr;
4409  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4410  M method = *methodPtr;
4411 
4412  C* ptr = ClassType<C>::GetInstance(vm, 1);
4413 
4414  Var<A1> a1(vm, 2);
4415  Var<A2> a2(vm, 3);
4416  Var<A3> a3(vm, 4);
4417  Var<A4> a4(vm, 5);
4418  Var<A5> a5(vm, 6);
4419  Var<A6> a6(vm, 7);
4420  Var<A7> a7(vm, 8);
4421  Var<A8> a8(vm, 9);
4422  Var<A9> a9(vm, 10);
4423  Var<A10> a10(vm, 11);
4424  Var<A11> a11(vm, 12);
4425 
4426 #if !defined (SCRAT_NO_ERROR_CHECKING)
4427  if (Error::Instance().Occurred(vm)) {
4428  if (overloaded)
4429  return 0;
4430  else
4431  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4432  }
4433 #endif
4434 
4435  (ptr->*method)(
4436  a1.value,
4437  a2.value,
4438  a3.value,
4439  a4.value,
4440  a5.value,
4441  a6.value,
4442  a7.value,
4443  a8.value,
4444  a9.value,
4445  a10.value,
4446  a11.value
4447  );
4448 #if !defined (SCRAT_NO_ERROR_CHECKING)
4449  if (!overloaded && Error::Instance().Occurred(vm)) {
4450  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4451  }
4452 #endif
4453  return 0;
4454  }
4455 
4456  template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool overloaded /*= false*/ >
4457  static SQInteger Func11C(HSQUIRRELVM vm) {
4458 
4459 #if !defined (SCRAT_NO_ERROR_CHECKING)
4460  if (!overloaded && sq_gettop(vm) != 13) {
4461  return sq_throwerror(vm, _SC("wrong number of parameters"));
4462  }
4463 #endif
4464  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const;
4465  M* methodPtr;
4466  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4467  M method = *methodPtr;
4468 
4469  C* ptr = ClassType<C>::GetInstance(vm, 1);
4470 
4471  Var<A1> a1(vm, 2);
4472  Var<A2> a2(vm, 3);
4473  Var<A3> a3(vm, 4);
4474  Var<A4> a4(vm, 5);
4475  Var<A5> a5(vm, 6);
4476  Var<A6> a6(vm, 7);
4477  Var<A7> a7(vm, 8);
4478  Var<A8> a8(vm, 9);
4479  Var<A9> a9(vm, 10);
4480  Var<A10> a10(vm, 11);
4481  Var<A11> a11(vm, 12);
4482 
4483 #if !defined (SCRAT_NO_ERROR_CHECKING)
4484  if (Error::Instance().Occurred(vm)) {
4485  if (overloaded)
4486  return 0;
4487  else
4488  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4489  }
4490 #endif
4491 
4492  (ptr->*method)(
4493  a1.value,
4494  a2.value,
4495  a3.value,
4496  a4.value,
4497  a5.value,
4498  a6.value,
4499  a7.value,
4500  a8.value,
4501  a9.value,
4502  a10.value,
4503  a11.value
4504  );
4505 #if !defined (SCRAT_NO_ERROR_CHECKING)
4506  if (!overloaded && Error::Instance().Occurred(vm)) {
4507  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4508  }
4509 #endif
4510  return 0;
4511  }
4512 
4513  // Arg Count 12
4514  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, bool overloaded /*= false*/ >
4515  static SQInteger Func12(HSQUIRRELVM vm) {
4516 
4517 #if !defined (SCRAT_NO_ERROR_CHECKING)
4518  if (!overloaded && sq_gettop(vm) != 14) {
4519  return sq_throwerror(vm, _SC("wrong number of parameters"));
4520  }
4521 #endif
4522  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
4523  M* methodPtr;
4524  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4525  M method = *methodPtr;
4526 
4527  C* ptr = ClassType<C>::GetInstance(vm, 1);
4528 
4529  Var<A1> a1(vm, 2);
4530  Var<A2> a2(vm, 3);
4531  Var<A3> a3(vm, 4);
4532  Var<A4> a4(vm, 5);
4533  Var<A5> a5(vm, 6);
4534  Var<A6> a6(vm, 7);
4535  Var<A7> a7(vm, 8);
4536  Var<A8> a8(vm, 9);
4537  Var<A9> a9(vm, 10);
4538  Var<A10> a10(vm, 11);
4539  Var<A11> a11(vm, 12);
4540  Var<A12> a12(vm, 13);
4541 
4542 #if !defined (SCRAT_NO_ERROR_CHECKING)
4543  if (Error::Instance().Occurred(vm)) {
4544  if (overloaded)
4545  return 0;
4546  else
4547  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4548  }
4549 #endif
4550 
4551  (ptr->*method)(
4552  a1.value,
4553  a2.value,
4554  a3.value,
4555  a4.value,
4556  a5.value,
4557  a6.value,
4558  a7.value,
4559  a8.value,
4560  a9.value,
4561  a10.value,
4562  a11.value,
4563  a12.value
4564  );
4565 #if !defined (SCRAT_NO_ERROR_CHECKING)
4566  if (!overloaded && Error::Instance().Occurred(vm)) {
4567  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4568  }
4569 #endif
4570  return 0;
4571  }
4572 
4573  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, bool overloaded /*= false*/ >
4574  static SQInteger Func12C(HSQUIRRELVM vm) {
4575 
4576 #if !defined (SCRAT_NO_ERROR_CHECKING)
4577  if (!overloaded && sq_gettop(vm) != 14) {
4578  return sq_throwerror(vm, _SC("wrong number of parameters"));
4579  }
4580 #endif
4581  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const;
4582  M* methodPtr;
4583  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4584  M method = *methodPtr;
4585 
4586  C* ptr = ClassType<C>::GetInstance(vm, 1);
4587 
4588  Var<A1> a1(vm, 2);
4589  Var<A2> a2(vm, 3);
4590  Var<A3> a3(vm, 4);
4591  Var<A4> a4(vm, 5);
4592  Var<A5> a5(vm, 6);
4593  Var<A6> a6(vm, 7);
4594  Var<A7> a7(vm, 8);
4595  Var<A8> a8(vm, 9);
4596  Var<A9> a9(vm, 10);
4597  Var<A10> a10(vm, 11);
4598  Var<A11> a11(vm, 12);
4599  Var<A12> a12(vm, 13);
4600 
4601 #if !defined (SCRAT_NO_ERROR_CHECKING)
4602  if (Error::Instance().Occurred(vm)) {
4603  if (overloaded)
4604  return 0;
4605  else
4606  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4607  }
4608 #endif
4609 
4610  (ptr->*method)(
4611  a1.value,
4612  a2.value,
4613  a3.value,
4614  a4.value,
4615  a5.value,
4616  a6.value,
4617  a7.value,
4618  a8.value,
4619  a9.value,
4620  a10.value,
4621  a11.value,
4622  a12.value
4623  );
4624 #if !defined (SCRAT_NO_ERROR_CHECKING)
4625  if (!overloaded && Error::Instance().Occurred(vm)) {
4626  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4627  }
4628 #endif
4629  return 0;
4630  }
4631 
4632  // Arg Count 13
4633  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, bool overloaded /*= false*/>
4634  static SQInteger Func13(HSQUIRRELVM vm) {
4635 
4636 #if !defined (SCRAT_NO_ERROR_CHECKING)
4637  if (!overloaded && sq_gettop(vm) != 15) {
4638  return sq_throwerror(vm, _SC("wrong number of parameters"));
4639  }
4640 #endif
4641  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
4642  M* methodPtr;
4643  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4644  M method = *methodPtr;
4645 
4646  C* ptr = ClassType<C>::GetInstance(vm, 1);
4647 
4648  Var<A1> a1(vm, 2);
4649  Var<A2> a2(vm, 3);
4650  Var<A3> a3(vm, 4);
4651  Var<A4> a4(vm, 5);
4652  Var<A5> a5(vm, 6);
4653  Var<A6> a6(vm, 7);
4654  Var<A7> a7(vm, 8);
4655  Var<A8> a8(vm, 9);
4656  Var<A9> a9(vm, 10);
4657  Var<A10> a10(vm, 11);
4658  Var<A11> a11(vm, 12);
4659  Var<A12> a12(vm, 13);
4660  Var<A13> a13(vm, 14);
4661 
4662 #if !defined (SCRAT_NO_ERROR_CHECKING)
4663  if (Error::Instance().Occurred(vm)) {
4664  if (overloaded)
4665  return 0;
4666  else
4667  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4668  }
4669 #endif
4670 
4671  (ptr->*method)(
4672  a1.value,
4673  a2.value,
4674  a3.value,
4675  a4.value,
4676  a5.value,
4677  a6.value,
4678  a7.value,
4679  a8.value,
4680  a9.value,
4681  a10.value,
4682  a11.value,
4683  a12.value,
4684  a13.value
4685  );
4686 #if !defined (SCRAT_NO_ERROR_CHECKING)
4687  if (!overloaded && Error::Instance().Occurred(vm)) {
4688  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4689  }
4690 #endif
4691  return 0;
4692  }
4693 
4694  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, bool overloaded /*= false*/>
4695  static SQInteger Func13C(HSQUIRRELVM vm) {
4696 
4697 #if !defined (SCRAT_NO_ERROR_CHECKING)
4698  if (!overloaded && sq_gettop(vm) != 15) {
4699  return sq_throwerror(vm, _SC("wrong number of parameters"));
4700  }
4701 #endif
4702  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const;
4703  M* methodPtr;
4704  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4705  M method = *methodPtr;
4706 
4707  C* ptr = ClassType<C>::GetInstance(vm, 1);
4708 
4709  Var<A1> a1(vm, 2);
4710  Var<A2> a2(vm, 3);
4711  Var<A3> a3(vm, 4);
4712  Var<A4> a4(vm, 5);
4713  Var<A5> a5(vm, 6);
4714  Var<A6> a6(vm, 7);
4715  Var<A7> a7(vm, 8);
4716  Var<A8> a8(vm, 9);
4717  Var<A9> a9(vm, 10);
4718  Var<A10> a10(vm, 11);
4719  Var<A11> a11(vm, 12);
4720  Var<A12> a12(vm, 13);
4721  Var<A13> a13(vm, 14);
4722 
4723 #if !defined (SCRAT_NO_ERROR_CHECKING)
4724  if (Error::Instance().Occurred(vm)) {
4725  if (overloaded)
4726  return 0;
4727  else
4728  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4729  }
4730 #endif
4731 
4732  (ptr->*method)(
4733  a1.value,
4734  a2.value,
4735  a3.value,
4736  a4.value,
4737  a5.value,
4738  a6.value,
4739  a7.value,
4740  a8.value,
4741  a9.value,
4742  a10.value,
4743  a11.value,
4744  a12.value,
4745  a13.value
4746  );
4747 #if !defined (SCRAT_NO_ERROR_CHECKING)
4748  if (!overloaded && Error::Instance().Occurred(vm)) {
4749  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4750  }
4751 #endif
4752  return 0;
4753  }
4754 
4755  // Arg Count 14
4756  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, bool overloaded /*= false*/ >
4757  static SQInteger Func14(HSQUIRRELVM vm) {
4758 
4759 #if !defined (SCRAT_NO_ERROR_CHECKING)
4760  if (!overloaded && sq_gettop(vm) != 16) {
4761  return sq_throwerror(vm, _SC("wrong number of parameters"));
4762  }
4763 #endif
4764  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
4765  M* methodPtr;
4766  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4767  M method = *methodPtr;
4768 
4769  C* ptr = ClassType<C>::GetInstance(vm, 1);
4770 
4771  Var<A1> a1(vm, 2);
4772  Var<A2> a2(vm, 3);
4773  Var<A3> a3(vm, 4);
4774  Var<A4> a4(vm, 5);
4775  Var<A5> a5(vm, 6);
4776  Var<A6> a6(vm, 7);
4777  Var<A7> a7(vm, 8);
4778  Var<A8> a8(vm, 9);
4779  Var<A9> a9(vm, 10);
4780  Var<A10> a10(vm, 11);
4781  Var<A11> a11(vm, 12);
4782  Var<A12> a12(vm, 13);
4783  Var<A13> a13(vm, 14);
4784  Var<A14> a14(vm, 15);
4785 
4786 #if !defined (SCRAT_NO_ERROR_CHECKING)
4787  if (Error::Instance().Occurred(vm)) {
4788  if (overloaded)
4789  return 0;
4790  else
4791  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4792  }
4793 #endif
4794 
4795  (ptr->*method)(
4796  a1.value,
4797  a2.value,
4798  a3.value,
4799  a4.value,
4800  a5.value,
4801  a6.value,
4802  a7.value,
4803  a8.value,
4804  a9.value,
4805  a10.value,
4806  a11.value,
4807  a12.value,
4808  a13.value,
4809  a14.value
4810  );
4811 #if !defined (SCRAT_NO_ERROR_CHECKING)
4812  if (!overloaded && Error::Instance().Occurred(vm)) {
4813  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4814  }
4815 #endif
4816  return 0;
4817  }
4818 
4819  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, bool overloaded /*= false*/ >
4820  static SQInteger Func14C(HSQUIRRELVM vm) {
4821 
4822 #if !defined (SCRAT_NO_ERROR_CHECKING)
4823  if (!overloaded && sq_gettop(vm) != 16) {
4824  return sq_throwerror(vm, _SC("wrong number of parameters"));
4825  }
4826 #endif
4827  typedef void (C::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const;
4828  M* methodPtr;
4829  sq_getuserdata(vm, -1, (SQUserPointer*)&methodPtr, NULL);
4830  M method = *methodPtr;
4831 
4832  C* ptr = ClassType<C>::GetInstance(vm, 1);
4833 
4834  Var<A1> a1(vm, 2);
4835  Var<A2> a2(vm, 3);
4836  Var<A3> a3(vm, 4);
4837  Var<A4> a4(vm, 5);
4838  Var<A5> a5(vm, 6);
4839  Var<A6> a6(vm, 7);
4840  Var<A7> a7(vm, 8);
4841  Var<A8> a8(vm, 9);
4842  Var<A9> a9(vm, 10);
4843  Var<A10> a10(vm, 11);
4844  Var<A11> a11(vm, 12);
4845  Var<A12> a12(vm, 13);
4846  Var<A13> a13(vm, 14);
4847  Var<A14> a14(vm, 15);
4848 
4849 #if !defined (SCRAT_NO_ERROR_CHECKING)
4850  if (Error::Instance().Occurred(vm)) {
4851  if (overloaded)
4852  return 0;
4853  else
4854  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
4855  }
4856 #endif
4857 
4858  (ptr->*method)(
4859  a1.value,
4860  a2.value,
4861  a3.value,
4862  a4.value,
4863  a5.value,
4864  a6.value,
4865  a7.value,
4866  a8.value,
4867  a9.value,
4868  a10.value,
4869  a11.value,
4870  a12.value,
4871  a13.value,
4872  a14.value
4873  );
4874 #if !defined (SCRAT_NO_ERROR_CHECKING)
4875  if (!overloaded && Error::Instance().Occurred(vm)) {
4876  return sq_throwerror(vm, Sqrat::Error::Instance().Message(vm).c_str());
4877  }
4878 #endif
4879  return 0;
4880  }
4881 
4882 };
4883 
4884 
4885 //
4886 // Member Function Resolvers
4887 //
4888 
4889 // Arg Count 0
4890 template <class C, class R>
4891 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)()) {
4892  return &SqMember<C, R>::template Func0<false>;
4893 }
4894 
4895 template <class C, class R>
4896 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)() const) {
4897  return &SqMember<C, R>::template Func0C<false>;
4898 }
4899 
4900 template <class C, class R>
4901 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)()) {
4902  return &SqMember<C, R& >::template Func0<false>;
4903 }
4904 
4905 template <class C, class R>
4906 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)() const) {
4907  return &SqMember<C, R& >::template Func0C<false>;
4908 }
4909 
4910 // Arg Count 1
4911 template <class C, class R, class A1>
4912 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1)) {
4913  return &SqMember<C, R>::template Func1<A1, false>;
4914 }
4915 
4916 template <class C, class R, class A1>
4917 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1) const) {
4918  return &SqMember<C, R>::template Func1C<A1, false>;
4919 }
4920 
4921 template <class C, class R, class A1>
4922 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1)) {
4923  return &SqMember<C, R& >::template Func1<A1, false>;
4924 }
4925 
4926 template <class C, class R, class A1>
4927 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1) const) {
4928  return &SqMember<C, R& >::template Func1C<A1, false>;
4929 }
4930 
4931 // Arg Count 2
4932 template <class C, class R, class A1, class A2>
4933 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2)) {
4934  return &SqMember<C, R>::template Func2<A1, A2, false>;
4935 }
4936 
4937 template <class C, class R, class A1, class A2>
4938 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2) const) {
4939  return &SqMember<C, R>::template Func2C<A1, A2, false>;
4940 }
4941 
4942 template <class C, class R, class A1, class A2>
4943 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2)) {
4944  return &SqMember<C, R& >::template Func2<A1, A2, false>;
4945 }
4946 
4947 template <class C, class R, class A1, class A2>
4948 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2) const) {
4949  return &SqMember<C, R&>::template Func2C<A1, A2, false>;
4950 }
4951 
4952 // Arg Count 3
4953 template <class C, class R, class A1, class A2, class A3>
4954 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3)) {
4955  return &SqMember<C, R>::template Func3<A1, A2, A3, false>;
4956 }
4957 
4958 template <class C, class R, class A1, class A2, class A3>
4959 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3) const) {
4960  return &SqMember<C, R>::template Func3C<A1, A2, A3, false>;
4961 }
4962 
4963 template <class C, class R, class A1, class A2, class A3>
4964 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3)) {
4965  return &SqMember<C, R& >::template Func3<A1, A2, A3, false>;
4966 }
4967 
4968 template <class C, class R, class A1, class A2, class A3>
4969 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3) const) {
4970  return &SqMember<C, R& >::template Func3C<A1, A2, A3, false>;
4971 }
4972 
4973 // Arg Count 4
4974 template <class C, class R, class A1, class A2, class A3, class A4>
4975 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4)) {
4976  return &SqMember<C, R>::template Func4<A1, A2, A3, A4, false>;
4977 }
4978 
4979 template <class C, class R, class A1, class A2, class A3, class A4>
4980 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4) const) {
4981  return &SqMember<C, R>::template Func4C<A1, A2, A3, A4, false>;
4982 }
4983 
4984 template <class C, class R, class A1, class A2, class A3, class A4>
4985 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4)) {
4986  return &SqMember<C, R& >::template Func4<A1, A2, A3, A4, false>;
4987 }
4988 
4989 template <class C, class R, class A1, class A2, class A3, class A4>
4990 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4) const) {
4991  return &SqMember<C, R&>::template Func4C<A1, A2, A3, A4, false>;
4992 }
4993 
4994 // Arg Count 5
4995 template <class C, class R, class A1, class A2, class A3, class A4, class A5>
4996 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5)) {
4997  return &SqMember<C, R>::template Func5<A1, A2, A3, A4, A5, false>;
4998 }
4999 
5000 template <class C, class R, class A1, class A2, class A3, class A4, class A5>
5001 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5) const) {
5002  return &SqMember<C, R>::template Func5C<A1, A2, A3, A4, A5, false>;
5003 }
5004 
5005 template <class C, class R, class A1, class A2, class A3, class A4, class A5>
5006 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5)) {
5007  return &SqMember<C, R& >::template Func5<A1, A2, A3, A4, A5, false>;
5008 }
5009 
5010 template <class C, class R, class A1, class A2, class A3, class A4, class A5>
5011 inline SQFUNCTION SqMemberFunc(R &(C::*/*method*/)(A1, A2, A3, A4, A5) const) {
5012  return &SqMember<C, R& >::template Func5C<A1, A2, A3, A4, A5, false>;
5013 }
5014 
5015 // Arg Count 6
5016 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6>
5017 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6)) {
5018  return &SqMember<C, R>::template Func6<A1, A2, A3, A4, A5, A6, false>;
5019 }
5020 
5021 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6>
5022 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6) const) {
5023  return &SqMember<C, R>::template Func6C<A1, A2, A3, A4, A5, A6, false>;
5024 }
5025 
5026 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6>
5027 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6)) {
5028  return &SqMember<C, R& >::template Func6<A1, A2, A3, A4, A5, A6, false>;
5029 }
5030 
5031 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6>
5032 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6) const) {
5033  return &SqMember<C, R& >::template Func6C<A1, A2, A3, A4, A5, A6, false>;
5034 }
5035 
5036 // Arg Count 7
5037 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
5038 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7)) {
5039  return &SqMember<C, R>::template Func7<A1, A2, A3, A4, A5, A6, A7, false>;
5040 }
5041 
5042 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
5043 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7) const) {
5044  return &SqMember<C, R>::template Func7C<A1, A2, A3, A4, A5, A6, A7, false>;
5045 }
5046 
5047 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
5048 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7)) {
5049  return &SqMember<C, R& >::template Func7<A1, A2, A3, A4, A5, A6, A7, false>;
5050 }
5051 
5052 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
5053 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7) const) {
5054  return &SqMember<C, R& >::template Func7C<A1, A2, A3, A4, A5, A6, A7, false>;
5055 }
5056 
5057 // Arg Count 8
5058 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
5059 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8)) {
5060  return &SqMember<C, R>::template Func8<A1, A2, A3, A4, A5, A6, A7, A8, false>;
5061 }
5062 
5063 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
5064 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8) const) {
5065  return &SqMember<C, R>::template Func8C<A1, A2, A3, A4, A5, A6, A7, A8, false>;
5066 }
5067 
5068 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
5069 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8)) {
5070  return &SqMember<C, R& >::template Func8<A1, A2, A3, A4, A5, A6, A7, A8, false>;
5071 }
5072 
5073 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
5074 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8) const) {
5075  return &SqMember<C, R& >::template Func8C<A1, A2, A3, A4, A5, A6, A7, A8, false>;
5076 }
5077 
5078 // Arg Count 9
5079 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
5080 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) {
5081  return &SqMember<C, R>::template Func9<A1, A2, A3, A4, A5, A6, A7, A8, A9, false>;
5082 }
5083 
5084 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
5085 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) {
5086  return &SqMember<C, R>::template Func9C<A1, A2, A3, A4, A5, A6, A7, A8, A9, false>;
5087 }
5088 
5089 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
5090 inline SQFUNCTION SqMemberFunc(R &(C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) {
5091  return &SqMember<C, R& >::template Func9<A1, A2, A3, A4, A5, A6, A7, A8, A9, false>;
5092 }
5093 
5094 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
5095 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) {
5096  return &SqMember<C, R& >::template Func9C<A1, A2, A3, A4, A5, A6, A7, A8, A9, false>;
5097 }
5098 
5099 // Arg Count 10
5100 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
5101 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) {
5102  return &SqMember<C, R>::template Func10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, false>;
5103 }
5104 
5105 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
5106 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) {
5107  return &SqMember<C, R>::template Func10C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, false>;
5108 }
5109 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
5110 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) {
5111  return &SqMember<C, R& >::template Func10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, false>;
5112 }
5113 
5114 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
5115 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) {
5116  return &SqMember<C, R& >::template Func10C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, false>;
5117 }
5118 
5119 // Arg Count 11
5120 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
5121 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) {
5122  return &SqMember<C, R>::template Func11<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, false>;
5123 }
5124 
5125 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
5126 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const) {
5127  return &SqMember<C, R>::template Func11C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, false>;
5128 }
5129 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
5130 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) {
5131  return &SqMember<C, R& >::template Func11<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, false>;
5132 }
5133 
5134 template <class C, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
5135 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const) {
5136  return &SqMember<C, R& >::template Func11C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, false>;
5137 }
5138 
5139 // Arg Count 12
5140 template <class C, 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>
5141 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) {
5142  return &SqMember<C, R>::template Func12<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, false>;
5143 }
5144 
5145 template <class C, 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>
5146 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const) {
5147  return &SqMember<C, R>::template Func12C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, false>;
5148 }
5149 
5150 template <class C, 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>
5151 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) {
5152  return &SqMember<C, R& >::template Func12<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, false>;
5153 }
5154 
5155 template <class C, 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>
5156 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const) {
5157  return &SqMember<C, R& >::template Func12C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, false>;
5158 }
5159 
5160 // Arg Count 13
5161 template <class C, 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>
5162 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) {
5163  return &SqMember<C, R>::template Func13<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, false>;
5164 }
5165 
5166 template <class C, 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>
5167 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const) {
5168  return &SqMember<C, R>::template Func13C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, false>;
5169 }
5170 
5171 template <class C, 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>
5172 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) {
5173  return &SqMember<C, R & >::template Func13<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, false>;
5174 }
5175 
5176 template <class C, 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>
5177 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const) {
5178  return &SqMember<C, R & >::template Func13C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, false>;
5179 }
5180 
5181 // Arg Count 14
5182 template <class C, 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>
5183 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) {
5184  return &SqMember<C, R>::template Func14<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, false>;
5185 }
5186 
5187 template <class C, 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>
5188 inline SQFUNCTION SqMemberFunc(R (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const) {
5189  return &SqMember<C, R>::template Func14C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, false>;
5190 }
5191 
5192 template <class C, 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>
5193 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) {
5194  return &SqMember<C, R& >::template Func14<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, false>;
5195 }
5196 
5197 template <class C, 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>
5198 inline SQFUNCTION SqMemberFunc(R & (C::*/*method*/)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const) {
5199  return &SqMember<C, R& >::template Func14C<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, false>;
5200 }
5201 
5202 
5203 //
5204 // Variable Get
5205 //
5206 
5207 template <class C, class V>
5208 inline SQInteger sqDefaultGet(HSQUIRRELVM vm) {
5209  C* ptr = ClassType<C>::GetInstance(vm, 1);
5210 
5211  typedef V C::*M;
5212  M* memberPtr = NULL;
5213  sq_getuserdata(vm, -1, (SQUserPointer*)&memberPtr, NULL); // Get Member...
5214  M member = *memberPtr;
5215 
5216  PushVar(vm, ptr->*member);
5217 
5218  return 1;
5219 }
5220 
5221 
5222 template <class C, class V>
5223 inline SQInteger sqStaticGet(HSQUIRRELVM vm) {
5224  typedef V *M;
5225  M* memberPtr = NULL;
5226  sq_getuserdata(vm, -1, (SQUserPointer*)&memberPtr, NULL); // Get Member...
5227  M member = *memberPtr;
5228 
5229  PushVar(vm, *member);
5230 
5231  return 1;
5232 }
5233 
5234 
5235 inline SQInteger sqVarGet(HSQUIRRELVM vm) {
5236  // Find the get method in the get table
5237  sq_push(vm, 2);
5238 #if !defined (SCRAT_NO_ERROR_CHECKING)
5239  if (SQ_FAILED( sq_get(vm,-2) )) {
5240 #if (SQUIRREL_VERSION_NUMBER >= 200) && (SQUIRREL_VERSION_NUMBER < 300) // Squirrel 2.x
5241  return sq_throwerror(vm,_SC("member variable not found"));
5242 #else // Squirrel 3.x
5243  sq_pushnull(vm);
5244  return sq_throwobject(vm);
5245 #endif
5246  }
5247 #else
5248  sq_get(vm,-2);
5249 #endif
5250 
5251  // push 'this'
5252  sq_push(vm, 1);
5253 
5254  // Call the getter
5255  sq_call(vm, 1, true, ErrorHandling::IsEnabled());
5256 #if !defined (SCRAT_NO_ERROR_CHECKING)
5257  if (Error::Instance().Occurred(vm)) {
5258  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
5259  }
5260 #endif
5261 
5262  return 1;
5263 }
5264 
5265 
5266 //
5267 // Variable Set
5268 //
5269 
5270 template <class C, class V>
5271 inline SQInteger sqDefaultSet(HSQUIRRELVM vm) {
5272  C* ptr = ClassType<C>::GetInstance(vm, 1);
5273 
5274  typedef V C::*M;
5275  M* memberPtr = NULL;
5276  sq_getuserdata(vm, -1, (SQUserPointer*)&memberPtr, NULL); // Get Member...
5277  M member = *memberPtr;
5278 
5279  ptr->*member = Var<V>(vm, 2).value;
5280  return 0;
5281 }
5282 
5283 template <class C, class V>
5284 inline SQInteger sqStaticSet(HSQUIRRELVM vm) {
5285  typedef V *M;
5286  M* memberPtr = NULL;
5287  sq_getuserdata(vm, -1, (SQUserPointer*)&memberPtr, NULL); // Get Member...
5288  M member = *memberPtr;
5289 
5290  *member = Var<V>(vm, 2).value;
5291  return 0;
5292 }
5293 
5294 inline SQInteger sqVarSet(HSQUIRRELVM vm) {
5295  // Find the set method in the set table
5296  sq_push(vm, 2);
5297 #if !defined (SCRAT_NO_ERROR_CHECKING)
5298  if (SQ_FAILED( sq_get(vm,-2) )) {
5299 #if (SQUIRREL_VERSION_NUMBER >= 200) && (SQUIRREL_VERSION_NUMBER < 300) // Squirrel 2.x
5300  return sq_throwerror(vm,_SC("member variable not found"));
5301 #else // Squirrel 3.x
5302  sq_pushnull(vm);
5303  return sq_throwobject(vm);
5304 #endif
5305  }
5306 #else
5307  sq_get(vm,-2);
5308 #endif
5309 
5310  // push 'this'
5311  sq_push(vm, 1);
5312  sq_push(vm, 3);
5313 
5314  // Call the setter
5315  sq_call(vm, 2, false, ErrorHandling::IsEnabled());
5316 #if !defined (SCRAT_NO_ERROR_CHECKING)
5317  if (Error::Instance().Occurred(vm)) {
5318  return sq_throwerror(vm, Error::Instance().Message(vm).c_str());
5319  }
5320 #endif
5321 
5322  return 0;
5323 }
5324 
5325 #if !defined (SCRAT_NO_ERROR_CHECKING)
5326 template <class C, class R>
5327 const SQChar SqMember<C, R>::STATICCALLERROR[] = _SC("this function isn't static");
5328 template <class C, class R>
5329 const SQChar SqMember<C, R&>::STATICCALLERROR[] = _SC("this function isn't static");
5330 #endif
5331 
5333 
5334 }
5335 
5336 #endif
Sqrat::ErrorHandling::IsEnabled
static bool IsEnabled()
Definition: sqratUtil.h:244
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