Initial commit

engines/hpl1/engine/libraries/angelscript/sources/as_context.h

@@ -0,0 +1,246 @@
+/*
+   AngelCode Scripting Library
+   Copyright (c) 2003-2018 Andreas Jonsson
+
+   This software is provided 'as-is', without any express or implied
+   warranty. In no event will the authors be held liable for any
+   damages arising from the use of this software.
+
+   Permission is granted to anyone to use this software for any
+   purpose, including commercial applications, and to alter it and
+   redistribute it freely, subject to the following restrictions:
+
+   1. The origin of this software must not be misrepresented; you
+      must not claim that you wrote the original software. If you use
+      this software in a product, an acknowledgment in the product
+      documentation would be appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and
+      must not be misrepresented as being the original software.
+
+   3. This notice may not be removed or altered from any source
+      distribution.
+
+   The original version of this library can be located at:
+   http://www.angelcode.com/angelscript/
+
+   Andreas Jonsson
+   andreas@angelcode.com
+*/
+
+
+//
+// as_context.h
+//
+// This class handles the execution of the byte code
+//
+
+
+#ifndef AS_CONTEXT_H
+#define AS_CONTEXT_H
+
+#include "as_config.h"
+#include "as_atomic.h"
+#include "as_memory.h"
+#include "as_string.h"
+#include "as_objecttype.h"
+#include "as_callfunc.h"
+
+BEGIN_AS_NAMESPACE
+
+class asCScriptFunction;
+class asCScriptEngine;
+
+class asCContext : public asIScriptContext {
+public:
+	// Memory management
+	int  AddRef() const;
+	int  Release() const;
+
+	// Miscellaneous
+	asIScriptEngine *GetEngine() const;
+
+	// Execution
+	int             Prepare(asIScriptFunction *func);
+	int             Unprepare();
+	int             Execute();
+	int             Abort();
+	int             Suspend();
+	asEContextState GetState() const;
+	int             PushState();
+	int             PopState();
+	bool            IsNested(asUINT *nestCount = 0) const;
+
+	// Object pointer for calling class methods
+	int SetObject(void *obj);
+
+	// Arguments
+	int   SetArgByte(asUINT arg, asBYTE value);
+	int   SetArgWord(asUINT arg, asWORD value);
+	int   SetArgDWord(asUINT arg, asDWORD value);
+	int   SetArgQWord(asUINT arg, asQWORD value);
+	int   SetArgFloat(asUINT arg, float value);
+	int   SetArgDouble(asUINT arg, double value);
+	int   SetArgAddress(asUINT arg, void *addr);
+	int   SetArgObject(asUINT arg, void *obj);
+	int   SetArgVarType(asUINT arg, void *ptr, int typeId);
+	void *GetAddressOfArg(asUINT arg);
+
+	// Return value
+	asBYTE  GetReturnByte();
+	asWORD  GetReturnWord();
+	asDWORD GetReturnDWord();
+	asQWORD GetReturnQWord();
+	float   GetReturnFloat();
+	double  GetReturnDouble();
+	void   *GetReturnAddress();
+	void   *GetReturnObject();
+	void   *GetAddressOfReturnValue();
+
+	// Exception handling
+	int                SetException(const char *descr, bool allowCatch = true);
+	int                GetExceptionLineNumber(int *column, const char **sectionName);
+	asIScriptFunction *GetExceptionFunction();
+	const char        *GetExceptionString();
+	bool               WillExceptionBeCaught();
+	int                SetExceptionCallback(asSFuncPtr callback, void *obj, int callConv);
+	void               ClearExceptionCallback();
+
+	// Debugging
+	int                SetLineCallback(asSFuncPtr callback, void *obj, int callConv);
+	void               ClearLineCallback();
+	asUINT             GetCallstackSize() const;
+	asIScriptFunction *GetFunction(asUINT stackLevel);
+	int                GetLineNumber(asUINT stackLevel, int *column, const char **sectionName);
+	int                GetVarCount(asUINT stackLevel);
+	const char        *GetVarName(asUINT varIndex, asUINT stackLevel);
+	const char        *GetVarDeclaration(asUINT varIndex, asUINT stackLevel, bool includeNamespace);
+	int                GetVarTypeId(asUINT varIndex, asUINT stackLevel);
+	void              *GetAddressOfVar(asUINT varIndex, asUINT stackLevel);
+	bool               IsVarInScope(asUINT varIndex, asUINT stackLevel);
+	int                GetThisTypeId(asUINT stackLevel);
+	void              *GetThisPointer(asUINT stackLevel);
+	asIScriptFunction *GetSystemFunction();
+
+	// User data
+	void *SetUserData(void *data, asPWORD type);
+	void *GetUserData(asPWORD type) const;
+
+public:
+	// Internal public functions
+	asCContext(asCScriptEngine *engine, bool holdRef);
+	virtual ~asCContext();
+
+//protected:
+	friend class asCScriptEngine;
+
+	void CallLineCallback();
+	void CallExceptionCallback();
+
+	int  CallGeneric(asCScriptFunction *func);
+#ifndef AS_NO_EXCEPTIONS
+	void HandleAppException();
+#endif
+	void DetachEngine();
+
+	void ExecuteNext();
+	void CleanStack(bool catchException = false);
+	bool CleanStackFrame(bool catchException = false);
+	void CleanArgsOnStack();
+	void CleanReturnObject();
+	void DetermineLiveObjects(asCArray<int> &liveObjects, asUINT stackLevel);
+
+	int  PushCallState();
+	void PopCallState();
+	void CallScriptFunction(asCScriptFunction *func);
+	void CallInterfaceMethod(asCScriptFunction *func);
+	void PrepareScriptFunction();
+
+	bool ReserveStackSpace(asUINT size);
+
+	void SetInternalException(const char *descr, bool allowCatch = true);
+	bool FindExceptionTryCatch();
+
+	// Must be protected for multiple accesses
+	mutable asCAtomic m_refCount;
+
+	bool             m_holdEngineRef;
+	asCScriptEngine *m_engine;
+
+	asEContextState m_status;
+	bool            m_doSuspend;
+	bool            m_doAbort;
+	bool            m_externalSuspendRequest;
+
+	asCScriptFunction *m_currentFunction;
+	asCScriptFunction *m_callingSystemFunction;
+
+	// The call stack holds program pointer, stack pointer, etc for caller functions
+	asCArray<size_t>    m_callStack;
+
+	// Dynamically growing local stack
+	asCArray<asDWORD *> m_stackBlocks;
+	asUINT              m_stackBlockSize;
+	asUINT              m_stackIndex;
+	asDWORD            *m_originalStackPointer;
+
+	// Exception handling
+	bool      m_isStackMemoryNotAllocated;
+	bool      m_needToCleanupArgs;
+	bool      m_inExceptionHandler;
+	asCString m_exceptionString;
+	int       m_exceptionFunction;
+	int       m_exceptionSectionIdx;
+	int       m_exceptionLine;
+	int       m_exceptionColumn;
+	bool      m_exceptionWillBeCaught;
+
+	// The last prepared function, and some cached values related to it
+	asCScriptFunction *m_initialFunction;
+	int                m_returnValueSize;
+	int                m_argumentsSize;
+
+	// callbacks
+	bool                       m_lineCallback;
+	asSSystemFunctionInterface m_lineCallbackFunc;
+	void                      *m_lineCallbackObj;
+
+	bool                       m_exceptionCallback;
+	asSSystemFunctionInterface m_exceptionCallbackFunc;
+	void                      *m_exceptionCallbackObj;
+
+	asCArray<asPWORD> m_userData;
+
+	// Registers available to JIT compiler functions
+	asSVMRegisters m_regs;
+};
+
+// TODO: Move these to as_utils.h
+int     as_powi(int base, int exponent, bool &isOverflow);
+asDWORD as_powu(asDWORD base, asDWORD exponent, bool &isOverflow);
+asINT64 as_powi64(asINT64 base, asINT64 exponent, bool &isOverflow);
+asQWORD as_powu64(asQWORD base, asQWORD exponent, bool &isOverflow);
+
+// Optional template version of powi if overflow detection is not used.
+#if 0
+template <class T>
+T as_powi(T base, T exponent) {
+	// Test for sign bit (huge number is OK)
+	if (exponent & (T(1) << (sizeof(T) * 8 - 1)))
+		return 0;
+	else {
+		int result = 1;
+		while (exponent) {
+			if (exponent & 1)
+				result *= base;
+			exponent >>= 1;
+			base *= base;
+		}
+		return result;
+	}
+}
+#endif
+
+END_AS_NAMESPACE
+
+#endif