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

#include "squirrel_std.hpp"

    12

#include <sqstdaux.h>

    13

    14

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

    15

{

    16

	char *src = strdup(FS2OTTD(source));

    17

	char *dsc = strdup(FS2OTTD(desc));

    18

#ifdef _SQ64

    19

	DEBUG(misc, 0, "Error %s:%ld/%ld: %s", src, line, column, dsc);

    20

#else

    21

	DEBUG(misc, 0, "Error %s:%d/%d: %s", src, line, column, dsc);

    22

#endif

    23

	free(src);

    24

	free(dsc);

    25

}

    26

    27

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

    28

{

    29

	va_list arglist;

    30

	SQChar buf[1024];

    31

    32

	va_start(arglist, s);

    33

	scvsnprintf(buf, lengthof(buf), s, arglist);

    34

	va_end(arglist);

    35

    36

	/* Check if we have a custom print function */

    37

	SQPrintFunc *func = ((Squirrel *)sq_getforeignptr(vm))->print_func;

    38

	if (func == NULL) {

    39

		scfprintf(stderr, _SC("%s"), buf);

    40

	} else {

    41

		(*func)(true, buf);

    42

	}

    43

}

    44

    45

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

    46

{

    47

	/* Set the print function to something that prints to stderr */

    48

	SQPRINTFUNCTION pf = sq_getprintfunc(vm);

    49

	sq_setprintfunc(vm, &Squirrel::ErrorPrintFunc);

    50

    51

	/* Check if we have a custom print function */

    52

	SQChar buf[1024];

    53

	scsnprintf(buf, lengthof(buf), _SC("Your script made an error: %s\n"), error);

    54

	SQPrintFunc *func = ((Squirrel *)sq_getforeignptr(vm))->print_func;

    55

	if (func == NULL) {

    56

		scfprintf(stderr, _SC("%s"), buf);

    57

	} else {

    58

		(*func)(true, buf);

    59

	}

    60

    61

	/* Print below the error the stack, so the users knows what is happening */

    62

	sqstd_printcallstack(vm);

    63

	/* Reset the old print function */

    64

	sq_setprintfunc(vm, pf);

    65

}

    66

    67

SQInteger Squirrel::_RunError(HSQUIRRELVM vm)

    68

{

    69

	const SQChar *sErr = 0;

    70

    71

	if (sq_gettop(vm) >= 1) {

    72

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

    73

			Squirrel::RunError(vm, sErr);

    74

			return 0;

    75

		}

    76

	}

    77

    78

	Squirrel::RunError(vm, _SC("unknown error"));

    79

	return 0;

    80

}

    81

    82

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

    83

{

    84

	va_list arglist;

    85

	SQChar buf[1024];

    86

    87

	va_start(arglist, s);

    88

	scvsnprintf(buf, lengthof(buf) - 2, s, arglist);

    89

	va_end(arglist);

    90

	scstrcat(buf, _SC("\n"));

    91

    92

	/* Check if we have a custom print function */

    93

	SQPrintFunc *func = ((Squirrel *)sq_getforeignptr(vm))->print_func;

    94

	if (func == NULL) {

    95

		scprintf(_SC("%s"), buf);

    96

	} else {

    97

		(*func)(false, buf);

    98

	}

    99

}

   100

   101

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

   102

{

   103

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

   104

   105

	if (size != 0) {

   106

		void *ptr = sq_newuserdata(vm, size);

   107

		memcpy(ptr, userdata, size);

   108

	}

   109

   110

	sq_newclosure(this->vm, proc, size != 0 ? 1 : 0);

   111

	if (nparam != 0) sq_setparamscheck(this->vm, nparam, OTTD2FS(params));

   112

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

   113

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

   114

}

   115

   116

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

   117

{

   118

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

   119

	sq_pushinteger(this->vm, value);

   120

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

   121

}

   122

   123

void Squirrel::AddClassBegin(const char *class_name)

   124

{

   125

	sq_pushroottable(this->vm);

   126

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

   127

	sq_newclass(this->vm, SQFalse);

   128

}

   129

   130

