Mercurial Mercurial > openttd-ottdgrfs / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
src/squirrel_helper.hpp
branchnoai
changeset 10734 06f95974ac15
parent 10722 6ea1daff57aa
child 10992 4dd4f4327c3a
equal deleted inserted replaced
10732:ef8213a6e805 10734:06f95974ac15 
    12 
    12 
    13 /**
 
    13 /**
 
    14  * The Squirrel convert routines
 
    14  * The Squirrel convert routines
 
    15  */
 
    15  */
 
    16 namespace SQConvert {
 
    16 namespace SQConvert {
 
    17 	struct SQConvertedStrings : SmallVector<char *, 1> {
 
    17 	/**
 
    18 		~SQConvertedStrings()
 
    18 	 * Pointers assigned to this class will be free'd when this instance
 
       
    19 	 *  comes out of scope. Useful to make sure you can use strdup(),
 
       
    20 	 *  without leaking memory.
 
       
    21 	 */
 
       
    22 	struct SQAutoFreePointers : SmallVector<void *, 1> {
 
       
    23 		~SQAutoFreePointers()
 
    19 		{
 
    24 		{
 
    20 			for (uint i = 0; i < this->items; i++) free(this->data[i]);
 
    25 			for (uint i = 0; i < this->items; i++) free(this->data[i]);
 
    21 		}
 
    26 		}
 
    22 	};
 
    27 	};
 
    23 
    28 
    76 	template <> inline int Return<void *>      (HSQUIRRELVM vm, void *res)       { sq_pushuserpointer(vm, res); return 1; }
 
    81 	template <> inline int Return<void *>      (HSQUIRRELVM vm, void *res)       { sq_pushuserpointer(vm, res); return 1; }
 
    77 
    82 
    78 	/**
 
    83 	/**
 
    79 	 * To get a param from squirrel, we call this function. It converts to the right format.
 
    84 	 * To get a param from squirrel, we call this function. It converts to the right format.
 
    80 	 */
 
    85 	 */
 
    81 	template <typename T> static T GetParam(ForceType<T>, HSQUIRRELVM vm, int index, SQConvertedStrings *str);
 
    86 	template <typename T> static T GetParam(ForceType<T>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr);
 
    82 
    87 
    83 	template <> inline uint8       GetParam(ForceType<uint8>       , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    88 	template <> inline uint8       GetParam(ForceType<uint8>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    84 	template <> inline uint16      GetParam(ForceType<uint16>      , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    89 	template <> inline uint16      GetParam(ForceType<uint16>      , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    85 	template <> inline uint32      GetParam(ForceType<uint32>      , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    90 	template <> inline uint32      GetParam(ForceType<uint32>      , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    86 	template <> inline int8        GetParam(ForceType<int8>        , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    91 	template <> inline int8        GetParam(ForceType<int8>        , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    87 	template <> inline int16       GetParam(ForceType<int16>       , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    92 	template <> inline int16       GetParam(ForceType<int16>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    88 	template <> inline int32       GetParam(ForceType<int32>       , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    93 	template <> inline int32       GetParam(ForceType<int32>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }
 
    89 	template <> inline bool        GetParam(ForceType<bool>        , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQBool        tmp; sq_getbool       (vm, index, &tmp); return tmp != 0; }
 
    94 	template <> inline bool        GetParam(ForceType<bool>        , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQBool        tmp; sq_getbool       (vm, index, &tmp); return tmp != 0; }
 
    90 	template <> inline const char *GetParam(ForceType<const char *>, HSQUIRRELVM vm, int index, SQConvertedStrings *str) { const SQChar *tmp; sq_getstring     (vm, index, &tmp); char *tmp_str = *str->Append() = strdup(FS2OTTD(tmp)); return tmp_str; }
 
    95 	template <> inline const char *GetParam(ForceType<const char *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { const SQChar *tmp; sq_getstring     (vm, index, &tmp); char *tmp_str = strdup(FS2OTTD(tmp)); *ptr->Append() = (void *)tmp_str; return tmp_str; }
 
    91 	template <> inline void       *GetParam(ForceType<void *>      , HSQUIRRELVM vm, int index, SQConvertedStrings *str) { SQUserPointer tmp; sq_getuserpointer(vm, index, &tmp); return tmp; }
 
    96 	template <> inline void       *GetParam(ForceType<void *>      , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer tmp; sq_getuserpointer(vm, index, &tmp); return tmp; }
 
    92 
    97 
    93 	/**
 
    98 	/**
 
    94 	* Helper class to recognize the function type (retval type, args) and use the proper specialization
 
    99 	* Helper class to recognize the function type (retval type, args) and use the proper specialization
 
    95 	* for SQ callback. The partial specializations for the second arg (Tis_void_retval) are not possible
 
   100 	* for SQ callback. The partial specializations for the second arg (Tis_void_retval) are not possible
 
    96 	* on the function. Therefore the class is used instead.
 
   101 	* on the function. Therefore the class is used instead.
 
   153 	 */
 
   158 	 */
 
   154 	template <typename Tretval, typename Targ1>
 
   159 	template <typename Tretval, typename Targ1>
 
   155 	struct HelperT<Tretval (*)(Targ1), false> {
 
   160 	struct HelperT<Tretval (*)(Targ1), false> {
 
   156 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
 
   161 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
 
   157 		{
 
   162 		{
 
   158 			SQConvertedStrings str;
 
   163 			SQAutoFreePointers ptr;
 
   159 			Tretval ret = (*func)(
 
   164 			Tretval ret = (*func)(
 
   160 				GetParam(ForceType<Targ1>(), vm, 2,&str)
 
   165 				GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 
   161 			);
 
   166 			);
 
   162 			sq_pop(vm, 1);
 
   167 			sq_pop(vm, 1);
 
   163 			return Return(vm, ret);
 
   168 			return Return(vm, ret);
 
   164 		}
 
   169 		}
 
   165 	};
 
   170 	};
 
   169 	 */
 
   174 	 */
 
   170 	template <typename Tretval, typename Targ1>
 
   175 	template <typename Tretval, typename Targ1>
 
   171 	struct HelperT<Tretval (*)(Targ1), true> {
 
   176 	struct HelperT<Tretval (*)(Targ1), true> {
 
   172 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
 
   177 		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)
 
   173 		{
 
   178 		{
 
   174 			SQConvertedStrings str;
 
   179 			SQAutoFreePointers ptr;
 
   175 			(*func)(
 
   180 			(*func)(
 
   176 				GetParam(ForceType<Targ1>(), vm, 2,&str)
 
   181 				GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 
   177 			);
 
   182 			);
 
   178 			sq_pop(vm, 1);
 
   183 			sq_pop(vm, 1);
 
   179 			return 0;
 
   184 			return 0;
 
   180 		}
 
   185 		}
 
   181 	};
 
   186 	};
 
   185 	 */
 
   190 	 */
 
   186 	template <class Tcls, typename Tretval, typename Targ1>
 
   191 	template <class Tcls, typename Tretval, typename Targ1>
 
   187 	struct HelperT<Tretval (Tcls::*)(Targ1), false> {
 
   192 	struct HelperT<Tretval (Tcls::*)(Targ1), false> {
 
   188 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 
   193 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 
   189 		{
 
   194 		{
 
   190 			SQConvertedStrings str;
 
   195 			SQAutoFreePointers ptr;
 
   191 			Tretval ret = (instance->*func)(
 
   196 			Tretval ret = (instance->*func)(
 
   192 				GetParam(ForceType<Targ1>(), vm, 2,&str)
 
   197 				GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 
   193 			);
 
   198 			);
 
   194 			sq_pop(vm, 1);
 
   199 			sq_pop(vm, 1);
 
   195 			return Return(vm, ret);
 
   200 			return Return(vm, ret);
 
   196 		}
 
   201 		}
 
   197 	};
 
   202 	};
 
   201 	 */
 
   206 	 */
 
   202 	template <class Tcls, typename Tretval, typename Targ1>
 
   207 	template <class Tcls, typename Tretval, typename Targ1>
 
   203 	struct HelperT<Tretval (Tcls::*)(Targ1), true> {
 
   208 	struct HelperT<Tretval (Tcls::*)(Targ1), true> {
 
   204 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 
   209 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 
   205 		{
 
   210 		{
 
   206 			SQConvertedStrings str;
 
   211 			SQAutoFreePointers ptr;
 
   207 			(instance->*func)(
 
   212 			(instance->*func)(
 
   208 				GetParam(ForceType<Targ1>(), vm, 2,&str)
 
   213 				GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 
   209 			);
 
   214 			);
 
   210 			sq_pop(vm, 1);
 
   215 			sq_pop(vm, 1);
 
   211 			return 0;
 
   216 			return 0;
 
   212 		}
 
   217 		}
 
   213 
   218 
   214 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 
   219 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)
 
   215 		{
 
   220 		{
 
   216 			SQConvertedStrings str;
 
   221 			SQAutoFreePointers ptr;
 
   217 			Tcls *inst = new Tcls(
 
   222 			Tcls *inst = new Tcls(
 
   218 				GetParam(ForceType<Targ1>(), vm, 2,&str)
 
   223 				GetParam(ForceType<Targ1>(), vm, 2, &ptr)
 
   219 			);
 
   224 			);
 
   220 
   225 
   221 			return inst;
 
   226 			return inst;
 
   222 		}
 
   227 		}
 
   223 	};
 
   228 	};
 
   227 	 */
 
   232 	 */
 
   228 	template <typename Tretval, typename Targ1, typename Targ2>
 
   233 	template <typename Tretval, typename Targ1, typename Targ2>
 
   229 	struct HelperT<Tretval (*)(Targ1, Targ2), false> {
 
   234 	struct HelperT<Tretval (*)(Targ1, Targ2), false> {
 
   230 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   235 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   231 		{
 
   236 		{
 
   232 			SQConvertedStrings str;
 
   237 			SQAutoFreePointers ptr;
 
   233 			Tretval ret = (*func)(
 
   238 			Tretval ret = (*func)(
 
   234 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   239 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   235 				GetParam(ForceType<Targ2>(), vm, 3,&str)
 
   240 				GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 
   236 			);
 
   241 			);
 
   237 			sq_pop(vm, 2);
 
   242 			sq_pop(vm, 2);
 
   238 			return Return(vm, ret);
 
   243 			return Return(vm, ret);
 
   239 		}
 
   244 		}
 
   240 	};
 
   245 	};
 
   244 	 */
 
   249 	 */
 
   245 	template <typename Tretval, typename Targ1, typename Targ2>
 
   250 	template <typename Tretval, typename Targ1, typename Targ2>
 
   246 	struct HelperT<Tretval (*)(Targ1, Targ2), true> {
 
   251 	struct HelperT<Tretval (*)(Targ1, Targ2), true> {
 
   247 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   252 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   248 		{
 
   253 		{
 
   249 			SQConvertedStrings str;
 
   254 			SQAutoFreePointers ptr;
 
   250 			(*func)(
 
   255 			(*func)(
 
   251 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   256 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   252 				GetParam(ForceType<Targ2>(), vm, 3,&str)
 
   257 				GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 
   253 			);
 
   258 			);
 
   254 			sq_pop(vm, 2);
 
   259 			sq_pop(vm, 2);
 
   255 			return 0;
 
   260 			return 0;
 
   256 		}
 
   261 		}
 
   257 	};
 
   262 	};
 
   261 	 */
 
   266 	 */
 
   262 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2>
 
   267 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2>
 
   263 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), false> {
 
   268 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), false> {
 
   264 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   269 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   265 		{
 
   270 		{
 
   266 			SQConvertedStrings str;
 
   271 			SQAutoFreePointers ptr;
 
   267 			Tretval ret = (instance->*func)(
 
   272 			Tretval ret = (instance->*func)(
 
   268 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   273 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   269 				GetParam(ForceType<Targ2>(), vm, 3,&str)
 
   274 				GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 
   270 			);
 
   275 			);
 
   271 			sq_pop(vm, 2);
 
   276 			sq_pop(vm, 2);
 
   272 			return Return(vm, ret);
 
   277 			return Return(vm, ret);
 
   273 		}
 
   278 		}
 
   274 	};
 
   279 	};
 
   278 	 */
 
   283 	 */
 
   279 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2>
 
   284 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2>
 
   280 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), true> {
 
   285 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), true> {
 
   281 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   286 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   282 		{
 
   287 		{
 
   283 			SQConvertedStrings str;
 
   288 			SQAutoFreePointers ptr;
 
   284 			(instance->*func)(
 
   289 			(instance->*func)(
 
   285 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   290 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   286 				GetParam(ForceType<Targ2>(), vm, 3,&str)
 
   291 				GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 
   287 			);
 
   292 			);
 
   288 			sq_pop(vm, 2);
 
   293 			sq_pop(vm, 2);
 
   289 			return 0;
 
   294 			return 0;
 
   290 		}
 
   295 		}
 
   291 
   296 
   292 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   297 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)
 
   293 		{
 
   298 		{
 
   294 			SQConvertedStrings str;
 
   299 			SQAutoFreePointers ptr;
 
   295 			Tcls *inst = new Tcls(
 
   300 			Tcls *inst = new Tcls(
 
   296 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   301 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   297 				GetParam(ForceType<Targ2>(), vm, 3,&str)
 
   302 				GetParam(ForceType<Targ2>(), vm, 3, &ptr)
 
   298 			);
 
   303 			);
 
   299 
   304 
   300 			return inst;
 
   305 			return inst;
 
   301 		}
 
   306 		}
 
   302 	};
 
   307 	};
 
   306 	 */
 
   311 	 */
 
   307 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   312 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   308 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), false> {
 
   313 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), false> {
 
   309 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   314 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   310 		{
 
   315 		{
 
   311 			SQConvertedStrings str;
 
   316 			SQAutoFreePointers ptr;
 
   312 			Tretval ret = (*func)(
 
   317 			Tretval ret = (*func)(
 
   313 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   318 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   314 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   319 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   315 				GetParam(ForceType<Targ3>(), vm, 4,&str)
 
   320 				GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 
   316 			);
 
   321 			);
 
   317 			sq_pop(vm, 3);
 
   322 			sq_pop(vm, 3);
 
   318 			return Return(vm, ret);
 
   323 			return Return(vm, ret);
 
   319 		}
 
   324 		}
 
   320 	};
 
   325 	};
 
   324 	 */
 
   329 	 */
 
   325 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   330 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   326 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), true> {
 
   331 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), true> {
 
   327 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   332 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   328 		{
 
   333 		{
 
   329 			SQConvertedStrings str;
 
   334 			SQAutoFreePointers ptr;
 
   330 			(*func)(
 
   335 			(*func)(
 
   331 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   336 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   332 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   337 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   333 				GetParam(ForceType<Targ3>(), vm, 4,&str)
 
   338 				GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 
   334 			);
 
   339 			);
 
   335 			sq_pop(vm, 3);
 
   340 			sq_pop(vm, 3);
 
   336 			return 0;
 
   341 			return 0;
 
   337 		}
 
   342 		}
 
   338 	};
 
   343 	};
 
   342 	 */
 
   347 	 */
 
   343 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   348 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   344 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), false> {
 
   349 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), false> {
 
   345 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   350 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   346 		{
 
   351 		{
 
   347 			SQConvertedStrings str;
 
   352 			SQAutoFreePointers ptr;
 
   348 			Tretval ret = (instance->*func)(
 
   353 			Tretval ret = (instance->*func)(
 
   349 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   354 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   350 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   355 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   351 				GetParam(ForceType<Targ3>(), vm, 4,&str)
 
   356 				GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 
   352 			);
 
   357 			);
 
   353 			sq_pop(vm, 3);
 
   358 			sq_pop(vm, 3);
 
   354 			return Return(vm, ret);
 
   359 			return Return(vm, ret);
 
   355 		}
 
   360 		}
 
   356 	};
 
   361 	};
 
   360 	 */
 
   365 	 */
 
   361 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   366 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>
 
   362 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), true> {
 
   367 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), true> {
 
   363 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   368 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   364 		{
 
   369 		{
 
   365 			SQConvertedStrings str;
 
   370 			SQAutoFreePointers ptr;
 
   366 			(instance->*func)(
 
   371 			(instance->*func)(
 
   367 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   372 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   368 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   373 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   369 				GetParam(ForceType<Targ3>(), vm, 4,&str)
 
   374 				GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 
   370 			);
 
   375 			);
 
   371 			sq_pop(vm, 3);
 
   376 			sq_pop(vm, 3);
 
   372 			return 0;
 
   377 			return 0;
 
   373 		}
 
   378 		}
 
   374 
   379 
   375 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   380 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)
 
   376 		{
 
   381 		{
 
   377 			SQConvertedStrings str;
 
   382 			SQAutoFreePointers ptr;
 
   378 			Tcls *inst = new Tcls(
 
   383 			Tcls *inst = new Tcls(
 
   379 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   384 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   380 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   385 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   381 				GetParam(ForceType<Targ3>(), vm, 4,&str)
 
   386 				GetParam(ForceType<Targ3>(), vm, 4, &ptr)
 
   382 			);
 
   387 			);
 
   383 
   388 
   384 			return inst;
 
   389 			return inst;
 
   385 		}
 
   390 		}
 
   386 	};
 
   391 	};
 
   390 	 */
 
   395 	 */
 
   391 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   396 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   392 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), false> {
 
   397 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), false> {
 
   393 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   398 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   394 		{
 
   399 		{
 
   395 			SQConvertedStrings str;
 
   400 			SQAutoFreePointers ptr;
 
   396 			Tretval ret = (*func)(
 
   401 			Tretval ret = (*func)(
 
   397 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   402 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   398 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   403 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   399 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   404 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   400 				GetParam(ForceType<Targ4>(), vm, 5,&str)
 
   405 				GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 
   401 			);
 
   406 			);
 
   402 			sq_pop(vm, 4);
 
   407 			sq_pop(vm, 4);
 
   403 			return Return(vm, ret);
 
   408 			return Return(vm, ret);
 
   404 		}
 
   409 		}
 
   405 	};
 
   410 	};
 
   409 	 */
 
   414 	 */
 
   410 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   415 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   411 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), true> {
 
   416 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), true> {
 
   412 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   417 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   413 		{
 
   418 		{
 
   414 			SQConvertedStrings str;
 
   419 			SQAutoFreePointers ptr;
 
   415 			(*func)(
 
   420 			(*func)(
 
   416 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   421 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   417 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   422 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   418 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   423 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   419 				GetParam(ForceType<Targ4>(), vm, 5,&str)
 
   424 				GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 
   420 			);
 
   425 			);
 
   421 			sq_pop(vm, 4);
 
   426 			sq_pop(vm, 4);
 
   422 			return 0;
 
   427 			return 0;
 
   423 		}
 
   428 		}
 
   424 	};
 
   429 	};
 
   428 	 */
 
   433 	 */
 
   429 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   434 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   430 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), false> {
 
   435 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), false> {
 
   431 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   436 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   432 		{
 
   437 		{
 
   433 			SQConvertedStrings str;
 
   438 			SQAutoFreePointers ptr;
 
   434 			Tretval ret = (instance->*func)(
 
   439 			Tretval ret = (instance->*func)(
 
   435 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   440 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   436 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   441 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   437 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   442 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   438 				GetParam(ForceType<Targ4>(), vm, 5,&str)
 
   443 				GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 
   439 			);
 
   444 			);
 
   440 			sq_pop(vm, 4);
 
   445 			sq_pop(vm, 4);
 
   441 			return Return(vm, ret);
 
   446 			return Return(vm, ret);
 
   442 		}
 
   447 		}
 
   443 	};
 
   448 	};
 
   447 	 */
 
   452 	 */
 
   448 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   453 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>
 
   449 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), true> {
 
   454 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), true> {
 
   450 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   455 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   451 		{
 
   456 		{
 
   452 			SQConvertedStrings str;
 
   457 			SQAutoFreePointers ptr;
 
   453 			(instance->*func)(
 
   458 			(instance->*func)(
 
   454 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   459 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   455 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   460 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   456 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   461 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   457 				GetParam(ForceType<Targ4>(), vm, 5,&str)
 
   462 				GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 
   458 			);
 
   463 			);
 
   459 			sq_pop(vm, 4);
 
   464 			sq_pop(vm, 4);
 
   460 			return 0;
 
   465 			return 0;
 
   461 		}
 
   466 		}
 
   462 
   467 
   463 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   468 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)
 
   464 		{
 
   469 		{
 
   465 			SQConvertedStrings str;
 
   470 			SQAutoFreePointers ptr;
 
   466 			Tcls *inst = new Tcls(
 
   471 			Tcls *inst = new Tcls(
 
   467 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   472 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   468 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   473 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   469 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   474 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   470 				GetParam(ForceType<Targ4>(), vm, 5,&str)
 
   475 				GetParam(ForceType<Targ4>(), vm, 5, &ptr)
 
   471 			);
 
   476 			);
 
   472 
   477 
   473 			return inst;
 
   478 			return inst;
 
   474 		}
 
   479 		}
 
   475 	};
 
   480 	};
 
   479 	 */
 
   484 	 */
 
   480 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   485 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   481 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5), false> {
 
   486 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5), false> {
 
   482 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   487 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   483 		{
 
   488 		{
 
   484 			SQConvertedStrings str;
 
   489 			SQAutoFreePointers ptr;
 
   485 			Tretval ret = (*func)(
 
   490 			Tretval ret = (*func)(
 
   486 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   491 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   487 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   492 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   488 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   493 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   489 				GetParam(ForceType<Targ4>(), vm, 5,&str),
 
   494 				GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 
   490 				GetParam(ForceType<Targ5>(), vm, 6,&str)
 
   495 				GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 
   491 			);
 
   496 			);
 
   492 			sq_pop(vm, 5);
 
   497 			sq_pop(vm, 5);
 
   493 			return Return(vm, ret);
 
   498 			return Return(vm, ret);
 
   494 		}
 
   499 		}
 
   495 	};
 
   500 	};
 
   499 	 */
 
   504 	 */
 
   500 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   505 	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   501 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5), true> {
 
   506 	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5), true> {
 
   502 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   507 		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   503 		{
 
   508 		{
 
   504 			SQConvertedStrings str;
 
   509 			SQAutoFreePointers ptr;
 
   505 			(*func)(
 
   510 			(*func)(
 
   506 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   511 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   507 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   512 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   508 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   513 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   509 				GetParam(ForceType<Targ4>(), vm, 5,&str),
 
   514 				GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 
   510 				GetParam(ForceType<Targ5>(), vm, 6,&str)
 
   515 				GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 
   511 			);
 
   516 			);
 
   512 			sq_pop(vm, 5);
 
   517 			sq_pop(vm, 5);
 
   513 			return 0;
 
   518 			return 0;
 
   514 		}
 
   519 		}
 
   515 	};
 
   520 	};
 
   519 	 */
 
   524 	 */
 
   520 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   525 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   521 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), false> {
 
   526 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), false> {
 
   522 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   527 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   523 		{
 
   528 		{
 
   524 			SQConvertedStrings str;
 
   529 			SQAutoFreePointers ptr;
 
   525 			Tretval ret = (instance->*func)(
 
   530 			Tretval ret = (instance->*func)(
 
   526 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   531 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   527 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   532 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   528 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   533 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   529 				GetParam(ForceType<Targ4>(), vm, 5,&str),
 
   534 				GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 
   530 				GetParam(ForceType<Targ5>(), vm, 6,&str)
 
   535 				GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 
   531 			);
 
   536 			);
 
   532 			sq_pop(vm, 5);
 
   537 			sq_pop(vm, 5);
 
   533 			return Return(vm, ret);
 
   538 			return Return(vm, ret);
 
   534 		}
 
   539 		}
 
   535 	};
 
   540 	};
 
   539 	 */
 
   544 	 */
 
   540 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   545 	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>
 
   541 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), true> {
 
   546 	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4, Targ5), true> {
 
   542 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   547 		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   543 		{
 
   548 		{
 
   544 			SQConvertedStrings str;
 
   549 			SQAutoFreePointers ptr;
 
   545 			(instance->*func)(
 
   550 			(instance->*func)(
 
   546 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   551 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   547 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   552 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   548 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   553 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   549 				GetParam(ForceType<Targ4>(), vm, 5,&str),
 
   554 				GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 
   550 				GetParam(ForceType<Targ5>(), vm, 6,&str)
 
   555 				GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 
   551 			);
 
   556 			);
 
   552 			sq_pop(vm, 5);
 
   557 			sq_pop(vm, 5);
 
   553 			return 0;
 
   558 			return 0;
 
   554 		}
 
   559 		}
 
   555 
   560 
   556 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   561 		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)
 
   557 		{
 
   562 		{
 
   558 			SQConvertedStrings str;
 
   563 			SQAutoFreePointers ptr;
 
   559 			Tcls *inst = new Tcls(
 
   564 			Tcls *inst = new Tcls(
 
   560 				GetParam(ForceType<Targ1>(), vm, 2,&str),
 
   565 				GetParam(ForceType<Targ1>(), vm, 2, &ptr),
 
   561 				GetParam(ForceType<Targ2>(), vm, 3,&str),
 
   566 				GetParam(ForceType<Targ2>(), vm, 3, &ptr),
 
   562 				GetParam(ForceType<Targ3>(), vm, 4,&str),
 
   567 				GetParam(ForceType<Targ3>(), vm, 4, &ptr),
 
   563 				GetParam(ForceType<Targ4>(), vm, 5,&str),
 
   568 				GetParam(ForceType<Targ4>(), vm, 5, &ptr),
 
   564 				GetParam(ForceType<Targ5>(), vm, 6,&str)
 
   569 				GetParam(ForceType<Targ5>(), vm, 6, &ptr)
 
   565 			);
 
   570 			);
 
   566 
   571 
   567 			return inst;
 
   572 			return inst;
 
   568 		}
 
   573 		}
 
   569 	};
 
   574 	};
openttd-ottdgrfs