1

/* $Id$ */

     2

     3

/** @file squirrel.hpp defines the Squirrel class */

     4

     5

#ifndef SQUIRREL_HPP

     6

#define SQUIRREL_HPP

     7

     8

class Squirrel {

     9

private:

    10

	typedef void (SQPrintFunc)(bool error_msg, const SQChar *message);

    11

    12

	HSQUIRRELVM vm;          ///< The VirtualMachine instnace for squirrel

    13

	void *global_pointer;    ///< Can be set by who ever initializes Squirrel

    14

	SQPrintFunc *print_func; ///< Points to either NULL, or a custom print handler

    15

    16

	/**

    17

	 * The internal RunError handler. It looks up the real error and calls RunError with it.

    18

	 */

    19

	static SQInteger _RunError(HSQUIRRELVM vm);

    20

    21

protected:

    22

	/**

    23

	 * The CompileError handler.

    24

	 */

    25

	static void CompileError(HSQUIRRELVM vm, const SQChar *desc, const SQChar *source, SQInteger line, SQInteger column);

    26

    27

	/**

    28

	 * The RunError handler.

    29

	 */

    30

	static void RunError(HSQUIRRELVM vm, const SQChar *error);

    31

    32

	/**

    33

	 * If a user runs 'print' inside a script, this function gets the params.

    34

	 */

    35

	static void PrintFunc(HSQUIRRELVM vm, const SQChar *s, ...);

    36

    37

	/**

    38

	 * If an error has to be print, this function is called.

    39

	 */

    40

	static void ErrorPrintFunc(HSQUIRRELVM vm, const SQChar *s, ...);

    41

    42

public:

    43

	Squirrel();

    44

	~Squirrel();

    45

    46

	/**

    47

	 * Load a script.

    48

	 * @param script The full script-name to load.

    49

	 * @return False if loading failed.

    50

	 */

    51

	bool LoadScript(const char *script);

    52

	static bool LoadScript(HSQUIRRELVM vm, const char *script, bool in_root = true);

    53

    54

	/**

    55

	 * Load a file to a given VM.

    56

	 */

    57

	static SQRESULT LoadFile(HSQUIRRELVM vm, const char *filename, SQBool printerror);

    58

    59

	/**

    60

	 * Adds a function to the stack. Depending on the current state this means

    61

	 *  either a method or a global function.

    62

	 */

    63

	void AddMethod(const char *method_name, SQFUNCTION proc, uint nparam = 0, const char *params = NULL, void *userdata = NULL, int size = 0);

    64

    65

	/**

    66

	 * Adds a const to the stack. Depending on the current state this means

    67

	 *  either a const to a class or to the global space.

    68

	 */

    69

	void AddConst(const char *var_name, int value);

    70

    71

	/**

    72

	 * Adds a class to the global scope. Make sure to call AddClassEnd when you

    73

	 *  are done adding methods.

    74

	 */

    75

	void AddClassBegin(const char *class_name);

    76

    77

	/**

    78

	 * Adds a class to the global scope, extending 'parent_class'.

    79

	 * Make sure to call AddClassEnd when you are done adding methods.

    80

	 */

    81

	void AddClassBegin(const char *class_name, const char *parent_class);

    82

    83

	/**

    84

	 * Finishes adding a class to the global scope. If this isn't called, no

    85

	 *  class is really created.

    86

	 */

    87

	void AddClassEnd();

    88

    89

	/**

    90

	 * Call a method of an instance, in various flavors.

    91

	 */

    92

	void CallMethod(HSQOBJECT instance, const char *method_name, HSQOBJECT *ret);

    93

	void CallMethod(HSQOBJECT instance, const char *method_name) { this->CallMethod(instance, method_name, NULL); }

    94

	const char *CallStringMethodStrdup(HSQOBJECT instance, const char *method_name) { HSQOBJECT ret; this->CallMethod(instance, method_name, &ret); return strdup(ObjectToString(&ret)); }

    95

	int CallIntegerMethod(HSQOBJECT instance, const char *method_name) { HSQOBJECT ret; this->CallMethod(instance, method_name, &ret); return ObjectToInteger(&ret); }

    96

    97

	/**

    98

	 * Check if a method exists in an instance.

    99

	 */

   100

	bool MethodExists(HSQOBJECT instance, const char *method_name);

   101

   102

	/**

   103

	 * Creates a class instance.

   104

	 * @param class_name The name of the class of which we create an instance.

   105

	 * @param real_instance The instance to the real class, if it represents a real class.

   106

	 * @param instance Returning value with the pointer to the instance.

   107

	 * @param release_hook Optional param to give a release hook.

   108

	 * @return False if creating failed.

   109

	 */

   110

	static bool CreateClassInstanceVM(HSQUIRRELVM vm, const char *class_name, void *real_instance, HSQOBJECT *instance, SQRELEASEHOOK release_hook);

   111

   112

	/**

   113

	 * Exactly the same as CreateClassInstanceVM, only callable without instance of Squirrel.

   114

	 */

   115

	bool CreateClassInstance(const char *class_name, void *real_instance, HSQOBJECT *instance);

   116

   117

	/**

   118

	 * Get the real-instance pointer.

   119

	 * @note This will only work just after a function-call from within Squirrel

   120

	 *  to your C++ function.

   121

	 */

   122

	static bool GetRealInstance(HSQUIRRELVM vm, SQUserPointer *ptr) { return SQ_SUCCEEDED(sq_getinstanceup(vm, 1, ptr, 0)); }

   123

   124

	/**

   125

	 * Get the Squirrel-instance pointer.

   126

	 * @note This will only work just after a function-call from within Squirrel

   127

	 *  to your C++ function.

   128

	 */

   129

	static bool GetInstance(HSQUIRRELVM vm, HSQOBJECT *ptr, int pos = 1) { sq_getclass(vm, pos); sq_getstackobj(vm, pos, ptr); sq_pop(vm, 1); return true; }

   130

   131

	/**

   132

	 * Convert a Squirrel-object to a string.

   133

	 */

   134

	static const char *ObjectToString(HSQOBJECT *ptr) { return FS2OTTD(sq_objtostring(ptr)); }

   135

   136

	/**

   137

	 * Convert a Squirrel-object to an integer.

   138

	 */

   139

	static int ObjectToInteger(HSQOBJECT *ptr) { return sq_objtointeger(ptr); }

   140

   141

	/**

   142

	 * Sets a pointer in the VM that is reachable from where ever you are in SQ.

   143

	 *  Useful to keep track of the main instance.

   144

	 */

   145

	void SetGlobalPointer(void *ptr) { this->global_pointer = ptr; }

   146

   147

	/**

   148

	 * Get the pointer as set by SetGlobalPointer.

   149

	 */

   150

	static void *GetGlobalPointer(HSQUIRRELVM vm) { return ((Squirrel *)sq_getforeignptr(vm))->global_pointer; }

   151

   152

	/**

   153

	 * Set a custom print function, so you can handle outputs from SQ yourself.

   154

	 */

   155

	void SetPrintFunction(SQPrintFunc *func) { this->print_func = func; }

   156

   157

	/**

   158

	 * Throw a Squirrel error that will be nicely displayed to the user.

   159

	 */

   160

	void ThrowError(const char *error) { sq_throwerror(this->vm, OTTD2FS(error)); }

   161

   162

	/**

   163

	 * Release a SQ object.

   164

	 */

   165

	void ReleaseObject(HSQOBJECT *ptr) { sq_release(this->vm, ptr); }

   166

};

   167

   168

#endif /* SQUIRREL_HPP */