void Squirrel::AddClassBegin(const char *class_name, const char *parent_class)

   131

{

   132

	sq_pushroottable(this->vm);

   133

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

   134

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

   135

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

   136

		DEBUG(misc, 0, "[squirrel] Failed to initialize class '%s' based on parent class '%s'", class_name, parent_class);

   137

		DEBUG(misc, 0, "[squirrel] Make sure that '%s' exists before trying to define '%s'", parent_class, class_name);

   138

		return;

   139

	}

   140

	sq_newclass(this->vm, SQTrue);

   141

}

   142

   143

void Squirrel::AddClassEnd()

   144

{

   145

	sq_newslot(vm, -3, SQFalse);

   146

}

   147

   148

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

   149

{

   150

	int top = sq_gettop(this->vm);

   151

	/* Go to the instance-root */

   152

	sq_pushobject(this->vm, instance);

   153

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

   154

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

   155

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

   156

		sq_settop(this->vm, top);

   157

		return false;

   158

	}

   159

	sq_settop(this->vm, top);

   160

	return true;

   161

}

   162

   163

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

   164

{

   165

	/* Store the current top */

   166

	int top = sq_gettop(this->vm);

   167

	/* Go to the instance-root */

   168

	sq_pushobject(this->vm, instance);

   169

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

   170

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

   171

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

   172

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

   173

		sq_settop(this->vm, top);

   174

		return;

   175

	}

   176

	/* Call the method */

   177

	sq_pushobject(this->vm, instance);

   178

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

   179

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

   180

	/* Reset the top */

   181

	sq_settop(this->vm, top);

   182

}

   183

   184

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

   185

{

   186

	int oldtop = sq_gettop(vm);

   187

   188

	/* First, find the class */

   189

	sq_pushroottable(vm);

   190

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

   191

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

   192

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

   193

		sq_settop(vm, oldtop);

   194

		return false;

   195

	}

   196

   197

	/* Create the instance */

   198

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

   199

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

   200

		sq_settop(vm, oldtop);

   201

		return false;

   202

	}

   203

   204

	if (instance != NULL) {

   205

		/* Find our instance */

   206

		sq_getstackobj(vm, -1, instance);

   207

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

   208

		sq_addref(vm, instance);

   209

	}

   210

	sq_remove(vm, -2); // Class-name

   211

	sq_remove(vm, -2); // Root-table

   212

   213

	/* Store it in the class */

   214

	sq_setinstanceup(vm, -1, real_instance);

   215

	if (release_hook != NULL) sq_setreleasehook(vm, -1, release_hook);

   216

   217

	if (instance != NULL) sq_settop(vm, oldtop);

   218

   219

	return true;

   220

}

   221

   222

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

   223

{

   224

	return Squirrel::CreateClassInstanceVM(this->vm, class_name, real_instance, instance, NULL);

   225

}

   226

   227

Squirrel::Squirrel()

   228

{

   229

	this->vm = sq_open(1024);

   230

	this->print_func = NULL;

   231

	this->global_pointer = NULL;

   232

   233

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

   234

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

   235

	sq_notifyallexceptions(this->vm, SQTrue);

   236

	/* Set a good print-function */

   237

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

   238

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

   239

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

   240

	sq_seterrorhandler(this->vm);

   241

   242

	/* Set the foreigh pointer, so we can always find this instance from within the VM */

   243

	sq_setforeignptr(this->vm, this);

   244

   245

	sq_pushroottable(this->vm);

   246

	squirrel_register_global_std(this);

   247

}

   248

   249

bool Squirrel::LoadScript(const char *script)

   250

{

   251

	/* Make sure we are always in the root-table */

   252

	sq_pushroottable(this->vm);

   253

   254

	/* Load and run the script */

   255

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

   256

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

   257

		return false;

   258

	}

   259

   260

	return true;

   261

}

   262

   263

Squirrel::~Squirrel()

   264

{

   265

	/* Clean up the stuff */

   266

	sq_pop(this->vm, 1);

   267

	sq_close(this->vm);

   268

}