Initial commit

engines/hpl1/engine/libraries/angelscript/add-ons/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 "hpl1/engine/libraries/angelscript/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);
+	void *GetArrayItemPointer(int index);
+	void *GetDataPointer(void *buffer);
+	void  Copy(void *dst, void *src);
+	void  Swap(void *a, void *b);
+	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

engines/hpl1/engine/libraries/angelscript/add-ons/scripthelper.cpp

@@ -0,0 +1,76 @@
+#include "scripthelper.h"
+
+#include "hpl1/std/set.h"
+#include "common/str.h"
+
+using namespace std;
+
+BEGIN_AS_NAMESPACE
+
+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
+	Common::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;
+}
+
+END_AS_NAMESPACE

engines/hpl1/engine/libraries/angelscript/add-ons/scripthelper.h

@@ -0,0 +1,24 @@
+#ifndef SCRIPTHELPER_H
+#define SCRIPTHELPER_H
+
+#ifndef ANGELSCRIPT_H
+// Avoid having to inform include path if header is already include before
+#include "hpl1/engine/libraries/angelscript/angelscript.h"
+#endif
+
+
+BEGIN_AS_NAMESPACE
+
+// 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);
+
+END_AS_NAMESPACE
+
+#endif

engines/hpl1/engine/libraries/angelscript/add-ons/scriptstdstring.h

@@ -0,0 +1,46 @@
+//
+// 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 "hpl1/engine/libraries/angelscript/angelscript.h"
+#endif
+
+//---------------------------
+// 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 cleanupRegisteredString();
+
+END_AS_NAMESPACE
+
+#endif