diff options
Diffstat (limited to 'Runtime/Scripting/Backend/Flash/ScriptingBackendApi_Flash.cpp')
| -rw-r--r-- | Runtime/Scripting/Backend/Flash/ScriptingBackendApi_Flash.cpp | 287 |
1 files changed, 287 insertions, 0 deletions
diff --git a/Runtime/Scripting/Backend/Flash/ScriptingBackendApi_Flash.cpp b/Runtime/Scripting/Backend/Flash/ScriptingBackendApi_Flash.cpp new file mode 100644 index 0000000..8022f96 --- /dev/null +++ b/Runtime/Scripting/Backend/Flash/ScriptingBackendApi_Flash.cpp @@ -0,0 +1,287 @@ +#include "UnityPrefix.h" + +#include "../ScriptingTypes.h" +#include "ScriptingBackendApi_Flash.h" +#include "../ScriptingTypeRegistry.h" +#include "../ScriptingMethodRegistry.h" +#include <string> +#include "../ScriptingArguments.h" +#include "PlatformDependent\FlashSupport\cpp\FlashUtils.h" + +std::string scripting_cpp_string_for(ScriptingStringPtr str) +{ + return std::string((const char*)str); +} + +//implemented in raw actionscript +extern "C" ScriptingClass* Ext_Flash_GetBaseClassFromScriptingClass(ScriptingClass* klass); +bool scripting_method_is_instance(ScriptingMethodPtr method) +{ + //not implemented on flash yet. + return true; +} + +ScriptingStringPtr scripting_string_new(const char* str) +{ + __asm __volatile__("returnString = strFromPtr(%0);" : : "r" (str) ); + return (ScriptingStringPtr)str; +} + +ScriptingStringPtr scripting_string_new(const std::string& str) +{ + return scripting_string_new(str.c_str()); +} + +extern "C" int Ext_Flash_ScriptingGetMethodParamCount(ScriptingObjectPtr object, AS3String as3String); +int scripting_method_get_argument_count(ScriptingMethodPtr method, ScriptingTypeRegistry& typeRegistry) +{ + ScriptingObjectPtr methodInfo = method->GetSystemReflectionMethodInfo(); + if (methodInfo==NULL) + return 0; + + int result; + FLASH_ASM_WITH_NEWSP("%0 = ScriptingMethodHelper.NumberOfArgumentsOf(marshallmap.getObjectWithId(%1));" : "=r"(result) : "r"(methodInfo)); + + return result; +} + +ScriptingTypePtr scripting_method_get_nth_argumenttype(ScriptingMethodPtr method, int index, ScriptingTypeRegistry& typeRegistry) +{ + ScriptingObjectPtr methodInfo = method->GetSystemReflectionMethodInfo(); + if (methodInfo==NULL) + return NULL; + + ScriptingTypePtr result; + FLASH_ASM_WITH_NEWSP("scratch_object = ScriptingMethodHelper.NthArgumentType(marshallmap.getObjectWithId(%0), %1)" : : "r"(methodInfo), "r"(index)); + FLASH_ASM_WITH_NEWSP("if (scratch_object!=null) %0 = marshallmap.getIdForObject(scratch_object.GetClass()); else %0 = 0;" : "=r"(result)); + return result; +} + +const char* scripting_method_get_name(ScriptingMethodPtr method) +{ + return method->GetName(); +} + +bool scripting_method_has_attribute (ScriptingMethodPtr method, ScriptingClassPtr attribute) +{ + //not implemented on flash yet + return false; +} + +ScriptingTypePtr scripting_class_get_parent(ScriptingTypePtr type, ScriptingTypeRegistry& typeRegistry) +{ + return Ext_Flash_GetBaseClassFromScriptingClass(type); +} + +bool scripting_class_is_enum(ScriptingTypePtr type) +{ + //todo: implement + return false; +} + +extern "C" const char* Ext_Flash_GetNameFromClass(ScriptingClassPtr klass); +const char* scripting_class_get_name(ScriptingClassPtr klass) +{ + //Horrible, we can only clean this up once we create a struct ScriptingClass for flash. + std::string* s = new std::string(Ext_Flash_GetNameFromClass(klass)); + return s->c_str(); +} + +extern "C" const char* Ext_Flash_GetNameSpaceFromScriptingType(ScriptingType* scriptingType); +const char* scripting_class_get_namespace(ScriptingClassPtr klass) +{ + //Horrible, we can only clean this up once we create a struct ScriptingClass for flash. + std::string* s = new std::string(Ext_Flash_GetNameSpaceFromScriptingType(klass)); + return s->c_str(); +} + +extern "C" bool Ext_Flash_ScriptingClassIsSubclassOf(ScriptingTypePtr t1, ScriptingTypePtr t2); +bool scripting_class_is_subclass_of(ScriptingTypePtr t1, ScriptingTypePtr t2) +{ + return Ext_Flash_ScriptingClassIsSubclassOf(t1,t2); +} + +ScriptingTypePtr scripting_method_get_returntype(ScriptingMethodPtr method, ScriptingTypeRegistry& typeRegistry) +{ + return method->GetReturnType(); +} + +extern "C" ScriptingObjectPtr Ext_Flash_InvokeMethodOnObject(void* object, AS3String as3String, ScriptingException** exception); +ScriptingObjectPtr scripting_method_invoke(ScriptingMethodPtr method, ScriptingObjectPtr object, ScriptingArguments& arguments, ScriptingExceptionPtr* exception) +{ + void* objectToInvokeOn = object; + *exception = NULL; + if (object==NULL) + { + objectToInvokeOn = method->m_Class; + if (objectToInvokeOn == NULL) + ErrorString("flash_invoke_method called with NULL object, and scriptmethod->m_Class is NULL too."); + } + + __asm __volatile__("invocation_arguments.length = 0;\n"); + + for (int i=0; i!=arguments.GetCount(); i++) + { + switch (arguments.GetTypeAt(i)) + { + case ScriptingArguments::ARGTYPE_BOOLEAN: + __asm __volatile__("invocation_arguments.push(%0 ? true : false);" : : "r"(arguments.GetBooleanAt(i))); + break; + case ScriptingArguments::ARGTYPE_INT: + __asm __volatile__("invocation_arguments.push(%0);" : : "r"(arguments.GetIntAt(i))); + break; + case ScriptingArguments::ARGTYPE_FLOAT: + __asm __volatile__("invocation_arguments.push(%0);" : : "f"(arguments.GetFloatAt(i))); + break; + case ScriptingArguments::ARGTYPE_STRING: + __asm __volatile__("invocation_arguments.push(strFromPtr(%0));" : : "r"(arguments.GetStringAt(i))); + break; + case ScriptingArguments::ARGTYPE_OBJECT: + __asm __volatile__("invocation_arguments.push(marshallmap.getObjectWithId(%0));" : : "r"(arguments.GetObjectAt(i))); + break; + default: + ErrorString(Format("Flash does not support calling managed methods with this type of argument: %d",arguments.GetTypeAt(i))); + break; + } + } + return Ext_Flash_InvokeMethodOnObject(objectToInvokeOn, method->m_As3String,exception); +} + +ScriptingTypePtr scripting_class_from_systemtypeinstance(ScriptingObjectPtr systemTypeInstance, ScriptingTypeRegistry& typeRegistry) +{ + //todo: think about if this is actually correct. + return (ScriptingClassPtr)systemTypeInstance; +} + +extern "C" ScriptingObjectPtr Ext_Flash_CreateInstance(ScriptingClass* klass); +ScriptingObjectPtr scripting_object_new(ScriptingTypePtr t) +{ + return Ext_Flash_CreateInstance(t); +} + +extern "C" ScriptingClassPtr Ext_Flash_GetScriptingTypeOfScriptingObject(ScriptingObjectPtr); +ScriptingTypePtr scripting_object_get_class(ScriptingObjectPtr o, ScriptingTypeRegistry& typeRegistry) +{ + return Ext_Flash_GetScriptingTypeOfScriptingObject(o); +} + +ScriptingMethodPtr scripting_object_get_virtual_method(ScriptingObjectPtr o, ScriptingMethodPtr method, ScriptingMethodRegistry& methodRegistry) +{ + return method; +} + +void scripting_object_invoke_default_constructor(ScriptingObjectPtr o, ScriptingExceptionPtr* exc) +{ + *exc = NULL; + //todo: properly deal with exception. + FLASH_ASM_WITH_NEWSP("marshallmap.getObjectWithId(%0).cil2as_DefaultConstructor()" : : "r"(o)); +} + +int scripting_gchandle_new(ScriptingObjectPtr o) +{ + __asm __volatile__("marshallmap.gcHandle(%0);" : : "r" (o)); + return (int)o; +} + +int scripting_gchandle_weak_new(ScriptingObjectPtr o) +{ + FatalErrorMsg("ToDo"); + return 0; +} + +void scripting_gchandle_free(int handle) +{ + __asm __volatile__("marshallmap.gcFree(%0);" : : "r" (handle)); +} + +ScriptingObjectPtr scripting_gchandle_get_target(int handle) +{ + return (ScriptingObjectPtr) handle; +} + +int scripting_gc_maxgeneration() +{ + return 0; +} + +void scripting_gc_collect(int maxGeneration) +{ + FatalErrorMsg("ToDo"); +} + +void ScriptingMethod::Init(const char* name, const char* mappedName, const char* sig, ScriptingClass* klass) +{ + m_Name = strcpy(new char[strlen(name) + 1],name); + m_Mappedname = strcpy(new char[strlen(mappedName) + 1],mappedName); + __asm __volatile__("%0 = getAS3StringForPtr(%1);\n" : "=r" (m_As3String) : "r" (m_Mappedname)); + + m_Signature = strcpy(new char[strlen(sig) + 1],sig); + m_Class = klass; + m_MethodInfo = NULL; + FLASH_ASM_WITH_NEWSP("%0 = marshallmap.getIdForObject(System.Type.ForClass(marshallmap.getObjectWithId(%1)));\n" : "=r" (m_SystemType) : "r"(m_Class) ); + scripting_gchandle_new(m_SystemType); +} + +extern "C" const char* Ext_GetMappedMethodName(const char* name, ScriptingType* klass); +ScriptingMethod::ScriptingMethod(const char* name, ScriptingClass* klass) +{ + const char* mappedName = Ext_GetMappedMethodName(name,klass); + Init(name,mappedName,"",klass); +} + +ScriptingMethod::ScriptingMethod(const char* name, const char* mappedName, const char* sig, ScriptingClass* klass) +{ + Init(name,mappedName,sig,klass); +} + +extern "C" ScriptingClass* Ext_Flash_GetMethodReturnType(const char* methodname, ScriptingClass* klass); +ScriptingClass* ScriptingMethod::GetReturnType() +{ + return Ext_Flash_GetMethodReturnType(m_Mappedname, m_Class); +} + +ScriptingObjectPtr ScriptingMethod::GetSystemReflectionMethodInfo() +{ + if (m_MethodInfo) + return m_MethodInfo; + + FLASH_ASM_WITH_NEWSP("%0 = marshallmap.getIdForObject(ScriptingMethodHelper.GetMethodInfo(marshallmap.getObjectWithId(%1), strFromPtr(%2)));" : "=r"(m_MethodInfo) : "r"(m_SystemType),"r"(m_Name) ); + + scripting_gchandle_new(m_MethodInfo); + return m_MethodInfo; +} + +ScriptingObjectPtr scripting_class_get_object(ScriptingClassPtr klass) +{ + FatalErrorMsg("ToDo"); + return SCRIPTING_NULL; +} + +ScriptingArrayPtr scripting_cast_object_to_array(ScriptingObjectPtr o) +{ + FatalErrorMsg("ToDo"); + return SCRIPTING_NULL; +} + +void scripting_stack_trace_info_for(ScriptingExceptionPtr exception, StackTraceInfo& info) +{ + AssertIf (exception == NULL); + + __asm __volatile__("var errorStr:String = marshallmap.getObjectWithId(%0) as String;"::"r"(exception)); + int length; + __asm __volatile__("%0=getStringMarshallingLength(errorStr);":"=r"(length)); + char* errorStrPtr = (char*)alloca(length); + __asm __volatile__("var ptr:int = placeStringAtPtr(errorStr,%0);"::"r"(errorStrPtr)); + + info.condition = errorStrPtr; + info.strippedStacktrace = ""; + info.stacktrace = ""; + info.errorNum = 0; + info.file = ""; + info.line = 0; +} + +void* scripting_array_element_ptr(ScriptingArrayPtr array, int i, size_t element_size) +{ + return (UInt8*)array + sizeof(int) + i * element_size; +}
\ No newline at end of file |