1

/* $Id$ */

     2

     3

/** @file core.hpp the implementation of the SquirrelCore class. It handles all Squirrel-stuff and gives a nice API back to work with. */

     4

     5

#ifdef _UNICODE

     6

/* Disable unicode for squirrel to allow compilation with MINGW

     7

 * and simplify coding for WIN32 (squirrel headers miss a lot of "string" functions)

     8

 */

     9

#undef _UNICODE

    10

#endif

    11

#include <squirrel.h>

    12

#include <sqstdio.h>

    13

#include <stdarg.h>

    14

#include "../../stdafx.h"

    15

#include "../../debug.h"

    16

#include "core.hpp"

    17

    18

void SquirrelCore::CompileError(HSQUIRRELVM vm, const SQChar *desc, const SQChar *source, SQInteger line, SQInteger column)

    19

{

    20

#ifdef _SQ64

    21

	printf("Error %s:%ld/%ld: %s\n", source, line, column, desc);

    22

#else

    23

	printf("Error %s:%d/%d: %s\n", source, line, column, desc);

    24

#endif

    25

}

    26

    27

void SquirrelCore::RunError(HSQUIRRELVM vm, const char *error)

    28

{

    29

	printf("%s\n", error);

    30

}

    31

    32

SQInteger SquirrelCore::_RunError(HSQUIRRELVM vm)

    33

{

    34

	const SQChar *sErr = 0;

    35

    36

	if (sq_gettop(vm) >= 1) {

    37

		if (SQ_SUCCEEDED(sq_getstring(vm, -1, &sErr))) {

    38

			SquirrelCore::RunError(vm, sErr);

    39

		}

    40

	}

    41

    42

	SquirrelCore::RunError(vm, "Unknown error");

    43

	return 0;

    44

}

    45

    46

void SquirrelCore::PrintFunc(HSQUIRRELVM vm, const SQChar *s, ...)

    47

{

    48

	va_list arglist;

    49

	va_start(arglist, s);

    50

	vprintf(s, arglist);

    51

	va_end(arglist);

    52

	printf("\n");

    53

}

    54

    55

void SquirrelCore::AddMethod(const char *method_name, SQFUNCTION proc, uint nparam, const char *params)

    56

{

    57

	sq_pushstring(this->vm, method_name, -1);

    58

	sq_newclosure(this->vm, proc, 0);

    59

	sq_setparamscheck(this->vm, nparam, params);

    60

	sq_setnativeclosurename(this->vm, -1, method_name);

    61

	sq_createslot(this->vm, -3);

    62

}

    63

    64

void SquirrelCore::AddMethod(const char *method_name, SQFUNCTION proc)

    65

{

    66

	sq_pushstring(this->vm, method_name, -1);

    67

	sq_newclosure(this->vm, proc, 0);

    68

	sq_setnativeclosurename(this->vm, -1, method_name);

    69

	sq_createslot(this->vm, -3);

    70

}

    71

    72

void SquirrelCore::AddClassBegin(const char *class_name)

    73

{

    74

	sq_pushroottable(this->vm);

    75

	sq_pushstring(this->vm, class_name, -1);

    76

	sq_newclass(this->vm, SQFalse);

    77

}

    78

    79

void SquirrelCore::AddClassEnd()

    80

{

    81

	sq_createslot(vm, -3);

    82

}

    83

    84

void SquirrelCore::CallMethod(HSQOBJECT instance, const char *method_name)

    85

{

    86

	/* Store the current top */

    87

	int top = sq_gettop(this->vm);

    88

	/* Go to the instance-root */

    89

	sq_pushobject(this->vm, instance);

    90

	/* Find the function-name inside the script */

    91

	sq_pushstring(this->vm, method_name, -1);

    92

	if (SQ_FAILED(sq_get(this->vm, -2))) {

    93

		DEBUG(misc, 0, "[squirrel] Could not find '%s' in the class", method_name);

    94

		sq_settop(this->vm, top);

    95

		return;

    96

	}

    97

	/* Call the method */

    98

	sq_pushobject(this->vm, instance);

    99

	sq_call(this->vm, 1, 0, 0);

   100

	/* Reset the top */

   101

	sq_settop(this->vm, top);

   102

}

   103

   104

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

   105

{

   106

	int oldtop = sq_gettop(this->vm);

   107

   108

	/* First, find the class */

   109

	sq_pushroottable(this->vm);

   110

	sq_pushstring(this->vm, class_name, -1);

   111

	if (SQ_FAILED(sq_get(this->vm, -2))) {

   112

		DEBUG(misc, 0, "[squirrel] Failed to find class by the name '%s'", class_name);

   113

		sq_settop(this->vm, oldtop);

   114

		return false;

   115

	}

   116

   117

	/* Create the instance */

   118

	if (SQ_FAILED(sq_createinstance(this->vm, -1))) {

   119

		DEBUG(misc, 0, "[squirrel] Failed to create instance for class '%s'", class_name);

   120

		sq_settop(this->vm, oldtop);

   121

		return false;

   122

	}

   123

   124

	if (instance != NULL) {

   125

		/* Find our instance */

   126

		sq_getstackobj(this->vm, -1, instance);

   127

		/* Add a reference to it, so it survives for ever */

   128

		sq_addref(this->vm, instance);

   129

	}

   130

	/* Store it in the class */

   131

	sq_setinstanceup(this->vm, -1, real_instance);

   132

   133

	/* Reset the top */

   134

	sq_settop(this->vm, oldtop);

   135

   136

	return true;

   137

}

   138

   139

SquirrelCore::SquirrelCore()

   140

{

   141

	this->vm = sq_open(1024);

   142

   143

	/* Handle compile-errors ourself, so we can display it nicely */

   144

	sq_setcompilererrorhandler(this->vm, &SquirrelCore::CompileError);

   145

	sq_notifyallexceptions(this->vm, SQTrue);

   146

	/* Set a good print-function */

   147

	sq_setprintfunc(this->vm, &SquirrelCore::PrintFunc);

   148

	/* Handle runtime-errors ourself, so we can display it nicely */

   149

	sq_newclosure(this->vm, &SquirrelCore::_RunError, 0);

   150

	sq_seterrorhandler(this->vm);

   151

   152

	sq_pushroottable(this->vm);

   153

}

   154

   155

bool SquirrelCore::LoadScript(const char *script)

   156

{

   157

	/* Load and run the script */

   158

	if (SQ_FAILED(sqstd_dofile(this->vm, script, SQFalse, SQTrue))) {

   159

		DEBUG(misc, 0, "[squirrel] Failed to compile '%s'", script);

   160

		return false;

   161

	}

   162

   163

	return true;

   164

}

   165

   166

SquirrelCore::~SquirrelCore()

   167

{

   168

	/* Clean up the stuff */

   169

	sq_pop(this->vm, 1);

   170

	sq_close(this->vm);

   171

}