Layout work on an AngelScript implementation.

extern/angelscript_addons/scriptarray/scriptarray.h

@@ -0,0 +1,142 @@
+#ifndef SCRIPTARRAY_H
+#define SCRIPTARRAY_H
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+// Sometimes it may be desired to use the same method names as used by C++ STL.
+// This may for example reduce time when converting code from script to C++ or
+// back.
+//
+//  0 = off
+//  1 = on
+#ifndef AS_USE_STLNAMES
+#define AS_USE_STLNAMES 0
+#endif
+
+// Some prefer to use property accessors to get/set the length of the array
+// This option registers the accessors instead of the method length()
+#ifndef AS_USE_ACCESSORS
+#define AS_USE_ACCESSORS 0
+#endif
+
+BEGIN_AS_NAMESPACE
+
+struct SArrayBuffer;
+struct SArrayCache;
+
+class CScriptArray
+{
+public:
+	// Set the memory functions that should be used by all CScriptArrays
+	static void SetMemoryFunctions(asALLOCFUNC_t allocFunc, asFREEFUNC_t freeFunc);
+
+	// Factory functions
+	static CScriptArray *Create(asITypeInfo *ot);
+	static CScriptArray *Create(asITypeInfo *ot, asUINT length);
+	static CScriptArray *Create(asITypeInfo *ot, asUINT length, void *defaultValue);
+	static CScriptArray *Create(asITypeInfo *ot, void *listBuffer);
+
+	// Memory management
+	void AddRef() const;
+	void Release() const;
+
+	// Type information
+	asITypeInfo *GetArrayObjectType() const;
+	int          GetArrayTypeId() const;
+	int          GetElementTypeId() const;
+
+	// Get the current size
+	asUINT GetSize() const;
+
+	// Returns true if the array is empty
+	bool   IsEmpty() const;
+
+	// Pre-allocates memory for elements
+	void   Reserve(asUINT maxElements);
+
+	// Resize the array
+	void   Resize(asUINT numElements);
+
+	// Get a pointer to an element. Returns 0 if out of bounds
+	void       *At(asUINT index);
+	const void *At(asUINT index) const;
+
+	// Set value of an element. 
+	// The value arg should be a pointer to the value that will be copied to the element.
+	// Remember, if the array holds handles the value parameter should be the 
+	// address of the handle. The refCount of the object will also be incremented
+	void  SetValue(asUINT index, void *value);
+
+	// Copy the contents of one array to another (only if the types are the same)
+	CScriptArray &operator=(const CScriptArray&);
+
+	// Compare two arrays
+	bool operator==(const CScriptArray &) const;
+
+	// Array manipulation
+	void InsertAt(asUINT index, void *value);
+	void InsertAt(asUINT index, const CScriptArray &arr);
+	void InsertLast(void *value);
+	void RemoveAt(asUINT index);
+	void RemoveLast();
+	void RemoveRange(asUINT start, asUINT count);
+	void SortAsc();
+	void SortDesc();
+	void SortAsc(asUINT startAt, asUINT count);
+	void SortDesc(asUINT startAt, asUINT count);
+	void Sort(asUINT startAt, asUINT count, bool asc);
+	void Sort(asIScriptFunction *less, asUINT startAt, asUINT count);
+	void Reverse();
+	int  Find(void *value) const;
+	int  Find(asUINT startAt, void *value) const;
+	int  FindByRef(void *ref) const;
+	int  FindByRef(asUINT startAt, void *ref) const;
+
+	// Return the address of internal buffer for direct manipulation of elements
+	void *GetBuffer();
+
+	// GC methods
+	int  GetRefCount();
+	void SetFlag();
+	bool GetFlag();
+	void EnumReferences(asIScriptEngine *engine);
+	void ReleaseAllHandles(asIScriptEngine *engine);
+
+protected:
+	mutable int     refCount;
+	mutable bool    gcFlag;
+	asITypeInfo    *objType;
+	SArrayBuffer   *buffer;
+	int             elementSize;
+	int             subTypeId;
+
+	// Constructors
+	CScriptArray(asITypeInfo *ot, void *initBuf); // Called from script when initialized with list
+	CScriptArray(asUINT length, asITypeInfo *ot);
+	CScriptArray(asUINT length, void *defVal, asITypeInfo *ot);
+	CScriptArray(const CScriptArray &other);
+	virtual ~CScriptArray();
+
+	bool  Less(const void *a, const void *b, bool asc, asIScriptContext *ctx, SArrayCache *cache);
+	void *GetArrayItemPointer(int index);
+	void *GetDataPointer(void *buffer);
+	void  Copy(void *dst, void *src);
+	void  Precache();
+	bool  CheckMaxSize(asUINT numElements);
+	void  Resize(int delta, asUINT at);
+	void  CreateBuffer(SArrayBuffer **buf, asUINT numElements);
+	void  DeleteBuffer(SArrayBuffer *buf);
+	void  CopyBuffer(SArrayBuffer *dst, SArrayBuffer *src);
+	void  Construct(SArrayBuffer *buf, asUINT start, asUINT end);
+	void  Destruct(SArrayBuffer *buf, asUINT start, asUINT end);
+	bool  Equals(const void *a, const void *b, asIScriptContext *ctx, SArrayCache *cache) const;
+};
+
+void RegisterScriptArray(asIScriptEngine *engine, bool defaultArray);
+
+END_AS_NAMESPACE
+
+#endif

