1

/* $Id$ */

     2

     3

/** @file squirrel_helper.hpp declarations and parts of the implementation of the class for convert code */

     4

     5

#ifndef SQUIRREL_HELPER_HPP

     6

#define SQUIRREL_HELPER_HPP

     7

     8

#include <squirrel.h>

     9

    10

/**

    11

 * The Squirrel convert routines

    12

 */

    13

namespace SQConvert {

    14

    15

	template <bool Y> struct YesT {

    16

		static const bool Yes = Y;

    17

		static const bool No = !Y;

    18

	};

    19

    20

	/**

    21

	 * Helper class to recognize if the given type is void. Usage: 'IsVoidT<T>::Yes'

    22

	 */

    23

	template <typename T> struct IsVoidT : YesT<false> {};

    24

	template <> struct IsVoidT<void> : YesT<true> {};

    25

    26

	/**

    27

	 * Helper class to recognize if the function/method return type is void.

    28

	 */

    29

	template <typename Tfunc> struct HasVoidReturnT;

    30

	/* functions */

    31

	template <typename Tretval> struct HasVoidReturnT<Tretval (*)()> : IsVoidT<Tretval> {};

    32

	template <typename Tretval, typename Targ1> struct HasVoidReturnT<Tretval (*)(Targ1)> : IsVoidT<Tretval> {};

    33

