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 class. It doesn't have an instance, the methods only are used.

    12

 */

    13

class SQConvert {

    14

public:

    15

	/**

    16

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

    17

	 */

    18

	template <typename T> class ForceType { };

    19

    20

	/**

    21

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

    22

	 */

    23

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

    24

    25

	/**

    26

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

    27

	 */

    28

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

    29

    30

	/**

    31

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

    32

	 */

    33

	template <typename CL, typename RT>

    34

	static int SQCall(CL *instance, RT (CL::*func)(), HSQUIRRELVM vm)

    35

	{

    36

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

    37

	}

    38

    39

	/**

    50

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

    51

	 */

    52

	template <typename CL, typename RT, typename P1>

    53

	static int SQCall(CL *instance, RT (CL::*func)(P1), HSQUIRRELVM vm)

    54

	{

    55

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

    56

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

    57

					));

    58

	}

    59

    60

	/**

    73

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

    74

	 */

    75

	template <typename CL, typename RT, typename P1, typename P2>

    76

	static int SQCall(CL *instance, RT (CL::*func)(P1, P2), HSQUIRRELVM vm)

    77

	{

    78

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

    79

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

    80

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

    81

					));

    82

	}

    83

    84

	/**

    98

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

    99

	 */

   100

	template <typename CL, typename RT, typename P1, typename P2, typename P3>

   101

	static int SQCall(CL *instance, RT (CL::*func)(P1, P2, P3), HSQUIRRELVM vm)

   102

	{

   103

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

   104

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

   105

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

   106

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

   107

					));

   108

	}

   109

   110

	/**

   125

	 * A general template for all callback functions from Squirrel.

   126

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

   127

	 *  can handle this exact amount of params.

   128

	 */

   129

	template <typename CL, typename Func>

   130

	static SQInteger DefSQCallback(HSQUIRRELVM vm)

   131

	{

   132

		/* Find the amount of params we got */

   133

		int nparam = sq_gettop(vm);

   134

		SQUserPointer ptr = NULL;

   135

		SQUserPointer instance = NULL;

   136

   137

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

   138

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

   139

		/* Get the real function pointer */

   140

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

   141

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

   142

		return SQCall((CL *)instance, *(Func *)ptr, vm);

   143

	}

   144

};

   145

   146

#endif /* SQUIRREL_HELPER_HPP */