extern/angelscript_addons/scripthelper/scripthelper.cpp

@@ -0,0 +1,987 @@
+#include <string.h>
+#include "scripthelper.h"
+#include <assert.h>
+#include <stdio.h>
+#include <fstream>
+#include <set>
+#include <stdlib.h>
+
+using namespace std;
+
+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
+	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)
+			{
+				// Use the registered assignment operator to do a value assign. 
+				// This assumes that the ref is pointing to a valid object instance.
+				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)
+{
+	ofstream strm;
+	strm.open(filename);
+
+	return WriteConfigToStream(engine, strm);
+}
+
+int WriteConfigToStream(asIScriptEngine *engine, ostream &strm)
+{
+	// A helper function for escaping quotes in default arguments
+	struct Escape
+	{
+		static string Quotes(const char *decl)
+		{
+			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;
+	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 " << hex << (unsigned int)(accessMask) << 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 " << hex << (unsigned int)(accessMask) << 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 " << hex << (unsigned int)(accessMask) << 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 " << hex << (unsigned int)(accessMask) << dec << "\n";
+			currAccessMask = accessMask;
+		}
+		strm << "funcdef \"" << funcDef->GetFuncdefSignature()->GetDeclaration() << "\"\n";
+	}
+
+	// A helper for writing object type members
+	struct TypeWriter
+	{
+		static void Write(asIScriptEngine *engine, ostream &strm, asITypeInfo *type, string &currNamespace, asDWORD &currAccessMask)
+		{
+			const char *nameSpace = type->GetNamespace();
+			if( nameSpace != currNamespace )
+			{
+				strm << "namespace \"" << nameSpace << "\"\n";
+				currNamespace = nameSpace;
+				engine->SetDefaultNamespace(currNamespace.c_str());
+			}
+			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 " << hex << (unsigned int)(accessMask) << dec << "\n";
+						currAccessMask = accessMask;
+					}
+					strm << "intfmthd " << typeDecl.c_str() << " \"" << Escape::Quotes(func->GetDeclaration(false)).c_str() << (func->IsProperty() ? " property" : "") << "\"\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 " << hex << (unsigned int)(accessMask) << 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 " << hex << (unsigned int)(accessMask) << dec << "\n";
+						currAccessMask = accessMask;
+					}
+					strm << "objmthd \"" << typeDecl.c_str() << "\" \"" << Escape::Quotes(func->GetDeclaration(false)).c_str() << (func->IsProperty() ? " property" : "") << "\"\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 " << hex << (unsigned int)(accessMask) << 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 " << hex << (unsigned int)(accessMask) << dec << "\n";
+			currAccessMask = accessMask;
+		}
+		strm << "func \"" << Escape::Quotes(func->GetDeclaration()).c_str() << (func->IsProperty() ? " property" : "") << "\"\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 " << hex << (unsigned int)(accessMask) << 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 string factory
+	strm << "\n// String factory\n";
+
+	// Reset the namespace for the 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, istream &strm, const char *configFile, asIStringFactory *stringFactory)
+{
+	int r;
+
+	// Some helper functions for parsing the configuration
+	struct in
+	{
+		static asETokenClass GetToken(asIScriptEngine *engine, string &token, const 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(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 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];
+	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() )
+	{
+		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" )
+		{
+			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);
+				stringstream s(tmp);
+				asPWORD value;
+
+				s >> value;
+
+				engine->SetEngineProperty(ep, value);
+			}
+		}
+		else if( token == "namespace" )
+		{
+			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" )
+		{
+			string maskStr;
+			in::GetToken(engine, maskStr, config, pos);
+			asDWORD mask = strtoul(maskStr.c_str(), 0, 16);
+			engine->SetDefaultAccessMask(mask);
+		}
+		else if( token == "objtype" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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 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 string factory");
+					return -1;
+				}
+			}
+		}
+		else if( token == "defarray" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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" )
+		{
+			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;
+}
+
+string GetExceptionInfo(asIScriptContext *ctx, bool showStack)
+{
+	if( ctx->GetState() != asEXECUTION_EXCEPTION ) return "";
+
+	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 text.str();
+}
+
+void ScriptThrow(const string &msg)
+{
+	asIScriptContext *ctx = asGetActiveContext();
+	if (ctx)
+		ctx->SetException(msg.c_str());
+}
+
+string ScriptGetExceptionInfo()
+{
+	asIScriptContext *ctx = asGetActiveContext();
+	if (!ctx)
+		return "";
+	
+	const char *msg = ctx->GetExceptionString();
+	if (msg == 0)
+		return "";
+
+	return string(msg);
+}
+
+void RegisterExceptionRoutines(asIScriptEngine *engine)
+{
+	int r;
+
+	// The string type must be available
+	assert(engine->GetTypeInfoByDecl("string"));
+
+	r = engine->RegisterGlobalFunction("void throw(const string &in)", asFUNCTION(ScriptThrow), asCALL_CDECL); assert(r >= 0);
+	r = engine->RegisterGlobalFunction("string getExceptionInfo()", asFUNCTION(ScriptGetExceptionInfo), asCALL_CDECL); assert(r >= 0);
+}
+
+END_AS_NAMESPACE

extern/angelscript_addons/scripthelper/scripthelper.h

@@ -0,0 +1,53 @@
+#ifndef SCRIPTHELPER_H
+#define SCRIPTHELPER_H
+
+#include <sstream>
+#include <string>
+
+#ifndef ANGELSCRIPT_H
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+// Compare relation between two objects of the same type
+int CompareRelation(asIScriptEngine *engine, void *lobj, void *robj, int typeId, int &result);
+
+// Compare equality between two objects of the same type
+int CompareEquality(asIScriptEngine *engine, void *lobj, void *robj, int typeId, bool &result);
+
+// Compile and execute simple statements
+// The module is optional. If given the statements can access the entities compiled in the module.
+// The caller can optionally provide its own context, for example if a context should be reused.
+int ExecuteString(asIScriptEngine *engine, const char *code, asIScriptModule *mod = 0, asIScriptContext *ctx = 0);
+
+// Compile and execute simple statements with option of return value
+// The module is optional. If given the statements can access the entitites compiled in the module.
+// The caller can optionally provide its own context, for example if a context should be reused.
+int ExecuteString(asIScriptEngine *engine, const char *code, void *ret, int retTypeId, asIScriptModule *mod = 0, asIScriptContext *ctx = 0);
+
+// Write the registered application interface to a file for an offline compiler.
+// The format is compatible with the offline compiler in /sdk/samples/asbuild/.
+int WriteConfigToFile(asIScriptEngine *engine, const char *filename);
+
+// Write the registered application interface to a text stream. 
+int WriteConfigToStream(asIScriptEngine *engine, std::ostream &strm); 
+
+// Loads an interface from a text stream and configures the engine with it. This will not 
+// set the correct function pointers, so it is not possible to use this engine to execute
+// scripts, but it can be used to compile scripts and save the byte code.
+int ConfigEngineFromStream(asIScriptEngine *engine, std::istream &strm, const char *nameOfStream = "config", asIStringFactory *stringFactory = 0);
+
+// Format the details of the script exception into a human readable text
+std::string GetExceptionInfo(asIScriptContext *ctx, bool showStack = false);
+
+// Register the exception routines
+//  'void throw(const string &msg)'
+//  'string getExceptionInfo()'
+void RegisterExceptionRoutines(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif

extern/angelscript_addons/scriptstdstring/scriptstdstring.h

@@ -0,0 +1,48 @@
+//
+// Script std::string
+//
+// This function registers the std::string type with AngelScript to be used as the default string type.
+//
+// The string type is registered as a value type, thus may have performance issues if a lot of 
+// string operations are performed in the script. However, for relatively few operations, this should
+// not cause any problem for most applications.
+//
+
+#ifndef SCRIPTSTDSTRING_H
+#define SCRIPTSTDSTRING_H
+
+#ifndef ANGELSCRIPT_H 
+// Avoid having to inform include path if header is already include before
+#include <angelscript.h>
+#endif
+
+#include <string>
+
+//---------------------------
+// Compilation settings
+//
+
+// Sometimes it may be desired to use the same method names as used by C++ STL.
+// This may for example reduce time when converting code from script to C++ or
+// back.
+//
+//  0 = off
+//  1 = on
+#ifndef AS_USE_STLNAMES
+#define AS_USE_STLNAMES 0
+#endif
+
+// Some prefer to use property accessors to get/set the length of the string
+// This option registers the accessors instead of the method length()
+#ifndef AS_USE_ACCESSORS
+#define AS_USE_ACCESSORS 0
+#endif
+
+BEGIN_AS_NAMESPACE
+
+void RegisterStdString(asIScriptEngine *engine);
+void RegisterStdStringUtils(asIScriptEngine *engine);
+
+END_AS_NAMESPACE
+
+#endif

extern/angelscript_addons/scriptstdstring/scriptstdstring_utils.cpp

@@ -0,0 +1,129 @@
+#include <assert.h>
+#include "scriptstdstring.h"
+#include "../scriptarray/scriptarray.h"
+#include <stdio.h>
+#include <string.h>
+
+using namespace std;
+
+BEGIN_AS_NAMESPACE
+
+// This function takes an input string and splits it into parts by looking
+// for a specified delimiter. Example:
+//
+// string str = "A|B||D";
+// array<string>@ array = str.split("|");
+//
+// The resulting array has the following elements:
+//
+// {"A", "B", "", "D"}
+//
+// AngelScript signature:
+// array<string>@ string::split(const string &in delim) const
+static CScriptArray *StringSplit(const string &delim, const string &str)
+{
+	// Obtain a pointer to the engine
+	asIScriptContext *ctx = asGetActiveContext();
+	asIScriptEngine *engine = ctx->GetEngine();
+
+	// TODO: This should only be done once
+	// TODO: This assumes that CScriptArray was already registered
+	asITypeInfo *arrayType = engine->GetTypeInfoByDecl("array<string>");
+
+	// Create the array object
+	CScriptArray *array = CScriptArray::Create(arrayType);
+
+	// Find the existence of the delimiter in the input string
+	int pos = 0, prev = 0, count = 0;
+	while( (pos = (int)str.find(delim, prev)) != (int)string::npos )
+	{
+		// Add the part to the array
+		array->Resize(array->GetSize()+1);
+		((string*)array->At(count))->assign(&str[prev], pos-prev);
+
+		// Find the next part
+		count++;
+		prev = pos + (int)delim.length();
+	}
+
+	// Add the remaining part
+	array->Resize(array->GetSize()+1);
+	((string*)array->At(count))->assign(&str[prev]);
+
+	return array;
+}
+
+static void StringSplit_Generic(asIScriptGeneric *gen)
+{
+	// Get the arguments
+	string *str   = (string*)gen->GetObject();
+	string *delim = *(string**)gen->GetAddressOfArg(0);
+
+	// Return the array by handle
+	*(CScriptArray**)gen->GetAddressOfReturnLocation() = StringSplit(*delim, *str);
+}
+
+
+
+// This function takes as input an array of string handles as well as a
+// delimiter and concatenates the array elements into one delimited string.
+// Example:
+//
+// array<string> array = {"A", "B", "", "D"};
+// string str = join(array, "|");
+//
+// The resulting string is:
+//
+// "A|B||D"
+//
+// AngelScript signature:
+// string join(const array<string> &in array, const string &in delim)
+static string StringJoin(const CScriptArray &array, const string &delim)
+{
+	// Create the new string
+	string str = "";
+	if( array.GetSize() )
+	{
+		int n;
+		for( n = 0; n < (int)array.GetSize() - 1; n++ )
+		{
+			str += *(string*)array.At(n);
+			str += delim;
+		}
+
+		// Add the last part
+		str += *(string*)array.At(n);
+	}
+
+	return str;
+}
+
+static void StringJoin_Generic(asIScriptGeneric *gen)
+{
+	// Get the arguments
+	CScriptArray  *array = *(CScriptArray**)gen->GetAddressOfArg(0);
+	string *delim = *(string**)gen->GetAddressOfArg(1);
+
+	// Return the string
+	new(gen->GetAddressOfReturnLocation()) string(StringJoin(*array, *delim));
+}
+
+// This is where the utility functions are registered.
+// The string type must have been registered first.
+void RegisterStdStringUtils(asIScriptEngine *engine)
+{
+	int r;
+
+	if( strstr(asGetLibraryOptions(), "AS_MAX_PORTABILITY") )
+	{
+		r = engine->RegisterObjectMethod("string", "array<string>@ split(const string &in) const", asFUNCTION(StringSplit_Generic), asCALL_GENERIC); assert(r >= 0);
+		r = engine->RegisterGlobalFunction("string join(const array<string> &in, const string &in)", asFUNCTION(StringJoin_Generic), asCALL_GENERIC); assert(r >= 0);
+	}
+	else
+	{
+		r = engine->RegisterObjectMethod("string", "array<string>@ split(const string &in) const", asFUNCTION(StringSplit), asCALL_CDECL_OBJLAST); assert(r >= 0);
+		r = engine->RegisterGlobalFunction("string join(const array<string> &in, const string &in)", asFUNCTION(StringJoin), asCALL_CDECL); assert(r >= 0);
+	}
+}
+
+END_AS_NAMESPACE