+Unity Runtime codeHEADmaster

1 files changed, 418 insertions, 0 deletions

diff --git a/Runtime/Mono/MonoFunctions.h b/Runtime/Mono/MonoFunctions.h
new file mode 100644
index 0000000..e93a298
--- /dev/null
+++ b/Runtime/Mono/MonoFunctions.h
@@ -0,0 +1,418 @@
+#ifndef DO_API_NO_RETURN
+#define DO_API_NO_RETURN(a,b,c) DO_API(a,b,c)
+#endif
+
+// If you add functions to this file you also need to expose them in MonoBundle.exp
+// Otherwise they wont be exported in the web plugin!
+DO_API(void,mono_thread_suspend_all_other_threads, ())
+DO_API(void,mono_thread_pool_cleanup, ())
+DO_API(void,mono_threads_set_shutting_down, ())
+DO_API(void,mono_runtime_set_shutting_down, ())
+DO_API(gboolean,mono_runtime_is_shutting_down, ())
+DO_API(gboolean,mono_domain_finalize, (MonoDomain *domain, int timeout))
+DO_API(void,mono_runtime_cleanup, (MonoDomain *domain))
+DO_API(MonoMethod*,mono_object_get_virtual_method, (MonoObject *obj, MonoMethod *method))
+
+DO_API(void,mono_verifier_set_mode,(MiniVerifierMode) );
+DO_API(void,mono_security_set_mode,(MonoSecurityMode) );
+DO_API(void,mono_add_internal_call,(const char *name, gconstpointer method))
+DO_API(void,mono_jit_cleanup,(MonoDomain *domain))
+DO_API(MonoDomain*,mono_jit_init,(const char *file))
+DO_API(MonoDomain*,mono_jit_init_version,(const char *file, const char* runtime_version))
+DO_API(int, mono_jit_exec, (MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]))
+DO_API(MonoClass *,mono_class_from_name,(MonoImage *image, const char* name_space, const char *name))
+DO_API(MonoClass *,mono_class_from_name_case,(MonoImage *image, const char* name_space, const char *name))
+DO_API(MonoAssembly *,mono_domain_assembly_open,(MonoDomain *domain, const char *name))
+DO_API(MonoDomain *, mono_domain_create_appdomain,(const char *domainname, const char* configfile))
+DO_API(void, mono_domain_unload, (MonoDomain* domain))
+DO_API(MonoObject*,mono_object_new,(MonoDomain *domain, MonoClass *klass))
+DO_API(void,mono_runtime_object_init,(MonoObject *this_obj))
+DO_API(MonoObject*,mono_runtime_invoke,(MonoMethod *method, void *obj, void **params, MonoException **exc))
+DO_API(void,mono_field_set_value,(MonoObject *obj, MonoClassField *field, void *value))
+DO_API(void,mono_field_get_value,(MonoObject *obj, MonoClassField *field, void *value))
+DO_API(int,mono_field_get_offset,(MonoClassField *field))
+DO_API(MonoClassField*,mono_class_get_fields,(MonoClass* klass, gpointer *iter))
+DO_API(MonoMethod*,mono_class_get_methods,(MonoClass* klass, gpointer *iter))
+DO_API(MonoDomain*,mono_domain_get,())
+DO_API(MonoDomain*,mono_get_root_domain,())
+DO_API(gint32,mono_domain_get_id,(MonoDomain *domain))
+DO_API(void,mono_assembly_foreach,(GFunc func, gpointer user_data))
+DO_API(void,mono_image_close,(MonoImage *image))
+DO_API(void,mono_unity_socket_security_enabled_set,(gboolean))
+//DO_API(void,mono_set_unhandled_exception_handler,(void* function))
+DO_API(const char*, mono_image_get_name, (MonoImage *image))
+DO_API(MonoClass*, mono_get_object_class, ())
+#if UNITY_WIN || UNITY_OSX || UNITY_ANDROID || UNITY_BB10 || UNITY_TIZEN
+DO_API(void,mono_set_signal_chaining, (bool))
+#endif
+#if UNITY_WIN
+DO_API(long, mono_unity_seh_handler, (EXCEPTION_POINTERS*))
+DO_API(void, mono_unity_set_unhandled_exception_handler, (void*))
+#endif
+DO_API(void, mono_set_commandline_arguments, (int, const char* argv[], const char*))
+#if USE_MONO_AOT
+DO_API(void*, mono_aot_get_method,(MonoDomain *domain, MonoMethod *method))
+#endif
+//DO_API(MonoMethod*, mono_marshal_get_xappdomain_invoke, (MonoMethod*))
+
+#if UNITY_EDITOR
+// Type-safe way of looking up methods based on method signatures
+DO_API(MonoObject*,mono_runtime_invoke_array,(MonoMethod *method, void *obj, MonoArray *params, MonoException **exc))
+DO_API(MonoMethodDesc*, mono_method_desc_new, (const char *name, gboolean include_namespace))
+DO_API(MonoMethod*, mono_method_desc_search_in_class, (MonoMethodDesc* desc, MonoClass* klass))
+DO_API(void, mono_method_desc_free, (MonoMethodDesc* desc))
+DO_API(char*,mono_type_get_name_full,(MonoType *type, MonoTypeNameFormat format))
+#endif
+
+#if UNITY_WIN || UNITY_XENON
+DO_API(gunichar2*,mono_string_to_utf16,(MonoString *string_obj))
+#endif
+
+DO_API(const char*,mono_field_get_name,(MonoClassField *field))
+DO_API(MonoType*,mono_field_get_type,(MonoClassField *field))
+DO_API(int,mono_type_get_type,(MonoType *type))
+DO_API(const char*,mono_method_get_name,(MonoMethod *method))
+DO_API(MonoImage*,mono_assembly_get_image,(MonoAssembly *assembly))
+DO_API(MonoClass* ,mono_method_get_class,(MonoMethod *method))
+DO_API(MonoClass*,mono_object_get_class,(MonoObject *obj))
+DO_API(gboolean,mono_class_is_valuetype,(MonoClass *klass))
+DO_API(guint32,mono_signature_get_param_count,(MonoMethodSignature *sig))
+DO_API(char*,mono_string_to_utf8,(MonoString *string_obj))
+DO_API(MonoString*,mono_string_new_wrapper,(const char* text))
+DO_API(MonoString*,mono_string_new_len,(MonoDomain *domain, const char *text, guint32 length))
+DO_API(MonoString*,mono_string_from_utf16,(const gunichar2* text))
+DO_API(MonoClass*,mono_class_get_parent,(MonoClass *klass))
+DO_API(const char*,mono_class_get_namespace,(MonoClass *klass))
+DO_API(gboolean,mono_class_is_subclass_of,(MonoClass *klass, MonoClass *klassc,  gboolean check_interfaces))
+DO_API(const char*,mono_class_get_name,(MonoClass *klass))
+DO_API(char*,mono_type_get_name,(MonoType *type))
+DO_API(MonoClass*,mono_type_get_class,(MonoType *type))
+DO_API(MonoException *,mono_exception_from_name_msg,(MonoImage *image, const char *name_space, const char *name, const char *msg))
+DO_API_NO_RETURN(void,mono_raise_exception,(MonoException *ex)) 
+DO_API(MonoClass*,mono_get_exception_class,())
+DO_API(MonoClass*,mono_get_array_class,())
+DO_API(MonoClass*,mono_get_string_class,())
+DO_API(MonoClass*,mono_get_boolean_class,())
+DO_API(MonoClass*,mono_get_byte_class,())
+DO_API(MonoClass*,mono_get_char_class,())
+DO_API(MonoClass*,mono_get_int16_class,())
+DO_API(MonoClass*,mono_get_int32_class,())
+DO_API(MonoClass*,mono_get_int64_class,())
+DO_API(MonoClass*,mono_get_single_class,())
+DO_API(MonoClass*,mono_get_double_class,())
+DO_API(MonoArray*,mono_array_new,(MonoDomain *domain, MonoClass *eclass, guint32 n))
+//DO_API(MonoArray *, mono_array_new_specific, (MonoVTable *vtable, guint32 n))
+DO_API(MonoArray*, mono_array_new_full, (MonoDomain *domain, MonoClass *array_class, guint32 *lengths, guint32 *lower_bounds))
+
+DO_API(MonoClass *, mono_array_class_get, (MonoClass *eclass, guint32 rank))
+
+DO_API(gint32,mono_class_array_element_size,(MonoClass *ac))
+DO_API(MonoObject*, mono_type_get_object, (MonoDomain *domain, MonoType *type))
+DO_API(gboolean, mono_class_is_generic, (MonoClass* klass))
+DO_API(gboolean, mono_class_is_inflated, (MonoClass* klass))
+
+DO_API(MonoThread *,mono_thread_attach,(MonoDomain *domain))
+
+DO_API(void, mono_thread_detach,(MonoThread *thread))
+DO_API(MonoThread *,mono_thread_exit,())
+
+DO_API(MonoThread *,mono_thread_current,(void))
+DO_API(void,mono_thread_set_main,(MonoThread* thread))
+DO_API(void,mono_set_find_plugin_callback,(gconstpointer method))
+DO_API(void,mono_security_enable_core_clr, ())
+
+typedef bool (*MonoCoreClrPlatformCB) (const char *image_name);
+DO_API(bool,mono_security_set_core_clr_platform_callback, (MonoCoreClrPlatformCB))
+
+#if MONO_2_12
+DO_API(void,mono_security_core_clr_set_options, (MonoSecurityCoreCLROptions))
+#endif
+
+DO_API(void, mono_runtime_unhandled_exception_policy_set, (MonoRuntimeUnhandledExceptionPolicy policy))
+
+#if UNITY_OSX	
+//DO_API(void,SetNativeSigsegvHandler,(gconstpointer ptr))
+#endif
+#if UNITY_WIN
+//DO_API(void,SetNativeSigsegvHandlerWin,(gconstpointer ptr))
+// @TODO: move this out of windows specific
+//DO_API(void,unity_mono_redirect_output,(const char* fout, const char* ferr))
+//DO_API(void,unity_mono_close_output,())
+#endif
+
+DO_API(MonoClass*,mono_class_get_nesting_type,(MonoClass *klass))
+DO_API(MonoVTable* ,mono_class_vtable,(MonoDomain *domain, MonoClass *klass))
+DO_API(MonoReflectionMethod* ,mono_method_get_object,(MonoDomain *domain, MonoMethod *method, MonoClass *refclass))
+
+DO_API(MonoMethodSignature* ,mono_method_signature,(MonoMethod *method))
+DO_API(MonoType*,mono_signature_get_params,(MonoMethodSignature *sig, gpointer *iter))
+DO_API(MonoType*,mono_signature_get_return_type,(MonoMethodSignature *sig))
+DO_API(MonoType*,mono_class_get_type,(MonoClass *klass))
+DO_API(void,mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded,(gboolean value))
+DO_API (void,mono_debug_init ,(int format))
+
+DO_API (void,mono_debug_open_image_from_memory,(MonoImage *image, const char *raw_contents, int size))
+DO_API(guint32,mono_field_get_flags,(MonoClassField *field))
+DO_API(MonoImage*,mono_image_open_from_data_full,(const void *data, guint32 data_len, gboolean need_copy, int *status, gboolean ref_only))
+DO_API(MonoImage*,mono_image_open_from_data_with_name,(char *data, guint32 data_len, gboolean need_copy, int *status, gboolean refonly, const char *name))
+DO_API(MonoAssembly *,mono_assembly_load_from,(MonoImage *image, const char*fname,  int *status))
+DO_API(bool, mono_assembly_fill_assembly_name, (MonoImage *image, MonoAssemblyName *aname))
+DO_API(char* , mono_stringify_assembly_name, (MonoAssemblyName *aname))
+DO_API(int, mono_assembly_name_parse,(const char* name, MonoAssemblyName *assembly))
+DO_API(MonoAssembly*, mono_assembly_loaded, (MonoAssemblyName *aname))
+DO_API(int, mono_image_get_table_rows, (MonoImage *image, int table_id))
+DO_API(MonoClass*, mono_class_get, (MonoImage *image, guint32 type_token))
+DO_API(gboolean, mono_metadata_signature_equal, (MonoMethodSignature *sig1, MonoMethodSignature *sig2))
+
+DO_API(MonoObject *,mono_value_box,(MonoDomain *domain, MonoClass *klass, gpointer val))
+DO_API(MonoImage*,mono_class_get_image,(MonoClass *klass))
+DO_API(char,mono_signature_is_instance,(MonoMethodSignature *signature))
+DO_API(MonoMethod*,mono_method_get_last_managed,())
+DO_API(MonoClass*,mono_get_enum_class,())
+DO_API(MonoType*,mono_class_get_byref_type,(MonoClass *klass))
+
+DO_API (void,mono_field_static_get_value,(MonoVTable *vt, MonoClassField *field, void *value))
+DO_API(void,mono_unity_set_embeddinghostname,(const char* name))
+DO_API(void,mono_set_assemblies_path,(const char* name))
+
+DO_API (guint32, mono_gchandle_new, (MonoObject *obj, gboolean pinned))
+DO_API (MonoObject*, mono_gchandle_get_target, (guint32 gchandle))
+
+DO_API (guint32, mono_gchandle_new_weakref, (MonoObject *obj, gboolean track_resurrection))
+
+DO_API (gboolean, mono_gchandle_is_in_domain, (guint32 gchandle, MonoDomain *domain))
+DO_API (MonoObject*, mono_assembly_get_object, (MonoDomain *domain, MonoAssembly *assembly))
+
+DO_API (void,mono_gchandle_free, (guint32 gchandle))
+
+typedef gboolean (*MonoStackWalk) (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed, gpointer data);
+DO_API (void, mono_stack_walk, (MonoStackWalk func, gpointer user_data));
+DO_API (char*, mono_pmip, (void *ip));
+DO_API (MonoObject*, mono_runtime_delegate_invoke, (MonoObject *delegate, void **params, MonoException **exc))
+
+//DO_API (void,GC_free,(void* p))
+//DO_API(void*,GC_malloc_uncollectable,(int size))
+DO_API(MonoProperty*,mono_class_get_properties,(MonoClass* klass, gpointer *iter))
+DO_API(MonoMethod*,mono_property_get_get_method,(MonoProperty *prop))
+DO_API(MonoObject *,mono_object_new_alloc_specific,(MonoVTable *vtable))
+DO_API(MonoObject *,mono_object_new_specific,(MonoVTable *vtable))
+
+DO_API (void,mono_gc_collect,(int generation))
+DO_API(int,mono_gc_max_generation,())
+
+DO_API(gint64,mono_gc_get_used_size,())
+DO_API(gint64,mono_gc_get_heap_size,())
+
+DO_API(MonoAssembly*,mono_image_get_assembly,(MonoImage *image))
+DO_API(MonoAssembly*,mono_assembly_open,(const char *filename, int *status))
+
+DO_API(gboolean,mono_class_is_enum,(MonoClass *klass))
+DO_API(MonoType* ,mono_class_enum_basetype, (MonoClass *klass))
+DO_API(gint32,mono_class_instance_size,(MonoClass *klass))
+DO_API(guint32,mono_object_get_size,(MonoObject *obj))
+DO_API(const char*,mono_image_get_filename,(MonoImage *image))
+DO_API(MonoAssembly*,mono_assembly_load_from_full,(MonoImage *image, const char *fname,int *status,gboolean refonly))
+DO_API(MonoClass*,mono_class_get_interfaces,(MonoClass* klass, gpointer *iter))
+DO_API (void,mono_assembly_close,(MonoAssembly *assembly))
+DO_API(MonoProperty*,mono_class_get_property_from_name,(MonoClass *klass, const char *name))
+DO_API(MonoMethod*,mono_class_get_method_from_name,(MonoClass *klass, const char *name, int param_count))
+DO_API(MonoClass*,mono_class_from_mono_type,(MonoType *image))
+DO_API(int, mono_class_get_rank, (MonoClass *klass));
+DO_API(MonoClass*, mono_class_get_element_class, (MonoClass *klass));
+DO_API(bool,mono_unity_class_is_interface,(MonoClass* klass))
+DO_API(bool,mono_unity_class_is_abstract,(MonoClass* klass))
+
+DO_API (gboolean,mono_domain_set,(MonoDomain *domain, gboolean force))
+DO_API (void,mono_thread_push_appdomain_ref,(MonoDomain *domain))
+DO_API (void,mono_thread_pop_appdomain_ref,())
+
+DO_API (int, mono_runtime_exec_main, (MonoMethod *method, MonoArray *args, MonoObject **exc))
+
+DO_API (MonoImage*,mono_get_corlib,())
+DO_API (MonoClassField*, mono_class_get_field_from_name, (MonoClass *klass, const char *name))
+DO_API (guint32, mono_class_get_flags, (MonoClass *klass))
+
+DO_API(int, mono_parse_default_optimizations, (const char* p))
+DO_API (void, mono_set_defaults, (int verbose_level, guint32 opts))
+DO_API(void, mono_config_parse, (const char *filename))
+DO_API(void, mono_set_dirs, (const char *assembly_dir, const char *config_dir))
+//DO_API(void,ves_icall_System_AppDomain_InternalUnload,(int domain_id))
+//DO_API(MonoObject*,ves_icall_System_AppDomain_createDomain,(MonoString *friendly_name, MonoObject *setup))
+DO_API(void,mono_jit_parse_options,(int argc, char * argv[]))
+DO_API(gpointer, mono_object_unbox, (MonoObject* o))
+
+DO_API(MonoObject*, mono_custom_attrs_get_attr,  (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass))
+
+DO_API(gboolean, mono_custom_attrs_has_attr, (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass))
+DO_API(MonoCustomAttrInfo*, mono_custom_attrs_from_field, (MonoClass *klass, MonoClassField *field))
+DO_API(MonoCustomAttrInfo*, mono_custom_attrs_from_method, (MonoMethod *method))
+DO_API(MonoCustomAttrInfo*, mono_custom_attrs_from_class, (MonoClass *klass))
+DO_API(void, mono_custom_attrs_free, (MonoCustomAttrInfo* attr))
+
+#if UNITY_STANDALONE || UNITY_EDITOR
+// DllImport fallback handling to load native libraries from custom locations
+typedef void* (*MonoDlFallbackLoad) (const char *name, int flags, char **err, void *user_data);
+typedef void* (*MonoDlFallbackSymbol) (void *handle, const char *name, char **err, void *user_data);
+typedef void* (*MonoDlFallbackClose) (void *handle, void *user_data);
+DO_API(MonoDlFallbackHandler*, mono_dl_fallback_register, (MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, MonoDlFallbackClose close_func, void *user_data))
+DO_API(void, mono_dl_fallback_unregister, (MonoDlFallbackHandler *handler))
+#endif
+
+#if UNITY_EDITOR
+typedef void (*vprintf_func)(const char* msg, va_list args);
+DO_API(void, mono_unity_set_vprintf_func, (vprintf_func func))
+DO_API(void*, mono_loader_get_last_error, (void))
+DO_API(MonoException*, mono_loader_error_prepare_exception, (void *error))
+#endif
+
+typedef void (*register_object_callback)(gpointer* arr, int size, void* userdata);
+DO_API(void*, mono_unity_liveness_calculation_begin, (MonoClass* filter, int max_object_count, register_object_callback callback, void* userdata))
+DO_API(void, mono_unity_liveness_calculation_end, (void* state))
+DO_API(void, mono_unity_liveness_calculation_from_root, (MonoObject* root, void* state))
+DO_API(void, mono_unity_liveness_calculation_from_statics, (void* state))
+
+
+///@TODO add this as an optimization when upgrading mono, used by MonoStringNewLength:
+/// mono_string_new_len      (MonoDomain *domain, const char *text, guint length);
+
+// Profiler
+#if ENABLE_MONO_MEMORY_PROFILER || ENABLE_MONO_HEAPSHOT
+typedef void (*MonoProfileFunc) (void *prof);
+typedef void (*MonoProfileMethodFunc)   (void *prof, MonoMethod   *method);
+typedef void (*MonoProfileExceptionFunc) (void *prof, MonoObject *object);
+typedef void (*MonoProfileExceptionClauseFunc) (void *prof, MonoMethod *method, int clause_type, int clause_num);
+typedef void (*MonoProfileGCFunc)         (void *prof, int event, int generation);
+typedef void (*MonoProfileGCResizeFunc)   (void *prof, SInt64 new_size);
+typedef void (*MonoProfileAllocFunc)      (void *prof, MonoObject *obj, MonoClass *klass);
+typedef void (*MonoProfileStatCallChainFunc) (void *prof, int call_chain_depth, guchar **ip, void *context);
+typedef void (*MonoProfileStatFunc)       (void *prof, guchar *ip, void *context);
+
+
+DO_API(void, mono_profiler_install, (void *prof, MonoProfileFunc shutdown_callback))
+DO_API(void, mono_profiler_set_events, (int events))
+DO_API(void, mono_profiler_install_enter_leave, (MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave))
+DO_API(void, mono_profiler_install_gc, (MonoProfileGCFunc callback, MonoProfileGCResizeFunc heap_resize_callback))
+DO_API(void, mono_profiler_install_allocation, (MonoProfileAllocFunc callback))
+//DO_API(void, mono_gc_base_init, ())
+//DO_API(void, mono_profiler_install_statistical, (MonoProfileStatFunc callback))
+//DO_API(void, mono_profiler_install_statistical_call_chain, (MonoProfileStatCallChainFunc callback, int call_chain_depth))
+DO_API(void, mono_profiler_install_exception, (MonoProfileExceptionFunc throw_callback, MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback))
+
+#	if ENABLE_MONO_HEAPSHOT
+	typedef void (*MonoProfileClassFunc) (void *prof, MonoClass* klass);
+	typedef void (*MonoProfileClassResult) (void *prof, MonoClass* klass,int result);
+
+	DO_API(void, mono_profiler_install_class, (MonoProfileClassFunc start_load, MonoProfileClassResult end_load, MonoProfileClassFunc start_unload, MonoProfileClassFunc end_unload))
+	DO_API(gboolean, mono_type_is_reference, (MonoType *type));
+	DO_API(gint32, mono_class_value_size, (MonoClass *klass, guint32 *align));
+	DO_API(char*, mono_array_addr_with_size, (MonoArray *array, int size, uintptr_t idx));
+	#define mono_array_addr(array,type,index) ((type*)(void*) mono_array_addr_with_size (array, sizeof (type), index))
+	#define mono_array_get(array,type,index) ( *(type*)mono_array_addr ((array), type, (index)) ) 
+	DO_API(gint32, mono_array_element_size, (MonoClass *ac));
+	DO_API(char*, mono_type_full_name, (MonoType *type));
+	typedef void (*MonoDomainFunc) (MonoDomain *domain, void* user_data);
+	DO_API(void, mono_domain_foreach, (MonoDomainFunc func, void* user_data));
+	DO_API(gboolean, mono_object_is_alive, (MonoObject* obj));
+#	endif
+#endif
+
+#if UNITY_IPHONE || UNITY_PEPPER
+DO_API(void, mono_aot_register_module, (void *aot_info))
+#endif
+
+// GLib functions
+#if UNITY_IPHONE || UNITY_PEPPER // iPhone uses eglib which just calls free
+#define g_free free
+#elif MONO_2_12
+#define g_free mono_unity_g_free
+DO_API(void,mono_unity_g_free,(void* p))
+#else
+DO_API(void,g_free,(void* p))
+#endif
+/*
+#if UNITY_PS3 || UNITY_XENON || UNITY_ANDROID
+static inline char   *g_strdup (const char *str) { if (str) {return strdup (str);} return NULL; }
+#define g_mem_set_vtable(x)
+#else
+DO_API(char*,g_strdup,(const char *image))
+DO_API(void,g_mem_set_vtable,(gpointer vtable))
+#endif*/
+
+
+//DO_API(void,macosx_register_exception_handler,())
+
+DO_API(void, mono_trace_set_level_string, (const char *value))
+DO_API(void, mono_trace_set_mask_string, (const char *value))
+ 
+#if UNITY_WII
+DO_API(char*, g_strdup_d, (char const* str))
+
+// memory and string functions
+DO_API(void*, console_g_malloc, ( size_t size ))
+DO_API(void*, console_g_calloc, ( size_t size, size_t elemSize ))
+DO_API(void*, console_g_realloc, (void *memblock, size_t size))
+DO_API(void, console_g_free, ( void* p ))
+
+// specific allocations
+DO_API(void*, console_g_malloc_image, (size_t size))
+DO_API(void, console_g_free_image, (void* p))
+
+DO_API(void*, console_g_malloc0_handles, (size_t size))
+DO_API(void, console_g_free_handles, (void* p))
+
+#define g_free                  console_g_free
+//#define g_malloc_d(x)	        console_g_malloc(x)
+//#define g_calloc_d(obj,size)	console_g_calloc(obj,size)
+#define g_free_d(x)				console_g_free(x)
+#define g_strdup_d(x)			g_strdup(x)
+
+DO_API(void*, g_memdup, (void const* mem, unsigned int byte_size))
+DO_API(char*, g_strdup, (const char *str))
+
+#endif
+
+#if UNITY_XENON || UNITY_PS3
+// memory and string functions
+DO_API(void*, console_g_malloc, ( size_t size ))
+DO_API(void*, console_g_calloc, ( size_t size, size_t elemSize ))
+DO_API(void*, console_g_realloc, (void *memblock, size_t size))
+DO_API(void, console_g_free, ( void* p ))
+
+#define g_free console_g_free
+#endif
+
+#if UNITY_PEPPER
+DO_API(void, mono_set_corlib_data, (void *data, size_t size))
+DO_API(void, mono_runtime_set_no_exec, (gboolean val))
+DO_API(void, mono_jit_set_aot_only, (gboolean val))
+typedef MonoAssembly *(*MonoAssemblySearchFunc)         (char **aname, void* user_data);
+
+DO_API(void, mono_install_assembly_postload_search_hook, (MonoAssemblySearchFunc func, gpointer user_data))
+#endif
+
+#if UNITY_PS3 || UNITY_XENON
+DO_API(char*, g_strdup_d, (char const* str))
+#define g_strdup_d(x)			g_strdup(x)
+DO_API(void*, g_memdup, (void const* mem, unsigned int byte_size))
+//DO_API(char*, g_strdup, (const char *str))
+
+#endif
+
+#if UNITY_XENON
+DO_API(void, mono_xenon_dl_set_min_version, (DWORD min_version))
+DO_API(void, mono_runtime_set_main_args, (const char** args, int num_args))
+#endif
+
+#if UNITY_PLUGINS_AVAILABLE && UNITY_XENON
+DO_API(MonoDl*, mono_dl_open, (const char* name, int flags, char** error_msg))
+DO_API(char*, mono_dl_symbol, (void* MonoDl, const char* name, void** symbol))
+DO_API(void, mono_dl_close, (void* MonoDl))
+DO_API(MonoDl*, cached_module_load, (const char* name, int flags, char** error_msg))
+#endif
+
+#if UNITY_OSX
+DO_API(int,mono_backtrace_from_context, (void* context, void* array[], int count))
+#endif
+
+#undef DO_API
+#undef DO_API_NO_RETURN