text: #include "scripthelper.h"
  #include <string.h>
  #include <assert.h>
  #include <stdio.h>
  #include <fstream>
  #include <set>
  #include <stdlib.h>
  
  using namespace lambda;
  
  BEGIN_AS_NAMESPACE
  
  int CompareRelation(asIScriptEngine *engine, void *lobj, void *robj, int typeId, int &result)
  {
  	// TODO: If a lot of script objects are going to be compared, e.g. when sorting an array,
  	//       then the method id and context should be cached between calls.
  
  	int retval = -1;
  	asIScriptFunction *func = 0;
  
  	asITypeInfo *ti = engine->GetTypeInfoById(typeId);
  	if (ti)
  	{
  		// Check if the object type has a compatible opCmp method
  		for (asUINT n = 0; n < ti->GetMethodCount(); n++)
  		{
  			asIScriptFunction *f = ti->GetMethodByIndex(n);
  			asDWORD flags;
  			if (strcmp(f->GetName(), "opCmp") == 0 &&
  				f->GetReturnTypeId(&flags) == asTYPEID_INT32 &&
  				flags == asTM_NONE &&
  				f->GetParamCount() == 1)
  			{
  				int paramTypeId;
  				f->GetParam(0, &paramTypeId, &flags);
  
  				// The parameter must be an input reference of the same type
  				// If the reference is a inout reference, then it must also be read-only
  				if (!(flags & asTM_INREF) || typeId != paramTypeId || ((flags & asTM_OUTREF) && !(flags & asTM_CONST)))
  					break;
  
  				// Found the method
  				func = f;
  				break;
  			}
  		}
  	}
  
  	if (func)
  	{
  		// Call the method
  		asIScriptContext *ctx = engine->CreateContext();
  		ctx->Prepare(func);
  		ctx->SetObject(lobj);
  		ctx->SetArgAddress(0, robj);
  		int r = ctx->Execute();
  		if (r == asEXECUTION_FINISHED)
  		{
  			result = (int)ctx->GetReturnDWord();
  
  			// The comparison was successful
  			retval = 0;
  		}
  		ctx->Release();
  	}
  
  	return retval;
  }
  
  int CompareEquality(asIScriptEngine *engine, void *lobj, void *robj, int typeId, bool &result)
  {
  	// TODO: If a lot of script objects are going to be compared, e.g. when searching for an
  	//       entry in a set, then the method and context should be cached between calls.
  
  	int retval = -1;
  	asIScriptFunction *func = 0;
  
  	asITypeInfo *ti = engine->GetTypeInfoById(typeId);
  	if (ti)
  	{
  		// Check if the object type has a compatible opEquals method
  		for (asUINT n = 0; n < ti->GetMethodCount(); n++)
  		{
  			asIScriptFunction *f = ti->GetMethodByIndex(n);
  			asDWORD flags;
  			if (strcmp(f->GetName(), "opEquals") == 0 &&
  				f->GetReturnTypeId(&flags) == asTYPEID_BOOL &&
  				flags == asTM_NONE &&
  				f->GetParamCount() == 1)
  			{
  				int paramTypeId;
  				f->GetParam(0, &paramTypeId, &flags);
  
  				// The parameter must be an input reference of the same type
  				// If the reference is a inout reference, then it must also be read-only
  				if (!(flags & asTM_INREF) || typeId != paramTypeId || ((flags & asTM_OUTREF) && !(flags & asTM_CONST)))
  					break;
  
  				// Found the method
  				func = f;
  				break;
  			}
  		}
  	}
  
  	if (func)
  	{
  		// Call the method
  		asIScriptContext *ctx = engine->CreateContext();
  		ctx->Prepare(func);
  		ctx->SetObject(lobj);
  		ctx->SetArgAddress(0, robj);
  		int r = ctx->Execute();
  		if (r == asEXECUTION_FINISHED)
  		{
  			result = ctx->GetReturnByte() ? true : false;
  
  			// The comparison was successful
  			retval = 0;
  		}
  		ctx->Release();
  	}
  	else
  	{
  		// If the opEquals method doesn't exist, then we try with opCmp instead
  		int relation;
  		retval = CompareRelation(engine, lobj, robj, typeId, relation);
  		if (retval >= 0)
  			result = relation == 0 ? true : false;
  	}
  
  	return retval;
  }
  
  int ExecuteString(asIScriptEngine *engine, const char *code, asIScriptModule *mod, asIScriptContext *ctx)
  {
  	return ExecuteString(engine, code, 0, asTYPEID_VOID, mod, ctx);
  }
  
  int ExecuteString(asIScriptEngine *engine, const char *code, void *ref, int refTypeId, asIScriptModule *mod, asIScriptContext *ctx)
  {
  	// Wrap the code in a function so that it can be compiled and executed
  	lambda::String funcCode = " ExecuteString() {\n";
  	funcCode += code;
  	funcCode += "\n;}";
  
  	// Determine the return type based on the type of the ref arg
  	funcCode = engine->GetTypeDeclaration(refTypeId, true) + funcCode;
  
  	// GetModule will free unused types, so to be on the safe side we'll hold on to a reference to the type
  	asITypeInfo *type = 0;
  	if (refTypeId & asTYPEID_MASK_OBJECT)
  	{
  		type = engine->GetTypeInfoById(refTypeId);
  		if (type)
  			type->AddRef();
  	}
  
  	// If no module was provided, get a dummy from the engine
  	asIScriptModule *execMod = mod ? mod : engine->GetModule("ExecuteString", asGM_ALWAYS_CREATE);
  
  	// Now it's ok to release the type
  	if (type)
  		type->Release();
  
  	// Compile the function that can be executed
  	asIScriptFunction *func = 0;
  	int r = execMod->CompileFunction("ExecuteString", funcCode.c_str(), -1, 0, &func);
  	if (r < 0)
  		return r;
  
  	// If no context was provided, request a new one from the engine
  	asIScriptContext *execCtx = ctx ? ctx : engine->RequestContext();
  	r = execCtx->Prepare(func);
  	if (r >= 0)
  	{
  		// Execute the function
  		r = execCtx->Execute();
  
  		// Unless the provided type was void retrieve it's value
  		if (ref != 0 && refTypeId != asTYPEID_VOID)
  		{
  			if (refTypeId & asTYPEID_OBJHANDLE)
  			{
  				// Expect the pointer to be null to start with
  				assert(*reinterpret_cast<void**>(ref) == 0);
  				*reinterpret_cast<void**>(ref) = *reinterpret_cast<void**>(execCtx->GetAddressOfReturnValue());
  				engine->AddRefScriptObject(*reinterpret_cast<void**>(ref), engine->GetTypeInfoById(refTypeId));
  			}
  			else if (refTypeId & asTYPEID_MASK_OBJECT)
  			{
  				// Expect the pointer to point to a valid object
  				assert(*reinterpret_cast<void**>(ref) != 0);
  				engine->AssignScriptObject(ref, execCtx->GetAddressOfReturnValue(), engine->GetTypeInfoById(refTypeId));
  			}
  			else
  			{
  				// Copy the primitive value
  				memcpy(ref, execCtx->GetAddressOfReturnValue(), engine->GetSizeOfPrimitiveType(refTypeId));
  			}
  		}
  	}
  
  	// Clean up
  	func->Release();
  	if (!ctx) engine->ReturnContext(execCtx);
  
  	return r;
  }
  
  int WriteConfigToFile(asIScriptEngine *engine, const char *filename)
  {
  	std::ofstream strm;
  	strm.open(filename);
  
  	return WriteConfigToStream(engine, strm);
  }
  
  int WriteConfigToStream(asIScriptEngine *engine, std::ostream &strm)
  {
  	// A helper function for escaping quotes in default arguments
  	struct Escape
  	{
  		static lambda::String Quotes(const char *decl)
  		{
  			lambda::String str = decl;
  			size_t pos = 0;
  			for (;;)
  			{
  				// Find " characters
  				pos = str.find("\"", pos);
  				if (pos == String::npos)
  					break;
  
  				// Add a \ to escape them
  				str.insert(pos, "\\");
  				pos += 2;
  			}
  
  			return str;
  		}
  	};
  
  	int c, n;
  
  	asDWORD currAccessMask = 0;
  	lambda::String currNamespace = "";
  	engine->SetDefaultNamespace("");
  
  	// Export the engine version, just for info
  	strm << "// AngelScript " << asGetLibraryVersion() << "\n";
  	strm << "// Lib options " << asGetLibraryOptions() << "\n";
  
  	// Export the relevant engine properties
  	strm << "// Engine properties\n";
  	for (n = 0; n < asEP_LAST_PROPERTY; n++)
  		strm << "ep " << n << " " << engine->GetEngineProperty(asEEngineProp(n)) << "\n";
  
  	// Make sure the default array type is expanded to the template form
  	bool expandDefArrayToTempl = engine->GetEngineProperty(asEP_EXPAND_DEF_ARRAY_TO_TMPL) ? true : false;
  	engine->SetEngineProperty(asEP_EXPAND_DEF_ARRAY_TO_TMPL, true);
  
  	// Write enum types and their values
  	strm << "\n// Enums\n";
  	c = engine->GetEnumCount();
  	for (n = 0; n < c; n++)
  	{
  		asITypeInfo *ti = engine->GetEnumByIndex(n);
  		asDWORD accessMask = ti->GetAccessMask();
  		if (accessMask != currAccessMask)
  		{
  			strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  			currAccessMask = accessMask;
  		}
  		const char *nameSpace = ti->GetNamespace();
  		if (nameSpace != currNamespace)
  		{
  			strm << "namespace \"" << nameSpace << "\"\n";
  			currNamespace = nameSpace;
  			engine->SetDefaultNamespace(currNamespace.c_str());
  		}
  		const char *enumName = ti->GetName();
  		strm << "enum " << enumName << "\n";
  		for (asUINT m = 0; m < ti->GetEnumValueCount(); m++)
  		{
  			const char *valName;
  			int val;
  			valName = ti->GetEnumValueByIndex(m, &val);
  			strm << "enumval " << enumName << " " << valName << " " << val << "\n";
  		}
  	}
  
  	// Enumerate all types
  	strm << "\n// Types\n";
  
  	// Keep a list of the template types, as the methods for these need to be exported first
  	Set<asITypeInfo*> templateTypes;
  
  	c = engine->GetObjectTypeCount();
  	for (n = 0; n < c; n++)
  	{
  		asITypeInfo *type = engine->GetObjectTypeByIndex(n);
  		asDWORD accessMask = type->GetAccessMask();
  		if (accessMask != currAccessMask)
  		{
  			strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  			currAccessMask = accessMask;
  		}
  		const char *nameSpace = type->GetNamespace();
  		if (nameSpace != currNamespace)
  		{
  			strm << "namespace \"" << nameSpace << "\"\n";
  			currNamespace = nameSpace;
  			engine->SetDefaultNamespace(currNamespace.c_str());
  		}
  		if (type->GetFlags() & asOBJ_SCRIPT_OBJECT)
  		{
  			// This should only be interfaces
  			assert(type->GetSize() == 0);
  
  			strm << "intf " << type->GetName() << "\n";
  		}
  		else
  		{
  			// Only the type flags are necessary. The application flags are application
  			// specific and doesn't matter to the offline compiler. The object size is also
  			// unnecessary for the offline compiler
  			strm << "objtype \"" << engine->GetTypeDeclaration(type->GetTypeId()) << "\" " << (unsigned int)(type->GetFlags() & asOBJ_MASK_VALID_FLAGS) << "\n";
  
  			// Store the template types (but not template instances)
  			if ((type->GetFlags() & asOBJ_TEMPLATE) && type->GetSubType() && (type->GetSubType()->GetFlags() & asOBJ_TEMPLATE_SUBTYPE))
  				templateTypes.insert(type);
  		}
  	}
  
  	c = engine->GetTypedefCount();
  	for (n = 0; n < c; n++)
  	{
  		asITypeInfo *ti = engine->GetTypedefByIndex(n);
  		const char *nameSpace = ti->GetNamespace();
  		if (nameSpace != currNamespace)
  		{
  			strm << "namespace \"" << nameSpace << "\"\n";
  			currNamespace = nameSpace;
  			engine->SetDefaultNamespace(currNamespace.c_str());
  		}
  		asDWORD accessMask = ti->GetAccessMask();
  		if (accessMask != currAccessMask)
  		{
  			strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  			currAccessMask = accessMask;
  		}
  		strm << "typedef " << ti->GetName() << " \"" << engine->GetTypeDeclaration(ti->GetTypedefTypeId()) << "\"\n";
  	}
  
  	c = engine->GetFuncdefCount();
  	for (n = 0; n < c; n++)
  	{
  		asITypeInfo *funcDef = engine->GetFuncdefByIndex(n);
  		asDWORD accessMask = funcDef->GetAccessMask();
  		const char *nameSpace = funcDef->GetNamespace();
  		// Child funcdefs do not have any namespace, as they belong to the parent object
  		if (nameSpace && nameSpace != currNamespace)
  		{
  			strm << "namespace \"" << nameSpace << "\"\n";
  			currNamespace = nameSpace;
  			engine->SetDefaultNamespace(currNamespace.c_str());
  		}
  		if (accessMask != currAccessMask)
  		{
  			strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  			currAccessMask = accessMask;
  		}
  		strm << "funcdef \"" << funcDef->GetFuncdefSignature()->GetDeclaration() << "\"\n";
  	}
  
  	// A helper for writing object type members
  	struct TypeWriter
  	{
  		static void Write(asIScriptEngine *engine, std::ostream &strm, asITypeInfo *type, lambda::String &currNamespace, asDWORD &currAccessMask)
  		{
  			const char *nameSpace = type->GetNamespace();
  			if (nameSpace != currNamespace)
  			{
  				strm << "namespace \"" << nameSpace << "\"\n";
  				currNamespace = nameSpace;
  				engine->SetDefaultNamespace(currNamespace.c_str());
  			}
  			lambda::String typeDecl = engine->GetTypeDeclaration(type->GetTypeId());
  			if (type->GetFlags() & asOBJ_SCRIPT_OBJECT)
  			{
  				for (asUINT m = 0; m < type->GetMethodCount(); m++)
  				{
  					asIScriptFunction *func = type->GetMethodByIndex(m);
  					asDWORD accessMask = func->GetAccessMask();
  					if (accessMask != currAccessMask)
  					{
  						strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  						currAccessMask = accessMask;
  					}
  					strm << "intfmthd " << typeDecl.c_str() << " \"" << Escape::Quotes(func->GetDeclaration(false)).c_str() << "\"\n";
  				}
  			}
  			else
  			{
  				asUINT m;
  				for (m = 0; m < type->GetFactoryCount(); m++)
  				{
  					asIScriptFunction *func = type->GetFactoryByIndex(m);
  					asDWORD accessMask = func->GetAccessMask();
  					if (accessMask != currAccessMask)
  					{
  						strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  						currAccessMask = accessMask;
  					}
  					strm << "objbeh \"" << typeDecl.c_str() << "\" " << asBEHAVE_FACTORY << " \"" << Escape::Quotes(func->GetDeclaration(false)).c_str() << "\"\n";
  				}
  				for (m = 0; m < type->GetBehaviourCount(); m++)
  				{
  					asEBehaviours beh;
  					asIScriptFunction *func = type->GetBehaviourByIndex(m, &beh);
  
  					if (beh == asBEHAVE_CONSTRUCT)
  						// Prefix 'void'
  						strm << "objbeh \"" << typeDecl.c_str() << "\" " << beh << " \"void " << Escape::Quotes(func->GetDeclaration(false)).c_str() << "\"\n";
  					else if (beh == asBEHAVE_DESTRUCT)
  						// Prefix 'void' and remove ~
  						strm << "objbeh \"" << typeDecl.c_str() << "\" " << beh << " \"void " << Escape::Quotes(func->GetDeclaration(false)).c_str() + 1 << "\"\n";
  					else
  						strm << "objbeh \"" << typeDecl.c_str() << "\" " << beh << " \"" << Escape::Quotes(func->GetDeclaration(false)).c_str() << "\"\n";
  				}
  				for (m = 0; m < type->GetMethodCount(); m++)
  				{
  					asIScriptFunction *func = type->GetMethodByIndex(m);
  					asDWORD accessMask = func->GetAccessMask();
  					if (accessMask != currAccessMask)
  					{
  						strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  						currAccessMask = accessMask;
  					}
  					strm << "objmthd \"" << typeDecl.c_str() << "\" \"" << Escape::Quotes(func->GetDeclaration(false)).c_str() << "\"\n";
  				}
  				for (m = 0; m < type->GetPropertyCount(); m++)
  				{
  					asDWORD accessMask;
  					type->GetProperty(m, 0, 0, 0, 0, 0, 0, &accessMask);
  					if (accessMask != currAccessMask)
  					{
  						strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  						currAccessMask = accessMask;
  					}
  					strm << "objprop \"" << typeDecl.c_str() << "\" \"" << type->GetPropertyDeclaration(m) << "\"";
  
  					// Save information about composite properties
  					int compositeOffset;
  					bool isCompositeIndirect;
  					type->GetProperty(m, 0, 0, 0, 0, 0, 0, 0, &compositeOffset, &isCompositeIndirect);
  					strm << " " << compositeOffset << " " << (isCompositeIndirect ? "1" : "0") << "\n";
  				}
  			}
  		}
  	};
  
  	// Write the members of the template types, so they can be fully registered before any other type uses them
  	// TODO: Order the template types based on dependency to avoid failure if one type uses instances of another 
  	strm << "\n// Template type members\n";
  	for (Set<asITypeInfo*>::iterator it = templateTypes.begin(); it != templateTypes.end(); ++it)
  	{
  		asITypeInfo *type = *it;
  		TypeWriter::Write(engine, strm, type, currNamespace, currAccessMask);
  	}
  
  	// Write the object types members
  	strm << "\n// Type members\n";
  
  	c = engine->GetObjectTypeCount();
  	for (n = 0; n < c; n++)
  	{
  		asITypeInfo *type = engine->GetObjectTypeByIndex(n);
  		if (templateTypes.find(type) == templateTypes.end())
  			TypeWriter::Write(engine, strm, type, currNamespace, currAccessMask);
  	}
  
  	// Write functions
  	strm << "\n// Functions\n";
  
  	c = engine->GetGlobalFunctionCount();
  	for (n = 0; n < c; n++)
  	{
  		asIScriptFunction *func = engine->GetGlobalFunctionByIndex(n);
  		const char *nameSpace = func->GetNamespace();
  		if (nameSpace != currNamespace)
  		{
  			strm << "namespace \"" << nameSpace << "\"\n";
  			currNamespace = nameSpace;
  			engine->SetDefaultNamespace(currNamespace.c_str());
  		}
  		asDWORD accessMask = func->GetAccessMask();
  		if (accessMask != currAccessMask)
  		{
  			strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  			currAccessMask = accessMask;
  		}
  		strm << "func \"" << Escape::Quotes(func->GetDeclaration()).c_str() << "\"\n";
  	}
  
  	// Write global properties
  	strm << "\n// Properties\n";
  
  	c = engine->GetGlobalPropertyCount();
  	for (n = 0; n < c; n++)
  	{
  		const char *name;
  		int typeId;
  		bool isConst;
  		asDWORD accessMask;
  		const char *nameSpace;
  		engine->GetGlobalPropertyByIndex(n, &name, &nameSpace, &typeId, &isConst, 0, 0, &accessMask);
  		if (accessMask != currAccessMask)
  		{
  			strm << "access " << std::hex << (unsigned int)(accessMask) << std::dec << "\n";
  			currAccessMask = accessMask;
  		}
  		if (nameSpace != currNamespace)
  		{
  			strm << "namespace \"" << nameSpace << "\"\n";
  			currNamespace = nameSpace;
  			engine->SetDefaultNamespace(currNamespace.c_str());
  		}
  		strm << "prop \"" << (isConst ? "const " : "") << engine->GetTypeDeclaration(typeId) << " " << name << "\"\n";
  	}
  
  	// Write lambda::String factory
  	strm << "\n// lambda::String factory\n";
  
  	// Reset the namespace for the lambda::String factory and default array type
  	if ("" != currNamespace)
  	{
  		strm << "namespace \"\"\n";
  		currNamespace = "";
  		engine->SetDefaultNamespace("");
  	}
  
  	asDWORD flags = 0;
  	int typeId = engine->GetStringFactoryReturnTypeId(&flags);
  	if (typeId > 0)
  		strm << "strfactory \"" << ((flags & asTM_CONST) ? "const " : "") << engine->GetTypeDeclaration(typeId) << ((flags & asTM_INOUTREF) ? "&" : "") << "\"\n";
  
  	// Write default array type
  	strm << "\n// Default array type\n";
  	typeId = engine->GetDefaultArrayTypeId();
  	if (typeId > 0)
  		strm << "defarray \"" << engine->GetTypeDeclaration(typeId) << "\"\n";
  
  	// Restore original settings
  	engine->SetEngineProperty(asEP_EXPAND_DEF_ARRAY_TO_TMPL, expandDefArrayToTempl);
  
  	return 0;
  }
  
  int ConfigEngineFromStream(asIScriptEngine *engine, std::istream &strm, const char *configFile, asIStringFactory *stringFactory)
  {
  	int r;
  
  	// Some helper functions for parsing the configuration
  	struct in
  	{
  		static asETokenClass GetToken(asIScriptEngine *engine, lambda::String &token, const lambda::String &text, asUINT &pos)
  		{
  			asUINT len = 0;
  			asETokenClass t = engine->ParseToken(&text[pos], text.length() - pos, &len);
  			while ((t == asTC_WHITESPACE || t == asTC_COMMENT) && pos < text.length())
  			{
  				pos += len;
  				t = engine->ParseToken(&text[pos], text.length() - pos, &len);
  			}
  
  			token.assign(&text[pos], len);
  
  			pos += len;
  
  			return t;
  		}
  
  		static void ReplaceSlashQuote(lambda::String &str)
  		{
  			size_t pos = 0;
  			for (;;)
  			{
  				// Search for \" in the string
  				pos = str.find("\\\"", pos);
  				if (pos == String::npos)
  					break;
  
  				// Remove the \ character
  				str.erase(pos, 1);
  			}
  		}
  
  		static asUINT GetLineNumber(const lambda::String &text, asUINT pos)
  		{
  			asUINT count = 1;
  			for (asUINT n = 0; n < pos; n++)
  				if (text[n] == '\n')
  					count++;
  
  			return count;
  		}
  	};
  
  	// Since we are only going to compile the script and never actually execute it,
  	// we turn off the initialization of global variables, so that the compiler can
  	// just register dummy types and functions for the application interface.
  	r = engine->SetEngineProperty(asEP_INIT_GLOBAL_VARS_AFTER_BUILD, false); assert(r >= 0);
  
  	// Read the entire file
  	char buffer[1000];
  	lambda::String config;
  	do {
  		strm.getline(buffer, 1000);
  		config += buffer;
  		config += "\n";
  	} while (!strm.eof() && strm.good());
  
  	// Process the configuration file and register each entity
  	asUINT pos = 0;
  	while (pos < config.length())
  	{
  		lambda::String token;
  		// TODO: The position where the initial token is found should be stored for error messages
  		in::GetToken(engine, token, config, pos);
  		if (token == "ep")
  		{
  			lambda::String tmp;
  			in::GetToken(engine, tmp, config, pos);
  
  			asEEngineProp ep = asEEngineProp(atol(tmp.c_str()));
  
  			// Only set properties that affect the compiler
  			if (ep != asEP_COPY_SCRIPT_SECTIONS &&
  				ep != asEP_MAX_STACK_SIZE &&
  				ep != asEP_INIT_GLOBAL_VARS_AFTER_BUILD &&
  				ep != asEP_EXPAND_DEF_ARRAY_TO_TMPL &&
  				ep != asEP_AUTO_GARBAGE_COLLECT)
  			{
  				// Get the value for the property
  				in::GetToken(engine, tmp, config, pos);
  				std::stringstream s(tmp.c_str());
  				asPWORD value;
  
  				s >> value;
  
  				engine->SetEngineProperty(ep, value);
  			}
  		}
  		else if (token == "namespace")
  		{
  			lambda::String ns;
  			in::GetToken(engine, ns, config, pos);
  			ns = ns.substr(1, ns.length() - 2);
  
  			r = engine->SetDefaultNamespace(ns.c_str());
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to set namespace");
  				return -1;
  			}
  		}
  		else if (token == "access")
  		{
  			lambda::String maskStr;
  			in::GetToken(engine, maskStr, config, pos);
  			asDWORD mask = strtoul(maskStr.c_str(), 0, 16);
  			engine->SetDefaultAccessMask(mask);
  		}
  		else if (token == "objtype")
  		{
  			lambda::String name, flags;
  			in::GetToken(engine, name, config, pos);
  			name = name.substr(1, name.length() - 2);
  			in::GetToken(engine, flags, config, pos);
  
  			// The size of the value type doesn't matter, because the
  			// engine must adjust it anyway for different platforms
  			r = engine->RegisterObjectType(name.c_str(), (atol(flags.c_str()) & asOBJ_VALUE) ? 1 : 0, atol(flags.c_str()));
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register object type");
  				return -1;
  			}
  		}
  		else if (token == "objbeh")
  		{
  			lambda::String name, behaviour, decl;
  			in::GetToken(engine, name, config, pos);
  			name = name.substr(1, name.length() - 2);
  			in::GetToken(engine, behaviour, config, pos);
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  			in::ReplaceSlashQuote(decl);
  
  			// Remove the $ that the engine prefixes the behaviours with
  			size_t n = decl.find("$");
  			if (n != String::npos)
  				decl[n] = ' ';
  
  			asEBehaviours behave = static_cast<asEBehaviours>(atol(behaviour.c_str()));
  			if (behave == asBEHAVE_TEMPLATE_CALLBACK)
  			{
  				// TODO: How can we let the compiler register this? Maybe through a plug-in system? Or maybe by implementing the callback as a script itself
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_WARNING, "Cannot register template callback without the actual implementation");
  			}
  			else
  			{
  				r = engine->RegisterObjectBehaviour(name.c_str(), behave, decl.c_str(), asFUNCTION(0), asCALL_GENERIC);
  				if (r < 0)
  				{
  					engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register behaviour");
  					return -1;
  				}
  			}
  		}
  		else if (token == "objmthd")
  		{
  			lambda::String name, decl;
  			in::GetToken(engine, name, config, pos);
  			name = name.substr(1, name.length() - 2);
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  			in::ReplaceSlashQuote(decl);
  
  			r = engine->RegisterObjectMethod(name.c_str(), decl.c_str(), asFUNCTION(0), asCALL_GENERIC);
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register object method");
  				return -1;
  			}
  		}
  		else if (token == "objprop")
  		{
  			lambda::String name, decl, compositeOffset, isCompositeIndirect;
  			in::GetToken(engine, name, config, pos);
  			name = name.substr(1, name.length() - 2);
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  			in::GetToken(engine, compositeOffset, config, pos);
  			in::GetToken(engine, isCompositeIndirect, config, pos);
  
  			asITypeInfo *type = engine->GetTypeInfoById(engine->GetTypeIdByDecl(name.c_str()));
  			if (type == 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Type doesn't exist for property registration");
  				return -1;
  			}
  
  			// All properties must have different offsets in order to make them
  			// distinct, so we simply register them with an incremental offset
  			r = engine->RegisterObjectProperty(name.c_str(), decl.c_str(), type->GetPropertyCount(), compositeOffset != "0" ? type->GetPropertyCount() : 0, isCompositeIndirect != "0");
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register object property");
  				return -1;
  			}
  		}
  		else if (token == "intf")
  		{
  			lambda::String name, size, flags;
  			in::GetToken(engine, name, config, pos);
  
  			r = engine->RegisterInterface(name.c_str());
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register interface");
  				return -1;
  			}
  		}
  		else if (token == "intfmthd")
  		{
  			lambda::String name, decl;
  			in::GetToken(engine, name, config, pos);
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  			in::ReplaceSlashQuote(decl);
  
  			r = engine->RegisterInterfaceMethod(name.c_str(), decl.c_str());
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register interface method");
  				return -1;
  			}
  		}
  		else if (token == "func")
  		{
  			lambda::String decl;
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  			in::ReplaceSlashQuote(decl);
  
  			r = engine->RegisterGlobalFunction(decl.c_str(), asFUNCTION(0), asCALL_GENERIC);
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register global function");
  				return -1;
  			}
  		}
  		else if (token == "prop")
  		{
  			lambda::String decl;
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  
  			// All properties must have different offsets in order to make them
  			// distinct, so we simply register them with an incremental offset.
  			// The pointer must also be non-null so we add 1 to have a value.
  			r = engine->RegisterGlobalProperty(decl.c_str(), reinterpret_cast<void*>(asPWORD(engine->GetGlobalPropertyCount() + 1)));
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register global property");
  				return -1;
  			}
  		}
  		else if (token == "strfactory")
  		{
  			lambda::String type;
  			in::GetToken(engine, type, config, pos);
  			type = type.substr(1, type.length() - 2);
  
  			if (stringFactory == 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_WARNING, "Cannot register lambda::String factory without the actual implementation");
  				return -1;
  			}
  			else
  			{
  				r = engine->RegisterStringFactory(type.c_str(), stringFactory);
  				if (r < 0)
  				{
  					engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register lambda::String factory");
  					return -1;
  				}
  			}
  		}
  		else if (token == "defarray")
  		{
  			lambda::String type;
  			in::GetToken(engine, type, config, pos);
  			type = type.substr(1, type.length() - 2);
  
  			r = engine->RegisterDefaultArrayType(type.c_str());
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register the default array type");
  				return -1;
  			}
  		}
  		else if (token == "enum")
  		{
  			lambda::String type;
  			in::GetToken(engine, type, config, pos);
  
  			r = engine->RegisterEnum(type.c_str());
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register enum type");
  				return -1;
  			}
  		}
  		else if (token == "enumval")
  		{
  			lambda::String type, name, value;
  			in::GetToken(engine, type, config, pos);
  			in::GetToken(engine, name, config, pos);
  			in::GetToken(engine, value, config, pos);
  
  			r = engine->RegisterEnumValue(type.c_str(), name.c_str(), atol(value.c_str()));
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register enum value");
  				return -1;
  			}
  		}
  		else if (token == "typedef")
  		{
  			lambda::String type, decl;
  			in::GetToken(engine, type, config, pos);
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  
  			r = engine->RegisterTypedef(type.c_str(), decl.c_str());
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register typedef");
  				return -1;
  			}
  		}
  		else if (token == "funcdef")
  		{
  			lambda::String decl;
  			in::GetToken(engine, decl, config, pos);
  			decl = decl.substr(1, decl.length() - 2);
  
  			r = engine->RegisterFuncdef(decl.c_str());
  			if (r < 0)
  			{
  				engine->WriteMessage(configFile, in::GetLineNumber(config, pos), 0, asMSGTYPE_ERROR, "Failed to register funcdef");
  				return -1;
  			}
  		}
  	}
  
  	return 0;
  }
  
  lambda::String GetExceptionInfo(asIScriptContext *ctx, bool showStack)
  {
  	if (ctx->GetState() != asEXECUTION_EXCEPTION) return "";
  
  	std::stringstream text;
  
  	const asIScriptFunction *function = ctx->GetExceptionFunction();
  	text << "func: " << function->GetDeclaration() << "\n";
  	text << "modl: " << (function->GetModuleName() ? function->GetModuleName() : "") << "\n";
  	text << "sect: " << (function->GetScriptSectionName() ? function->GetScriptSectionName() : "") << "\n";
  	text << "line: " << ctx->GetExceptionLineNumber() << "\n";
  	text << "desc: " << ctx->GetExceptionString() << "\n";
  
  	if (showStack)
  	{
  		text << "--- call stack ---\n";
  		for (asUINT n = 1; n < ctx->GetCallstackSize(); n++)
  		{
  			function = ctx->GetFunction(n);
  			if (function)
  			{
  				if (function->GetFuncType() == asFUNC_SCRIPT)
  				{
  					text << (function->GetScriptSectionName() ? function->GetScriptSectionName() : "") << " (" << ctx->GetLineNumber(n) << "): " << function->GetDeclaration() << "\n";
  				}
  				else
  				{
  					// The context is being reused by the application for a nested call
  					text << "{...application...}: " << function->GetDeclaration() << "\n";
  				}
  			}
  			else
  			{
  				// The context is being reused by the script engine for a nested call
  				text << "{...script engine...}\n";
  			}
  		}
  	}
  
  	return lmbString(text.str());
  }
  
  void ScriptThrow(const lambda::String &msg)
  {
  	asIScriptContext *ctx = asGetActiveContext();
  	if (ctx)
  		ctx->SetException(msg.c_str());
  }
  
  lambda::String ScriptGetExceptionInfo()
  {
  	asIScriptContext *ctx = asGetActiveContext();
  	if (!ctx)
  		return "";
  
  	const char *msg = ctx->GetExceptionString();
  	if (msg == 0)
  		return "";
  
  	return lambda::String(msg);
  }
  
  void RegisterExceptionRoutines(asIScriptEngine *engine)
  {
  	int r;
  
  	// The lambda::String type must be available
  	assert(engine->GetTypeInfoByDecl("string"));
  
  	r = engine->RegisterGlobalFunction("void throw(const lambda::String &in)", asFUNCTION(ScriptThrow), asCALL_CDECL); assert(r >= 0);
  	r = engine->RegisterGlobalFunction("lambda::String getExceptionInfo()", asFUNCTION(ScriptGetExceptionInfo), asCALL_CDECL); assert(r >= 0);
  }
  
  END_AS_NAMESPACE
  