1

/* $Id$ */

     2

     3

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

     4

     5

#include <squirrel.h>

     6

#include <sqstdio.h>

     7

#include <stdarg.h>

     8

#include "stdafx.h"

     9

#include "debug.h"

    10

#include "squirrel.hpp"

    11

    12

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

    13

{

    14

#ifdef _SQ64

    15

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

    16

#else

    17

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

    18

#endif

    19

}

    20

    21

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

    22

{

    23

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

    24

}

    25

    26

SQInteger Squirrel::_RunError(HSQUIRRELVM vm)

    27

{

    28

	const SQChar *sErr = 0;

    29

    30

	if (sq_gettop(vm) >= 1) {

    31

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

    32

			Squirrel::RunError(vm, FS2OTTD(sErr));

    33

		}

    34

	}

    35

    36

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

    37

	return 0;

    38

}

    39

    40

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

    41

{

    42

	va_list arglist;

    43

	va_start(arglist, s);

    44

	scvprintf(s, arglist);

    45

	va_end(arglist);

    46

	printf("\n");

    47

}

    48

    49

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

    50

{

    51

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

    52

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

    53

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

    54

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

    55

	sq_newslot(this->vm, -3, SQFalse);

    56

}

    57

    58

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

    59

{

    60

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

    61

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

    62

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

    63

	sq_newslot(this->vm, -3, SQFalse);

    64

}

    65

    66

void Squirrel::AddMethod(const char *method_name, SQFUNCTION proc, void *userdata, int size)

    67

{

    68

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

    69

    70

	void *ptr;

    71

	ptr = sq_newuserdata(vm, size);

    72

	memcpy(ptr, userdata, size);

    73

    74

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

    75

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

    76

	sq_newslot(this->vm, -3, SQFalse);

    77

}

    78

    79

void Squirrel::AddConst(const char *var_name, int value)

    80

{

    81

	sq_pushstring(this->vm, OTTD2FS(var_name), -1);

    82

	sq_pushinteger(this->vm, value);

    83

	sq_newslot(this->vm, -3, SQTrue);

    84

}

    85

    86

void Squirrel::AddClassBegin(const char *class_name)

    87

{

    88

	sq_pushroottable(this->vm);

    89

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

    90

	sq_newclass(this->vm, SQFalse);

    91

}

    92

    93

void Squirrel::AddClassEnd()

    94

{

    95

	sq_newslot(vm, -3, SQFalse);

    96

}

    97

    98

bool Squirrel::MethodExists(HSQOBJECT instance, const char *method_name)

    99

{

   100

	int top = sq_gettop(this->vm);

   101

	/* Go to the instance-root */

   102

	sq_pushobject(this->vm, instance);

   103

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

   104

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

   105

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

   106

		sq_settop(this->vm, top);

   107

		return false;

   108

	}

   109

	sq_settop(this->vm, top);

   110

	return true;

   111

}

   112

   113

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

   114

{

   115

	/* Store the current top */

   116

	int top = sq_gettop(this->vm);

   117

	/* Go to the instance-root */

   118

	sq_pushobject(this->vm, instance);

   119

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

   120

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

   121

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

   122

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

   123

		sq_settop(this->vm, top);

   124

		return;

   125

	}

   126

	/* Call the method */

   127

	sq_pushobject(this->vm, instance);

   128

	sq_call(this->vm, 1, ret == NULL ? SQFalse : SQTrue, SQFalse);

   129

	if (ret != NULL) sq_getstackobj(vm, -1, ret);

   130

	/* Reset the top */

   131

	sq_settop(this->vm, top);

   132

}

   133

   134

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

   135

{

   136

	int oldtop = sq_gettop(this->vm);

   137

   138

	/* First, find the class */

   139

	sq_pushroottable(this->vm);

   140

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

   141

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

   142

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

   143

		sq_settop(this->vm, oldtop);

   144

		return false;

   145

	}

   146

   147

	/* Create the instance */

   148

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

   149

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

   150

		sq_settop(this->vm, oldtop);

   151

		return false;

   152

	}

   153

   154

	if (instance != NULL) {

   155

		/* Find our instance */

   156

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

   157

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

   158

		sq_addref(this->vm, instance);

   159

	}

   160

	/* Store it in the class */

   161

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

   162

   163

	/* Reset the top */

   164

	sq_settop(this->vm, oldtop);

   165

   166

	return true;

   167

}

   168

   169

Squirrel::Squirrel()

   170

{

   171

	this->vm = sq_open(1024);

   172

   173

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

   174

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

   175

	sq_notifyallexceptions(this->vm, SQTrue);

   176

	/* Set a good print-function */

   177

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

   178

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

   179

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

   180

	sq_seterrorhandler(this->vm);

   181

   182

	sq_pushroottable(this->vm);

   183

}

   184

   185

bool Squirrel::LoadScript(const char *script)

   186

{

   187

	/* Load and run the script */

   188

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

   189

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

   190

		return false;

   191

	}

   192

   193

	return true;

   194

}

   195

   196

Squirrel::~Squirrel()

   197

{

   198

	/* Clean up the stuff */

   199

	sq_pop(this->vm, 1);

   200

	sq_close(this->vm);

   201

}