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

#include "core/math_func.hpp"

    10

#include "economy_type.h"

    11

#include "misc/smallvec.h"

    12

    13

/**

    14

 * The Squirrel convert routines

    15

 */

    16

namespace SQConvert {

    17

	/**

    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()

    24

		{

    25

			for (uint i = 0; i < this->items; i++) free(this->data[i]);

    26

		}

    27

	};

    28

    29

	template <bool Y> struct YesT {

    30

		static const bool Yes = Y;

    31

		static const bool No = !Y;

    32

	};

    33

    34

	/**

    35

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

    36

	 */

    37

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

    38

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

    39

    40

	/**

    41

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

    42

	 */

    43

	template <typename Tfunc> struct HasVoidReturnT;

    44

	/* functions */

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

	/* methods */

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

    59

    60

	/**

    61

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

    62

	 */

    63

	template <typename T> class ForceType { };

    64

    65

	/**

    66

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

    67

	 */

    68

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

    69

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

    83

	/**

    84

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

    85

	 */

    86

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

    87

    88

	template <> inline uint8       GetParam(ForceType<uint8>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { 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; }

    90

	template <> inline uint32      GetParam(ForceType<uint32>      , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { 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; }

    92

	template <> inline int16       GetParam(ForceType<int16>       , HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { 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; }

    94

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

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

    96

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

    97

    98

	/**

    99

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

   100

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

   101

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

   102

	*/

   103

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

   104

   105

	/**

   106

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

   107

	 */

   108

	template <typename Tretval>

   109

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

   110

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

   111

		{

   112

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

   113

		}

   114

	};

   115

   116

	/**

   117

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

   118

	 */

   119

	template <typename Tretval>

   120

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

   121

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

   122

		{

   123

			(*func)();

   124

			return 0;

   125

		}

   126

	};

   127

   128

	/**

   129

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

   130

	 */

   131

	template <class Tcls, typename Tretval>

   132

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

   133

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

   134

		{

   135

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

   136

		}

   137

	};

   138

   139

	/**

   140

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

   141

	 */

   142

	template <class Tcls, typename Tretval>

   143

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

   144

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

   145

		{

   146

			(instance->*func)();

   147

			return 0;

   148

		}

   149

   150

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

   151

		{

   152

			return new Tcls();

   153

		}

