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 "core/smallvec_type.hpp"

    11

#include "economy_type.h"

    12

#include "squirrel_helper_type.hpp"

    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

    99

	template <> inline Array      *GetParam(ForceType<Array *>,      HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr)

   100

	{

   101

		SQObject obj;

   102

		sq_getstackobj(vm, index, &obj);

   103

		sq_pushobject(vm, obj);

   104

		sq_pushnull(vm);

   105

   106

		SmallVector<int32, 2> data;

   107

   108

		while (SQ_SUCCEEDED(sq_next(vm, -2))) {

   109

			SQInteger tmp;

   110

			if (SQ_SUCCEEDED(sq_getinteger(vm, -1, &tmp))) {

   111

				*data.Append() = (int32)tmp;

   112

			} else {

   113

				sq_pop(vm, 4);

   114

				throw sq_throwerror(vm, _SC("a member of an array used as parameter to a function is not numeric"));

   115

			}

   116

   117

			sq_pop(vm, 2);

   118

		}

   119

		sq_pop(vm, 2);

   120

   121

		Array *arr = (Array*)MallocT<byte>(sizeof(Array) + sizeof(int32) * data.Length());

   122

		arr->size = data.Length();

   123

		memcpy(arr->array, data.Begin(), sizeof(int32) * data.Length());

   124

   125

		*ptr->Append() = arr;

   126

		return arr;

   127

	}

   128

   129

	/**

   130

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

   131

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

   132

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

   133

	*/

   134

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

   135

   136

	/**

   137

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

   138

	 */

   139

	template <typename Tretval>

   140

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

   141

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

   142

		{

   143

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

   144

		}

   145

	};

   146

   147

	/**

   148

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

   149

	 */

   150

	template <typename Tretval>

   151

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

   152

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

   153

		{

   154

			(*func)();

   155

			return 0;

   156

		}

   157

	};

   158

   159

	/**

   160

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

   161

	 */

   162

	template <class Tcls, typename Tretval>

   163

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

   164

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

   165

		{

   166

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

   167

		}

   168

	};

   169

   170

	/**

   171

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

   172

	 */

   173

	template <class Tcls, typename Tretval>

   174

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

   175

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

   176

		{

   177

			(instance->*func)();

   178

			return 0;

   179

		}

   180

   181

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

   182

		{

   183

			return new Tcls();

   184

		}

   185

	};

   186

   187

	/**

   188

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

   189

	 */

   190

	template <typename Tretval, typename Targ1>

   191

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

   192

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

   193

		{

   194

			SQAutoFreePointers ptr;

   195

			Tretval ret = (*func)(

   196

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

   197

			);

   198

			sq_pop(vm, 1);

   199

			return Return(vm, ret);

   200

		}

   201

	};

   202

   203

	/**

   204

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

   205

	 */

   206

	template <typename Tretval, typename Targ1>

   207

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

   208

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

   209

		{

   210

			SQAutoFreePointers ptr;

   211

			(*func)(

   212

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

   213

			);

   214

			sq_pop(vm, 1);

   215

			return 0;

   216

		}

   217

	};

   218

   219

	/**

   220

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

   221

	 */

   222

	template <class Tcls, typename Tretval, typename Targ1>

   223

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

   224

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

   225

		{

   226

			SQAutoFreePointers ptr;

   227

			Tretval ret = (instance->*func)(

   228

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

   229

			);

   230

			sq_pop(vm, 1);

   231

			return Return(vm, ret);

   232

		}

   233

	};

   234

   235

	/**

   236

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

   237

	 */

   238

	template <class Tcls, typename Tretval, typename Targ1>

   239

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

   240

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

   241

		{

   242

			SQAutoFreePointers ptr;

   243

			(instance->*func)(

   244

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

   245

			);

   246

			sq_pop(vm, 1);

   247

			return 0;

   248

		}

   249

   250

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

   251

		{

   252

			SQAutoFreePointers ptr;

   253

			Tcls *inst = new Tcls(

   254

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

   255

			);

   256

   257

			return inst;

   258

		}

   259

	};

   260

   261

	/**

   262

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

   263

	 */

   264

	template <typename Tretval, typename Targ1, typename Targ2>

   265

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

   266

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

   267

		{

   268

			SQAutoFreePointers ptr;

   269

			Tretval ret = (*func)(

   270

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

   271

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

   272

			);

   273

			sq_pop(vm, 2);

   274

			return Return(vm, ret);

   275

		}

   276

	};

   277

   278

	/**

   279

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

   280

	 */

   281

	template <typename Tretval, typename Targ1, typename Targ2>

   282

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

   283

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

   284

		{

   285

			SQAutoFreePointers ptr;

   286

			(*func)(

   287

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

   288

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

   289

			);

   290

			sq_pop(vm, 2);

   291

			return 0;

   292

		}

   293

	};

   294

   295

	/**

   296

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

   297

	 */

   298

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

   299

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

   300

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

   301

		{

   302

			SQAutoFreePointers ptr;

   303

			Tretval ret = (instance->*func)(

   304

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

   305

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

   306

			);

   307

			sq_pop(vm, 2);

   308

			return Return(vm, ret);

   309

		}

   310

	};

   311

   312

	/**

   313

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

   314

	 */

   315

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

   316

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

   317

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

   318

		{

   319

			SQAutoFreePointers ptr;

   320

			(instance->*func)(

   321

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

   322

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

   323

			);

   324

			sq_pop(vm, 2);

   325

			return 0;

   326

		}

   327

   328

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

   329

		{

   330

			SQAutoFreePointers ptr;

   331

			Tcls *inst = new Tcls(

   332

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

   333

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

   334

			);

   335

   336

			return inst;

   337

		}

   338

	};

   339

   340

	/**

   341

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

   342

	 */

   343

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

   344

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

   345

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

   346

		{

   347

			SQAutoFreePointers ptr;

   348

			Tretval ret = (*func)(

   349

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

   350

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

   351

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

   352

			);

   353

			sq_pop(vm, 3);

   354

			return Return(vm, ret);

   355

		}

   356

	};

   357

   358

	/**

   359

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

   360

	 */

   361

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

   362

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

   363

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

   364

		{

   365

			SQAutoFreePointers ptr;

   366

			(*func)(

   367

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

   368

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

   369

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

   370

			);

   371

			sq_pop(vm, 3);

   372

			return 0;

   373

		}

   374

	};

   375

   376

	/**

   377

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

   378

	 */

   379

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

   380

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

   381

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

   382

		{

   383

			SQAutoFreePointers ptr;

   384

			Tretval ret = (instance->*func)(

   385

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

   386

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

   387

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

   388

			);

   389

			sq_pop(vm, 3);

   390

			return Return(vm, ret);

   391

		}

   392

	};

   393

   394

	/**

   395

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

   396

	 */

   397

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

   398

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

   399

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

   400

		{

   401

			SQAutoFreePointers ptr;

   402

			(instance->*func)(

   403

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

   404

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

   405

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

   406

			);

   407

			sq_pop(vm, 3);

   408

			return 0;

   409

		}

   410

   411

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

   412

		{

   413

			SQAutoFreePointers ptr;

   414

			Tcls *inst = new Tcls(

   415

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

   416

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

   417

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

   418

			);

   419

   420

			return inst;

   421

		}

   422

	};

   423

   424

	/**

   425

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

   426

	 */

   427

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

   428

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

   429

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

   430

		{

   431

			SQAutoFreePointers ptr;

   432

			Tretval ret = (*func)(

   433

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

   434

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

   435

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

   436

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

   437

			);

   438

			sq_pop(vm, 4);

   439

			return Return(vm, ret);

   440

		}

   441

	};

   442

   443

	/**

   444

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

   445

	 */

   446

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

   447

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

   448

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

   449

		{

   450

			SQAutoFreePointers ptr;

   451

			(*func)(

   452

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

   453

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

   454

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

   455

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

   456

			);

   457

			sq_pop(vm, 4);

   458

			return 0;

   459

		}

   460

	};

   461

   462

	/**

   463

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

   464

	 */

   465

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

   466

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

   467

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

   468

		{

   469

			SQAutoFreePointers ptr;

   470

			Tretval ret = (instance->*func)(

   471

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

   472

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

   473

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

   474

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

   475

			);

   476

			sq_pop(vm, 4);

   477

			return Return(vm, ret);

   478

		}

   479

	};

   480

   481

	/**

   482

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

   483

	 */

   484

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

   485

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

   486

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