	template <typename Tretval, typename Targ1, typename Targ2> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2)> : IsVoidT<Tretval> {};

    34

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2, Targ3)> : IsVoidT<Tretval> {};

    35

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2, Targ3, Targ4)> : IsVoidT<Tretval> {};

    36

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5> struct HasVoidReturnT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5)> : IsVoidT<Tretval> {};

    37

	/* methods */

    38

	template <class Tcls, typename Tretval> struct HasVoidReturnT<Tretval (Tcls::*)()> : IsVoidT<Tretval> {};

    39

	template <class Tcls, typename Tretval, typename Targ1> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1)> : IsVoidT<Tretval> {};

    40

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2)> : IsVoidT<Tretval> {};

    41

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2, Targ3)> : IsVoidT<Tretval> {};

    42

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4> struct HasVoidReturnT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4)> : IsVoidT<Tretval> {};

    43

	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> {};

    44

    45

    46

	/**

    47

	 * Special class to make it possible for the compiler to pick the correct GetParam().

    48

	 */

    49

	template <typename T> class ForceType { };

    50

    51

	/**

    52

	 * To return a value to squirrel, we call this function. It converts to the right format.

    53

	 */

    54

	template <typename T> static int Return(HSQUIRRELVM vm, T t);

    55

    56

	template <> inline int Return<uint8>       (HSQUIRRELVM vm, uint8 res)       { sq_pushinteger(vm, (int32)res); return 1; }

    57

	template <> inline int Return<uint16>      (HSQUIRRELVM vm, uint16 res)      { sq_pushinteger(vm, (int32)res); return 1; }

    58

	template <> inline int Return<uint32>      (HSQUIRRELVM vm, uint32 res)      { sq_pushinteger(vm, (int32)res); return 1; }

    59

	template <> inline int Return<int8>        (HSQUIRRELVM vm, int8 res)        { sq_pushinteger(vm, res); return 1; }

    60

	template <> inline int Return<int16>       (HSQUIRRELVM vm, int16 res)       { sq_pushinteger(vm, res); return 1; }

    61

	template <> inline int Return<int32>       (HSQUIRRELVM vm, int32 res)       { sq_pushinteger(vm, res); return 1; }

    62

	template <> inline int Return<int64>       (HSQUIRRELVM vm, int64 res)       { sq_pushinteger(vm, ClampToI32(res)); return 1; }

    64

	template <> inline int Return<bool>        (HSQUIRRELVM vm, bool res)        { sq_pushbool   (vm, res); return 1; }

    65

	template <> inline int Return<char *>      (HSQUIRRELVM vm, char *res)       { if (res == NULL) sq_pushnull(vm); else sq_pushstring (vm, OTTD2FS(res), strlen(res)); free(res); return 1; }

    66

	template <> inline int Return<const char *>(HSQUIRRELVM vm, const char *res) { if (res == NULL) sq_pushnull(vm); else sq_pushstring (vm, OTTD2FS(res), strlen(res)); return 1; }

    67

	template <> inline int Return<void *>      (HSQUIRRELVM vm, void *res)       { sq_pushuserpointer(vm, res); return 1; }

    68

    69

	/**

    70

	 * To get a param from squirrel, we call this function. It converts to the right format.

    71

	 */

    72

	template <typename T> static T GetParam(ForceType<T>, HSQUIRRELVM vm, int index);

    73

    74

	template <> inline uint8       GetParam(ForceType<uint8>       , HSQUIRRELVM vm, int index) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }

    75

	template <> inline uint16      GetParam(ForceType<uint16>      , HSQUIRRELVM vm, int index) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }

    76

	template <> inline uint32      GetParam(ForceType<uint32>      , HSQUIRRELVM vm, int index) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }

    77

	template <> inline int8        GetParam(ForceType<int8>        , HSQUIRRELVM vm, int index) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }

    78

	template <> inline int16       GetParam(ForceType<int16>       , HSQUIRRELVM vm, int index) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }

    79

	template <> inline int32       GetParam(ForceType<int32>       , HSQUIRRELVM vm, int index) { SQInteger     tmp; sq_getinteger    (vm, index, &tmp); return tmp; }

    80

	template <> inline bool        GetParam(ForceType<bool>        , HSQUIRRELVM vm, int index) { SQBool        tmp; sq_getbool       (vm, index, &tmp); return tmp != 0; }

    81

	template <> inline const char *GetParam(ForceType<const char *>, HSQUIRRELVM vm, int index) { const SQChar *tmp; sq_getstring     (vm, index, &tmp); return FS2OTTD(tmp); }

    82

	template <> inline void       *GetParam(ForceType<void *>      , HSQUIRRELVM vm, int index) { SQUserPointer tmp; sq_getuserpointer(vm, index, &tmp); return tmp; }

    83

    84

	/**

    85

	* Helper class to recognize the function type (retval type, args) and use the proper specialization

    86

	* for SQ callback. The partial specializations for the second arg (Tis_void_retval) are not possible

    87

	* on the function. Therefore the class is used instead.

    88

	*/

    89

	template <typename Tfunc, bool Tis_void_retval = HasVoidReturnT<Tfunc>::Yes> struct HelperT;

    90

    91

	/**

    92

	 * The real C++ caller for function with return value and 0 params.

    93

	 */

    94

	template <typename Tretval>

    95

	struct HelperT<Tretval (*)(), false> {

    96

		static int SQCall(void *instance, Tretval (*func)(), HSQUIRRELVM vm)

    97

		{

    98

			return Return(vm, (*func)());

    99

		}

   100

	};

   101

   102

	/**

   103

	 * The real C++ caller for function with no return value and 0 params.

   104

	 */

   105

	template <typename Tretval>

   106

	struct HelperT<Tretval (*)(), true> {

   107

		static int SQCall(void *instance, Tretval (*func)(), HSQUIRRELVM vm)

   108

		{

   109

			(*func)();

   110

			return 0;

   111

		}

   112

	};

   113

   114

	/**

   115

	 * The real C++ caller for method with return value and 0 params.

   116

	 */

   117

	template <class Tcls, typename Tretval>

   118

	struct HelperT<Tretval (Tcls::*)(), false> {

   119

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(), HSQUIRRELVM vm)

   120

		{

   121

			return Return(vm, (instance->*func)());

   122

		}

   123

	};

   124

   125

	/**

   126

	 * The real C++ caller for method with no return value and 0 params.

   127

	 */

   128

	template <class Tcls, typename Tretval>

   129

	struct HelperT<Tretval (Tcls::*)(), true> {

   130

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(), HSQUIRRELVM vm)

   131

		{

   132

			(instance->*func)();

   133

			return 0;

   134

		}

   135

   136

		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(), HSQUIRRELVM vm)

   137

		{

   138

			return new Tcls();

   139

		}

   140

	};

   141

   142

	/**

   143

	 * The real C++ caller for function with return value and 1 param.

   144

	 */

   145

	template <typename Tretval, typename Targ1>

   146

	struct HelperT<Tretval (*)(Targ1), false> {

   147

		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)

   148

		{

   149

			Tretval ret = (*func)(

   150

				GetParam(ForceType<Targ1>(), vm, 2)

   151

			);

   152

			sq_remove(vm, 2);

   153

			return Return(vm, ret);

   154

		}

   155

	};

   156

   157

	/**

   158

	 * The real C++ caller for function with no return value and 1 param.

   159

	 */

   160

	template <typename Tretval, typename Targ1>

   161

	struct HelperT<Tretval (*)(Targ1), true> {

   162

		static int SQCall(void *instance, Tretval (*func)(Targ1), HSQUIRRELVM vm)

   163

		{

   164

			(*func)(

   165

				GetParam(ForceType<Targ1>(), vm, 2)

   166

			);

   167

			sq_remove(vm, 2);

   168

			return 0;

   169

		}

   170

	};

   171

   172

	/**

   173

	 * The real C++ caller for method with return value and 1 param.

   174

	 */

   175

	template <class Tcls, typename Tretval, typename Targ1>

   176

	struct HelperT<Tretval (Tcls::*)(Targ1), false> {

   177

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)

   178

		{

   179

			Tretval ret = (instance->*func)(

   180

				GetParam(ForceType<Targ1>(), vm, 2)

   181

			);

   182

			sq_remove(vm, 2);

   183

			return Return(vm, ret);

   184

		}

   185

	};

   186

   187

	/**

   188

	 * The real C++ caller for method with no return value and 1 param.

   189

	 */

   190

	template <class Tcls, typename Tretval, typename Targ1>

   191

	struct HelperT<Tretval (Tcls::*)(Targ1), true> {

   192

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)

   193

		{

   194

			(instance->*func)(

   195

				GetParam(ForceType<Targ1>(), vm, 2)

   196

			);

   197

			sq_remove(vm, 2);

   198

			return 0;

   199

		}

   200

   201

		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1), HSQUIRRELVM vm)

   202

		{

   203

			Tcls *inst = new Tcls(

   204

				GetParam(ForceType<Targ1>(), vm, 2)

   205

			);

   206

   207

			return inst;

   208

		}

   209

	};

   210

   211

	/**

   212

	 * The real C++ caller for function with return value and 2 params.

   213

	 */

   214

	template <typename Tretval, typename Targ1, typename Targ2>

   215

	struct HelperT<Tretval (*)(Targ1, Targ2), false> {

   216

		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)

   217

		{

   218

			Tretval ret = (*func)(

   219

				GetParam(ForceType<Targ1>(), vm, 2),

   220

				GetParam(ForceType<Targ2>(), vm, 3)

   221

			);

   222

			sq_remove(vm, 2);

   223

			sq_remove(vm, 3);

   224

			return Return(vm, ret);

   225

		}

   226

	};

   227

   228

	/**

   229

	 * The real C++ caller for function with no return value and 2 params.

   230

	 */

   231

	template <typename Tretval, typename Targ1, typename Targ2>

   232

	struct HelperT<Tretval (*)(Targ1, Targ2), true> {

   233

		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2), HSQUIRRELVM vm)

   234

		{

   235

			(*func)(

   236

				GetParam(ForceType<Targ1>(), vm, 2),

   237

				GetParam(ForceType<Targ2>(), vm, 3)

   238

			);

   239

			sq_remove(vm, 2);

   240

			sq_remove(vm, 3);

   241

			return 0;

   242

		}

   243

	};

   244

   245

	/**

   246

	 * The real C++ caller for method with return value and 2 params.

   247

	 */

   248

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2>

   249

	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), false> {

   250

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)

   251

		{

   252

			Tretval ret = (instance->*func)(

   253

				GetParam(ForceType<Targ1>(), vm, 2),

   254

				GetParam(ForceType<Targ2>(), vm, 3)

   255

			);

   256

			sq_remove(vm, 2);

   257

			sq_remove(vm, 3);

   258

			return Return(vm, ret);

   259

		}

   260

	};

   261

   262

	/**

   263

	 * The real C++ caller for method with no return value and 2 params.

   264

	 */

   265

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2>

   266

	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2), true> {

   267

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)

   268

		{

   269

			(instance->*func)(

   270

				GetParam(ForceType<Targ1>(), vm, 2),

   271

				GetParam(ForceType<Targ2>(), vm, 3)

   272

			);

   273

			sq_remove(vm, 2);

   274

			sq_remove(vm, 3);

   275

			return 0;

   276

		}

   277

   278

		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2), HSQUIRRELVM vm)

   279

		{

   280

			Tcls *inst = new Tcls(

   281

				GetParam(ForceType<Targ1>(), vm, 2),

   282

				GetParam(ForceType<Targ2>(), vm, 3)

   283

			);

   284

   285

			return inst;

   286

		}

   287

	};

   288

   289

	/**

   290

	 * The real C++ caller for function with return value and 3 params.

   291

	 */

   292

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>

   293

	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), false> {

   294

		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)

   295

		{

   296

			Tretval ret = (*func)(

   297

				GetParam(ForceType<Targ1>(), vm, 2),

   298

				GetParam(ForceType<Targ2>(), vm, 3),

   299

				GetParam(ForceType<Targ3>(), vm, 4)

   300

			);

   301

			sq_remove(vm, 2);

   302

			sq_remove(vm, 3);

   303

			sq_remove(vm, 4);

   304

			return Return(vm, ret);

   305

		}

   306

	};

   307

   308

	/**

   309

	 * The real C++ caller for function with no return value and 3 params.

   310

	 */

   311

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3>

   312

	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3), true> {

   313

		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)

   314

		{

   315

			(*func)(

   316

				GetParam(ForceType<Targ1>(), vm, 2),

   317

				GetParam(ForceType<Targ2>(), vm, 3),

   318

				GetParam(ForceType<Targ3>(), vm, 4)

   319

			);

   320

			sq_remove(vm, 2);

   321

			sq_remove(vm, 3);

   322

			sq_remove(vm, 4);

   323

			return 0;

   324

		}

   325

	};

   326

   327

	/**

   328

	 * The real C++ caller for method with return value and 3 params.

   329

	 */

   330

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>

   331

	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), false> {

   332

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)

   333

		{

   334

			Tretval ret = (instance->*func)(

   335

				GetParam(ForceType<Targ1>(), vm, 2),

   336

				GetParam(ForceType<Targ2>(), vm, 3),

   337

				GetParam(ForceType<Targ3>(), vm, 4)

   338

			);

   339

			sq_remove(vm, 2);

   340

			sq_remove(vm, 3);

   341

			sq_remove(vm, 4);

   342

			return Return(vm, ret);

   343

		}

   344

	};

   345

   346

	/**

   347

	 * The real C++ caller for method with no return value and 3 params.

   348

	 */

   349

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3>

   350

	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3), true> {

   351

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)

   352

		{

   353

			(instance->*func)(

   354

				GetParam(ForceType<Targ1>(), vm, 2),

   355

				GetParam(ForceType<Targ2>(), vm, 3),

   356

				GetParam(ForceType<Targ3>(), vm, 4)

   357

			);

   358

			sq_remove(vm, 2);

   359

			sq_remove(vm, 3);

   360

			sq_remove(vm, 4);

   361

			return 0;

   362

		}

   363

   364

		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3), HSQUIRRELVM vm)

   365

		{

   366

			Tcls *inst = new Tcls(

   367

				GetParam(ForceType<Targ1>(), vm, 2),

   368

				GetParam(ForceType<Targ2>(), vm, 3),

   369

				GetParam(ForceType<Targ3>(), vm, 4)

   370

			);

   371

   372

			return inst;

   373

		}

   374

	};

   375

   376

	/**

   377

	 * The real C++ caller for function with return value and 4 params.

   378

	 */

   379

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>

   380

	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), false> {

   381

		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)

   382

		{

   383

			Tretval ret = (*func)(

   384

				GetParam(ForceType<Targ1>(), vm, 2),

   385

				GetParam(ForceType<Targ2>(), vm, 3),

   386

				GetParam(ForceType<Targ3>(), vm, 4),

   387

				GetParam(ForceType<Targ4>(), vm, 5)

   388

			);

   389

			sq_remove(vm, 2);

   390

			sq_remove(vm, 3);

   391

			sq_remove(vm, 4);

   392

			sq_remove(vm, 5);

   393

			return Return(vm, ret);

   394

		}

   395

	};

   396

   397

	/**

   398

	 * The real C++ caller for function with no return value and 4 params.

   399

	 */

   400

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>

   401

	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4), true> {

   402

		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)

   403

		{

   404

			(*func)(

   405

				GetParam(ForceType<Targ1>(), vm, 2),

   406

				GetParam(ForceType<Targ2>(), vm, 3),

   407

				GetParam(ForceType<Targ3>(), vm, 4),

   408

				GetParam(ForceType<Targ4>(), vm, 5)

   409

			);

   410

			sq_remove(vm, 2);

   411

			sq_remove(vm, 3);

   412

			sq_remove(vm, 4);

   413

			sq_remove(vm, 5);

   414

			return 0;

   415

		}

   416

	};

   417

   418

	/**

   419

	 * The real C++ caller for method with return value and 4 params.

   420

	 */

   421

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>

   422

	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), false> {

   423

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)

   424

		{

   425

			Tretval ret = (instance->*func)(

   426

				GetParam(ForceType<Targ1>(), vm, 2),

   427

				GetParam(ForceType<Targ2>(), vm, 3),

   428

				GetParam(ForceType<Targ3>(), vm, 4),

   429

				GetParam(ForceType<Targ4>(), vm, 5)

   430

			);

   431

			sq_remove(vm, 2);

   432

			sq_remove(vm, 3);

   433

			sq_remove(vm, 4);

   434

			sq_remove(vm, 5);

   435

			return Return(vm, ret);

   436

		}

   437

	};

   438

   439

	/**

   440

	 * The real C++ caller for method with no return value and 4 params.

   441

	 */

   442

	template <class Tcls, typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4>

   443

	struct HelperT<Tretval (Tcls::*)(Targ1, Targ2, Targ3, Targ4), true> {

   444

		static int SQCall(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)

   445

		{

   446

			(instance->*func)(

   447

				GetParam(ForceType<Targ1>(), vm, 2),

   448

				GetParam(ForceType<Targ2>(), vm, 3),

   449

				GetParam(ForceType<Targ3>(), vm, 4),

   450

				GetParam(ForceType<Targ4>(), vm, 5)

   451

			);

   452

			sq_remove(vm, 2);

   453

			sq_remove(vm, 3);

   454

			sq_remove(vm, 4);

   455

			sq_remove(vm, 5);

   456

			return 0;

   457

		}

   458

   459

		static Tcls *SQConstruct(Tcls *instance, Tretval (Tcls::*func)(Targ1, Targ2, Targ3, Targ4), HSQUIRRELVM vm)

   460

		{

   461

			Tcls *inst = new Tcls(

   462

				GetParam(ForceType<Targ1>(), vm, 2),

   463

				GetParam(ForceType<Targ2>(), vm, 3),

   464

				GetParam(ForceType<Targ3>(), vm, 4),

   465

				GetParam(ForceType<Targ4>(), vm, 5)

   466

			);

   467

   468

			return inst;

   469

		}

   470

	};

   471

   472

	/**

   473

	 * The real C++ caller for function with return value and 5 params.

   474

	 */

   475

	template <typename Tretval, typename Targ1, typename Targ2, typename Targ3, typename Targ4, typename Targ5>

   476

	struct HelperT<Tretval (*)(Targ1, Targ2, Targ3, Targ4, Targ5), false> {

   477

		static int SQCall(void *instance, Tretval (*func)(Targ1, Targ2, Targ3, Targ4, Targ5), HSQUIRRELVM vm)

   478

		{

   479

			Tretval ret = (*func)(

   480

				GetParam(ForceType<Targ1>(), vm, 2),

   481

				GetParam(ForceType<Targ2>(), vm, 3),

   482

				GetParam(ForceType<Targ3>(), vm, 4),

   483

				GetParam(ForceType<Targ4>(), vm, 5),

   484

				GetParam(ForceType<Targ5>(), vm, 6)

   485

			);

   486

			sq_remove(vm, 2);

   487

			sq_remove(vm, 3);

   488

			sq_remove(vm, 4);

   489

			sq_remove(vm, 5);

   490

			sq_remove(vm, 6);