1 /* 2 Boost Software License - Version 1.0 - August 17th, 2003 3 Permission is hereby granted,free of charge,to any person or organization 4 obtaining a copy of the software and accompanying documentation covered by 5 this license (the "Software") to use,reproduce,display,distribute, 6 execute,and transmit the Software,and to prepare derivative works of the 7 Software,and to permit third-parties to whom the Software is furnished to 8 do so,all subject to the following: 9 10 The copyright notices in the Software and this entire statement,including 11 the above license grant,this restriction and the following disclaimer, 12 must be included in all copies of the Software,in whole or in part,and 13 all derivative works of the Software,unless such copies or derivative 14 works are solely in the form of machine-executable object code generated by 15 a source language processor. 16 17 THE SOFTWARE IS PROVIDED "AS IS",WITHOUT WARRANTY OF ANY KIND,EXPRESS OR 18 IMPLIED,INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 FITNESS FOR A PARTICULAR PURPOSE,TITLE AND NON-INFRINGEMENT. IN NO EVENT 20 SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 21 FOR ANY DAMAGES OR OTHER LIABILITY,WHETHER IN CONTRACT,TORT OR OTHERWISE, 22 ARISING FROM,OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 DEALINGS IN THE SOFTWARE. 24 */ 25 module derelict.mono.dynfunctions; 26 27 version(DerelictMono_Static) 28 public import derelict.mono.stafunctions; 29 else: 30 31 private 32 { 33 import core.stdc.config; 34 import core.stdc.stdint; 35 import core.stdc.stdio; 36 import derelict.util.system; 37 import derelict.mono.types; 38 } 39 40 extern (C) @nogc nothrow 41 { 42 // utils/mono-publib.h 43 alias da_mono_free = void function(void*); 44 alias da_mono_set_allocator_vtable = mono_bool function(MonoAllocatorVTable*); 45 // utils/mono-logger.h 46 alias da_mono_trace_set_level_string = void function(const(char)* value); 47 alias da_mono_trace_set_mask_string = void function(const(char)* value); 48 alias da_mono_trace_set_log_handler = void function(MonoLogCallback callback, void* user_data); 49 alias da_mono_trace_set_print_handler = void function(MonoPrintCallback callback); 50 alias da_mono_trace_set_printerr_handler = void function(MonoPrintCallback callback); 51 // utils/mono-error.h 52 alias da_mono_error_init = void function(MonoError*); 53 alias da_mono_error_init_flags = void function(MonoError*, ushort); 54 alias da_mono_error_cleanup = void function(MonoError*); 55 alias da_mono_error_ok = mono_bool function(MonoError*); 56 alias da_mono_error_get_error_code = ushort function(MonoError*); 57 alias da_mono_error_get_message = const(char)* function(MonoError*); 58 // utils/mono-dl-fallback.h 59 alias da_mono_dl_fallback_register = MonoDlFallbackHandler* function(MonoDlFallbackLoad load_func, 60 MonoDlFallbackSymbol symbol_func, MonoDlFallbackClose close_func, void* user_data); 61 alias da_mono_dl_fallback_unregister = void function(MonoDlFallbackHandler* handler); 62 // utils/mono-counters.h 63 alias da_mono_counters_enable = void function(int section_mask); 64 alias da_mono_counters_init = void function(); 65 alias da_mono_counters_register = void function(const(char)* descr, int type, void* addr); 66 alias da_mono_counters_register_with_size = void function(const(char)* name, 67 int type, void* addr, int size); 68 alias da_mono_counters_on_register = void function(MonoCounterRegisterCallback callback); 69 alias da_mono_counters_dump = void function(int section_mask, FILE* outfile); 70 alias da_mono_counters_cleanup = void function(); 71 alias da_mono_counters_foreach = void function(CountersEnumCallback cb, void* user_data); 72 alias da_mono_counters_sample = int function(MonoCounter* counter, void* buffer, int buffer_size); 73 alias da_mono_counter_get_name = const(char)* function(MonoCounter* name); 74 alias da_mono_counter_get_type = int function(MonoCounter* counter); 75 alias da_mono_counter_get_section = int function(MonoCounter* counter); 76 alias da_mono_counter_get_unit = int function(MonoCounter* counter); 77 alias da_mono_counter_get_variance = int function(MonoCounter* counter); 78 alias da_mono_counter_get_size = size_t function(MonoCounter* counter); 79 alias da_mono_runtime_resource_limit = int function(int resource_type, 80 uintptr_t soft_limit, uintptr_t hard_limit); 81 alias da_mono_runtime_resource_set_callback = void function(MonoResourceCallback callback); 82 alias da_mono_runtime_resource_check_limit = void function(int resource_type, uintptr_t value); 83 // metadata/appdomain.h 84 alias da_mono_init = MonoDomain* function(const(char)* filename); 85 alias da_mono_init_from_assembly = MonoDomain* function(const(char)* domain_name, 86 const(char)* filename); 87 alias da_mono_init_version = MonoDomain* function(const(char)* domain_name, 88 const(char)* version_); 89 alias da_mono_get_root_domain = MonoDomain* function(); 90 alias da_mono_runtime_init = void function(MonoDomain* domain, 91 MonoThreadStartCB start_cb, MonoThreadAttachCB attach_cb); 92 alias da_mono_runtime_cleanup = void function(MonoDomain* domain); 93 alias da_mono_install_runtime_cleanup = void function(MonoDomainFunc func); 94 alias da_mono_runtime_quit = void function(); 95 alias da_mono_runtime_set_shutting_down = void function(); 96 alias da_mono_runtime_is_shutting_down = mono_bool function(); 97 alias da_mono_check_corlib_version = const(char)* function(); 98 alias da_mono_domain_create = MonoDomain* function(); 99 alias da_mono_domain_create_appdomain = MonoDomain* function(char* friendly_name, 100 char* configuration_file); 101 alias da_mono_domain_set_config = void function(MonoDomain* domain, 102 const(char)* base_dir, const(char)* config_file_name); 103 alias da_mono_domain_get = MonoDomain* function(); 104 alias da_mono_domain_get_by_id = MonoDomain* function(int domainid); 105 alias da_mono_domain_get_id = int function(MonoDomain* domain); 106 alias da_mono_domain_get_friendly_name = const(char)* function(MonoDomain* domain); 107 alias da_mono_domain_set = mono_bool function(MonoDomain* domain, mono_bool force); 108 alias da_mono_domain_set_internal = void function(MonoDomain* domain); 109 alias da_mono_domain_unload = void function(MonoDomain* domain); 110 alias da_mono_domain_try_unload = void function(MonoDomain* domain, MonoObject** exc); 111 alias da_mono_domain_is_unloading = mono_bool function(MonoDomain* domain); 112 alias da_mono_domain_from_appdomain = MonoDomain* function(MonoAppDomain* appdomain); 113 alias da_mono_domain_foreach = void function(MonoDomainFunc func, void* user_data); 114 alias da_mono_domain_assembly_open = MonoAssembly* function(MonoDomain* domain, 115 const(char)* name); 116 alias da_mono_domain_finalize = mono_bool function(MonoDomain* domain, uint timeout); 117 alias da_mono_domain_free = void function(MonoDomain* domain, mono_bool force); 118 alias da_mono_domain_has_type_resolve = mono_bool function(MonoDomain* domain); 119 alias da_mono_domain_try_type_resolve = MonoReflectionAssembly* function( 120 MonoDomain* domain, char* name, MonoObject* tb); 121 alias da_mono_domain_owns_vtable_slot = mono_bool function(MonoDomain* domain, 122 void* vtable_slot); 123 alias da_mono_context_init = void function(MonoDomain* domain); 124 alias da_mono_context_set = void function(MonoAppContext* new_context); 125 alias da_mono_context_get = MonoAppContext* function(); 126 alias da_mono_context_get_id = int function(MonoAppContext* context); 127 alias da_mono_context_get_domain_id = int function(MonoAppContext* context); 128 alias da_mono_jit_info_table_find = MonoJitInfo* function(MonoDomain* domain, char* addr); 129 alias da_mono_jit_info_get_code_start = void* function(MonoJitInfo* ji); 130 alias da_mono_jit_info_get_code_size = int function(MonoJitInfo* ji); 131 alias da_mono_jit_info_get_method = MonoMethod* function(MonoJitInfo* ji); 132 alias da_mono_get_corlib = MonoImage* function(); 133 alias da_mono_get_object_class = MonoClass* function(); 134 alias da_mono_get_byte_class = MonoClass* function(); 135 alias da_mono_get_void_class = MonoClass* function(); 136 alias da_mono_get_boolean_class = MonoClass* function(); 137 alias da_mono_get_sbyte_class = MonoClass* function(); 138 alias da_mono_get_int16_class = MonoClass* function(); 139 alias da_mono_get_uint16_class = MonoClass* function(); 140 alias da_mono_get_int32_class = MonoClass* function(); 141 alias da_mono_get_uint32_class = MonoClass* function(); 142 alias da_mono_get_intptr_class = MonoClass* function(); 143 alias da_mono_get_uintptr_class = MonoClass* function(); 144 alias da_mono_get_int64_class = MonoClass* function(); 145 alias da_mono_get_uint64_class = MonoClass* function(); 146 alias da_mono_get_single_class = MonoClass* function(); 147 alias da_mono_get_double_class = MonoClass* function(); 148 alias da_mono_get_char_class = MonoClass* function(); 149 alias da_mono_get_string_class = MonoClass* function(); 150 alias da_mono_get_enum_class = MonoClass* function(); 151 alias da_mono_get_array_class = MonoClass* function(); 152 alias da_mono_get_thread_class = MonoClass* function(); 153 alias da_mono_get_exception_class = MonoClass* function(); 154 alias da_mono_security_enable_core_clr = void function(); 155 alias da_mono_security_set_core_clr_platform_callback = void function( 156 MonoCoreClrPlatformCB callback); 157 // metadata/assembly.h 158 alias da_mono_assemblies_init = void function(); 159 alias da_mono_assemblies_cleanup = void function(); 160 alias da_mono_assembly_open = MonoAssembly* function(const(char)* filename, 161 MonoImageOpenStatus* status); 162 alias da_mono_assembly_open_full = MonoAssembly* function(const(char)* filename, 163 MonoImageOpenStatus* status, mono_bool refonly); 164 alias da_mono_assembly_load = MonoAssembly* function(MonoAssemblyName* aname, 165 const(char)* basedir, MonoImageOpenStatus* status); 166 alias da_mono_assembly_load_full = MonoAssembly* function(MonoAssemblyName* aname, 167 const(char)* basedir, MonoImageOpenStatus* status, mono_bool refonly); 168 alias da_mono_assembly_load_from = MonoAssembly* function(MonoImage* image, 169 const(char)* fname, MonoImageOpenStatus* status); 170 alias da_mono_assembly_load_from_full = MonoAssembly* function(MonoImage* image, 171 const(char)* fname, MonoImageOpenStatus* status, mono_bool refonly); 172 alias da_mono_assembly_load_with_partial_name = MonoAssembly* function( 173 const(char)* name, MonoImageOpenStatus* status); 174 alias da_mono_assembly_loaded = MonoAssembly* function(MonoAssemblyName* aname); 175 alias da_mono_assembly_loaded_full = MonoAssembly* function(MonoAssemblyName* aname, 176 mono_bool refonly); 177 alias da_mono_assembly_get_assemblyref = void function(MonoImage* image, 178 int index, MonoAssemblyName* aname); 179 alias da_mono_assembly_load_reference = void function(MonoImage* image, int index); 180 alias da_mono_assembly_load_references = void function(MonoImage* image, 181 MonoImageOpenStatus* status); 182 alias da_mono_assembly_load_module = MonoImage* function(MonoAssembly* assembly, uint idx); 183 alias da_mono_assembly_close = void function(MonoAssembly* assembly); 184 alias da_mono_assembly_setrootdir = void function(const(char)* root_dir); 185 alias da_mono_assembly_getrootdir = const(char)* function(); 186 alias da_mono_native_getrootdir = char* function(); 187 alias da_mono_assembly_foreach = void function(MonoFunc func, void* user_data); 188 alias da_mono_assembly_set_main = void function(MonoAssembly* assembly); 189 alias da_mono_assembly_get_main = MonoAssembly* function(); 190 alias da_mono_assembly_get_image = MonoImage* function(MonoAssembly* assembly); 191 alias da_mono_assembly_get_name = MonoAssemblyName* function(MonoAssembly* assembly); 192 alias da_mono_assembly_fill_assembly_name = mono_bool function(MonoImage* image, 193 MonoAssemblyName* aname); 194 alias da_mono_assembly_names_equal = mono_bool function(MonoAssemblyName* l, 195 MonoAssemblyName* r); 196 alias da_mono_stringify_assembly_name = char* function(MonoAssemblyName* aname); 197 alias da_mono_install_assembly_load_hook = void function(MonoAssemblyLoadFunc func, 198 void* user_data); 199 alias da_mono_install_assembly_search_hook = void function( 200 MonoAssemblySearchFunc func, void* user_data); 201 alias da_mono_install_assembly_refonly_search_hook = void function( 202 MonoAssemblySearchFunc func, void* user_data); 203 alias da_mono_assembly_invoke_search_hook = MonoAssembly* function(MonoAssemblyName* aname); 204 alias da_mono_install_assembly_postload_search_hook = void function( 205 MonoAssemblySearchFunc func, void* user_data); 206 alias da_mono_install_assembly_postload_refonly_search_hook = void function( 207 MonoAssemblySearchFunc func, void* user_data); 208 alias da_mono_install_assembly_preload_hook = void function( 209 MonoAssemblyPreLoadFunc func, void* user_data); 210 alias da_mono_install_assembly_refonly_preload_hook = void function( 211 MonoAssemblyPreLoadFunc func, void* user_data); 212 alias da_mono_assembly_invoke_load_hook = void function(MonoAssembly* ass); 213 alias da_mono_assembly_name_new = MonoAssemblyName* function(const(char)* name); 214 alias da_mono_assembly_name_get_name = const(char)* function(MonoAssemblyName* aname); 215 alias da_mono_assembly_name_get_culture = const(char)* function(MonoAssemblyName* aname); 216 alias da_mono_assembly_name_get_version = ushort function(MonoAssemblyName* aname, 217 ushort* minor, ushort* build, ushort* revision); 218 alias da_mono_assembly_name_get_pubkeytoken = mono_byte* function(MonoAssemblyName* aname); 219 alias da_mono_assembly_name_free = void function(MonoAssemblyName* aname); 220 alias da_mono_register_bundled_assemblies = void function( 221 const(MonoBundledAssembly*)* assemblies); 222 alias da_mono_register_config_for_assembly = void function( 223 const(char)* assembly_name, const(char)* config_xml); 224 alias da_mono_register_symfile_for_assembly = void function( 225 const(char)* assembly_name, const(mono_byte)* raw_contents, int size); 226 alias da_mono_register_machine_config = void function(const(char)* config_xml); 227 alias da_mono_set_rootdir = void function(); 228 alias da_mono_set_dirs = void function(const(char)* assembly_dir, const(char)* config_dir); 229 alias da_mono_set_assemblies_path = void function(const(char)* path); 230 // metadata/attrdefs.h 231 // metadata/blob.h 232 // metadata/class.h 233 alias da_mono_class_get = MonoClass* function(MonoImage* image, uint type_token); 234 alias da_mono_class_get_full = MonoClass* function(MonoImage* image, 235 uint type_token, MonoGenericContext* context); 236 alias da_mono_class_init = mono_bool function(MonoClass* klass); 237 alias da_mono_class_vtable = MonoVTable* function(MonoDomain* domain, MonoClass* klass); 238 alias da_mono_class_from_name = MonoClass* function(MonoImage* image, 239 const(char)* name_space, const(char)* name); 240 alias da_mono_class_from_name_case = MonoClass* function(MonoImage* image, 241 const(char)* name_space, const(char)* name); 242 alias da_mono_class_get_method_from_name_flags = MonoMethod* function( 243 MonoClass* klass, const(char)* name, int param_count, int flags); 244 alias da_mono_class_from_typeref = MonoClass* function(MonoImage* image, uint type_token); 245 alias da_mono_class_from_typeref_checked = MonoClass* function(MonoImage* image, 246 uint type_token, MonoError* error); 247 alias da_mono_class_from_generic_parameter = MonoClass* function( 248 MonoGenericParam* param, MonoImage* image, mono_bool is_mvar); 249 alias da_mono_class_inflate_generic_type = MonoType* function(MonoType* type, 250 MonoGenericContext* context); 251 alias da_mono_class_inflate_generic_method = MonoMethod* function( 252 MonoMethod* method, MonoGenericContext* context); 253 alias da_mono_get_inflated_method = MonoMethod* function(MonoMethod* method); 254 alias da_mono_field_from_token = MonoClassField* function(MonoImage* image, 255 uint token, MonoClass** retklass, MonoGenericContext* context); 256 alias da_mono_bounded_array_class_get = MonoClass* function( 257 MonoClass* element_class, uint rank, mono_bool bounded); 258 alias da_mono_array_class_get = MonoClass* function(MonoClass* element_class, uint rank); 259 alias da_mono_ptr_class_get = MonoClass* function(MonoType* type); 260 alias da_mono_class_get_field = MonoClassField* function(MonoClass* klass, uint field_token); 261 alias da_mono_class_get_field_from_name = MonoClassField* function(MonoClass* klass, 262 const(char)* name); 263 alias da_mono_class_get_field_token = uint function(MonoClassField* field); 264 alias da_mono_class_get_event_token = uint function(MonoEvent* event); 265 alias da_mono_class_get_property_from_name = MonoProperty* function( 266 MonoClass* klass, const(char)* name); 267 alias da_mono_class_get_property_token = uint function(MonoProperty* prop); 268 alias da_mono_array_element_size = int function(MonoClass* ac); 269 alias da_mono_class_instance_size = int function(MonoClass* klass); 270 alias da_mono_class_array_element_size = int function(MonoClass* klass); 271 alias da_mono_class_data_size = int function(MonoClass* klass); 272 alias da_mono_class_value_size = int function(MonoClass* klass, uint* align_); 273 alias da_mono_class_min_align = int function(MonoClass* klass); 274 alias da_mono_class_from_mono_type = MonoClass* function(MonoType* type); 275 alias da_mono_class_is_subclass_of = mono_bool function(MonoClass* klass, 276 MonoClass* klassc, mono_bool check_interfaces); 277 alias da_mono_class_is_assignable_from = mono_bool function(MonoClass* klass, MonoClass* oklass); 278 alias da_mono_ldtoken = void* function(MonoImage* image, uint token, 279 MonoClass** retclass, MonoGenericContext* context); 280 alias da_mono_type_get_name = char* function(MonoType* type); 281 alias da_mono_type_get_underlying_type = MonoType* function(MonoType* type); 282 alias da_mono_class_get_image = MonoImage* function(MonoClass* klass); 283 alias da_mono_class_get_element_class = MonoClass* function(MonoClass* klass); 284 alias da_mono_class_is_valuetype = mono_bool function(MonoClass* klass); 285 alias da_mono_class_is_enum = mono_bool function(MonoClass* klass); 286 alias da_mono_class_enum_basetype = MonoType* function(MonoClass* klass); 287 alias da_mono_class_get_parent = MonoClass* function(MonoClass* klass); 288 alias da_mono_class_get_nesting_type = MonoClass* function(MonoClass* klass); 289 alias da_mono_class_get_rank = int function(MonoClass* klass); 290 alias da_mono_class_get_flags = uint function(MonoClass* klass); 291 alias da_mono_class_get_name = const(char)* function(MonoClass* klass); 292 alias da_mono_class_get_namespace = const(char)* function(MonoClass* klass); 293 alias da_mono_class_get_type = MonoType* function(MonoClass* klass); 294 alias da_mono_class_get_type_token = uint function(MonoClass* klass); 295 alias da_mono_class_get_byref_type = MonoType* function(MonoClass* klass); 296 alias da_mono_class_num_fields = int function(MonoClass* klass); 297 alias da_mono_class_num_methods = int function(MonoClass* klass); 298 alias da_mono_class_num_properties = int function(MonoClass* klass); 299 alias da_mono_class_num_events = int function(MonoClass* klass); 300 alias da_mono_class_get_fields = MonoClassField* function(MonoClass* klass, void** iter); 301 alias da_mono_class_get_methods = MonoMethod* function(MonoClass* klass, void** iter); 302 alias da_mono_class_get_properties = MonoProperty* function(MonoClass* klass, void** iter); 303 alias da_mono_class_get_events = MonoEvent* function(MonoClass* klass, void** iter); 304 alias da_mono_class_get_interfaces = MonoClass* function(MonoClass* klass, void** iter); 305 alias da_mono_class_get_nested_types = MonoClass* function(MonoClass* klass, void** iter); 306 alias da_mono_class_is_delegate = mono_bool function(MonoClass* klass); 307 alias da_mono_class_implements_interface = mono_bool function(MonoClass* klass, 308 MonoClass* iface); 309 alias da_mono_field_get_name = const(char)* function(MonoClassField* field); 310 alias da_mono_field_get_type = MonoType* function(MonoClassField* field); 311 alias da_mono_field_get_parent = MonoClass* function(MonoClassField* field); 312 alias da_mono_field_get_flags = uint function(MonoClassField* field); 313 alias da_mono_field_get_offset = uint function(MonoClassField* field); 314 alias da_mono_field_get_data = const(char)* function(MonoClassField* field); 315 alias da_mono_property_get_name = const(char)* function(MonoProperty* prop); 316 alias da_mono_property_get_set_method = MonoMethod* function(MonoProperty* prop); 317 alias da_mono_property_get_get_method = MonoMethod* function(MonoProperty* prop); 318 alias da_mono_property_get_parent = MonoClass* function(MonoProperty* prop); 319 alias da_mono_property_get_flags = uint function(MonoProperty* prop); 320 alias da_mono_event_get_name = const(char)* function(MonoEvent* event); 321 alias da_mono_event_get_add_method = MonoMethod* function(MonoEvent* event); 322 alias da_mono_event_get_remove_method = MonoMethod* function(MonoEvent* event); 323 alias da_mono_event_get_raise_method = MonoMethod* function(MonoEvent* event); 324 alias da_mono_event_get_parent = MonoClass* function(MonoEvent* event); 325 alias da_mono_event_get_flags = uint function(MonoEvent* event); 326 alias da_mono_class_get_method_from_name = MonoMethod* function(MonoClass* klass, 327 const(char)* name, int param_count); 328 alias da_mono_class_name_from_token = char* function(MonoImage* image, uint type_token); 329 alias da_mono_method_can_access_field = mono_bool function(MonoMethod* method, 330 MonoClassField* field); 331 alias da_mono_method_can_access_method = mono_bool function(MonoMethod* method, 332 MonoMethod* called); 333 // metadata/debug-helpers.h 334 alias da_mono_disasm_code_one = char* function(MonoDisHelper* dh, 335 MonoMethod* method, const(mono_byte)* ip, const(mono_byte*)* endp); 336 alias da_mono_disasm_code = char* function(MonoDisHelper* dh, 337 MonoMethod* method, const(mono_byte)* ip, const(mono_byte)* end); 338 alias da_mono_type_full_name = char* function(MonoType* type); 339 alias da_mono_signature_get_desc = char* function(MonoMethodSignature* sig, 340 mono_bool include_namespace); 341 alias da_mono_context_get_desc = char* function(MonoGenericContext* context); 342 alias da_mono_method_desc_new = MonoMethodDesc* function(const(char)* name, 343 mono_bool include_namespace); 344 alias da_mono_method_desc_from_method = MonoMethodDesc* function(MonoMethod* method); 345 alias da_mono_method_desc_free = void function(MonoMethodDesc* desc); 346 alias da_mono_method_desc_match = mono_bool function(MonoMethodDesc* desc, MonoMethod* method); 347 alias da_mono_method_desc_full_match = mono_bool function(MonoMethodDesc* desc, 348 MonoMethod* method); 349 alias da_mono_method_desc_search_in_class = MonoMethod* function( 350 MonoMethodDesc* desc, MonoClass* klass); 351 alias da_mono_method_desc_search_in_image = MonoMethod* function( 352 MonoMethodDesc* desc, MonoImage* image); 353 alias da_mono_method_full_name = char* function(MonoMethod* method, mono_bool signature); 354 alias da_mono_field_full_name = char* function(MonoClassField* field); 355 // metadata/debug-mono-symfile.h 356 alias da_mono_debug_open_mono_symbols = MonoSymbolFile* function(MonoDebugHandle* handle, 357 const(ubyte)* raw_contents, int size, mono_bool in_the_debugger); 358 alias da_mono_debug_close_mono_symbol_file = void function(MonoSymbolFile* symfile); 359 alias da_mono_debug_symfile_is_loaded = mono_bool function(MonoSymbolFile* symfile); 360 alias da_mono_debug_symfile_lookup_location = MonoDebugSourceLocation* function( 361 MonoDebugMethodInfo* minfo, uint offset); 362 alias da_mono_debug_symfile_free_location = void function(MonoDebugSourceLocation* location); 363 alias da_mono_debug_symfile_lookup_method = MonoDebugMethodInfo* function( 364 MonoDebugHandle* handle, MonoMethod* method); 365 alias da_mono_debug_symfile_lookup_locals = MonoDebugLocalsInfo* function( 366 MonoDebugMethodInfo* minfo); 367 alias da_mono_debug_image_has_debug_info = int function(MonoImage* image); 368 // metadata/environment.h 369 alias da_mono_environment_exitcode_get = int function(); 370 alias da_mono_environment_exitcode_set = void function(int value); 371 // metadata/exception.h 372 alias da_mono_exception_from_name = MonoException* function(MonoImage* image, 373 const(char)* name_space, const(char)* name); 374 alias da_mono_exception_from_token = MonoException* function(MonoImage* image, uint token); 375 alias da_mono_exception_from_name_two_strings = MonoException* function(MonoImage* image, 376 const(char)* name_space, const(char)* name, MonoString* a1, MonoString* a2); 377 alias da_mono_exception_from_name_msg = MonoException* function(MonoImage* image, 378 const(char)* name_space, const(char)* name, const(char)* msg); 379 alias da_mono_exception_from_token_two_strings = MonoException* function( 380 MonoImage* image, uint token, MonoString* a1, MonoString* a2); 381 alias da_mono_exception_from_name_domain = MonoException* function(MonoDomain* domain, 382 MonoImage* image, const(char)* name_space, const(char)* name); 383 alias da_mono_get_exception_divide_by_zero = MonoException* function(); 384 alias da_mono_get_exception_security = MonoException* function(); 385 alias da_mono_get_exception_arithmetic = MonoException* function(); 386 alias da_mono_get_exception_overflow = MonoException* function(); 387 alias da_mono_get_exception_null_reference = MonoException* function(); 388 alias da_mono_get_exception_execution_engine = MonoException* function(const(char)* msg); 389 alias da_mono_get_exception_thread_abort = MonoException* function(); 390 alias da_mono_get_exception_thread_state = MonoException* function(const(char)* msg); 391 alias da_mono_get_exception_thread_interrupted = MonoException* function(); 392 alias da_mono_get_exception_serialization = MonoException* function(const(char)* msg); 393 alias da_mono_get_exception_invalid_cast = MonoException* function(); 394 alias da_mono_get_exception_invalid_operation = MonoException* function(const(char)* msg); 395 alias da_mono_get_exception_index_out_of_range = MonoException* function(); 396 alias da_mono_get_exception_array_type_mismatch = MonoException* function(); 397 alias da_mono_get_exception_type_load = MonoException* function( 398 MonoString* class_name, char* assembly_name); 399 alias da_mono_get_exception_missing_method = MonoException* function( 400 const(char)* class_name, const(char)* member_name); 401 alias da_mono_get_exception_missing_field = MonoException* function( 402 const(char)* class_name, const(char)* member_name); 403 alias da_mono_get_exception_not_implemented = MonoException* function(const(char)* msg); 404 alias da_mono_get_exception_not_supported = MonoException* function(const(char)* msg); 405 alias da_mono_get_exception_argument_null = MonoException* function(const(char)* arg); 406 alias da_mono_get_exception_argument = MonoException* function(const(char)* arg, 407 const(char)* msg); 408 alias da_mono_get_exception_argument_out_of_range = MonoException* function(const(char)* arg); 409 alias da_mono_get_exception_io = MonoException* function(const(char)* msg); 410 alias da_mono_get_exception_file_not_found = MonoException* function(MonoString* fname); 411 alias da_mono_get_exception_file_not_found2 = MonoException* function( 412 const(char)* msg, MonoString* fname); 413 alias da_mono_get_exception_type_initialization = MonoException* function( 414 const(char)* type_name, MonoException* inner); 415 alias da_mono_get_exception_synchronization_lock = MonoException* function(const(char)* msg); 416 alias da_mono_get_exception_cannot_unload_appdomain = MonoException* function(const(char)* msg); 417 alias da_mono_get_exception_appdomain_unloaded = MonoException* function(); 418 alias da_mono_get_exception_bad_image_format = MonoException* function(const(char)* msg); 419 alias da_mono_get_exception_bad_image_format2 = MonoException* function( 420 const(char)* msg, MonoString* fname); 421 alias da_mono_get_exception_stack_overflow = MonoException* function(); 422 alias da_mono_get_exception_out_of_memory = MonoException* function(); 423 alias da_mono_get_exception_field_access = MonoException* function(); 424 alias da_mono_get_exception_method_access = MonoException* function(); 425 alias da_mono_get_exception_reflection_type_load = MonoException* function( 426 MonoArray* types, MonoArray* exceptions); 427 alias da_mono_get_exception_runtime_wrapped = MonoException* function( 428 MonoObject* wrapped_exception); 429 alias da_mono_install_unhandled_exception_hook = void function( 430 MonoUnhandledExceptionFunc func, void* user_data); 431 alias da_mono_invoke_unhandled_exception_hook = void function(MonoObject* exc); 432 // metadata/image.h 433 alias da_mono_images_init = void function(); 434 alias da_mono_images_cleanup = void function(); 435 alias da_mono_image_open = MonoImage* function(const(char)* fname, MonoImageOpenStatus* status); 436 alias da_mono_image_open_full = MonoImage* function(const(char)* fname, 437 MonoImageOpenStatus* status, mono_bool refonly); 438 alias da_mono_pe_file_open = MonoImage* function(const(char)* fname, 439 MonoImageOpenStatus* status); 440 alias da_mono_image_open_from_data = MonoImage* function(char* data, 441 uint data_len, mono_bool need_copy, MonoImageOpenStatus* status); 442 alias da_mono_image_open_from_data_full = MonoImage* function(char* data, 443 uint data_len, mono_bool need_copy, MonoImageOpenStatus* status, mono_bool refonly); 444 alias da_mono_image_open_from_data_with_name = MonoImage* function(char* data, uint data_len, 445 mono_bool need_copy, MonoImageOpenStatus* status, mono_bool refonly, const(char)* name); 446 alias da_mono_image_fixup_vtable = void function(MonoImage* image); 447 alias da_mono_image_loaded = MonoImage* function(const(char)* name); 448 alias da_mono_image_loaded_full = MonoImage* function(const(char)* name, mono_bool refonly); 449 alias da_mono_image_loaded_by_guid = MonoImage* function(const(char)* guid); 450 alias da_mono_image_loaded_by_guid_full = MonoImage* function(const(char)* guid, 451 mono_bool refonly); 452 alias da_mono_image_init = void function(MonoImage* image); 453 alias da_mono_image_close = void function(MonoImage* image); 454 alias da_mono_image_addref = void function(MonoImage* image); 455 alias da_mono_image_strerror = const(char)* function(MonoImageOpenStatus status); 456 alias da_mono_image_ensure_section = int function(MonoImage* image, const(char)* section); 457 alias da_mono_image_ensure_section_idx = int function(MonoImage* image, int section); 458 alias da_mono_image_get_entry_point = uint function(MonoImage* image); 459 alias da_mono_image_get_resource = const(char)* function(MonoImage* image, 460 uint offset, uint* size); 461 alias da_mono_image_load_file_for_image = MonoImage* function(MonoImage* image, int fileidx); 462 alias da_mono_image_load_module = MonoImage* function(MonoImage* image, int idx); 463 alias da_mono_image_get_name = const(char)* function(MonoImage* image); 464 alias da_mono_image_get_filename = const(char)* function(MonoImage* image); 465 alias da_mono_image_get_guid = const(char)* function(MonoImage* image); 466 alias da_mono_image_get_assembly = MonoAssembly* function(MonoImage* image); 467 alias da_mono_image_is_dynamic = mono_bool function(MonoImage* image); 468 alias da_mono_image_rva_map = char* function(MonoImage* image, uint rva); 469 alias da_mono_image_get_table_info = const(MonoTableInfo)* function( 470 MonoImage* image, int table_id); 471 alias da_mono_image_get_table_rows = int function(MonoImage* image, int table_id); 472 alias da_mono_table_info_get_rows = int function(const(MonoTableInfo)* table); 473 alias da_mono_image_lookup_resource = void* function(MonoImage* image, 474 uint res_id, uint lang_id, mono_unichar2* name); 475 alias da_mono_image_get_public_key = const(char)* function(MonoImage* image, uint* size); 476 alias da_mono_image_get_strong_name = const(char)* function(MonoImage* image, uint* size); 477 alias da_mono_image_strong_name_position = uint function(MonoImage* image, uint* size); 478 alias da_mono_image_add_to_name_cache = void function(MonoImage* image, 479 const(char)* nspace, const(char)* name, uint idx); 480 alias da_mono_image_has_authenticode_entry = mono_bool function(MonoImage* image); 481 // metadata/loader.h 482 alias da_mono_get_method = MonoMethod* function(MonoImage* image, uint token, MonoClass* klass); 483 alias da_mono_get_method_full = MonoMethod* function(MonoImage* image, 484 uint token, MonoClass* klass, MonoGenericContext* context); 485 alias da_mono_get_method_constrained = MonoMethod* function(MonoImage* image, uint token, 486 MonoClass* constrained_class, MonoGenericContext* context, MonoMethod** cil_method); 487 alias da_mono_free_method = void function(MonoMethod* method); 488 alias da_mono_method_get_signature_full = MonoMethodSignature* function( 489 MonoMethod* method, MonoImage* image, uint token, MonoGenericContext* context); 490 alias da_mono_method_get_signature = MonoMethodSignature* function( 491 MonoMethod* method, MonoImage* image, uint token); 492 alias da_mono_method_signature = MonoMethodSignature* function(MonoMethod* method); 493 alias da_mono_method_get_header = MonoMethodHeader* function(MonoMethod* method); 494 alias da_mono_method_get_name = const(char)* function(MonoMethod* method); 495 alias da_mono_method_get_class = MonoClass* function(MonoMethod* method); 496 alias da_mono_method_get_token = uint function(MonoMethod* method); 497 alias da_mono_method_get_flags = uint function(MonoMethod* method, uint* iflags); 498 alias da_mono_method_get_index = uint function(MonoMethod* method); 499 alias da_mono_load_image = MonoImage* function(const(char)* fname, MonoImageOpenStatus* status); 500 alias da_mono_add_internal_call = void function(const(char)* name, const(void)* method); 501 alias da_mono_lookup_internal_call = void* function(MonoMethod* method); 502 alias da_mono_lookup_internal_call_full = void* function(MonoMethod* method, 503 mono_bool* uses_handles); 504 alias da_mono_lookup_icall_symbol = const(char)* function(MonoMethod* m); 505 alias da_mono_dllmap_insert = void function(MonoImage* assembly, 506 const(char)* dll, const(char)* func, const(char)* tdll, const(char)* tfunc); 507 alias da_mono_lookup_pinvoke_call = void* function(MonoMethod* method, 508 const(char*)* exc_class, const(char*)* exc_arg); 509 alias da_mono_method_get_param_names = void function(MonoMethod* method, const(char*)* names); 510 alias da_mono_method_get_param_token = uint function(MonoMethod* method, int idx); 511 alias da_mono_method_get_marshal_info = void function(MonoMethod* method, 512 MonoMarshalSpec** mspecs); 513 alias da_mono_method_has_marshal_info = mono_bool function(MonoMethod* method); 514 alias da_mono_method_get_last_managed = MonoMethod* function(); 515 alias da_mono_stack_walk = void function(MonoStackWalk func, void* user_data); 516 alias da_mono_stack_walk_no_il = void function(MonoStackWalk func, void* user_data); 517 alias da_mono_stack_walk_async_safe = void function(MonoStackWalkAsyncSafe func, 518 void* initial_sig_context, void* user_data); 519 alias da_mono_method_get_header_checked = MonoMethodHeader* function( 520 MonoMethod* method, MonoError* error); 521 // metadata/metadata.h 522 alias da_mono_metadata_init = void function(); 523 alias da_mono_metadata_decode_row = void function(const(MonoTableInfo)* t, 524 int idx, uint* res, int res_size); 525 alias da_mono_metadata_decode_row_col = uint function(const(MonoTableInfo)* t, int idx, uint col); 526 alias da_mono_metadata_compute_size = int function(MonoImage* meta, 527 int tableindex, uint* result_bitfield); 528 alias da_mono_metadata_locate = const(char)* function(MonoImage* meta, int table, int idx); 529 alias da_mono_metadata_locate_token = const(char)* function(MonoImage* meta, uint token); 530 alias da_mono_metadata_string_heap = const(char)* function(MonoImage* meta, uint table_index); 531 alias da_mono_metadata_blob_heap = const(char)* function(MonoImage* meta, uint table_index); 532 alias da_mono_metadata_user_string = const(char)* function(MonoImage* meta, uint table_index); 533 alias da_mono_metadata_guid_heap = const(char)* function(MonoImage* meta, uint table_index); 534 alias da_mono_metadata_typedef_from_field = uint function(MonoImage* meta, uint table_index); 535 alias da_mono_metadata_typedef_from_method = uint function(MonoImage* meta, uint table_index); 536 alias da_mono_metadata_nested_in_typedef = uint function(MonoImage* meta, uint table_index); 537 alias da_mono_metadata_nesting_typedef = uint function(MonoImage* meta, 538 uint table_index, uint start_index); 539 alias da_mono_metadata_interfaces_from_typedef = MonoClass** function( 540 MonoImage* meta, uint table_index, uint* count); 541 alias da_mono_metadata_events_from_typedef = uint function(MonoImage* meta, 542 uint table_index, uint* end_idx); 543 alias da_mono_metadata_methods_from_event = uint function(MonoImage* meta, 544 uint table_index, uint* end); 545 alias da_mono_metadata_properties_from_typedef = uint function(MonoImage* meta, 546 uint table_index, uint* end); 547 alias da_mono_metadata_methods_from_property = uint function(MonoImage* meta, 548 uint table_index, uint* end); 549 alias da_mono_metadata_packing_from_typedef = uint function(MonoImage* meta, 550 uint table_index, uint* packing, uint* size); 551 alias da_mono_metadata_get_marshal_info = const(char)* function(MonoImage* meta, 552 uint idx, mono_bool is_field); 553 alias da_mono_metadata_custom_attrs_from_index = uint function(MonoImage* meta, uint cattr_index); 554 alias da_mono_metadata_parse_marshal_spec = MonoMarshalSpec* function( 555 MonoImage* image, const(char)* ptr); 556 alias da_mono_metadata_free_marshal_spec = void function(MonoMarshalSpec* spec); 557 alias da_mono_metadata_implmap_from_method = uint function(MonoImage* meta, uint method_idx); 558 alias da_mono_metadata_field_info = void function(MonoImage* meta, 559 uint table_index, uint* offset, uint* rva, MonoMarshalSpec** marshal_spec); 560 alias da_mono_metadata_get_constant_index = uint function(MonoImage* meta, uint token, uint hint); 561 alias da_mono_metadata_decode_value = uint function(const(char)* ptr, const(char*)* rptr); 562 alias da_mono_metadata_decode_signed_value = int function(const(char)* ptr, const(char*)* rptr); 563 alias da_mono_metadata_decode_blob_size = uint function(const(char)* ptr, const(char*)* rptr); 564 alias da_mono_metadata_encode_value = void function(uint value, char* bug, char** endbuf); 565 alias da_mono_type_is_byref = mono_bool function(MonoType* type); 566 alias da_mono_type_get_type = int function(MonoType* type); 567 alias da_mono_type_get_signature = MonoMethodSignature* function(MonoType* type); 568 alias da_mono_type_get_class = MonoClass* function(MonoType* type); 569 alias da_mono_type_get_array_type = MonoArrayType* function(MonoType* type); 570 alias da_mono_type_get_ptr_type = MonoType* function(MonoType* type); 571 alias da_mono_type_get_modifiers = MonoClass* function(MonoType* type, 572 mono_bool* is_required, void** iter); 573 alias da_mono_type_is_struct = mono_bool function(MonoType* type); 574 alias da_mono_type_is_void = mono_bool function(MonoType* type); 575 alias da_mono_type_is_pointer = mono_bool function(MonoType* type); 576 alias da_mono_type_is_reference = mono_bool function(MonoType* type); 577 alias da_mono_type_is_generic_parameter = mono_bool function(MonoType* type); 578 alias da_mono_signature_get_return_type = MonoType* function(MonoMethodSignature* sig); 579 alias da_mono_signature_get_params = MonoType* function(MonoMethodSignature* sig, void** iter); 580 alias da_mono_signature_get_param_count = uint function(MonoMethodSignature* sig); 581 alias da_mono_signature_get_call_conv = uint function(MonoMethodSignature* sig); 582 alias da_mono_signature_vararg_start = int function(MonoMethodSignature* sig); 583 alias da_mono_signature_is_instance = mono_bool function(MonoMethodSignature* sig); 584 alias da_mono_signature_explicit_this = mono_bool function(MonoMethodSignature* sig); 585 alias da_mono_signature_param_is_out = mono_bool function(MonoMethodSignature* sig, 586 int param_num); 587 alias da_mono_metadata_parse_typedef_or_ref = uint function(MonoImage* m, 588 const(char)* ptr, const(char*)* rptr); 589 alias da_mono_metadata_parse_custom_mod = int function(MonoImage* m, 590 MonoCustomMod* dest, const(char)* ptr, const(char*)* rptr); 591 alias da_mono_metadata_parse_array = MonoArrayType* function(MonoImage* m, 592 const(char)* ptr, const(char*)* rptr); 593 alias da_mono_metadata_free_array = void function(MonoArrayType* array); 594 alias da_mono_metadata_parse_type = MonoType* function(MonoImage* m, 595 MonoParseTypeMode mode, short opt_attrs, const(char)* ptr, const(char*)* rptr); 596 alias da_mono_metadata_parse_param = MonoType* function(MonoImage* m, 597 const(char)* ptr, const(char*)* rptr); 598 alias da_mono_metadata_parse_ret_type = MonoType* function(MonoImage* m, 599 const(char)* ptr, const(char*)* rptr); 600 alias da_mono_metadata_parse_field_type = MonoType* function(MonoImage* m, 601 short field_flags, const(char)* ptr, const(char*)* rptr); 602 alias da_mono_type_create_from_typespec = MonoType* function(MonoImage* image, uint type_spec); 603 alias da_mono_metadata_free_type = void function(MonoType* type); 604 alias da_mono_type_size = int function(MonoType* type, int* alignment); 605 alias da_mono_type_stack_size = int function(MonoType* type, int* alignment); 606 alias da_mono_type_generic_inst_is_valuetype = mono_bool function(MonoType* type); 607 alias da_mono_metadata_generic_class_is_valuetype = mono_bool function(MonoGenericClass* gclass); 608 alias da_mono_metadata_generic_class_hash = uint function(MonoGenericClass* gclass); 609 alias da_mono_metadata_generic_class_equal = mono_bool function( 610 MonoGenericClass* g1, MonoGenericClass* g2); 611 alias da_mono_metadata_type_hash = uint function(MonoType* t1); 612 alias da_mono_metadata_type_equal = mono_bool function(MonoType* t1, MonoType* t2); 613 alias da_mono_metadata_signature_alloc = MonoMethodSignature* function( 614 MonoImage* image, uint nparams); 615 alias da_mono_metadata_signature_dup = MonoMethodSignature* function(MonoMethodSignature* sig); 616 alias da_mono_metadata_parse_signature = MonoMethodSignature* function( 617 MonoImage* image, uint token); 618 alias da_mono_metadata_parse_method_signature = MonoMethodSignature* function( 619 MonoImage* m, int def, const(char)* ptr, const(char*)* rptr); 620 alias da_mono_metadata_free_method_signature = void function(MonoMethodSignature* method); 621 alias da_mono_metadata_signature_equal = mono_bool function( 622 MonoMethodSignature* sig1, MonoMethodSignature* sig2); 623 alias da_mono_signature_hash = uint function(MonoMethodSignature* sig); 624 alias da_mono_metadata_parse_mh = MonoMethodHeader* function(MonoImage* m, const(char)* ptr); 625 alias da_mono_metadata_free_mh = void function(MonoMethodHeader* mh); 626 alias da_mono_method_header_get_code = const(ubyte)* function( 627 MonoMethodHeader* header, uint* code_size, uint* max_stack); 628 alias da_mono_method_header_get_locals = MonoType** function( 629 MonoMethodHeader* header, uint* num_locals, mono_bool* init_locals); 630 alias da_mono_method_header_get_num_clauses = int function(MonoMethodHeader* header); 631 alias da_mono_method_header_get_clauses = int function(MonoMethodHeader* header, 632 MonoMethod* method, void** iter, MonoExceptionClause* clause); 633 alias da_mono_type_to_unmanaged = uint function(MonoType* type, 634 MonoMarshalSpec* mspec, mono_bool as_field, mono_bool unicode, MonoMarshalConv* conv); 635 alias da_mono_metadata_token_from_dor = uint function(uint dor_index); 636 alias da_mono_guid_to_string = char* function(const(ubyte)* guid); 637 alias da_mono_guid_to_string_minimal = char* function(const(ubyte)* guid); 638 alias da_mono_metadata_declsec_from_index = uint function(MonoImage* meta, uint idx); 639 alias da_mono_metadata_translate_token_index = uint function(MonoImage* image, 640 int table, uint idx); 641 alias da_mono_metadata_decode_table_row = void function(MonoImage* image, 642 int table, int idx, uint* res, int res_size); 643 alias da_mono_metadata_decode_table_row_col = uint function(MonoImage* image, 644 int table, int idx, uint col); 645 // metadata/mono-config.h 646 alias da_mono_config_get_os = const(char)* function(); 647 alias da_mono_config_get_cpu = const(char)* function(); 648 alias da_mono_config_get_wordsize = const(char)* function(); 649 alias da_mono_get_config_dir = const(char)* function(); 650 alias da_mono_set_config_dir = void function(const(char)* dir); 651 alias da_mono_get_machine_config = const(char)* function(); 652 alias da_mono_config_cleanup = void function(); 653 alias da_mono_config_parse = void function(const(char)* filename); 654 alias da_mono_config_for_assembly = void function(MonoImage* assembly); 655 alias da_mono_config_parse_memory = void function(const(char)* buffer); 656 alias da_mono_config_string_for_assembly_file = const(char)* function(const(char)* filename); 657 alias da_mono_config_set_server_mode = void function(mono_bool server_mode); 658 alias da_mono_config_is_server_mode = mono_bool function(); 659 // metadata/mono-debug.h 660 alias da_mono_debug_init = void function(MonoDebugFormat format); 661 alias da_mono_debug_open_image_from_memory = void function(MonoImage* image, 662 const(mono_byte)* raw_contents, int size); 663 alias da_mono_debug_cleanup = void function(); 664 alias da_mono_debug_close_image = void function(MonoImage* image); 665 alias da_mono_debug_domain_unload = void function(MonoDomain* domain); 666 alias da_mono_debug_domain_create = void function(MonoDomain* domain); 667 alias da_mono_debug_add_method = MonoDebugMethodAddress* function( 668 MonoMethod* method, MonoDebugMethodJitInfo* jit, MonoDomain* domain); 669 alias da_mono_debug_remove_method = void function(MonoMethod* method, MonoDomain* domain); 670 alias da_mono_debug_lookup_method = MonoDebugMethodInfo* function(MonoMethod* method); 671 alias da_mono_debug_lookup_method_addresses = MonoDebugMethodAddressList* function( 672 MonoMethod* method); 673 alias da_mono_debug_find_method = MonoDebugMethodJitInfo* function( 674 MonoMethod* method, MonoDomain* domain); 675 alias da_mono_debug_free_method_jit_info = void function(MonoDebugMethodJitInfo* jit); 676 alias da_mono_debug_add_delegate_trampoline = void function(void* code, int size); 677 alias da_mono_debug_lookup_locals = MonoDebugLocalsInfo* function(MonoMethod* method); 678 alias da_mono_debug_lookup_method_async_debug_info = MonoDebugMethodAsyncInfo* function( 679 MonoMethod* method); 680 alias da_mono_debug_method_lookup_location = MonoDebugSourceLocation* function( 681 MonoDebugMethodInfo* minfo, int il_offset); 682 alias da_mono_debug_lookup_source_location = MonoDebugSourceLocation* function( 683 MonoMethod* method, uint address, MonoDomain* domain); 684 alias da_mono_debug_il_offset_from_address = int function(MonoMethod* method, 685 MonoDomain* domain, uint native_offset); 686 alias da_mono_debug_free_source_location = void function(MonoDebugSourceLocation* location); 687 alias da_mono_debug_print_stack_frame = char* function(MonoMethod* method, 688 uint native_offset, MonoDomain* domain); 689 alias da_mono_debugger_method_has_breakpoint = int function(MonoMethod* method); 690 alias da_mono_debugger_insert_breakpoint = int function(const(char)* method_name, 691 mono_bool include_namespace); 692 alias da_mono_set_is_debugger_attached = void function(mono_bool attached); 693 alias da_mono_is_debugger_attached = mono_bool function(); 694 // metadata/mono-gc.h 695 alias da_mono_gc_collect = void function(int generation); 696 alias da_mono_gc_max_generation = int function(); 697 alias da_mono_gc_get_generation = int function(MonoObject* object); 698 alias da_mono_gc_collection_count = int function(int generation); 699 alias da_mono_gc_get_used_size = long function(); 700 alias da_mono_gc_get_heap_size = long function(); 701 alias da_mono_gc_pending_finalizers = MonoBoolean function(); 702 alias da_mono_gc_finalize_notify = void function(); 703 alias da_mono_gc_invoke_finalizers = int function(); 704 alias da_mono_gc_walk_heap = int function(int flags, MonoGCReferences callback, void* data); 705 // metadata/object.h 706 alias da_mono_string_chars = mono_unichar2* function(MonoString* s); 707 alias da_mono_string_length = int function(MonoString* s); 708 alias da_mono_object_new = MonoObject* function(MonoDomain* domain, MonoClass* klass); 709 alias da_mono_object_new_specific = MonoObject* function(MonoVTable* vtable); 710 alias da_mono_object_new_fast = MonoObject* function(MonoVTable* vtable); 711 alias da_mono_object_new_alloc_specific = MonoObject* function(MonoVTable* vtable); 712 alias da_mono_object_new_from_token = MonoObject* function(MonoDomain* domain, 713 MonoImage* image, uint token); 714 alias da_mono_array_new = MonoArray* function(MonoDomain* domain, MonoClass* eclass, uintptr_t n); 715 alias da_mono_array_new_full = MonoArray* function(MonoDomain* domain, 716 MonoClass* array_class, uintptr_t* lengths, intptr_t* lower_bounds); 717 alias da_mono_array_new_specific = MonoArray* function(MonoVTable* vtable, uintptr_t n); 718 alias da_mono_array_clone = MonoArray* function(MonoArray* array); 719 alias da_mono_array_addr_with_size = char* function(MonoArray* array, int size, uintptr_t idx); 720 alias da_mono_array_length = uintptr_t function(MonoArray* array); 721 alias da_mono_string_empty = MonoString* function(MonoDomain* domain); 722 alias da_mono_string_empty_wrapper = MonoString* function(); 723 alias da_mono_string_new_utf16 = MonoString* function(MonoDomain* domain, 724 const(mono_unichar2)* text, int len); 725 alias da_mono_string_new_size = MonoString* function(MonoDomain* domain, int len); 726 alias da_mono_ldstr = MonoString* function(MonoDomain* domain, MonoImage* image, uint str_index); 727 alias da_mono_string_is_interned = MonoString* function(MonoString* str); 728 alias da_mono_string_intern = MonoString* function(MonoString* str); 729 alias da_mono_string_new = MonoString* function(MonoDomain* domain, const(char)* text); 730 alias da_mono_string_new_wrapper = MonoString* function(const(char)* text); 731 alias da_mono_string_new_len = MonoString* function(MonoDomain* domain, 732 const(char)* text, uint length); 733 alias da_mono_string_new_utf32 = MonoString* function(MonoDomain* domain, 734 const(mono_unichar4)* text, int len); 735 alias da_mono_string_to_utf8 = char* function(MonoString* string_obj); 736 alias da_mono_string_to_utf8_checked = char* function(MonoString* string_obj, MonoError* error); 737 alias da_mono_string_to_utf16 = mono_unichar2* function(MonoString* string_obj); 738 alias da_mono_string_to_utf32 = mono_unichar4* function(MonoString* string_obj); 739 alias da_mono_string_from_utf16 = MonoString* function(mono_unichar2* data); 740 alias da_mono_string_from_utf32 = MonoString* function(mono_unichar4* data); 741 alias da_mono_string_equal = mono_bool function(MonoString* s1, MonoString* s2); 742 alias da_mono_string_hash = uint function(MonoString* s); 743 alias da_mono_object_hash = int function(MonoObject* obj); 744 alias da_mono_object_to_string = MonoString* function(MonoObject* obj, MonoObject** exc); 745 alias da_mono_value_box = MonoObject* function(MonoDomain* domain, MonoClass* klass, void* val); 746 alias da_mono_value_copy = void function(void* dest, void* src, MonoClass* klass); 747 alias da_mono_value_copy_array = void function(MonoArray* dest, 748 int dest_idx, void* src, int count); 749 alias da_mono_object_get_domain = MonoDomain* function(MonoObject* obj); 750 alias da_mono_object_get_class = MonoClass* function(MonoObject* obj); 751 alias da_mono_object_unbox = void* function(MonoObject* obj); 752 alias da_mono_object_clone = MonoObject* function(MonoObject* obj); 753 alias da_mono_object_isinst = MonoObject* function(MonoObject* obj, MonoClass* klass); 754 alias da_mono_object_isinst_mbyref = MonoObject* function(MonoObject* obj, MonoClass* klass); 755 alias da_mono_object_castclass_mbyref = MonoObject* function(MonoObject* obj, MonoClass* klass); 756 alias da_mono_monitor_try_enter = mono_bool function(MonoObject* obj, uint ms); 757 alias da_mono_monitor_enter = mono_bool function(MonoObject* obj); 758 alias da_mono_monitor_enter_v4 = void function(MonoObject* obj, char* lock_taken); 759 alias da_mono_object_get_size = uint function(MonoObject* o); 760 alias da_mono_monitor_exit = void function(MonoObject* obj); 761 alias da_mono_raise_exception = void function(MonoException* ex); 762 alias da_mono_runtime_object_init = void function(MonoObject* this_obj); 763 alias da_mono_runtime_class_init = void function(MonoVTable* vtable); 764 alias da_mono_object_get_virtual_method = MonoMethod* function(MonoObject* obj, 765 MonoMethod* method); 766 alias da_mono_runtime_invoke = MonoObject* function(MonoMethod* method, 767 void* obj, void** params, MonoObject** exc); 768 alias da_mono_get_delegate_invoke = MonoMethod* function(MonoClass* klass); 769 alias da_mono_get_delegate_begin_invoke = MonoMethod* function(MonoClass* klass); 770 alias da_mono_get_delegate_end_invoke = MonoMethod* function(MonoClass* klass); 771 alias da_mono_runtime_delegate_invoke = MonoObject* function(MonoObject* delegate_, 772 void** params, MonoObject** exc); 773 alias da_mono_runtime_invoke_array = MonoObject* function(MonoMethod* method, 774 void* obj, MonoArray* params, MonoObject** exc); 775 alias da_mono_method_get_unmanaged_thunk = void* function(MonoMethod* method); 776 alias da_mono_runtime_get_main_args = MonoArray* function(); 777 alias da_mono_runtime_exec_managed_code = void function(MonoDomain* domain, 778 MonoMainThreadFunc main_func, void* main_args); 779 alias da_mono_runtime_run_main = int function(MonoMethod* method, int argc, 780 char** argv, MonoObject** exc); 781 alias da_mono_runtime_exec_main = int function(MonoMethod* method, 782 MonoArray* args, MonoObject** exc); 783 alias da_mono_runtime_set_main_args = int function(int argc, char** argv); 784 alias da_mono_load_remote_field = void* function(MonoObject* this_obj, 785 MonoClass* klass, MonoClassField* field, void** res); 786 alias da_mono_load_remote_field_new = MonoObject* function(MonoObject* this_obj, 787 MonoClass* klass, MonoClassField* field); 788 alias da_mono_store_remote_field = void function(MonoObject* this_obj, 789 MonoClass* klass, MonoClassField* field, void* val); 790 alias da_mono_store_remote_field_new = void function(MonoObject* this_obj, 791 MonoClass* klass, MonoClassField* field, MonoObject* arg); 792 alias da_mono_unhandled_exception = void function(MonoObject* exc); 793 alias da_mono_print_unhandled_exception = void function(MonoObject* exc); 794 alias da_mono_compile_method = void* function(MonoMethod* method); 795 alias da_mono_field_set_value = void function(MonoObject* obj, 796 MonoClassField* field, void* value); 797 alias da_mono_field_static_set_value = void function(MonoVTable* vt, 798 MonoClassField* field, void* value); 799 alias da_mono_field_get_value = void function(MonoObject* obj, 800 MonoClassField* field, void* value); 801 alias da_mono_field_static_get_value = void function(MonoVTable* vt, 802 MonoClassField* field, void* value); 803 alias da_mono_field_get_value_object = MonoObject* function(MonoDomain* domain, 804 MonoClassField* field, MonoObject* obj); 805 alias da_mono_property_set_value = void function(MonoProperty* prop, 806 void* obj, void** params, MonoObject** exc); 807 alias da_mono_property_get_value = MonoObject* function(MonoProperty* prop, 808 void* obj, void** params, MonoObject** exc); 809 alias da_mono_gchandle_new = uint function(MonoObject* obj, mono_bool pinned); 810 alias da_mono_gchandle_new_weakref = uint function(MonoObject* obj, mono_bool track_resurrection); 811 alias da_mono_gchandle_get_target = MonoObject* function(uint gchandle); 812 alias da_mono_gchandle_free = void function(uint gchandle); 813 alias da_mono_gc_reference_queue_new = MonoReferenceQueue* function( 814 mono_reference_queue_callback callback); 815 alias da_mono_gc_reference_queue_free = void function(MonoReferenceQueue* queue); 816 alias da_mono_gc_reference_queue_add = mono_bool function(MonoReferenceQueue* queue, 817 MonoObject* obj, void* user_data); 818 alias da_mono_gc_wbarrier_set_field = void function(MonoObject* obj, 819 void* field_ptr, MonoObject* value); 820 alias da_mono_gc_wbarrier_set_arrayref = void function(MonoArray* arr, 821 void* slot_ptr, MonoObject* value); 822 alias da_mono_gc_wbarrier_arrayref_copy = void function(void* dest_ptr, void* src_ptr, int count); 823 alias da_mono_gc_wbarrier_generic_store = void function(void* ptr, MonoObject* value); 824 alias da_mono_gc_wbarrier_generic_store_atomic = void function(void* ptr, MonoObject* value); 825 alias da_mono_gc_wbarrier_generic_nostore = void function(void* ptr); 826 alias da_mono_gc_wbarrier_value_copy = void function(void* dest, void* src, 827 int count, MonoClass* klass); 828 alias da_mono_gc_wbarrier_object_copy = void function(MonoObject* obj, MonoObject* src); 829 // metadata/opcodes.h 830 alias da_mono_opcode_name = const(char)* function(int opcode); 831 alias da_mono_opcode_value = MonoOpcodeEnum function(const(mono_byte*)* ip, 832 const(mono_byte)* end); 833 // metadata/profiler.h 834 alias da_mono_profiler_install = void function(MonoProfiler* prof, 835 MonoProfileFunc shutdown_callback); 836 alias da_mono_profiler_set_events = void function(MonoProfileFlags events); 837 alias da_mono_profiler_get_events = MonoProfileFlags function(); 838 alias da_mono_profiler_install_appdomain = void function( 839 MonoProfileAppDomainFunc start_load, MonoProfileAppDomainResult end_load, 840 MonoProfileAppDomainFunc start_unload, MonoProfileAppDomainFunc end_unload); 841 alias da_mono_profiler_install_appdomain_name = void function( 842 MonoProfileAppDomainFriendlyNameFunc domain_name_cb); 843 alias da_mono_profiler_install_context = void function(MonoProfileContextFunc load, 844 MonoProfileContextFunc unload); 845 alias da_mono_profiler_install_assembly = void function(MonoProfileAssemblyFunc start_load, 846 MonoProfileAssemblyResult end_load, MonoProfileAssemblyFunc start_unload, 847 MonoProfileAssemblyFunc end_unload); 848 alias da_mono_profiler_install_module = void function(MonoProfileModuleFunc start_load, 849 MonoProfileModuleResult end_load, MonoProfileModuleFunc start_unload, 850 MonoProfileModuleFunc end_unload); 851 alias da_mono_profiler_install_class = void function(MonoProfileClassFunc start_load, 852 MonoProfileClassResult end_load, MonoProfileClassFunc start_unload, 853 MonoProfileClassFunc end_unload); 854 alias da_mono_profiler_install_jit_compile = void function( 855 MonoProfileMethodFunc start, MonoProfileMethodResult end); 856 alias da_mono_profiler_install_jit_end = void function(MonoProfileJitResult end); 857 alias da_mono_profiler_install_method_free = void function(MonoProfileMethodFunc callback); 858 alias da_mono_profiler_install_method_invoke = void function( 859 MonoProfileMethodFunc start, MonoProfileMethodFunc end); 860 alias da_mono_profiler_install_enter_leave = void function( 861 MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave); 862 alias da_mono_profiler_install_thread = void function(MonoProfileThreadFunc start, 863 MonoProfileThreadFunc end); 864 alias da_mono_profiler_install_thread_name = void function( 865 MonoProfileThreadNameFunc thread_name_cb); 866 alias da_mono_profiler_install_transition = void function(MonoProfileMethodResult callback); 867 alias da_mono_profiler_install_allocation = void function(MonoProfileAllocFunc callback); 868 alias da_mono_profiler_install_monitor = void function(MonoProfileMonitorFunc callback); 869 alias da_mono_profiler_install_statistical = void function(MonoProfileStatFunc callback); 870 alias da_mono_profiler_install_statistical_call_chain = void function(MonoProfileStatCallChainFunc callback, 871 int call_chain_depth, MonoProfilerCallChainStrategy call_chain_strategy); 872 alias da_mono_profiler_install_exception = void function(MonoProfileExceptionFunc throw_callback, 873 MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback); 874 alias da_mono_profiler_install_coverage_filter = void function( 875 MonoProfileCoverageFilterFunc callback); 876 alias da_mono_profiler_coverage_get = void function(MonoProfiler* prof, 877 MonoMethod* method, MonoProfileCoverageFunc func); 878 alias da_mono_profiler_install_gc = void function(MonoProfileGCFunc callback, 879 MonoProfileGCResizeFunc heap_resize_callback); 880 alias da_mono_profiler_install_gc_moves = void function(MonoProfileGCMoveFunc callback); 881 alias da_mono_profiler_install_gc_roots = void function( 882 MonoProfileGCHandleFunc handle_callback, MonoProfileGCRootFunc roots_callback); 883 alias da_mono_profiler_install_gc_finalize = void function(MonoProfileGCFinalizeFunc begin, 884 MonoProfileGCFinalizeObjectFunc begin_obj, 885 MonoProfileGCFinalizeObjectFunc end_obj, MonoProfileGCFinalizeFunc end); 886 alias da_mono_profiler_install_runtime_initialized = void function( 887 MonoProfileFunc runtime_initialized_callback); 888 alias da_mono_profiler_install_code_chunk_new = void function(MonoProfilerCodeChunkNew callback); 889 alias da_mono_profiler_install_code_chunk_destroy = void function( 890 MonoProfilerCodeChunkDestroy callback); 891 alias da_mono_profiler_install_code_buffer_new = void function( 892 MonoProfilerCodeBufferNew callback); 893 alias da_mono_profiler_install_iomap = void function(MonoProfileIomapFunc callback); 894 alias da_mono_profiler_load = void function(const(char)* desc); 895 alias da_mono_profiler_set_statistical_mode = void function( 896 MonoProfileSamplingMode mode, long sampling_frequency_hz); 897 // metadata/reflection.h 898 alias da_mono_reflection_parse_type = int function(char* name, MonoTypeNameParse* info); 899 alias da_mono_reflection_get_type = MonoType* function(MonoImage* image, 900 MonoTypeNameParse* info, mono_bool ignorecase, mono_bool* type_resolve); 901 alias da_mono_reflection_free_type_info = void function(MonoTypeNameParse* info); 902 alias da_mono_reflection_type_from_name = MonoType* function(char* name, MonoImage* image); 903 alias da_mono_reflection_get_token = uint function(MonoObject* obj); 904 alias da_mono_assembly_get_object = MonoReflectionAssembly* function( 905 MonoDomain* domain, MonoAssembly* assembly); 906 alias da_mono_module_get_object = MonoReflectionModule* function(MonoDomain* domain, 907 MonoImage* image); 908 alias da_mono_module_file_get_object = MonoReflectionModule* function( 909 MonoDomain* domain, MonoImage* image, int table_index); 910 alias da_mono_type_get_object = MonoReflectionType* function(MonoDomain* domain, MonoType* type); 911 alias da_mono_method_get_object = MonoReflectionMethod* function(MonoDomain* domain, 912 MonoMethod* method, MonoClass* refclass); 913 alias da_mono_field_get_object = MonoReflectionField* function(MonoDomain* domain, 914 MonoClass* klass, MonoClassField* field); 915 alias da_mono_property_get_object = MonoReflectionProperty* function( 916 MonoDomain* domain, MonoClass* klass, MonoProperty* property); 917 alias da_mono_event_get_object = MonoReflectionEvent* function(MonoDomain* domain, 918 MonoClass* klass, MonoEvent* event); 919 alias da_mono_param_get_objects = MonoArray* function(MonoDomain* domain, MonoMethod* method); 920 alias da_mono_method_body_get_object = MonoReflectionMethodBody* function( 921 MonoDomain* domain, MonoMethod* method); 922 alias da_mono_get_dbnull_object = MonoObject* function(MonoDomain* domain); 923 alias da_mono_reflection_get_custom_attrs_by_type = MonoArray* function( 924 MonoObject* obj, MonoClass* attr_klass, MonoError* error); 925 alias da_mono_reflection_get_custom_attrs = MonoArray* function(MonoObject* obj); 926 alias da_mono_reflection_get_custom_attrs_data = MonoArray* function(MonoObject* obj); 927 alias da_mono_reflection_get_custom_attrs_blob = MonoArray* function( 928 MonoReflectionAssembly* assembly, MonoObject* ctor, 929 MonoArray* ctorArgs, 930 MonoArray* properties, MonoArray* porpValues, MonoArray* fields, 931 MonoArray* fieldValues); 932 alias da_mono_reflection_get_custom_attrs_info = MonoCustomAttrInfo* function(MonoObject* obj); 933 alias da_mono_custom_attrs_construct = MonoArray* function(MonoCustomAttrInfo* cinfo); 934 alias da_mono_custom_attrs_from_index = MonoCustomAttrInfo* function(MonoImage* image, uint idx); 935 alias da_mono_custom_attrs_from_method = MonoCustomAttrInfo* function(MonoMethod* method); 936 alias da_mono_custom_attrs_from_class = MonoCustomAttrInfo* function(MonoClass* klass); 937 alias da_mono_custom_attrs_from_assembly = MonoCustomAttrInfo* function(MonoAssembly* assembly); 938 alias da_mono_custom_attrs_from_property = MonoCustomAttrInfo* function( 939 MonoClass* klass, MonoProperty* property); 940 alias da_mono_custom_attrs_from_event = MonoCustomAttrInfo* function( 941 MonoClass* klass, MonoEvent* event); 942 alias da_mono_custom_attrs_from_field = MonoCustomAttrInfo* function( 943 MonoClass* klass, MonoClassField* field); 944 alias da_mono_custom_attrs_from_param = MonoCustomAttrInfo* function( 945 MonoMethod* method, uint param); 946 alias da_mono_custom_attrs_has_attr = mono_bool function(MonoCustomAttrInfo* ainfo, 947 MonoClass* attr_klass); 948 alias da_mono_custom_attrs_get_attr = MonoObject* function( 949 MonoCustomAttrInfo* ainfo, MonoClass* attr_klass); 950 alias da_mono_custom_attrs_free = void function(MonoCustomAttrInfo* ainfo); 951 alias da_mono_declsec_flags_from_method = uint function(MonoMethod* method); 952 alias da_mono_declsec_flags_from_class = uint function(MonoClass* klass); 953 alias da_mono_declsec_flags_from_assembly = uint function(MonoAssembly* assembly); 954 alias da_mono_declsec_get_demands = MonoBoolean function(MonoMethod* callee, 955 MonoDeclSecurityActions* demands); 956 alias da_mono_declsec_get_linkdemands = MonoBoolean function(MonoMethod* callee, 957 MonoDeclSecurityActions* klass, MonoDeclSecurityActions* cmethod); 958 alias da_mono_declsec_get_inheritdemands_class = MonoBoolean function( 959 MonoClass* klass, MonoDeclSecurityActions* demands); 960 alias da_mono_declsec_get_inheritdemands_method = MonoBoolean function( 961 MonoMethod* callee, MonoDeclSecurityActions* demands); 962 alias da_mono_declsec_get_method_action = MonoBoolean function(MonoMethod* method, 963 uint action, MonoDeclSecurityEntry* entry); 964 alias da_mono_declsec_get_class_action = MonoBoolean function(MonoClass* klass, 965 uint action, MonoDeclSecurityEntry* entry); 966 alias da_mono_declsec_get_assembly_action = MonoBoolean function( 967 MonoAssembly* assembly, uint action, MonoDeclSecurityEntry* entry); 968 alias da_mono_reflection_type_get_type = MonoType* function(MonoReflectionType* reftype); 969 alias da_mono_reflection_assembly_get_assembly = MonoAssembly* function( 970 MonoReflectionAssembly* refassembly); 971 // metadata/row-indexes.h 972 // metadata/sgen-bridge.h 973 alias da_mono_gc_register_bridge_callbacks = void function(MonoGCBridgeCallbacks* callbacks); 974 alias da_mono_gc_wait_for_bridge_processing = void function(); 975 // metadata/threads.h 976 alias da_mono_thread_init = void function(MonoThreadStartCB start_cb, 977 MonoThreadAttachCB attach_cb); 978 alias da_mono_thread_cleanup = void function(); 979 alias da_mono_thread_manage = void function(); 980 alias da_mono_thread_current = MonoThread* function(); 981 alias da_mono_thread_set_main = void function(MonoThread* thread); 982 alias da_mono_thread_get_main = MonoThread* function(); 983 alias da_mono_thread_stop = void function(MonoThread* thread); 984 alias da_mono_thread_new_init = void function(intptr_t tid, void* stack_start, void* func); 985 alias da_mono_thread_create = void function(MonoDomain* domain, void* func, void* arg); 986 alias da_mono_thread_attach = MonoThread* function(MonoDomain* domain); 987 alias da_mono_thread_detach = void function(MonoThread* thread); 988 alias da_mono_thread_exit = void function(); 989 alias da_mono_thread_get_name_utf8 = char* function(MonoThread* thread); 990 alias da_mono_thread_get_managed_id = int function(MonoThread* thread); 991 alias da_mono_thread_set_manage_callback = void function(MonoThread* thread, 992 MonoThreadManageCallback func); 993 alias da_mono_threads_set_default_stacksize = void function(uint stacksize); 994 alias da_mono_threads_get_default_stacksize = uint function(); 995 alias da_mono_threads_request_thread_dump = void function(); 996 alias da_mono_thread_is_foreign = mono_bool function(MonoThread* thread); 997 alias da_mono_thread_detach_if_exiting = mono_bool function(); 998 // metadata/tokentype.h 999 // metadata/verify.h 1000 alias da_mono_method_verify = void* function(MonoMethod* method, int level); 1001 alias da_mono_free_verify_list = void function(void* list); 1002 alias da_mono_verify_corlib = char* function(); 1003 // jit/jit.h 1004 alias da_mono_jit_init = MonoDomain* function(const(char)* file); 1005 alias da_mono_jit_init_version = MonoDomain* function(const(char)* root_domain_name, 1006 const(char)* runtime_version); 1007 alias da_mono_jit_exec = int function(MonoDomain* domain, 1008 MonoAssembly* assembly, int argc, char** argv); 1009 alias da_mono_jit_cleanup = void function(MonoDomain* domain); 1010 alias da_mono_jit_set_trace_options = mono_bool function(const(char)* options); 1011 alias da_mono_set_signal_chaining = void function(mono_bool chain_signals); 1012 alias da_mono_set_crash_chaining = void function(mono_bool chain_signals); 1013 alias da_mono_jit_set_aot_only = void function(mono_bool aot_only); 1014 alias da_mono_jit_set_aot_mode = void function(MonoAotMode mode); 1015 alias da_mono_set_break_policy = void function(MonoBreakPolicyFunc policy_callback); 1016 alias da_mono_jit_parse_options = void function(int argc, char** argv); 1017 alias da_mono_get_runtime_build_info = char* function(); 1018 alias da_mono_get_jit_info_from_method = MonoJitInfo* function(MonoDomain* domain, 1019 MonoMethod* method); 1020 alias da_mono_aot_get_method = void* function(MonoDomain* domain, MonoMethod* method); 1021 } 1022 1023 __gshared 1024 { 1025 // utils/mono-publib.h 1026 da_mono_free mono_free; 1027 da_mono_set_allocator_vtable mono_set_allocator_vtable; 1028 // utils/mono-logger.h 1029 da_mono_trace_set_level_string mono_trace_set_level_string; 1030 da_mono_trace_set_mask_string mono_trace_set_mask_string; 1031 da_mono_trace_set_log_handler mono_trace_set_log_handler; 1032 da_mono_trace_set_print_handler mono_trace_set_print_handler; 1033 da_mono_trace_set_printerr_handler mono_trace_set_printerr_handler; 1034 // utils/mono-error.h 1035 da_mono_error_init mono_error_init; 1036 da_mono_error_init_flags mono_error_init_flags; 1037 da_mono_error_cleanup mono_error_cleanup; 1038 da_mono_error_ok mono_error_ok; 1039 da_mono_error_get_error_code mono_error_get_error_code; 1040 da_mono_error_get_message mono_error_get_message; 1041 // utils/mono-dl-fallback.h 1042 da_mono_dl_fallback_register mono_dl_fallback_register; 1043 da_mono_dl_fallback_unregister mono_dl_fallback_unregister; 1044 // utils/mono-counters.h 1045 da_mono_counters_enable mono_counters_enable; 1046 da_mono_counters_init mono_counters_init; 1047 da_mono_counters_register mono_counters_register; 1048 da_mono_counters_register_with_size mono_counters_register_with_size; 1049 da_mono_counters_on_register mono_counters_on_register; 1050 da_mono_counters_dump mono_counters_dump; 1051 da_mono_counters_cleanup mono_counters_cleanup; 1052 da_mono_counters_foreach mono_counters_foreach; 1053 da_mono_counters_sample mono_counters_sample; 1054 da_mono_counter_get_name mono_counter_get_name; 1055 da_mono_counter_get_type mono_counter_get_type; 1056 da_mono_counter_get_section mono_counter_get_section; 1057 da_mono_counter_get_unit mono_counter_get_unit; 1058 da_mono_counter_get_variance mono_counter_get_variance; 1059 da_mono_counter_get_size mono_counter_get_size; 1060 da_mono_runtime_resource_limit mono_runtime_resource_limit; 1061 da_mono_runtime_resource_set_callback mono_runtime_resource_set_callback; 1062 da_mono_runtime_resource_check_limit mono_runtime_resource_check_limit; 1063 // metadata/appdomain.h 1064 da_mono_init mono_init; 1065 da_mono_init_from_assembly mono_init_from_assembly; 1066 da_mono_init_version mono_init_version; 1067 da_mono_get_root_domain mono_get_root_domain; 1068 da_mono_runtime_init mono_runtime_init; 1069 da_mono_runtime_cleanup mono_runtime_cleanup; 1070 da_mono_install_runtime_cleanup mono_install_runtime_cleanup; 1071 da_mono_runtime_quit mono_runtime_quit; 1072 da_mono_runtime_set_shutting_down mono_runtime_set_shutting_down; 1073 da_mono_runtime_is_shutting_down mono_runtime_is_shutting_down; 1074 da_mono_check_corlib_version mono_check_corlib_version; 1075 da_mono_domain_create mono_domain_create; 1076 da_mono_domain_create_appdomain mono_domain_create_appdomain; 1077 da_mono_domain_set_config mono_domain_set_config; 1078 da_mono_domain_get mono_domain_get; 1079 da_mono_domain_get_by_id mono_domain_get_by_id; 1080 da_mono_domain_get_id mono_domain_get_id; 1081 da_mono_domain_get_friendly_name mono_domain_get_friendly_name; 1082 da_mono_domain_set mono_domain_set; 1083 da_mono_domain_set_internal mono_domain_set_internal; 1084 da_mono_domain_unload mono_domain_unload; 1085 da_mono_domain_try_unload mono_domain_try_unload; 1086 da_mono_domain_is_unloading mono_domain_is_unloading; 1087 da_mono_domain_from_appdomain mono_domain_from_appdomain; 1088 da_mono_domain_foreach mono_domain_foreach; 1089 da_mono_domain_assembly_open mono_domain_assembly_open; 1090 da_mono_domain_finalize mono_domain_finalize; 1091 da_mono_domain_free mono_domain_free; 1092 da_mono_domain_has_type_resolve mono_domain_has_type_resolve; 1093 da_mono_domain_try_type_resolve mono_domain_try_type_resolve; 1094 da_mono_domain_owns_vtable_slot mono_domain_owns_vtable_slot; 1095 da_mono_context_init mono_context_init; 1096 da_mono_context_set mono_context_set; 1097 da_mono_context_get mono_context_get; 1098 da_mono_context_get_id mono_context_get_id; 1099 da_mono_context_get_domain_id mono_context_get_domain_id; 1100 da_mono_jit_info_table_find mono_jit_info_table_find; 1101 da_mono_jit_info_get_code_start mono_jit_info_get_code_start; 1102 da_mono_jit_info_get_code_size mono_jit_info_get_code_size; 1103 da_mono_jit_info_get_method mono_jit_info_get_method; 1104 da_mono_get_corlib mono_get_corlib; 1105 da_mono_get_object_class mono_get_object_class; 1106 da_mono_get_byte_class mono_get_byte_class; 1107 da_mono_get_void_class mono_get_void_class; 1108 da_mono_get_boolean_class mono_get_boolean_class; 1109 da_mono_get_sbyte_class mono_get_sbyte_class; 1110 da_mono_get_int16_class mono_get_int16_class; 1111 da_mono_get_uint16_class mono_get_uint16_class; 1112 da_mono_get_int32_class mono_get_int32_class; 1113 da_mono_get_uint32_class mono_get_uint32_class; 1114 da_mono_get_intptr_class mono_get_intptr_class; 1115 da_mono_get_uintptr_class mono_get_uintptr_class; 1116 da_mono_get_int64_class mono_get_int64_class; 1117 da_mono_get_uint64_class mono_get_uint64_class; 1118 da_mono_get_single_class mono_get_single_class; 1119 da_mono_get_double_class mono_get_double_class; 1120 da_mono_get_char_class mono_get_char_class; 1121 da_mono_get_string_class mono_get_string_class; 1122 da_mono_get_enum_class mono_get_enum_class; 1123 da_mono_get_array_class mono_get_array_class; 1124 da_mono_get_thread_class mono_get_thread_class; 1125 da_mono_get_exception_class mono_get_exception_class; 1126 da_mono_security_enable_core_clr mono_security_enable_core_clr; 1127 da_mono_security_set_core_clr_platform_callback mono_security_set_core_clr_platform_callback; 1128 // metadata/assembly.h 1129 da_mono_assemblies_init mono_assemblies_init; 1130 da_mono_assemblies_cleanup mono_assemblies_cleanup; 1131 da_mono_assembly_open mono_assembly_open; 1132 da_mono_assembly_open_full mono_assembly_open_full; 1133 da_mono_assembly_load mono_assembly_load; 1134 da_mono_assembly_load_full mono_assembly_load_full; 1135 da_mono_assembly_load_from mono_assembly_load_from; 1136 da_mono_assembly_load_from_full mono_assembly_load_from_full; 1137 da_mono_assembly_load_with_partial_name mono_assembly_load_with_partial_name; 1138 da_mono_assembly_loaded mono_assembly_loaded; 1139 da_mono_assembly_loaded_full mono_assembly_loaded_full; 1140 da_mono_assembly_get_assemblyref mono_assembly_get_assemblyref; 1141 da_mono_assembly_load_reference mono_assembly_load_reference; 1142 da_mono_assembly_load_references mono_assembly_load_references; 1143 da_mono_assembly_load_module mono_assembly_load_module; 1144 da_mono_assembly_close mono_assembly_close; 1145 da_mono_assembly_setrootdir mono_assembly_setrootdir; 1146 da_mono_assembly_getrootdir mono_assembly_getrootdir; 1147 da_mono_native_getrootdir mono_native_getrootdir; 1148 da_mono_assembly_foreach mono_assembly_foreach; 1149 da_mono_assembly_set_main mono_assembly_set_main; 1150 da_mono_assembly_get_main mono_assembly_get_main; 1151 da_mono_assembly_get_image mono_assembly_get_image; 1152 da_mono_assembly_get_name mono_assembly_get_name; 1153 da_mono_assembly_fill_assembly_name mono_assembly_fill_assembly_name; 1154 da_mono_assembly_names_equal mono_assembly_names_equal; 1155 da_mono_stringify_assembly_name mono_stringify_assembly_name; 1156 da_mono_install_assembly_load_hook mono_install_assembly_load_hook; 1157 da_mono_install_assembly_search_hook mono_install_assembly_search_hook; 1158 da_mono_install_assembly_refonly_search_hook mono_install_assembly_refonly_search_hook; 1159 da_mono_assembly_invoke_search_hook mono_assembly_invoke_search_hook; 1160 da_mono_install_assembly_postload_search_hook mono_install_assembly_postload_search_hook; 1161 da_mono_install_assembly_postload_refonly_search_hook mono_install_assembly_postload_refonly_search_hook; 1162 da_mono_install_assembly_preload_hook mono_install_assembly_preload_hook; 1163 da_mono_install_assembly_refonly_preload_hook mono_install_assembly_refonly_preload_hook; 1164 da_mono_assembly_invoke_load_hook mono_assembly_invoke_load_hook; 1165 da_mono_assembly_name_new mono_assembly_name_new; 1166 da_mono_assembly_name_get_name mono_assembly_name_get_name; 1167 da_mono_assembly_name_get_culture mono_assembly_name_get_culture; 1168 da_mono_assembly_name_get_version mono_assembly_name_get_version; 1169 da_mono_assembly_name_get_pubkeytoken mono_assembly_name_get_pubkeytoken; 1170 da_mono_assembly_name_free mono_assembly_name_free; 1171 da_mono_register_bundled_assemblies mono_register_bundled_assemblies; 1172 da_mono_register_config_for_assembly mono_register_config_for_assembly; 1173 da_mono_register_symfile_for_assembly mono_register_symfile_for_assembly; 1174 da_mono_register_machine_config mono_register_machine_config; 1175 da_mono_set_rootdir mono_set_rootdir; 1176 da_mono_set_dirs mono_set_dirs; 1177 da_mono_set_assemblies_path mono_set_assemblies_path; 1178 // metadata/attrdefs.h 1179 // metadata/blob.h 1180 // metadata/class.h 1181 da_mono_class_get mono_class_get; 1182 da_mono_class_get_full mono_class_get_full; 1183 da_mono_class_init mono_class_init; 1184 da_mono_class_vtable mono_class_vtable; 1185 da_mono_class_from_name mono_class_from_name; 1186 da_mono_class_from_name_case mono_class_from_name_case; 1187 da_mono_class_get_method_from_name_flags mono_class_get_method_from_name_flags; 1188 da_mono_class_from_typeref mono_class_from_typeref; 1189 da_mono_class_from_typeref_checked mono_class_from_typeref_checked; 1190 da_mono_class_from_generic_parameter mono_class_from_generic_parameter; 1191 da_mono_class_inflate_generic_type mono_class_inflate_generic_type; 1192 da_mono_class_inflate_generic_method mono_class_inflate_generic_method; 1193 da_mono_get_inflated_method mono_get_inflated_method; 1194 da_mono_field_from_token mono_field_from_token; 1195 da_mono_bounded_array_class_get mono_bounded_array_class_get; 1196 da_mono_array_class_get mono_array_class_get; 1197 da_mono_ptr_class_get mono_ptr_class_get; 1198 da_mono_class_get_field mono_class_get_field; 1199 da_mono_class_get_field_from_name mono_class_get_field_from_name; 1200 da_mono_class_get_field_token mono_class_get_field_token; 1201 da_mono_class_get_event_token mono_class_get_event_token; 1202 da_mono_class_get_property_from_name mono_class_get_property_from_name; 1203 da_mono_class_get_property_token mono_class_get_property_token; 1204 da_mono_array_element_size mono_array_element_size; 1205 da_mono_class_instance_size mono_class_instance_size; 1206 da_mono_class_array_element_size mono_class_array_element_size; 1207 da_mono_class_data_size mono_class_data_size; 1208 da_mono_class_value_size mono_class_value_size; 1209 da_mono_class_min_align mono_class_min_align; 1210 da_mono_class_from_mono_type mono_class_from_mono_type; 1211 da_mono_class_is_subclass_of mono_class_is_subclass_of; 1212 da_mono_class_is_assignable_from mono_class_is_assignable_from; 1213 da_mono_ldtoken mono_ldtoken; 1214 da_mono_type_get_name mono_type_get_name; 1215 da_mono_type_get_underlying_type mono_type_get_underlying_type; 1216 da_mono_class_get_image mono_class_get_image; 1217 da_mono_class_get_element_class mono_class_get_element_class; 1218 da_mono_class_is_valuetype mono_class_is_valuetype; 1219 da_mono_class_is_enum mono_class_is_enum; 1220 da_mono_class_enum_basetype mono_class_enum_basetype; 1221 da_mono_class_get_parent mono_class_get_parent; 1222 da_mono_class_get_nesting_type mono_class_get_nesting_type; 1223 da_mono_class_get_rank mono_class_get_rank; 1224 da_mono_class_get_flags mono_class_get_flags; 1225 da_mono_class_get_name mono_class_get_name; 1226 da_mono_class_get_namespace mono_class_get_namespace; 1227 da_mono_class_get_type mono_class_get_type; 1228 da_mono_class_get_type_token mono_class_get_type_token; 1229 da_mono_class_get_byref_type mono_class_get_byref_type; 1230 da_mono_class_num_fields mono_class_num_fields; 1231 da_mono_class_num_methods mono_class_num_methods; 1232 da_mono_class_num_properties mono_class_num_properties; 1233 da_mono_class_num_events mono_class_num_events; 1234 da_mono_class_get_fields mono_class_get_fields; 1235 da_mono_class_get_methods mono_class_get_methods; 1236 da_mono_class_get_properties mono_class_get_properties; 1237 da_mono_class_get_events mono_class_get_events; 1238 da_mono_class_get_interfaces mono_class_get_interfaces; 1239 da_mono_class_get_nested_types mono_class_get_nested_types; 1240 da_mono_class_is_delegate mono_class_is_delegate; 1241 da_mono_class_implements_interface mono_class_implements_interface; 1242 da_mono_field_get_name mono_field_get_name; 1243 da_mono_field_get_type mono_field_get_type; 1244 da_mono_field_get_parent mono_field_get_parent; 1245 da_mono_field_get_flags mono_field_get_flags; 1246 da_mono_field_get_offset mono_field_get_offset; 1247 da_mono_field_get_data mono_field_get_data; 1248 da_mono_property_get_name mono_property_get_name; 1249 da_mono_property_get_set_method mono_property_get_set_method; 1250 da_mono_property_get_get_method mono_property_get_get_method; 1251 da_mono_property_get_parent mono_property_get_parent; 1252 da_mono_property_get_flags mono_property_get_flags; 1253 da_mono_event_get_name mono_event_get_name; 1254 da_mono_event_get_add_method mono_event_get_add_method; 1255 da_mono_event_get_remove_method mono_event_get_remove_method; 1256 da_mono_event_get_raise_method mono_event_get_raise_method; 1257 da_mono_event_get_parent mono_event_get_parent; 1258 da_mono_event_get_flags mono_event_get_flags; 1259 da_mono_class_get_method_from_name mono_class_get_method_from_name; 1260 da_mono_class_name_from_token mono_class_name_from_token; 1261 da_mono_method_can_access_field mono_method_can_access_field; 1262 da_mono_method_can_access_method mono_method_can_access_method; 1263 // metadata/debug-helpers.h 1264 da_mono_disasm_code_one mono_disasm_code_one; 1265 da_mono_disasm_code mono_disasm_code; 1266 da_mono_type_full_name mono_type_full_name; 1267 da_mono_signature_get_desc mono_signature_get_desc; 1268 da_mono_context_get_desc mono_context_get_desc; 1269 da_mono_method_desc_new mono_method_desc_new; 1270 da_mono_method_desc_from_method mono_method_desc_from_method; 1271 da_mono_method_desc_free mono_method_desc_free; 1272 da_mono_method_desc_match mono_method_desc_match; 1273 da_mono_method_desc_full_match mono_method_desc_full_match; 1274 da_mono_method_desc_search_in_class mono_method_desc_search_in_class; 1275 da_mono_method_desc_search_in_image mono_method_desc_search_in_image; 1276 da_mono_method_full_name mono_method_full_name; 1277 da_mono_field_full_name mono_field_full_name; 1278 // metadata/debug-mono-symfile.h 1279 da_mono_debug_open_mono_symbols mono_debug_open_mono_symbols; 1280 da_mono_debug_close_mono_symbol_file mono_debug_close_mono_symbol_file; 1281 da_mono_debug_symfile_is_loaded mono_debug_symfile_is_loaded; 1282 da_mono_debug_symfile_lookup_location mono_debug_symfile_lookup_location; 1283 da_mono_debug_symfile_free_location mono_debug_symfile_free_location; 1284 da_mono_debug_symfile_lookup_method mono_debug_symfile_lookup_method; 1285 da_mono_debug_symfile_lookup_locals mono_debug_symfile_lookup_locals; 1286 da_mono_debug_image_has_debug_info mono_debug_image_has_debug_info; 1287 // metadata/environment.h 1288 da_mono_environment_exitcode_get mono_environment_exitcode_get; 1289 da_mono_environment_exitcode_set mono_environment_exitcode_set; 1290 // metadata/exception.h 1291 da_mono_exception_from_name mono_exception_from_name; 1292 da_mono_exception_from_token mono_exception_from_token; 1293 da_mono_exception_from_name_two_strings mono_exception_from_name_two_strings; 1294 da_mono_exception_from_name_msg mono_exception_from_name_msg; 1295 da_mono_exception_from_token_two_strings mono_exception_from_token_two_strings; 1296 da_mono_exception_from_name_domain mono_exception_from_name_domain; 1297 da_mono_get_exception_divide_by_zero mono_get_exception_divide_by_zero; 1298 da_mono_get_exception_security mono_get_exception_security; 1299 da_mono_get_exception_arithmetic mono_get_exception_arithmetic; 1300 da_mono_get_exception_overflow mono_get_exception_overflow; 1301 da_mono_get_exception_null_reference mono_get_exception_null_reference; 1302 da_mono_get_exception_execution_engine mono_get_exception_execution_engine; 1303 da_mono_get_exception_thread_abort mono_get_exception_thread_abort; 1304 da_mono_get_exception_thread_state mono_get_exception_thread_state; 1305 da_mono_get_exception_thread_interrupted mono_get_exception_thread_interrupted; 1306 da_mono_get_exception_serialization mono_get_exception_serialization; 1307 da_mono_get_exception_invalid_cast mono_get_exception_invalid_cast; 1308 da_mono_get_exception_invalid_operation mono_get_exception_invalid_operation; 1309 da_mono_get_exception_index_out_of_range mono_get_exception_index_out_of_range; 1310 da_mono_get_exception_array_type_mismatch mono_get_exception_array_type_mismatch; 1311 da_mono_get_exception_type_load mono_get_exception_type_load; 1312 da_mono_get_exception_missing_method mono_get_exception_missing_method; 1313 da_mono_get_exception_missing_field mono_get_exception_missing_field; 1314 da_mono_get_exception_not_implemented mono_get_exception_not_implemented; 1315 da_mono_get_exception_not_supported mono_get_exception_not_supported; 1316 da_mono_get_exception_argument_null mono_get_exception_argument_null; 1317 da_mono_get_exception_argument mono_get_exception_argument; 1318 da_mono_get_exception_argument_out_of_range mono_get_exception_argument_out_of_range; 1319 da_mono_get_exception_io mono_get_exception_io; 1320 da_mono_get_exception_file_not_found mono_get_exception_file_not_found; 1321 da_mono_get_exception_file_not_found2 mono_get_exception_file_not_found2; 1322 da_mono_get_exception_type_initialization mono_get_exception_type_initialization; 1323 da_mono_get_exception_synchronization_lock mono_get_exception_synchronization_lock; 1324 da_mono_get_exception_cannot_unload_appdomain mono_get_exception_cannot_unload_appdomain; 1325 da_mono_get_exception_appdomain_unloaded mono_get_exception_appdomain_unloaded; 1326 da_mono_get_exception_bad_image_format mono_get_exception_bad_image_format; 1327 da_mono_get_exception_bad_image_format2 mono_get_exception_bad_image_format2; 1328 da_mono_get_exception_stack_overflow mono_get_exception_stack_overflow; 1329 da_mono_get_exception_out_of_memory mono_get_exception_out_of_memory; 1330 da_mono_get_exception_field_access mono_get_exception_field_access; 1331 da_mono_get_exception_method_access mono_get_exception_method_access; 1332 da_mono_get_exception_reflection_type_load mono_get_exception_reflection_type_load; 1333 da_mono_get_exception_runtime_wrapped mono_get_exception_runtime_wrapped; 1334 da_mono_install_unhandled_exception_hook mono_install_unhandled_exception_hook; 1335 da_mono_invoke_unhandled_exception_hook mono_invoke_unhandled_exception_hook; 1336 // metadata/image.h 1337 da_mono_images_init mono_images_init; 1338 da_mono_images_cleanup mono_images_cleanup; 1339 da_mono_image_open mono_image_open; 1340 da_mono_image_open_full mono_image_open_full; 1341 da_mono_pe_file_open mono_pe_file_open; 1342 da_mono_image_open_from_data mono_image_open_from_data; 1343 da_mono_image_open_from_data_full mono_image_open_from_data_full; 1344 da_mono_image_open_from_data_with_name mono_image_open_from_data_with_name; 1345 da_mono_image_fixup_vtable mono_image_fixup_vtable; 1346 da_mono_image_loaded mono_image_loaded; 1347 da_mono_image_loaded_full mono_image_loaded_full; 1348 da_mono_image_loaded_by_guid mono_image_loaded_by_guid; 1349 da_mono_image_loaded_by_guid_full mono_image_loaded_by_guid_full; 1350 da_mono_image_init mono_image_init; 1351 da_mono_image_close mono_image_close; 1352 da_mono_image_addref mono_image_addref; 1353 da_mono_image_strerror mono_image_strerror; 1354 da_mono_image_ensure_section mono_image_ensure_section; 1355 da_mono_image_ensure_section_idx mono_image_ensure_section_idx; 1356 da_mono_image_get_entry_point mono_image_get_entry_point; 1357 da_mono_image_get_resource mono_image_get_resource; 1358 da_mono_image_load_file_for_image mono_image_load_file_for_image; 1359 da_mono_image_load_module mono_image_load_module; 1360 da_mono_image_get_name mono_image_get_name; 1361 da_mono_image_get_filename mono_image_get_filename; 1362 da_mono_image_get_guid mono_image_get_guid; 1363 da_mono_image_get_assembly mono_image_get_assembly; 1364 da_mono_image_is_dynamic mono_image_is_dynamic; 1365 da_mono_image_rva_map mono_image_rva_map; 1366 da_mono_image_get_table_info mono_image_get_table_info; 1367 da_mono_image_get_table_rows mono_image_get_table_rows; 1368 da_mono_table_info_get_rows mono_table_info_get_rows; 1369 da_mono_image_lookup_resource mono_image_lookup_resource; 1370 da_mono_image_get_public_key mono_image_get_public_key; 1371 da_mono_image_get_strong_name mono_image_get_strong_name; 1372 da_mono_image_strong_name_position mono_image_strong_name_position; 1373 da_mono_image_add_to_name_cache mono_image_add_to_name_cache; 1374 da_mono_image_has_authenticode_entry mono_image_has_authenticode_entry; 1375 // metadata/loader.h 1376 da_mono_get_method mono_get_method; 1377 da_mono_get_method_full mono_get_method_full; 1378 da_mono_get_method_constrained mono_get_method_constrained; 1379 da_mono_free_method mono_free_method; 1380 da_mono_method_get_signature_full mono_method_get_signature_full; 1381 da_mono_method_get_signature mono_method_get_signature; 1382 da_mono_method_signature mono_method_signature; 1383 da_mono_method_get_header mono_method_get_header; 1384 da_mono_method_get_name mono_method_get_name; 1385 da_mono_method_get_class mono_method_get_class; 1386 da_mono_method_get_token mono_method_get_token; 1387 da_mono_method_get_flags mono_method_get_flags; 1388 da_mono_method_get_index mono_method_get_index; 1389 da_mono_load_image mono_load_image; 1390 da_mono_add_internal_call mono_add_internal_call; 1391 da_mono_lookup_internal_call mono_lookup_internal_call; 1392 da_mono_lookup_internal_call_full mono_lookup_internal_call_full; 1393 da_mono_lookup_icall_symbol mono_lookup_icall_symbol; 1394 da_mono_dllmap_insert mono_dllmap_insert; 1395 da_mono_lookup_pinvoke_call mono_lookup_pinvoke_call; 1396 da_mono_method_get_param_names mono_method_get_param_names; 1397 da_mono_method_get_param_token mono_method_get_param_token; 1398 da_mono_method_get_marshal_info mono_method_get_marshal_info; 1399 da_mono_method_has_marshal_info mono_method_has_marshal_info; 1400 da_mono_method_get_last_managed mono_method_get_last_managed; 1401 da_mono_stack_walk mono_stack_walk; 1402 da_mono_stack_walk_no_il mono_stack_walk_no_il; 1403 da_mono_stack_walk_async_safe mono_stack_walk_async_safe; 1404 da_mono_method_get_header_checked mono_method_get_header_checked; 1405 // metadata/metadata.h 1406 da_mono_metadata_init mono_metadata_init; 1407 da_mono_metadata_decode_row mono_metadata_decode_row; 1408 da_mono_metadata_decode_row_col mono_metadata_decode_row_col; 1409 da_mono_metadata_compute_size mono_metadata_compute_size; 1410 da_mono_metadata_locate mono_metadata_locate; 1411 da_mono_metadata_locate_token mono_metadata_locate_token; 1412 da_mono_metadata_string_heap mono_metadata_string_heap; 1413 da_mono_metadata_blob_heap mono_metadata_blob_heap; 1414 da_mono_metadata_user_string mono_metadata_user_string; 1415 da_mono_metadata_guid_heap mono_metadata_guid_heap; 1416 da_mono_metadata_typedef_from_field mono_metadata_typedef_from_field; 1417 da_mono_metadata_typedef_from_method mono_metadata_typedef_from_method; 1418 da_mono_metadata_nested_in_typedef mono_metadata_nested_in_typedef; 1419 da_mono_metadata_nesting_typedef mono_metadata_nesting_typedef; 1420 da_mono_metadata_interfaces_from_typedef mono_metadata_interfaces_from_typedef; 1421 da_mono_metadata_events_from_typedef mono_metadata_events_from_typedef; 1422 da_mono_metadata_methods_from_event mono_metadata_methods_from_event; 1423 da_mono_metadata_properties_from_typedef mono_metadata_properties_from_typedef; 1424 da_mono_metadata_methods_from_property mono_metadata_methods_from_property; 1425 da_mono_metadata_packing_from_typedef mono_metadata_packing_from_typedef; 1426 da_mono_metadata_get_marshal_info mono_metadata_get_marshal_info; 1427 da_mono_metadata_custom_attrs_from_index mono_metadata_custom_attrs_from_index; 1428 da_mono_metadata_parse_marshal_spec mono_metadata_parse_marshal_spec; 1429 da_mono_metadata_free_marshal_spec mono_metadata_free_marshal_spec; 1430 da_mono_metadata_implmap_from_method mono_metadata_implmap_from_method; 1431 da_mono_metadata_field_info mono_metadata_field_info; 1432 da_mono_metadata_get_constant_index mono_metadata_get_constant_index; 1433 da_mono_metadata_decode_value mono_metadata_decode_value; 1434 da_mono_metadata_decode_signed_value mono_metadata_decode_signed_value; 1435 da_mono_metadata_decode_blob_size mono_metadata_decode_blob_size; 1436 da_mono_metadata_encode_value mono_metadata_encode_value; 1437 da_mono_type_is_byref mono_type_is_byref; 1438 da_mono_type_get_type mono_type_get_type; 1439 da_mono_type_get_signature mono_type_get_signature; 1440 da_mono_type_get_class mono_type_get_class; 1441 da_mono_type_get_array_type mono_type_get_array_type; 1442 da_mono_type_get_ptr_type mono_type_get_ptr_type; 1443 da_mono_type_get_modifiers mono_type_get_modifiers; 1444 da_mono_type_is_struct mono_type_is_struct; 1445 da_mono_type_is_void mono_type_is_void; 1446 da_mono_type_is_pointer mono_type_is_pointer; 1447 da_mono_type_is_reference mono_type_is_reference; 1448 da_mono_type_is_generic_parameter mono_type_is_generic_parameter; 1449 da_mono_signature_get_return_type mono_signature_get_return_type; 1450 da_mono_signature_get_params mono_signature_get_params; 1451 da_mono_signature_get_param_count mono_signature_get_param_count; 1452 da_mono_signature_get_call_conv mono_signature_get_call_conv; 1453 da_mono_signature_vararg_start mono_signature_vararg_start; 1454 da_mono_signature_is_instance mono_signature_is_instance; 1455 da_mono_signature_explicit_this mono_signature_explicit_this; 1456 da_mono_signature_param_is_out mono_signature_param_is_out; 1457 da_mono_metadata_parse_typedef_or_ref mono_metadata_parse_typedef_or_ref; 1458 da_mono_metadata_parse_custom_mod mono_metadata_parse_custom_mod; 1459 da_mono_metadata_parse_array mono_metadata_parse_array; 1460 da_mono_metadata_free_array mono_metadata_free_array; 1461 da_mono_metadata_parse_type mono_metadata_parse_type; 1462 da_mono_metadata_parse_param mono_metadata_parse_param; 1463 da_mono_metadata_parse_ret_type mono_metadata_parse_ret_type; 1464 da_mono_metadata_parse_field_type mono_metadata_parse_field_type; 1465 da_mono_type_create_from_typespec mono_type_create_from_typespec; 1466 da_mono_metadata_free_type mono_metadata_free_type; 1467 da_mono_type_size mono_type_size; 1468 da_mono_type_stack_size mono_type_stack_size; 1469 da_mono_type_generic_inst_is_valuetype mono_type_generic_inst_is_valuetype; 1470 da_mono_metadata_generic_class_is_valuetype mono_metadata_generic_class_is_valuetype; 1471 da_mono_metadata_generic_class_hash mono_metadata_generic_class_hash; 1472 da_mono_metadata_generic_class_equal mono_metadata_generic_class_equal; 1473 da_mono_metadata_type_hash mono_metadata_type_hash; 1474 da_mono_metadata_type_equal mono_metadata_type_equal; 1475 da_mono_metadata_signature_alloc mono_metadata_signature_alloc; 1476 da_mono_metadata_signature_dup mono_metadata_signature_dup; 1477 da_mono_metadata_parse_signature mono_metadata_parse_signature; 1478 da_mono_metadata_parse_method_signature mono_metadata_parse_method_signature; 1479 da_mono_metadata_free_method_signature mono_metadata_free_method_signature; 1480 da_mono_metadata_signature_equal mono_metadata_signature_equal; 1481 da_mono_signature_hash mono_signature_hash; 1482 da_mono_metadata_parse_mh mono_metadata_parse_mh; 1483 da_mono_metadata_free_mh mono_metadata_free_mh; 1484 da_mono_method_header_get_code mono_method_header_get_code; 1485 da_mono_method_header_get_locals mono_method_header_get_locals; 1486 da_mono_method_header_get_num_clauses mono_method_header_get_num_clauses; 1487 da_mono_method_header_get_clauses mono_method_header_get_clauses; 1488 da_mono_type_to_unmanaged mono_type_to_unmanaged; 1489 da_mono_metadata_token_from_dor mono_metadata_token_from_dor; 1490 da_mono_guid_to_string mono_guid_to_string; 1491 da_mono_guid_to_string_minimal mono_guid_to_string_minimal; 1492 da_mono_metadata_declsec_from_index mono_metadata_declsec_from_index; 1493 da_mono_metadata_translate_token_index mono_metadata_translate_token_index; 1494 da_mono_metadata_decode_table_row mono_metadata_decode_table_row; 1495 da_mono_metadata_decode_table_row_col mono_metadata_decode_table_row_col; 1496 // metadata/mono-config.h 1497 da_mono_config_get_os mono_config_get_os; 1498 da_mono_config_get_cpu mono_config_get_cpu; 1499 da_mono_config_get_wordsize mono_config_get_wordsize; 1500 da_mono_get_config_dir mono_get_config_dir; 1501 da_mono_set_config_dir mono_set_config_dir; 1502 da_mono_get_machine_config mono_get_machine_config; 1503 da_mono_config_cleanup mono_config_cleanup; 1504 da_mono_config_parse mono_config_parse; 1505 da_mono_config_for_assembly mono_config_for_assembly; 1506 da_mono_config_parse_memory mono_config_parse_memory; 1507 da_mono_config_string_for_assembly_file mono_config_string_for_assembly_file; 1508 da_mono_config_set_server_mode mono_config_set_server_mode; 1509 da_mono_config_is_server_mode mono_config_is_server_mode; 1510 // metadata/mono-debug.h 1511 da_mono_debug_init mono_debug_init; 1512 da_mono_debug_open_image_from_memory mono_debug_open_image_from_memory; 1513 da_mono_debug_cleanup mono_debug_cleanup; 1514 da_mono_debug_close_image mono_debug_close_image; 1515 da_mono_debug_domain_unload mono_debug_domain_unload; 1516 da_mono_debug_domain_create mono_debug_domain_create; 1517 da_mono_debug_add_method mono_debug_add_method; 1518 da_mono_debug_remove_method mono_debug_remove_method; 1519 da_mono_debug_lookup_method mono_debug_lookup_method; 1520 da_mono_debug_lookup_method_addresses mono_debug_lookup_method_addresses; 1521 da_mono_debug_find_method mono_debug_find_method; 1522 da_mono_debug_free_method_jit_info mono_debug_free_method_jit_info; 1523 da_mono_debug_add_delegate_trampoline mono_debug_add_delegate_trampoline; 1524 da_mono_debug_lookup_locals mono_debug_lookup_locals; 1525 da_mono_debug_lookup_method_async_debug_info mono_debug_lookup_method_async_debug_info; 1526 da_mono_debug_method_lookup_location mono_debug_method_lookup_location; 1527 da_mono_debug_lookup_source_location mono_debug_lookup_source_location; 1528 da_mono_debug_il_offset_from_address mono_debug_il_offset_from_address; 1529 da_mono_debug_free_source_location mono_debug_free_source_location; 1530 da_mono_debug_print_stack_frame mono_debug_print_stack_frame; 1531 da_mono_debugger_method_has_breakpoint mono_debugger_method_has_breakpoint; 1532 da_mono_debugger_insert_breakpoint mono_debugger_insert_breakpoint; 1533 da_mono_set_is_debugger_attached mono_set_is_debugger_attached; 1534 da_mono_is_debugger_attached mono_is_debugger_attached; 1535 // metadata/mono-gc.h 1536 da_mono_gc_collect mono_gc_collect; 1537 da_mono_gc_max_generation mono_gc_max_generation; 1538 da_mono_gc_get_generation mono_gc_get_generation; 1539 da_mono_gc_collection_count mono_gc_collection_count; 1540 da_mono_gc_get_used_size mono_gc_get_used_size; 1541 da_mono_gc_get_heap_size mono_gc_get_heap_size; 1542 da_mono_gc_pending_finalizers mono_gc_pending_finalizers; 1543 da_mono_gc_finalize_notify mono_gc_finalize_notify; 1544 da_mono_gc_invoke_finalizers mono_gc_invoke_finalizers; 1545 da_mono_gc_walk_heap mono_gc_walk_heap; 1546 // metadata/object.h 1547 da_mono_string_chars mono_string_chars; 1548 da_mono_string_length mono_string_length; 1549 da_mono_object_new mono_object_new; 1550 da_mono_object_new_specific mono_object_new_specific; 1551 da_mono_object_new_fast mono_object_new_fast; 1552 da_mono_object_new_alloc_specific mono_object_new_alloc_specific; 1553 da_mono_object_new_from_token mono_object_new_from_token; 1554 da_mono_array_new mono_array_new; 1555 da_mono_array_new_full mono_array_new_full; 1556 da_mono_array_new_specific mono_array_new_specific; 1557 da_mono_array_clone mono_array_clone; 1558 da_mono_array_addr_with_size mono_array_addr_with_size; 1559 da_mono_array_length mono_array_length; 1560 da_mono_string_empty mono_string_empty; 1561 da_mono_string_empty_wrapper mono_string_empty_wrapper; 1562 da_mono_string_new_utf16 mono_string_new_utf16; 1563 da_mono_string_new_size mono_string_new_size; 1564 da_mono_ldstr mono_ldstr; 1565 da_mono_string_is_interned mono_string_is_interned; 1566 da_mono_string_intern mono_string_intern; 1567 da_mono_string_new mono_string_new; 1568 da_mono_string_new_wrapper mono_string_new_wrapper; 1569 da_mono_string_new_len mono_string_new_len; 1570 da_mono_string_new_utf32 mono_string_new_utf32; 1571 da_mono_string_to_utf8 mono_string_to_utf8; 1572 da_mono_string_to_utf8_checked mono_string_to_utf8_checked; 1573 da_mono_string_to_utf16 mono_string_to_utf16; 1574 da_mono_string_to_utf32 mono_string_to_utf32; 1575 da_mono_string_from_utf16 mono_string_from_utf16; 1576 da_mono_string_from_utf32 mono_string_from_utf32; 1577 da_mono_string_equal mono_string_equal; 1578 da_mono_string_hash mono_string_hash; 1579 da_mono_object_hash mono_object_hash; 1580 da_mono_object_to_string mono_object_to_string; 1581 da_mono_value_box mono_value_box; 1582 da_mono_value_copy mono_value_copy; 1583 da_mono_value_copy_array mono_value_copy_array; 1584 da_mono_object_get_domain mono_object_get_domain; 1585 da_mono_object_get_class mono_object_get_class; 1586 da_mono_object_unbox mono_object_unbox; 1587 da_mono_object_clone mono_object_clone; 1588 da_mono_object_isinst mono_object_isinst; 1589 da_mono_object_isinst_mbyref mono_object_isinst_mbyref; 1590 da_mono_object_castclass_mbyref mono_object_castclass_mbyref; 1591 da_mono_monitor_try_enter mono_monitor_try_enter; 1592 da_mono_monitor_enter mono_monitor_enter; 1593 da_mono_monitor_enter_v4 mono_monitor_enter_v4; 1594 da_mono_object_get_size mono_object_get_size; 1595 da_mono_monitor_exit mono_monitor_exit; 1596 da_mono_raise_exception mono_raise_exception; 1597 da_mono_runtime_object_init mono_runtime_object_init; 1598 da_mono_runtime_class_init mono_runtime_class_init; 1599 da_mono_object_get_virtual_method mono_object_get_virtual_method; 1600 da_mono_runtime_invoke mono_runtime_invoke; 1601 da_mono_get_delegate_invoke mono_get_delegate_invoke; 1602 da_mono_get_delegate_begin_invoke mono_get_delegate_begin_invoke; 1603 da_mono_get_delegate_end_invoke mono_get_delegate_end_invoke; 1604 da_mono_runtime_delegate_invoke mono_runtime_delegate_invoke; 1605 da_mono_runtime_invoke_array mono_runtime_invoke_array; 1606 da_mono_method_get_unmanaged_thunk mono_method_get_unmanaged_thunk; 1607 da_mono_runtime_get_main_args mono_runtime_get_main_args; 1608 da_mono_runtime_exec_managed_code mono_runtime_exec_managed_code; 1609 da_mono_runtime_run_main mono_runtime_run_main; 1610 da_mono_runtime_exec_main mono_runtime_exec_main; 1611 da_mono_runtime_set_main_args mono_runtime_set_main_args; 1612 da_mono_load_remote_field mono_load_remote_field; 1613 da_mono_load_remote_field_new mono_load_remote_field_new; 1614 da_mono_store_remote_field mono_store_remote_field; 1615 da_mono_store_remote_field_new mono_store_remote_field_new; 1616 da_mono_unhandled_exception mono_unhandled_exception; 1617 da_mono_print_unhandled_exception mono_print_unhandled_exception; 1618 da_mono_compile_method mono_compile_method; 1619 da_mono_field_set_value mono_field_set_value; 1620 da_mono_field_static_set_value mono_field_static_set_value; 1621 da_mono_field_get_value mono_field_get_value; 1622 da_mono_field_static_get_value mono_field_static_get_value; 1623 da_mono_field_get_value_object mono_field_get_value_object; 1624 da_mono_property_set_value mono_property_set_value; 1625 da_mono_property_get_value mono_property_get_value; 1626 da_mono_gchandle_new mono_gchandle_new; 1627 da_mono_gchandle_new_weakref mono_gchandle_new_weakref; 1628 da_mono_gchandle_get_target mono_gchandle_get_target; 1629 da_mono_gchandle_free mono_gchandle_free; 1630 da_mono_gc_reference_queue_new mono_gc_reference_queue_new; 1631 da_mono_gc_reference_queue_free mono_gc_reference_queue_free; 1632 da_mono_gc_reference_queue_add mono_gc_reference_queue_add; 1633 da_mono_gc_wbarrier_set_field mono_gc_wbarrier_set_field; 1634 da_mono_gc_wbarrier_set_arrayref mono_gc_wbarrier_set_arrayref; 1635 da_mono_gc_wbarrier_arrayref_copy mono_gc_wbarrier_arrayref_copy; 1636 da_mono_gc_wbarrier_generic_store mono_gc_wbarrier_generic_store; 1637 da_mono_gc_wbarrier_generic_store_atomic mono_gc_wbarrier_generic_store_atomic; 1638 da_mono_gc_wbarrier_generic_nostore mono_gc_wbarrier_generic_nostore; 1639 da_mono_gc_wbarrier_value_copy mono_gc_wbarrier_value_copy; 1640 da_mono_gc_wbarrier_object_copy mono_gc_wbarrier_object_copy; 1641 // metadata/opcodes.h 1642 da_mono_opcode_name mono_opcode_name; 1643 da_mono_opcode_value mono_opcode_value; 1644 // metadata/profiler.h 1645 da_mono_profiler_install mono_profiler_install; 1646 da_mono_profiler_set_events mono_profiler_set_events; 1647 da_mono_profiler_get_events mono_profiler_get_events; 1648 da_mono_profiler_install_appdomain mono_profiler_install_appdomain; 1649 da_mono_profiler_install_appdomain_name mono_profiler_install_appdomain_name; 1650 da_mono_profiler_install_context mono_profiler_install_context; 1651 da_mono_profiler_install_assembly mono_profiler_install_assembly; 1652 da_mono_profiler_install_module mono_profiler_install_module; 1653 da_mono_profiler_install_class mono_profiler_install_class; 1654 da_mono_profiler_install_jit_compile mono_profiler_install_jit_compile; 1655 da_mono_profiler_install_jit_end mono_profiler_install_jit_end; 1656 da_mono_profiler_install_method_free mono_profiler_install_method_free; 1657 da_mono_profiler_install_method_invoke mono_profiler_install_method_invoke; 1658 da_mono_profiler_install_enter_leave mono_profiler_install_enter_leave; 1659 da_mono_profiler_install_thread mono_profiler_install_thread; 1660 da_mono_profiler_install_thread_name mono_profiler_install_thread_name; 1661 da_mono_profiler_install_transition mono_profiler_install_transition; 1662 da_mono_profiler_install_allocation mono_profiler_install_allocation; 1663 da_mono_profiler_install_monitor mono_profiler_install_monitor; 1664 da_mono_profiler_install_statistical mono_profiler_install_statistical; 1665 da_mono_profiler_install_statistical_call_chain mono_profiler_install_statistical_call_chain; 1666 da_mono_profiler_install_exception mono_profiler_install_exception; 1667 da_mono_profiler_install_coverage_filter mono_profiler_install_coverage_filter; 1668 da_mono_profiler_coverage_get mono_profiler_coverage_get; 1669 da_mono_profiler_install_gc mono_profiler_install_gc; 1670 da_mono_profiler_install_gc_moves mono_profiler_install_gc_moves; 1671 da_mono_profiler_install_gc_roots mono_profiler_install_gc_roots; 1672 da_mono_profiler_install_gc_finalize mono_profiler_install_gc_finalize; 1673 da_mono_profiler_install_runtime_initialized mono_profiler_install_runtime_initialized; 1674 da_mono_profiler_install_code_chunk_new mono_profiler_install_code_chunk_new; 1675 da_mono_profiler_install_code_chunk_destroy mono_profiler_install_code_chunk_destroy; 1676 da_mono_profiler_install_code_buffer_new mono_profiler_install_code_buffer_new; 1677 da_mono_profiler_install_iomap mono_profiler_install_iomap; 1678 da_mono_profiler_load mono_profiler_load; 1679 da_mono_profiler_set_statistical_mode mono_profiler_set_statistical_mode; 1680 // metadata/reflection.h 1681 da_mono_reflection_parse_type mono_reflection_parse_type; 1682 da_mono_reflection_get_type mono_reflection_get_type; 1683 da_mono_reflection_free_type_info mono_reflection_free_type_info; 1684 da_mono_reflection_type_from_name mono_reflection_type_from_name; 1685 da_mono_reflection_get_token mono_reflection_get_token; 1686 da_mono_assembly_get_object mono_assembly_get_object; 1687 da_mono_module_get_object mono_module_get_object; 1688 da_mono_module_file_get_object mono_module_file_get_object; 1689 da_mono_type_get_object mono_type_get_object; 1690 da_mono_method_get_object mono_method_get_object; 1691 da_mono_field_get_object mono_field_get_object; 1692 da_mono_property_get_object mono_property_get_object; 1693 da_mono_event_get_object mono_event_get_object; 1694 da_mono_param_get_objects mono_param_get_objects; 1695 da_mono_method_body_get_object mono_method_body_get_object; 1696 da_mono_get_dbnull_object mono_get_dbnull_object; 1697 da_mono_reflection_get_custom_attrs_by_type mono_reflection_get_custom_attrs_by_type; 1698 da_mono_reflection_get_custom_attrs mono_reflection_get_custom_attrs; 1699 da_mono_reflection_get_custom_attrs_data mono_reflection_get_custom_attrs_data; 1700 da_mono_reflection_get_custom_attrs_blob mono_reflection_get_custom_attrs_blob; 1701 da_mono_reflection_get_custom_attrs_info mono_reflection_get_custom_attrs_info; 1702 da_mono_custom_attrs_construct mono_custom_attrs_construct; 1703 da_mono_custom_attrs_from_index mono_custom_attrs_from_index; 1704 da_mono_custom_attrs_from_method mono_custom_attrs_from_method; 1705 da_mono_custom_attrs_from_class mono_custom_attrs_from_class; 1706 da_mono_custom_attrs_from_assembly mono_custom_attrs_from_assembly; 1707 da_mono_custom_attrs_from_property mono_custom_attrs_from_property; 1708 da_mono_custom_attrs_from_event mono_custom_attrs_from_event; 1709 da_mono_custom_attrs_from_field mono_custom_attrs_from_field; 1710 da_mono_custom_attrs_from_param mono_custom_attrs_from_param; 1711 da_mono_custom_attrs_has_attr mono_custom_attrs_has_attr; 1712 da_mono_custom_attrs_get_attr mono_custom_attrs_get_attr; 1713 da_mono_custom_attrs_free mono_custom_attrs_free; 1714 da_mono_declsec_flags_from_method mono_declsec_flags_from_method; 1715 da_mono_declsec_flags_from_class mono_declsec_flags_from_class; 1716 da_mono_declsec_flags_from_assembly mono_declsec_flags_from_assembly; 1717 da_mono_declsec_get_demands mono_declsec_get_demands; 1718 da_mono_declsec_get_linkdemands mono_declsec_get_linkdemands; 1719 da_mono_declsec_get_inheritdemands_class mono_declsec_get_inheritdemands_class; 1720 da_mono_declsec_get_inheritdemands_method mono_declsec_get_inheritdemands_method; 1721 da_mono_declsec_get_method_action mono_declsec_get_method_action; 1722 da_mono_declsec_get_class_action mono_declsec_get_class_action; 1723 da_mono_declsec_get_assembly_action mono_declsec_get_assembly_action; 1724 da_mono_reflection_type_get_type mono_reflection_type_get_type; 1725 da_mono_reflection_assembly_get_assembly mono_reflection_assembly_get_assembly; 1726 // metadata/row-indexes.h 1727 // metadata/sgen-bridge.h 1728 da_mono_gc_register_bridge_callbacks mono_gc_register_bridge_callbacks; 1729 da_mono_gc_wait_for_bridge_processing mono_gc_wait_for_bridge_processing; 1730 // metadata/threads.h 1731 da_mono_thread_init mono_thread_init; 1732 da_mono_thread_cleanup mono_thread_cleanup; 1733 da_mono_thread_manage mono_thread_manage; 1734 da_mono_thread_current mono_thread_current; 1735 da_mono_thread_set_main mono_thread_set_main; 1736 da_mono_thread_get_main mono_thread_get_main; 1737 da_mono_thread_stop mono_thread_stop; 1738 da_mono_thread_new_init mono_thread_new_init; 1739 da_mono_thread_create mono_thread_create; 1740 da_mono_thread_attach mono_thread_attach; 1741 da_mono_thread_detach mono_thread_detach; 1742 da_mono_thread_exit mono_thread_exit; 1743 da_mono_thread_get_name_utf8 mono_thread_get_name_utf8; 1744 da_mono_thread_get_managed_id mono_thread_get_managed_id; 1745 da_mono_thread_set_manage_callback mono_thread_set_manage_callback; 1746 da_mono_threads_set_default_stacksize mono_threads_set_default_stacksize; 1747 da_mono_threads_get_default_stacksize mono_threads_get_default_stacksize; 1748 da_mono_threads_request_thread_dump mono_threads_request_thread_dump; 1749 da_mono_thread_is_foreign mono_thread_is_foreign; 1750 da_mono_thread_detach_if_exiting mono_thread_detach_if_exiting; 1751 // metadata/tokentype.h 1752 // metadata/verify.h 1753 da_mono_method_verify mono_method_verify; 1754 da_mono_free_verify_list mono_free_verify_list; 1755 da_mono_verify_corlib mono_verify_corlib; 1756 // jit/jit.h 1757 da_mono_jit_init mono_jit_init; 1758 da_mono_jit_init_version mono_jit_init_version; 1759 da_mono_jit_exec mono_jit_exec; 1760 da_mono_jit_cleanup mono_jit_cleanup; 1761 da_mono_jit_set_trace_options mono_jit_set_trace_options; 1762 da_mono_set_signal_chaining mono_set_signal_chaining; 1763 da_mono_set_crash_chaining mono_set_crash_chaining; 1764 da_mono_jit_set_aot_only mono_jit_set_aot_only; 1765 da_mono_jit_set_aot_mode mono_jit_set_aot_mode; 1766 da_mono_set_break_policy mono_set_break_policy; 1767 da_mono_jit_parse_options mono_jit_parse_options; 1768 da_mono_get_runtime_build_info mono_get_runtime_build_info; 1769 da_mono_get_jit_info_from_method mono_get_jit_info_from_method; 1770 da_mono_aot_get_method mono_aot_get_method; 1771 }