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

    60

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

    61

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

    62

    63

	/**

    64

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

    65

	 */

    66

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

    67

    68

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

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

    77

	/**

    78

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

    79

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

    80

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

    81

	*/

    82

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

    83

    84

	/**

    85

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

    86

	 */

    87

	template <typename Tretval>

    88

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

    89

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

    90

		{

    91

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

    92

		}

    93

	};

    94

    95

	/**

    96

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

    97

	 */

    98

	template <typename Tretval>

    99

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

   100

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

   101

		{

   102

			(*func)();

   103

			return 0;

   104

		}

   105

	};

   106

   107

	/**

   108

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

   109

	 */

   110

	template <class Tcls, typename Tretval>

   111

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

   112

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

   113

		{

   114

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

   115

		}

   116

	};

   117

   118

	/**

   119

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

   120

	 */

   121

	template <class Tcls, typename Tretval>

   122

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

   123

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

   124

		{

   125

			(instance->*func)();

   126

			return 0;

   127

		}

   128

	};

   129

   130

	/**

   131

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

   132

	 */

   133

	template <typename Tretval, typename Targ1>

   134

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

   135

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

   136

		{

   137

			return Return(vm, (*func)(

   138

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

   139

			));

   140

		}

   141

	};

   142

   143

	/**

   144

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

   145

	 */

   146

	template <typename Tretval, typename Targ1>

   147

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

   148

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

   149

		{

   150

			(*func)(

   151

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

   152

			);

   153

			return 0;

   154

		}

   155

	};

   156

   157

	/**

   158

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

   159

	 */

   160

	template <class Tcls, typename Tretval, typename Targ1>

   161

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

   162

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

   163

		{

   164

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

   165

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

   166

			));

   167

		}

   168

	};

   169

   170

	/**

   171

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

   172

	 */

   173

	template <class Tcls, typename Tretval, typename Targ1>

   174

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

   175

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

   176

		{

   177

			(instance->*func)(

   178

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

   179

			);

   180

			return 0;

   181

		}

   182

	};

   183

   184

	/**

   185

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

   186

	 */

   187

	template <typename Tretval, typename Targ1, typename Targ2>

   188

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

   189

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

   190

		{

   191

			return Return(vm, (*func)(

   192

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

   193

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

   194

			));

   195

		}

   196

	};

   197

   198

	/**

   199

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

   200

	 */

   201

	template <typename Tretval, typename Targ1, typename Targ2>

   202

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

   203

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

   204

		{

   205

			(*func)(

   206

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

   207

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

   208

			);

   209

			return 0;

   210

		}

   211

	};

   212

   213

	/**

   214

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

   215

	 */

   216

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

   217

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

   218

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

   219

		{

   220

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

   221

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

   222

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

   223

			));

   224

		}

   225

	};

   226

   227

	/**

   228

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

   229

	 */

   230

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

   231

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

   232

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

   233

		{

   234

			(instance->*func)(

   235

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

   236

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

   237

			);

   238

			return 0;

   239

		}

   240

	};

   241

   242

	/**

   243

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

   244

	 */

   245

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

   246

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

   247

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

   248

		{

   249

			return Return(vm, (*func)(

   250

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

   251

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

   252

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

   253

			));

   254

		}

   255

	};

   256

   257

	/**

   258

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

   259

	 */

   260

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

   261

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

   262

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

   263

		{

   264

			(*func)(

   265

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

   266

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

   267

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

   268

			);

   269

			return 0;

   270

		}

   271

	};

   272

   273

	/**

   274

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

   275

	 */

   276

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

   277

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

   278

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

   279

		{

   280

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

   281

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

   282

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

   283

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

   284

			));

   285

		}

   286

	};

   287

   288

	/**

   289

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

   290

	 */

   291

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

   292

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

   293

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

   294

		{

   295

			(instance->*func)(

   296

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

   297

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

   298

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

   299

			);

   300

			return 0;

   301

		}

   302

	};

   303

   304

	/**

   305

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

   306

	 */

   307

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

   308

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

   309

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

   310

		{

   311

			return Return(vm, (*func)(

   312

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

   313

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

   314

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

   315

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

   316

			));

   317

		}

   318

	};

   319

   320

	/**

   321

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

   322

	 */

   323

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

   324

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

   325

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

   326

		{

   327

			(*func)(

   328

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

   329

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

   330

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

   331

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

   332

			);

   333

			return 0;

   334

		}

   335

	};

   336

   337

	/**

   338

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

   339

	 */

   340

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

   341

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

   342

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

   343

		{

   344

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

   345

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

   346

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

   347

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

   348

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

   349

			));

   350

		}

   351

	};

   352

   353

	/**

   354

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

   355

	 */

   356

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

   357

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

   358

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

   359

		{

   360

			(instance->*func)(

   361

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

   362

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

   363

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

   364

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

   365

			);

   366

			return 0;

   367

		}

   368

	};

   369

   370

   371

	/**

   372

	 * A general template for all callback functions from Squirrel.

   373

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

   374

	 *  can handle this exact amount of params.

   375

	 */

   376

	template <typename Tcls, typename Tmethod>

   377

	inline SQInteger DefSQCallback(HSQUIRRELVM vm)

   378

	{

   379

		/* Find the amount of params we got */

   380

		int nparam = sq_gettop(vm);

   381

		SQUserPointer ptr = NULL;

   395

   396

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

   398

		/* Get the real function pointer */

   399

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

   401

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

   403

	}

   404

   405

}; // namespace SQConvert

   406

   407

#endif /* SQUIRREL_HELPER_HPP */