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

	/* methods */

    37

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

    38

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

    39

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

    40

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

    41

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

    42

    43

    44

	/**

    45

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

    46

	 */

    47

	template <typename T> class ForceType { };

    48

    49

	/**

    50

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

    51

	 */

    52

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

    53

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    61

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

    62

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

    63

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

    64

    65

	/**

    66

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

    67

	 */

    68

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

    69

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

    79

	/**

    80

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

    81

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

    82

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

    83

	*/

    84

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

    85

    86

	/**

    87

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

    88

	 */

    89

	template <typename Tretval>

    90

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

    91

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

    92

		{

    93

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

    94

		}

    95

	};

    96

    97

	/**

    98

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

    99

	 */

   100

	template <typename Tretval>

   101

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

   102

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

   103

		{

   104

			(*func)();

   105

			return 0;

   106

		}

   107

	};

   108

   109

	/**

   110

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

   111

	 */

   112

	template <class Tcls, typename Tretval>

   113

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

   114

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

   115

		{

   116

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

   117

		}

   118

	};

   119

   120

	/**

   121

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

   122

	 */

   123

	template <class Tcls, typename Tretval>

   124

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

   125

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

   126

		{

   127

			(instance->*func)();

   128

			return 0;

   129

		}

   130

   131

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

   132

		{

   133

			return new Tcls();

   134

		}

   135

	};

   136

   137

	/**

   138

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

   139

	 */

   140

	template <typename Tretval, typename Targ1>

   141

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

   142

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

   143

		{

   144

			return Return(vm, (*func)(

   145

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

   146

			));

   147

		}

   148

	};

   149

   150

	/**

   151

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

   152

	 */

   153

	template <typename Tretval, typename Targ1>

   154

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

   155

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

   156

		{

   157

			(*func)(

   158

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

   159

			);

   160

			return 0;

   161

		}

   162

	};

   163

   164

	/**

   165

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

   166

	 */

   167

	template <class Tcls, typename Tretval, typename Targ1>

   168

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

   169

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

   170

		{

   171

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

   172

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

   173

			));

   174

		}

   175

	};

   176

   177

	/**

   178

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

   179

	 */

   180

	template <class Tcls, typename Tretval, typename Targ1>

   181

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

   182

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

   183

		{

   184

			(instance->*func)(

   185

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

   186

			);

   187

			return 0;

   188

		}

   189

   190

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

   191

		{

   192

			Tcls *inst = new Tcls(

   193

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

   194

			);

   195

   196

			return inst;

   197

		}

   198

	};

   199

   200

	/**

   201

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

   202

	 */

   203

	template <typename Tretval, typename Targ1, typename Targ2>

   204

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

   205

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

   206

		{

   207

			return Return(vm, (*func)(

   208

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

   209

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

   210

			));

   211

		}

   212

	};

   213

   214

	/**

   215

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

   216

	 */

   217

	template <typename Tretval, typename Targ1, typename Targ2>

   218

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

   219

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

   220

		{

   221

			(*func)(

   222

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

   223

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

   224

			);

   225

			return 0;

   226

		}

   227

	};

   228

   229

	/**

   230

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

   231

	 */

   232

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

   233

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

   234

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

   235

		{

   236

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

   237

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

   238

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

   239

			));

   240

		}

   241

	};

   242

   243

	/**

   244

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

   245

	 */

   246

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

   247

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

   248

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

   249

		{

   250

			(instance->*func)(

   251

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

   252

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

   253

			);

   254

			return 0;

   255

		}

   256

   257

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

   258

		{

   259

			Tcls *inst = new Tcls(

   260

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

   261

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

   262

			);

   263

   264

			return inst;

   265

		}

   266

	};

   267

   268

	/**

   269

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

   270

	 */

   271

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

   272

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

   273

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

   274

		{

   275

			return Return(vm, (*func)(

   276

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

   277

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

   278

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

   279

			));

   280

		}

   281

	};

   282

   283

	/**

   284

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

   285

	 */

   286

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

   287

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

   288

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

   289

		{

   290

			(*func)(

   291

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

   292

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

   293

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

   294

			);

   295

			return 0;

   296

		}

   297

	};

   298

   299

	/**

   300

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

   301

	 */

   302

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

   303

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

   304

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

   305

		{

   306

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

   307

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

   308

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

   309

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

   310

			));

   311

		}

   312

	};

   313

   314

	/**

   315

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

   316

	 */

   317

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

   318

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

   319

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

   320

		{

   321

			(instance->*func)(

   322

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

   323

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

   324

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

   325

			);

   326

			return 0;

   327

		}

   328

   329

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

   330

		{

   331

			Tcls *inst = new Tcls(

   332

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

   333

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

   334

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

   335

			);

   336

   337

			return inst;

   338

		}

   339

	};

   340

   341

	/**

   342

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

   343

	 */

   344

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

   345

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

   346

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

   347

		{

   348

			return Return(vm, (*func)(

   349

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

   350

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

   351

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

   352

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

   353

			));

   354

		}

   355

	};

   356

   357

	/**

   358

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

   359

	 */

   360

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

   361

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

   362

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

   363

		{

   364

			(*func)(

   365

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

   366

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

   367

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

   368

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

   369

			);

   370

			return 0;

   371

		}

   372

	};

   373

   374

	/**

   375

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

   376

	 */

   377

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

   378

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

   379

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

   380

		{

   381

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

   382

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

   383

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

   384

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

   385

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

   386

			));

   387

		}

   388

	};

   389

   390

	/**

   391

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

   392

	 */

   393

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

   394

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

   395

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

   396

		{

   397

			(instance->*func)(

   398

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

   399

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

   400

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

   401

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

   402

			);

   403

			return 0;

   404

		}

   405

   406

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

   407

		{

   408

			Tcls *inst = new Tcls(

   409

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

   410

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

   411

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

   412

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

   413

			);

   414

   415

			return inst;

   416

		}

   417

	};

   418

   419

   420

	/**

   421

	 * A general template for all non-static method callbacks from Squirrel.

   422

	 *  In here the function_proc is recovered, and the SQCall is called that

   423

	 *  can handle this exact amount of params.

   424

	 */

   425

	template <typename Tcls, typename Tmethod>

   426

	inline SQInteger DefSQNonStaticCallback(HSQUIRRELVM vm)

   427

	{

   428

		/* Find the amount of params we got */

   429

		int nparam = sq_gettop(vm);

   430

		SQUserPointer ptr = NULL;

   431

		SQUserPointer real_instance = NULL;

   432

		HSQOBJECT instance;

   433

   434

		/* Get the 'SQ' instance of this class */

   435

		Squirrel::GetInstance(vm, &instance);

   436

   437

		/* Protect against calls to a non-static method in a static way */

   438

		sq_pushroottable(vm);

   439

		sq_pushstring(vm, OTTD2FS(Tcls::GetClassName()), -1);

   440

		sq_get(vm, -2);

   441

		sq_pushobject(vm, instance);

   442

		if (sq_instanceof(vm) != SQTrue) return sq_throwerror(vm, _SC("class method is non-static"));

   443

		sq_settop(vm, nparam);

   444

   445

		/* Get the 'real' instance of this class */

   446

		sq_getinstanceup(vm, 1, &real_instance, 0);

   447

		/* Get the real function pointer */

   448

		sq_getuserdata(vm, nparam, &ptr, 0);

   449

   450

		/* Delegate it to a template that can handle this specific function */

   451

		return HelperT<Tmethod>::SQCall((Tcls *)real_instance, *(Tmethod *)ptr, vm);

   452

	}

   453

   454

	/**

   455

	 * A general template for all function/static method callbacks from Squirrel.

   456

	 *  In here the function_proc is recovered, and the SQCall is called that

   457

	 *  can handle this exact amount of params.

   458

	 */

   459

	template <typename Tcls, typename Tmethod>

   460

	inline SQInteger DefSQStaticCallback(HSQUIRRELVM vm)

   461

	{

   462

		/* Find the amount of params we got */

   463

		int nparam = sq_gettop(vm);

   464

		SQUserPointer ptr = NULL;

   465

   466

		/* Get the real function pointer */

   467

		sq_getuserdata(vm, nparam, &ptr, 0);

   468

   469

		/* Delegate it to a template that can handle this specific function */

   470

		return HelperT<Tmethod>::SQCall((Tcls *)NULL, *(Tmethod *)ptr, vm);

   471

	}

   472

   473

	/**

   474

	 * A general template for the destructor of SQ instances. This is needed

   475

	 *  here as it has to be in the same scope as DefSQConstructorCallback.

   476

	 */

   477

	template <typename Tcls>

   478

	static SQInteger DefSQDestructorCallback(SQUserPointer p, SQInteger size)

   479

	{

   480

		/* Remove the real instance too */

   481

		if (p != NULL) delete (Tcls *)p;

   482

		return 0;

   483

	}

   484

   485

	/**

   486

	 * A general template to handle creating of instance with any amount of

   487

	 *  params. It creates the instance in C++, and it sets all the needed

   488

	 *  settings in SQ to register the instance.

   489

	 */

   490

	template <typename Tcls, typename Tmethod>

   491

	inline SQInteger DefSQConstructorCallback(HSQUIRRELVM vm)

   492

	{

   493

		/* Create the real instance */