   154

	};

   155

   156

	/**

   157

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

   158

	 */

   159

	template <typename Tretval, typename Targ1>

   160

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

   161

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

   162

		{

   163

			SQAutoFreePointers ptr;

   164

			Tretval ret = (*func)(

   165

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

   166

			);

   167

			sq_pop(vm, 1);

   168

			return Return(vm, ret);

   169

		}

   170

	};

   171

   172

	/**

   173

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

   174

	 */

   175

	template <typename Tretval, typename Targ1>

   176

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

   177

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

   178

		{

   179

			SQAutoFreePointers ptr;

   180

			(*func)(

   181

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

   182

			);

   183

			sq_pop(vm, 1);

   184

			return 0;

   185

		}

   186

	};

   187

   188

	/**

   189

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

   190

	 */

   191

	template <class Tcls, typename Tretval, typename Targ1>

   192

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

   193

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

   194

		{

   195

			SQAutoFreePointers ptr;

   196

			Tretval ret = (instance->*func)(

   197

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

   198

			);

   199

			sq_pop(vm, 1);

   200

			return Return(vm, ret);

   201

		}

   202

	};

   203

   204

	/**

   205

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

   206

	 */

   207

	template <class Tcls, typename Tretval, typename Targ1>

   208

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

   209

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

   210

		{

   211

			SQAutoFreePointers ptr;

   212

			(instance->*func)(

   213

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

   214

			);

   215

			sq_pop(vm, 1);

   216

			return 0;

   217

		}

   218

   219

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

   220

		{

   221

			SQAutoFreePointers ptr;

   222

			Tcls *inst = new Tcls(

   223

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

   224

			);

   225

   226

			return inst;

   227

		}

   228

	};

   229

   230

	/**

   231

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

   232

	 */

   233

	template <typename Tretval, typename Targ1, typename Targ2>

   234

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

   235

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

   236

		{

   237

			SQAutoFreePointers ptr;

   238

			Tretval ret = (*func)(

   239

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

   240

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

   241

			);

   242

			sq_pop(vm, 2);

   243

			return Return(vm, ret);

   244

		}

   245

	};

   246

   247

	/**

   248

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

   249

	 */

   250

	template <typename Tretval, typename Targ1, typename Targ2>

   251

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

   252

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

   253

		{

   254

			SQAutoFreePointers ptr;

   255

			(*func)(

   256

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

   257

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

   258

			);

   259

			sq_pop(vm, 2);

   260

			return 0;

   261

		}

   262

	};

   263

   264

	/**

   265

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

   266

	 */

   267

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

   268

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

   269

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

   270

		{

   271

			SQAutoFreePointers ptr;

   272

			Tretval ret = (instance->*func)(

   273

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

   274

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

   275

			);

   276

			sq_pop(vm, 2);

   277

			return Return(vm, ret);

   278

		}

   279

	};

   280

   281

	/**

   282

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

   283

	 */

   284

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

   285

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

   286

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

   287

		{

   288

			SQAutoFreePointers ptr;

   289

			(instance->*func)(

   290

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

   291

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

   292

			);

   293

			sq_pop(vm, 2);

   294

			return 0;

   295

		}

   296

   297

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

   298

		{

   299

			SQAutoFreePointers ptr;

   300

			Tcls *inst = new Tcls(

   301

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

   302

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

   303

			);

   304

   305

			return inst;

   306

		}

   307

	};

   308

   309

	/**

   310

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

   311

	 */

   312

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

   313

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

   314

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

   315

		{

   316

			SQAutoFreePointers ptr;

   317

			Tretval ret = (*func)(

   318

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

   319

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

   320

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

   321

			);

   322

			sq_pop(vm, 3);

   323

			return Return(vm, ret);

   324

		}

   325

	};

   326

   327

	/**

   328

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

   329

	 */

   330

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

   331

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

   332

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

   333

		{

   334

			SQAutoFreePointers ptr;

   335

			(*func)(

   336

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

   337

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

   338

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

   339

			);

   340

			sq_pop(vm, 3);

   341

			return 0;

   342

		}

   343

	};

   344

   345

	/**

   346

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

   347

	 */

   348

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

   349

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

   350

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

   351

		{

   352

			SQAutoFreePointers ptr;

   353

			Tretval ret = (instance->*func)(

   354

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

   355

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

   356

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

   357

			);

   358

			sq_pop(vm, 3);

   359

			return Return(vm, ret);

   360

		}

   361

	};

   362

   363

	/**

   364

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

   365

	 */

   366

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

   367

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

   368

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

   369

		{

   370

			SQAutoFreePointers ptr;

   371

			(instance->*func)(

   372

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

   373

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

   374

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

   375

			);

   376

			sq_pop(vm, 3);

   377

			return 0;

   378

		}

   379

   380

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

   381

		{

   382

			SQAutoFreePointers ptr;

   383

			Tcls *inst = new Tcls(

   384

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

   385

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

   386

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

   387

			);

   388

   389

			return inst;

   390

		}

   391

	};

   392

   393

	/**

   394

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

   395

	 */

   396

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

   397

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

   398

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

   399

		{

   400

			SQAutoFreePointers ptr;

   401

			Tretval ret = (*func)(

   402

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

   403

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

   404

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

   405

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

   406

			);

   407

			sq_pop(vm, 4);

   408

			return Return(vm, ret);

   409

		}

   410

	};

   411

   412

	/**

   413

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

   414

	 */

   415

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

   416

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

   417

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

   418

		{

   419

			SQAutoFreePointers ptr;

   420

			(*func)(

   421

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

   422

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

   423

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

   424

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

   425

			);

   426

			sq_pop(vm, 4);

   427

			return 0;

   428

		}

   429

	};

   430

   431

	/**

   432

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

   433

	 */

   434

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

   435

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

   436

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

   437

		{

   438

			SQAutoFreePointers ptr;

   439

			Tretval ret = (instance->*func)(

   440

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

   441

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

   442

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

   443

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

   444

			);

   445

			sq_pop(vm, 4);

   446

			return Return(vm, ret);

   447

		}

   448

	};

   449

   450

	/**

   451

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

   452

	 */

   453

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

   454

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

   455

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

   456

		{

   457

			SQAutoFreePointers ptr;

   458

			(instance->*func)(

   459

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

   460

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

   461

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

   462

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

   463

			);

   464

			sq_pop(vm, 4);

   465

			return 0;

   466

		}

   467

   468

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

   469

		{

   470

			SQAutoFreePointers ptr;

   471

			Tcls *inst = new Tcls(

   472

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

   473

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

   474

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

   475

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

   476

			);

   477

   478

			return inst;

   479

		}

   480

	};

   481

   482

	/**

   483

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

   484

	 */

   485

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