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"

    13

    14

/**

    15

 * The Squirrel convert routines

    16

 */

    17

namespace SQConvert {

    18

	/**

    19

	 * Pointers assigned to this class will be free'd when this instance

    20

	 *  comes out of scope. Useful to make sure you can use strdup(),

    21

	 *  without leaking memory.

    22

	 */

    23

	struct SQAutoFreePointers : SmallVector<void *, 1> {

    24

		~SQAutoFreePointers()

    25

		{

    26

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

    27

		}

    28

	};

    29

    30

	template <bool Y> struct YesT {

    31

		static const bool Yes = Y;

    32

		static const bool No = !Y;

    33

	};

    34

    35

	/**

    36

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

    37

	 */

    38

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

    39

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

    40

    41

	/**

    42

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

    43

	 */

    44

	template <typename Tfunc> struct HasVoidReturnT;

    45

	/* functions */

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

	/* methods */

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

    60

    61

	/**

    62

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

    63

	 */

    64

	template <typename T> class ForceType { };

    65

    66

	/**

    67

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

    68

	 */

    69

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

    70

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

    84

	/**

    85

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

    86

	 */

    87

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

    88

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

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

    97

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

    98

   128

	/**

   129

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

   130

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

   131

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

   132

	*/

   133

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

   134

   135

	/**

   136

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

   137

	 */

   138

	template <typename Tretval>

   139

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

   140

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

   141

		{

   142

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

   143

		}

