src/script/squirrel_helper.hpp

   1 /* $Id: squirrel_helper.hpp 23735 2012-01-03 20:26:05Z rubidium $ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file squirrel_helper.hpp declarations and parts of the implementation of the class for convert code */
  11
  12 #ifndef SQUIRREL_HELPER_HPP
  13 #define SQUIRREL_HELPER_HPP
  14
  15 #include "squirrel.hpp"
  16 #include "../core/smallvec_type.hpp"
  17 #include "../economy_type.h"
  18 #include "../string_func.h"
  19 #include "squirrel_helper_type.hpp"
  20
  21 template <class CL, ScriptType ST> const char *GetClassName();
  22
  23 /**
  24  * The Squirrel convert routines
  25  */
  26 namespace SQConvert {
  27         /**
  28          * Pointers assigned to this class will be free'd when this instance
  29          *  comes out of scope. Useful to make sure you can use stredup(),
  30          *  without leaking memory.
  31          */
  32         struct SQAutoFreePointers : SmallVector<void *, 1> {
  33                 ~SQAutoFreePointers()
  34                 {
  35                         for (uint i = 0; i < this->items; i++) free(this->data[i]);
  36                 }
  37         };
  38
  39         template <bool Y> struct YesT {
  40                 static const bool Yes = Y;
  41                 static const bool No = !Y;
  42         };
  43
  44         /**
  45          * Helper class to recognize if the given type is void. Usage: 'IsVoidT<T>::Yes'
  46          */
  47         template <typename T> struct IsVoidT : YesT<false> {};
  48         template <> struct IsVoidT<void> : YesT<true> {};
  49
  50         /**
  51          * Helper class to recognize if the function/method return type is void.
  52          */
  53         template <typename Tfunc> struct HasVoidReturnT;
  54         /* functions */
  55         template <typename Tretval> struct HasVoidReturnT<Tretval (*)()> : IsVoidT<Tretval> {};
  56         template <typename Tretval, typename Targ1> struct HasVoidReturnT<Tretval (*)(Targ1)> : IsVoidT<Tretval> {};
  57         template <typename Tretval, typename Targ1, typename Targ2> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2)> : IsVoidT<Tretval> {};
  58         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2, Targ3)> : IsVoidT<Tretval> {};
  59         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2, Targ3, Targ4)> : IsVoidT<Tretval> {};
  60         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5)> : IsVoidT<Tretval> {};
  61         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5, typename Targ6, typename Targ7, typename Targ8, typename Targ9, typename Targ10> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10)> : IsVoidT<Tretval> {};
  62         /* methods */
  63         template <class Tcls, typename Tretval> struct HasVoidReturnT<Tretval (Tcls::*)()> : IsVoidT<Tretval> {};
  64         template <class Tcls, typename Tretval, typename Targ1> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1)> : IsVoidT<Tretval> {};
  65         template <class Tcls, typename Tretval, typename Targ1, typename Targ2> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2)> : IsVoidT<Tretval> {};
  66         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2, Targ3)> : IsVoidT<Tretval> {};
  67         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4)> : IsVoidT<Tretval> {};
  68         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5)> : IsVoidT<Tretval> {};
  69         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5, typename Targ6, typename Targ7, typename Targ8, typename Targ9, typename Targ10> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10)> : IsVoidT<Tretval> {};
  70
  71
  72         /**
  73          * Special class to make it possible for the compiler to pick the correct GetParam().
  74          */
  75         template <typename T> class ForceType { };
  76
  77         /**
  78          * To return a value to squirrel, we call this function. It converts to the right format.
  79          */
  80         template <typename T> static int Return(HSQUIRRELVM vm, T t);
  81
  82         template <> inline int Return<uint8>       (HSQUIRRELVM vm, uint8 res)       { sq_pushinteger(vm, (int32)res); return 1; }
  83         template <> inline int Return<uint16>      (HSQUIRRELVM vm, uint16 res)      { sq_pushinteger(vm, (int32)res); return 1; }
  84         template <> inline int Return<uint32>      (HSQUIRRELVM vm, uint32 res)      { sq_pushinteger(vm, (int32)res); return 1; }
  85         template <> inline int Return<int8>        (HSQUIRRELVM vm, int8 res)        { sq_pushinteger(vm, res); return 1; }
  86         template <> inline int Return<int16>       (HSQUIRRELVM vm, int16 res)       { sq_pushinteger(vm, res); return 1; }
  87         template <> inline int Return<int32>       (HSQUIRRELVM vm, int32 res)       { sq_pushinteger(vm, res); return 1; }
  88         template <> inline int Return<int64>       (HSQUIRRELVM vm, int64 res)       { sq_pushinteger(vm, res); return 1; }
  89         template <> inline int Return<Money>       (HSQUIRRELVM vm, Money res)       { sq_pushinteger(vm, res); return 1; }
  90         template <> inline int Return<bool>        (HSQUIRRELVM vm, bool res)        { sq_pushbool   (vm, res); return 1; }
  91         template <> inline int Return<char *>      (HSQUIRRELVM vm, char *res)       { if (res == NULL) sq_pushnull(vm); else { sq_pushstring(vm, res, -1); free(res); } return 1; }
  92         template <> inline int Return<const char *>(HSQUIRRELVM vm, const char *res) { if (res == NULL) sq_pushnull(vm); else { sq_pushstring(vm, res, -1); } return 1; }
  93         template <> inline int Return<void *>      (HSQUIRRELVM vm, void *res)       { sq_pushuserpointer(vm, res); return 1; }
  94         template <> inline int Return<HSQOBJECT>   (HSQUIRRELVM vm, HSQOBJECT res)   { sq_pushobject(vm, res); return 1; }
  95
  96         /**
  97          * To get a param from squirrel, we call this function. It converts to the right format.
  98          */
  99         template <typename T> static T GetParam(ForceType<T>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr);
 100
 101         template <> inline uint8       GetParam(ForceType<uint8>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 102         template <> inline uint16      GetParam(ForceType<uint16>      , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 103         template <> inline uint32      GetParam(ForceType<uint32>      , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 104         template <> inline int8        GetParam(ForceType<int8>        , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 105         template <> inline int16       GetParam(ForceType<int16>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 106         template <> inline int32       GetParam(ForceType<int32>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 107         template <> inline int64       GetParam(ForceType<int64>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 108         template <> inline Money       GetParam(ForceType<Money>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 109         template <> inline bool        GetParam(ForceType<bool>        , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQBool        tmp; sq_getbool       (vm, index, &tmp); return tmp != 0; }
 110         template <> inline void       *GetParam(ForceType<void *>      , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer tmp; sq_getuserpointer(vm, index, &tmp); return tmp; }
 111         template <> inline const char *GetParam(ForceType<const char *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr)
 112         {
 113                 /* Convert what-ever there is as parameter to a string */
 114                 sq_tostring(vm, index);
 115
 116                 const SQChar *tmp;
 117                 sq_getstring(vm, -1, &tmp);
 118                 char *tmp_str = stredup(tmp);
 119                 sq_poptop(vm);
 120                 *ptr->Append() = (void *)tmp_str;
 121                 str_validate(tmp_str, tmp_str + strlen(tmp_str));
 122                 return tmp_str;
 123         }
 124
 125         template <> inline Array      *GetParam(ForceType<Array *>,      HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr)
 126         {
 127                 /* Sanity check of the size. */
 128                 if (sq_getsize(vm, index) > UINT16_MAX) throw sq_throwerror(vm, "an array used as parameter to a function is too large");
 129
 130                 SQObject obj;
 131                 sq_getstackobj(vm, index, &obj);
 132                 sq_pushobject(vm, obj);
 133                 sq_pushnull(vm);
 134
 135                 SmallVector<int32, 2> data;
 136
 137                 while (SQ_SUCCEEDED(sq_next(vm, -2))) {
 138                         SQInteger tmp;
 139                         if (SQ_SUCCEEDED(sq_getinteger(vm, -1, &tmp))) {
 140                                 *data.Append() = (int32)tmp;
 141                         } else {
 142                                 sq_pop(vm, 4);
 143                                 throw sq_throwerror(vm, "a member of an array used as parameter to a function is not numeric");
 144                         }
 145
 146                         sq_pop(vm, 2);
 147                 }
 148                 sq_pop(vm, 2);
 149
 150                 Array *arr = (Array*)MallocT<byte>(sizeof(Array) + sizeof(int32) * data.Length());
 151                 arr->size = data.Length();
 152                 memcpy(arr->array, data.Begin(), sizeof(int32) * data.Length());
 153
 154                 *ptr->Append() = arr;
 155                 return arr;
 156         }
 157
 158         /**
 159          * Helper class to recognize the function type (retval type, args) and use the proper specialization
 160          * for SQ callback. The partial specializations for the second arg (Tis_void_retval) are not possible
 161          * on the function. Therefore the class is used instead.
 162          */
 163         template <typename Tfunc, bool Tis_void_retval = HasVoidReturnT<Tfunc>::Yes> struct HelperT;
 164
 165         /**
 166          * The real C++ caller for function with return value and 0 params.
 167          */
 168         template <typename Tretval>
 169         struct HelperT<Tretval (*)(), false> {
 170                 static int SQCall(void *instance, Tretval (*func)(), HSQUIRRELVM vm)
 171                 {
 172                         return Return(vm, (*func)());
 173                 }
 174         };
 175
 176         /**
 177          * The real C++ caller for function with no return value and 0 params.
 178          */
 179         template <typename Tretval>
 180         struct HelperT<Tretval (*)(), true> {
 181                 static int SQCall(void *instance, Tretval (*func)(), HSQUIRRELVM vm)
 182                 {
 183                         (*func)();
 184                         return 0;
 185                 }
 186         };
 187
 188         /**
 189          * The real C++ caller for method with return value and 0 params.
 190          */
 191         template <class Tcls, typename Tretval>
 192         struct HelperT<Tretval (Tcls::*)(), false> {
 193                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(), HSQUIRRELVM vm)
 194                 {
 195                         return Return(vm, (instance->*func)());
 196                 }
 197         };
 198
 199         /**
 200          * The real C++ caller for method with no return value and 0 params.
 201          */
 202         template <class Tcls, typename Tretval>
 203         struct HelperT<Tretval (Tcls::*)(), true> {
 204                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(), HSQUIRRELVM vm)
 205                 {
 206                         (instance->*func)();
 207                         return 0;
 208                 }
 209
 210                 static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(), HSQUIRRELVM vm)
 211                 {
 212                         return new Tcls();
 213                 }
 214         };
 215
 216         /**
 217          * The real C++ caller for function with return value and 1 param.
 218          */
 219         template <typename Tretval, typename Targ1>
 220         struct HelperT<Tretval (*)(Targ1), false> {
 221                 static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
 222                 {
 223                         SQAutoFreePointers ptr;
 224                         Tretval ret = (*func)(
 225                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 226                         );
 227                         return Return(vm, ret);
 228                 }
 229         };
 230
 231         /**
 232          * The real C++ caller for function with no return value and 1 param.
 233          */
 234         template <typename Tretval, typename Targ1>
 235         struct HelperT<Tretval (*)(Targ1), true> {
 236                 static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
 237                 {
 238                         SQAutoFreePointers ptr;
 239                         (*func)(
 240                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 241                         );
 242                         return 0;
 243                 }
 244         };
 245
 246         /**
 247          * The real C++ caller for method with return value and 1 param.
 248          */
 249         template <class Tcls, typename Tretval, typename Targ1>
 250         struct HelperT<Tretval (Tcls::*)(Targ1), false> {
 251                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 252                 {
 253                         SQAutoFreePointers ptr;
 254                         Tretval ret = (instance->*func)(
 255                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 256                         );
 257                         return Return(vm, ret);
 258                 }
 259         };
 260
 261         /**
 262          * The real C++ caller for method with no return value and 1 param.
 263          */
 264         template <class Tcls, typename Tretval, typename Targ1>
 265         struct HelperT<Tretval (Tcls::*)(Targ1), true> {
 266                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 267                 {
 268                         SQAutoFreePointers ptr;
 269                         (instance->*func)(
 270                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 271                         );
 272                         return 0;
 273                 }
 274
 275                 static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 276                 {
 277                         SQAutoFreePointers ptr;
 278                         Tcls *inst = new Tcls(
 279                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 280                         );
 281
 282                         return inst;
 283                 }
 284         };
 285
 286         /**
 287          * The real C++ caller for function with return value and 2 params.
 288          */
 289         template <typename Tretval, typename Targ1, typename Targ2>
 290         struct HelperT<Tretval (*)(Targ1, Targ2), false> {
 291                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)
 292                 {
 293                         SQAutoFreePointers ptr;
 294                         Tretval ret = (*func)(
 295                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 296                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 297                         );
 298                         return Return(vm, ret);
 299                 }
 300         };
 301
 302         /**
 303          * The real C++ caller for function with no return value and 2 params.
 304          */
 305         template <typename Tretval, typename Targ1, typename Targ2>
 306         struct HelperT<Tretval (*)(Targ1, Targ2), true> {
 307                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)
 308                 {
 309                         SQAutoFreePointers ptr;
 310                         (*func)(
 311                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 312                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 313                         );
 314                         return 0;
 315                 }
 316         };
 317
 318         /**
 319          * The real C++ caller for method with return value and 2 params.
 320          */
 321         template <class Tcls, typename Tretval, typename Targ1, typename Targ2>
 322         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), false> {
 323                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 324                 {
 325                         SQAutoFreePointers ptr;
 326                         Tretval ret = (instance->*func)(
 327                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 328                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 329                         );
 330                         return Return(vm, ret);
 331                 }
 332         };
 333
 334         /**
 335          * The real C++ caller for method with no return value and 2 params.
 336          */
 337         template <class Tcls, typename Tretval, typename Targ1, typename Targ2>
 338         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), true> {
 339                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 340                 {
 341                         SQAutoFreePointers ptr;
 342                         (instance->*func)(
 343                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 344                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 345                         );
 346                         return 0;
 347                 }
 348
 349                 static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 350                 {
 351                         SQAutoFreePointers ptr;
 352                         Tcls *inst = new Tcls(
 353                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 354                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 355                         );
 356
 357                         return inst;
 358                 }
 359         };
 360
 361         /**
 362          * The real C++ caller for function with return value and 3 params.
 363          */
 364         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 365         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), false> {
 366                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 367                 {
 368                         SQAutoFreePointers ptr;
 369                         Tretval ret = (*func)(
 370                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 371                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 372                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 373                         );
 374                         return Return(vm, ret);
 375                 }
 376         };
 377
 378         /**
 379          * The real C++ caller for function with no return value and 3 params.
 380          */
 381         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 382         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), true> {
 383                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 384                 {
 385                         SQAutoFreePointers ptr;
 386                         (*func)(
 387                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 388                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 389                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 390                         );
 391                         return 0;
 392                 }
 393         };
 394
 395         /**
 396          * The real C++ caller for method with return value and 3 params.
 397          */
 398         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 399         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), false> {
 400                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 401                 {
 402                         SQAutoFreePointers ptr;
 403                         Tretval ret = (instance->*func)(
 404                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 405                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 406                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 407                         );
 408                         return Return(vm, ret);
 409                 }
 410         };
 411
 412         /**
 413          * The real C++ caller for method with no return value and 3 params.
 414          */
 415         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 416         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), true> {
 417                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 418                 {
 419                         SQAutoFreePointers ptr;
 420                         (instance->*func)(
 421                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 422                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 423                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 424                         );
 425                         return 0;
 426                 }
 427
 428                 static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 429                 {
 430                         SQAutoFreePointers ptr;
 431                         Tcls *inst = new Tcls(
 432                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 433                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 434                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 435                         );
 436
 437                         return inst;
 438                 }
 439         };
 440
 441         /**
 442          * The real C++ caller for function with return value and 4 params.
 443          */
 444         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 445         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), false> {
 446                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 447                 {
 448                         SQAutoFreePointers ptr;
 449                         Tretval ret = (*func)(
 450                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 451                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 452                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 453                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 454                         );
 455                         return Return(vm, ret);
 456                 }
 457         };
 458
 459         /**
 460          * The real C++ caller for function with no return value and 4 params.
 461          */
 462         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 463         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), true> {
 464                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 465                 {
 466                         SQAutoFreePointers ptr;
 467                         (*func)(
 468                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 469                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 470                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 471                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 472                         );
 473                         return 0;
 474                 }
 475         };
 476
 477         /**
 478          * The real C++ caller for method with return value and 4 params.
 479          */
 480         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 481         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), false> {
 482                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 483                 {
 484                         SQAutoFreePointers ptr;
 485                         Tretval ret = (instance->*func)(
 486                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 487                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 488                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 489                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 490                         );
 491                         return Return(vm, ret);
 492                 }
 493         };
 494
 495         /**
 496          * The real C++ caller for method with no return value and 4 params.
 497          */
 498         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 499         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), true> {
 500                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 501                 {
 502                         SQAutoFreePointers ptr;
 503                         (instance->*func)(
 504                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 505                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 506                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 507                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 508                         );
 509                         return 0;
 510                 }
 511
 512                 static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 513                 {
 514                         SQAutoFreePointers ptr;
 515                         Tcls *inst = new Tcls(
 516                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 517                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 518                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 519                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 520                         );
 521
 522                         return inst;
 523                 }
 524         };
 525
 526         /**
 527          * The real C++ caller for function with return value and 5 params.
 528          */
 529         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 530         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5), false> {
 531                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 532                 {
 533                         SQAutoFreePointers ptr;
 534                         Tretval ret = (*func)(
 535                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 536                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 537                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 538                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 539                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 540                         );
 541                         return Return(vm, ret);
 542                 }
 543         };
 544
 545         /**
 546          * The real C++ caller for function with no return value and 5 params.
 547          */
 548         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 549         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5), true> {
 550                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 551                 {
 552                         SQAutoFreePointers ptr;
 553                         (*func)(
 554                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 555                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 556                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 557                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 558                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 559                         );
 560                         return 0;
 561                 }
 562         };
 563
 564         /**
 565          * The real C++ caller for method with return value and 5 params.
 566          */
 567         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 568         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), false> {
 569                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 570                 {
 571                         SQAutoFreePointers ptr;
 572                         Tretval ret = (instance->*func)(
 573                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 574                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 575                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 576                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 577                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 578                         );
 579                         return Return(vm, ret);
 580                 }
 581         };
 582
 583         /**
 584          * The real C++ caller for method with no return value and 5 params.
 585          */
 586         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 587         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), true> {
 588                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 589                 {
 590                         SQAutoFreePointers ptr;
 591                         (instance->*func)(
 592                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 593                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 594                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 595                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 596                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 597                         );
 598                         return 0;
 599                 }
 600
 601                 static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 602                 {
 603                         SQAutoFreePointers ptr;
 604                         Tcls *inst = new Tcls(
 605                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 606                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 607                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 608                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 609                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 610                         );
 611
 612                         return inst;
 613                 }
 614         };
 615
 616         /**
 617          * The real C++ caller for function with return value and 10 params.
 618          */
 619         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5, typename Targ6, typename Targ7, typename Targ8, typename Targ9, typename Targ10>
 620         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), false> {
 621                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), HSQUIRRELVM vm)
 622                 {
 623                         SQAutoFreePointers ptr;
 624                         Tretval ret = (*func)(
 625                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 626                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 627                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 628                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 629                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr),
 630                                 GetParam(ForceType<Targ6>(), vm, 7, &ptr),
 631                                 GetParam(ForceType<Targ7>(), vm, 8, &ptr),
 632                                 GetParam(ForceType<Targ8>(), vm, 9, &ptr),
 633                                 GetParam(ForceType<Targ9>(), vm, 10, &ptr),
 634                                 GetParam(ForceType<Targ10>(), vm, 11, &ptr)
 635                         );
 636                         return Return(vm, ret);
 637                 }
 638         };
 639
 640         /**
 641          * The real C++ caller for function with no return value and 10 params.
 642          */
 643         template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5, typename Targ6, typename Targ7, typename Targ8, typename Targ9, typename Targ10>
 644         struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), true> {
 645                 static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), HSQUIRRELVM vm)
 646                 {
 647                         SQAutoFreePointers ptr;
 648                         (*func)(
 649                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 650                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 651                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 652                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 653                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr),
 654                                 GetParam(ForceType<Targ6>(), vm, 7, &ptr),
 655                                 GetParam(ForceType<Targ7>(), vm, 8, &ptr),
 656                                 GetParam(ForceType<Targ8>(), vm, 9, &ptr),
 657                                 GetParam(ForceType<Targ9>(), vm, 10, &ptr),
 658                                 GetParam(ForceType<Targ10>(), vm, 11, &ptr)
 659                         );
 660                         return 0;
 661                 }
 662         };
 663
 664         /**
 665          * The real C++ caller for method with return value and 10 params.
 666          */
 667         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5, typename Targ6, typename Targ7, typename Targ8, typename Targ9, typename Targ10>
 668         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), false> {
 669                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), HSQUIRRELVM vm)
 670                 {
 671                         SQAutoFreePointers ptr;
 672                         Tretval ret = (instance->*func)(
 673                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 674                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 675                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 676                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 677                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr),
 678                                 GetParam(ForceType<Targ6>(), vm, 7, &ptr),
 679                                 GetParam(ForceType<Targ7>(), vm, 8, &ptr),
 680                                 GetParam(ForceType<Targ8>(), vm, 9, &ptr),
 681                                 GetParam(ForceType<Targ9>(), vm, 10, &ptr),
 682                                 GetParam(ForceType<Targ10>(), vm, 11, &ptr)
 683                         );
 684                         return Return(vm, ret);
 685                 }
 686         };
 687
 688         /**
 689          * The real C++ caller for method with no return value and 10 params.
 690          */
 691         template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5, typename Targ6, typename Targ7, typename Targ8, typename Targ9, typename Targ10>
 692         struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), true> {
 693                 static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), HSQUIRRELVM vm)
 694                 {
 695                         SQAutoFreePointers ptr;
 696                         (instance->*func)(
 697                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 698                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 699                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 700                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 701                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr),
 702                                 GetParam(ForceType<Targ6>(), vm, 7, &ptr),
 703                                 GetParam(ForceType<Targ7>(), vm, 8, &ptr),
 704                                 GetParam(ForceType<Targ8>(), vm, 9, &ptr),
 705                                 GetParam(ForceType<Targ9>(), vm, 10, &ptr),
 706                                 GetParam(ForceType<Targ10>(), vm, 11, &ptr)
 707                         );
 708                         return 0;
 709                 }
 710
 711                 static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5, Targ6, Targ7, Targ8, Targ9, Targ10), HSQUIRRELVM vm)
 712                 {
 713                         SQAutoFreePointers ptr;
 714                         Tcls *inst = new Tcls(
 715                                 GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 716                                 GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 717                                 GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 718                                 GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 719                                 GetParam(ForceType<Targ5>(), vm, 6, &ptr),
 720                                 GetParam(ForceType<Targ6>(), vm, 7, &ptr),
 721                                 GetParam(ForceType<Targ7>(), vm, 8, &ptr),
 722                                 GetParam(ForceType<Targ8>(), vm, 9, &ptr),
 723                                 GetParam(ForceType<Targ9>(), vm, 10, &ptr),
 724                                 GetParam(ForceType<Targ10>(), vm, 11, &ptr)
 725                         );
 726
 727                         return inst;
 728                 }
 729         };
 730
 731
 732         /**
 733          * A general template for all non-static method callbacks from Squirrel.
 734          *  In here the function_proc is recovered, and the SQCall is called that
 735          *  can handle this exact amount of params.
 736          */
 737         template <typename Tcls, typename Tmethod, ScriptType Ttype>
 738         inline SQInteger DefSQNonStaticCallback(HSQUIRRELVM vm)
 739         {
 740                 /* Find the amount of params we got */
 741                 int nparam = sq_gettop(vm);
 742                 SQUserPointer ptr = NULL;
 743                 SQUserPointer real_instance = NULL;
 744                 HSQOBJECT instance;
 745
 746                 /* Get the 'SQ' instance of this class */
 747                 Squirrel::GetInstance(vm, &instance);
 748
 749                 /* Protect against calls to a non-static method in a static way */
 750                 sq_pushroottable(vm);
 751                 const char *className = GetClassName<Tcls, Ttype>();
 752                 sq_pushstring(vm, className, -1);
 753                 sq_get(vm, -2);
 754                 sq_pushobject(vm, instance);
 755                 if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, "class method is non-static");
 756                 sq_pop(vm, 3);
 757
 758                 /* Get the 'real' instance of this class */
 759                 sq_getinstanceup(vm, 1, &real_instance, 0);
 760                 /* Get the real function pointer */
 761                 sq_getuserdata(vm, nparam, &ptr, 0);
 762                 if (real_instance == NULL) return sq_throwerror(vm, "couldn't detect real instance of class for non-static call");
 763                 /* Remove the userdata from the stack */
 764                 sq_pop(vm, 1);
 765
 766                 try {
 767                         /* Delegate it to a template that can handle this specific function */
 768                         return HelperT<Tmethod>::SQCall((Tcls *)real_instance, *(Tmethod *)ptr, vm);
 769                 } catch (SQInteger e) {
 770                         return e;
 771                 }
 772         }
 773
 774         /**
 775          * A general template for all non-static advanced method callbacks from Squirrel.
 776          *  In here the function_proc is recovered, and the SQCall is called that
 777          *  can handle this exact amount of params.
 778          */
 779         template <typename Tcls, typename Tmethod, ScriptType Ttype>
 780         inline SQInteger DefSQAdvancedNonStaticCallback(HSQUIRRELVM vm)
 781         {
 782                 /* Find the amount of params we got */
 783                 int nparam = sq_gettop(vm);
 784                 SQUserPointer ptr = NULL;
 785                 SQUserPointer real_instance = NULL;
 786                 HSQOBJECT instance;
 787
 788                 /* Get the 'SQ' instance of this class */
 789                 Squirrel::GetInstance(vm, &instance);
 790
 791                 /* Protect against calls to a non-static method in a static way */
 792                 sq_pushroottable(vm);
 793                 const char *className = GetClassName<Tcls, Ttype>();
 794                 sq_pushstring(vm, className, -1);
 795                 sq_get(vm, -2);
 796                 sq_pushobject(vm, instance);
 797                 if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, "class method is non-static");
 798                 sq_pop(vm, 3);
 799
 800                 /* Get the 'real' instance of this class */
 801                 sq_getinstanceup(vm, 1, &real_instance, 0);
 802                 /* Get the real function pointer */
 803                 sq_getuserdata(vm, nparam, &ptr, 0);
 804                 if (real_instance == NULL) return sq_throwerror(vm, "couldn't detect real instance of class for non-static call");
 805                 /* Remove the userdata from the stack */
 806                 sq_pop(vm, 1);
 807
 808                 /* Call the function, which its only param is always the VM */
 809                 return (SQInteger)(((Tcls *)real_instance)->*(*(Tmethod *)ptr))(vm);
 810         }
 811
 812         /**
 813          * A general template for all function/static method callbacks from Squirrel.
 814          *  In here the function_proc is recovered, and the SQCall is called that
 815          *  can handle this exact amount of params.
 816          */
 817         template <typename Tcls, typename Tmethod>
 818         inline SQInteger DefSQStaticCallback(HSQUIRRELVM vm)
 819         {
 820                 /* Find the amount of params we got */
 821                 int nparam = sq_gettop(vm);
 822                 SQUserPointer ptr = NULL;
 823
 824                 /* Get the real function pointer */
 825                 sq_getuserdata(vm, nparam, &ptr, 0);
 826
 827                 try {
 828                         /* Delegate it to a template that can handle this specific function */
 829                         return HelperT<Tmethod>::SQCall((Tcls *)NULL, *(Tmethod *)ptr, vm);
 830                 } catch (SQInteger e) {
 831                         return e;
 832                 }
 833         }
 834
 835
 836         /**
 837          * A general template for all static advanced method callbacks from Squirrel.
 838          *  In here the function_proc is recovered, and the SQCall is called that
 839          *  can handle this exact amount of params.
 840          */
 841         template <typename Tcls, typename Tmethod>
 842         inline SQInteger DefSQAdvancedStaticCallback(HSQUIRRELVM vm)
 843         {
 844                 /* Find the amount of params we got */
 845                 int nparam = sq_gettop(vm);
 846                 SQUserPointer ptr = NULL;
 847
 848                 /* Get the real function pointer */
 849                 sq_getuserdata(vm, nparam, &ptr, 0);
 850                 /* Remove the userdata from the stack */
 851                 sq_pop(vm, 1);
 852
 853                 /* Call the function, which its only param is always the VM */
 854                 return (SQInteger)(*(*(Tmethod *)ptr))(vm);
 855         }
 856
 857         /**
 858          * A general template for the destructor of SQ instances. This is needed
 859          *  here as it has to be in the same scope as DefSQConstructorCallback.
 860          */
 861         template <typename Tcls>
 862         static SQInteger DefSQDestructorCallback(SQUserPointer p, SQInteger size)
 863         {
 864                 /* Remove the real instance too */
 865                 if (p != NULL) ((Tcls *)p)->Release();
 866                 return 0;
 867         }
 868
 869         /**
 870          * A general template to handle creating of instance with any amount of
 871          *  params. It creates the instance in C++, and it sets all the needed
 872          *  settings in SQ to register the instance.
 873          */
 874         template <typename Tcls, typename Tmethod, int Tnparam>
 875         inline SQInteger DefSQConstructorCallback(HSQUIRRELVM vm)
 876         {
 877                 try {
 878                         /* Create the real instance */
 879                         Tcls *instance = HelperT<Tmethod>::SQConstruct((Tcls *)NULL, (Tmethod)NULL, vm);
 880                         sq_setinstanceup(vm, -Tnparam, instance);
 881                         sq_setreleasehook(vm, -Tnparam, DefSQDestructorCallback<Tcls>);
 882                         instance->AddRef();
 883                         return 0;
 884                 } catch (SQInteger e) {
 885                         return e;
 886                 }
 887         }
 888
 889         /**
 890          * A general template to handle creating of an instance with a complex
 891          *  constructor.
 892          */
 893         template <typename Tcls>
 894         inline SQInteger DefSQAdvancedConstructorCallback(HSQUIRRELVM vm)
 895         {
 896                 try {
 897                         /* Find the amount of params we got */
 898                         int nparam = sq_gettop(vm);
 899
 900                         /* Create the real instance */
 901                         Tcls *instance = new Tcls(vm);
 902                         sq_setinstanceup(vm, -nparam, instance);
 903                         sq_setreleasehook(vm, -nparam, DefSQDestructorCallback<Tcls>);
 904                         instance->AddRef();
 905                         return 0;
 906                 } catch (SQInteger e) {
 907                         return e;
 908                 }
 909         }
 910
 911 } // namespace SQConvert
 912
 913 #endif /* SQUIRREL_HELPER_HPP */