   144

	};

   145

   146

	/**

   147

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

   148

	 */

   149

	template <typename Tretval>

   150

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

   151

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

   152

		{

   153

			(*func)();

   154

			return 0;

   155

		}

   156

	};

   157

   158

	/**

   159

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

   160

	 */

   161

	template <class Tcls, typename Tretval>

   162

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

   163

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

   164

		{

   165

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

   166

		}

   167

	};

   168

   169

	/**

   170

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

   171

	 */

   172

	template <class Tcls, typename Tretval>

   173

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

   174

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

   175

		{

   176

			(instance->*func)();

   177

			return 0;

   178

		}

   179

   180

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

   181

		{

   182

			return new Tcls();

   183

		}

   184

	};

   185

   186

	/**

   187

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

   188

	 */

   189

	template <typename Tretval, typename Targ1>

   190

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

   191

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

   192

		{

   193

			SQAutoFreePointers ptr;

   194

			Tretval ret = (*func)(

   195

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

   196

			);

   197

			sq_pop(vm, 1);

   198

			return Return(vm, ret);

   199

		}

   200

	};

   201

   202

	/**

   203

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

   204

	 */

   205

	template <typename Tretval, typename Targ1>

   206

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

   207

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

   208

		{

   209

			SQAutoFreePointers ptr;

   210

			(*func)(

   211

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

   212

			);

   213

			sq_pop(vm, 1);

   214

			return 0;

   215

		}

   216

	};

   217

   218

	/**

   219

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

   220

	 */

   221

	template <class Tcls, typename Tretval, typename Targ1>

   222

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

   223

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

   224

		{

   225

			SQAutoFreePointers ptr;

   226

			Tretval ret = (instance->*func)(

   227

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

   228

			);

   229

			sq_pop(vm, 1);

   230

			return Return(vm, ret);

   231

		}

   232

	};

   233

   234

	/**

   235

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

   236

	 */

   237

	template <class Tcls, typename Tretval, typename Targ1>

   238

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

   239

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

   240

		{

   241

			SQAutoFreePointers ptr;

   242

			(instance->*func)(

   243

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

   244

			);

   245

			sq_pop(vm, 1);

   246

			return 0;

   247

		}

   248

   249

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

   250

		{

   251

			SQAutoFreePointers ptr;

   252

			Tcls *inst = new Tcls(

   253

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

   254

			);

   255

   256

			return inst;

   257

		}

   258

	};

   259

   260

	/**

   261

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

   262

	 */

   263

	template <typename Tretval, typename Targ1, typename Targ2>

   264

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

   265

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

   266

		{

   267

			SQAutoFreePointers ptr;

   268

			Tretval ret = (*func)(

   269

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

   270

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

   271

			);

   272

			sq_pop(vm, 2);

   273

			return Return(vm, ret);

   274

		}

   275

	};

   276

   277

	/**

   278

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

   279

	 */

   280

	template <typename Tretval, typename Targ1, typename Targ2>

   281

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

   282

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

   283

		{

   284

			SQAutoFreePointers ptr;

   285

			(*func)(

   286

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

   287

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

   288

			);

   289

			sq_pop(vm, 2);

   290

			return 0;

   291

		}

   292

	};

   293

   294

	/**

   295

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

   296

	 */

   297

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

   298

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

   299

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

   300

		{

   301

			SQAutoFreePointers ptr;

   302

			Tretval ret = (instance->*func)(

   303

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

   304

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

   305

			);

   306

			sq_pop(vm, 2);

   307

			return Return(vm, ret);

   308

		}

   309

	};

   310

   311

	/**

   312

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

   313

	 */

   314

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

   315

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

   316

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

   317

		{

   318

			SQAutoFreePointers ptr;

   319

			(instance->*func)(

   320

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

   321

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

   322

			);

   323

			sq_pop(vm, 2);

   324

			return 0;

   325

		}

   326

   327

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

   328

		{

   329

			SQAutoFreePointers ptr;

   330

			Tcls *inst = new Tcls(

   331

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

   332

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

   333

			);

   334

   335

			return inst;

   336

		}

   337

	};

   338

   339

	/**

   340

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

   341

	 */

   342

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

   343

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

   344

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

   345

		{

   346

			SQAutoFreePointers ptr;

   347

			Tretval ret = (*func)(

   348

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

   349

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

   350

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

   351

			);

   352

			sq_pop(vm, 3);

   353

			return Return(vm, ret);

   354

		}

   355

	};

   356

   357

	/**

   358

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

   359

	 */

   360

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

   361

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

   362

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

   363

		{

   364

			SQAutoFreePointers ptr;

   365

			(*func)(

   366

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

   367

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

   368

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

   369

			);

   370

			sq_pop(vm, 3);

   371

			return 0;

   372

		}

   373

	};

   374

   375

	/**

   376

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

   377

	 */

   378

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

   379

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

   380

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

   381

		{

   382

			SQAutoFreePointers ptr;

   383

			Tretval ret = (instance->*func)(

   384

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

   385

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

   386

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

   387

			);

   388

			sq_pop(vm, 3);

   389

			return Return(vm, ret);

   390

		}

   391

	};

   392

   393

	/**

   394

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

   395

	 */

   396

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

   397

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

   398

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

   399

		{

   400

			SQAutoFreePointers ptr;

   401

			(instance->*func)(

   402

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

   403

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

   404

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

   405

			);

   406

			sq_pop(vm, 3);

   407

			return 0;

   408

		}

   409

   410

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

   411

		{

   412

			SQAutoFreePointers ptr;

   413

			Tcls *inst = new Tcls(

   414

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

   415

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

   416

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

   417

			);

   418

   419

			return inst;

   420

		}

   421

	};

   422

   423

	/**

   424

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

   425

	 */

   426

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

   427

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

   428

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

   429

		{

   430

			SQAutoFreePointers ptr;

   431

			Tretval ret = (*func)(

   432

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

   433

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

   434

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

   435

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

   436

			);

   437

			sq_pop(vm, 4);

   438

			return Return(vm, ret);

   439

		}

   440

	};

   441

   442

	/**

   443

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

   444

	 */

   445

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

   446

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

   447

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

   448

		{

   449

			SQAutoFreePointers ptr;

   450

			(*func)(

   451

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

   452

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

   453

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

   454

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

   455

			);

   456

			sq_pop(vm, 4);

   457

			return 0;

   458

		}

   459

	};

   460

   461

	/**

   462

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

   463

	 */

   464

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

   465

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

   466

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

   467

		{

   468

			SQAutoFreePointers ptr;

   469

			Tretval ret = (instance->*func)(

   470

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

   471

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

   472

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

   473

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

   474

			);

   475

			sq_pop(vm, 4);

   476

			return Return(vm, ret);

   477

		}

   478

	};

   479

   480

	/**

   481

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

   482

	 */

   483

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

   484

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

   485

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

   486