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.stafunctions; 26 version(DerelictMono_Static): 27 28 // Regex replace from dynfunctions: 29 // alias da_([a-zA-Z_]+) = (((?! function).)+ )function(([^;]|\s|\n)+;) 30 // $2$1$4 31 32 private 33 { 34 import core.stdc.config; 35 import core.stdc.stdint; 36 import core.stdc.stdio; 37 import derelict.mono.types; 38 } 39 40 extern (C) @nogc nothrow 41 { 42 // utils/mono-publib.h 43 void mono_free(void*); 44 mono_bool mono_set_allocator_vtable(MonoAllocatorVTable*); 45 // utils/mono-logger.h 46 void mono_trace_set_level_string(const(char)* value); 47 void mono_trace_set_mask_string(const(char)* value); 48 void mono_trace_set_log_handler(MonoLogCallback callback, void* user_data); 49 void mono_trace_set_print_handler(MonoPrintCallback callback); 50 void mono_trace_set_printerr_handler(MonoPrintCallback callback); 51 // utils/mono-error.h 52 void mono_error_init(MonoError*); 53 void mono_error_init_flags(MonoError*, ushort); 54 void mono_error_cleanup(MonoError*); 55 mono_bool mono_error_ok(MonoError*); 56 ushort mono_error_get_error_code(MonoError*); 57 const(char)* mono_error_get_message(MonoError*); 58 // utils/mono-dl-fallback.h 59 MonoDlFallbackHandler* mono_dl_fallback_register(MonoDlFallbackLoad load_func, 60 MonoDlFallbackSymbol symbol_func, MonoDlFallbackClose close_func, void* user_data); 61 void mono_dl_fallback_unregister(MonoDlFallbackHandler* handler); 62 // utils/mono-counters.h 63 void mono_counters_enable(int section_mask); 64 void mono_counters_init(); 65 void mono_counters_register(const(char)* descr, int type, void* addr); 66 void mono_counters_register_with_size(const(char)* name, 67 int type, void* addr, int size); 68 void mono_counters_on_register(MonoCounterRegisterCallback callback); 69 void mono_counters_dump(int section_mask, FILE* outfile); 70 void mono_counters_cleanup(); 71 void mono_counters_foreach(CountersEnumCallback cb, void* user_data); 72 int mono_counters_sample(MonoCounter* counter, void* buffer, int buffer_size); 73 const(char)* mono_counter_get_name(MonoCounter* name); 74 int mono_counter_get_type(MonoCounter* counter); 75 int mono_counter_get_section(MonoCounter* counter); 76 int mono_counter_get_unit(MonoCounter* counter); 77 int mono_counter_get_variance(MonoCounter* counter); 78 size_t mono_counter_get_size(MonoCounter* counter); 79 int mono_runtime_resource_limit(int resource_type, 80 uintptr_t soft_limit, uintptr_t hard_limit); 81 void mono_runtime_resource_set_callback(MonoResourceCallback callback); 82 void mono_runtime_resource_check_limit(int resource_type, uintptr_t value); 83 // metadata/appdomain.h 84 MonoDomain* mono_init(const(char)* filename); 85 MonoDomain* mono_init_from_assembly(const(char)* domain_name, 86 const(char)* filename); 87 MonoDomain* mono_init_version(const(char)* domain_name, 88 const(char)* version_); 89 MonoDomain* mono_get_root_domain(); 90 void mono_runtime_init(MonoDomain* domain, 91 MonoThreadStartCB start_cb, MonoThreadAttachCB attach_cb); 92 void mono_runtime_cleanup(MonoDomain* domain); 93 void mono_install_runtime_cleanup(MonoDomainFunc func); 94 void mono_runtime_quit(); 95 void mono_runtime_set_shutting_down(); 96 mono_bool mono_runtime_is_shutting_down(); 97 const(char)* mono_check_corlib_version(); 98 MonoDomain* mono_domain_create(); 99 MonoDomain* mono_domain_create_appdomain(char* friendly_name, 100 char* configuration_file); 101 void mono_domain_set_config(MonoDomain* domain, 102 const(char)* base_dir, const(char)* config_file_name); 103 MonoDomain* mono_domain_get(); 104 MonoDomain* mono_domain_get_by_id(int domainid); 105 int mono_domain_get_id(MonoDomain* domain); 106 const(char)* mono_domain_get_friendly_name(MonoDomain* domain); 107 mono_bool mono_domain_set(MonoDomain* domain, mono_bool force); 108 void mono_domain_set_internal(MonoDomain* domain); 109 void mono_domain_unload(MonoDomain* domain); 110 void mono_domain_try_unload(MonoDomain* domain, MonoObject** exc); 111 mono_bool mono_domain_is_unloading(MonoDomain* domain); 112 MonoDomain* mono_domain_from_appdomain(MonoAppDomain* appdomain); 113 void mono_domain_foreach(MonoDomainFunc func, void* user_data); 114 MonoAssembly* mono_domain_assembly_open(MonoDomain* domain, 115 const(char)* name); 116 mono_bool mono_domain_finalize(MonoDomain* domain, uint timeout); 117 void mono_domain_free(MonoDomain* domain, mono_bool force); 118 mono_bool mono_domain_has_type_resolve(MonoDomain* domain); 119 MonoReflectionAssembly* mono_domain_try_type_resolve( 120 MonoDomain* domain, char* name, MonoObject* tb); 121 mono_bool mono_domain_owns_vtable_slot(MonoDomain* domain, 122 void* vtable_slot); 123 void mono_context_init(MonoDomain* domain); 124 void mono_context_set(MonoAppContext* new_context); 125 MonoAppContext* mono_context_get(); 126 int mono_context_get_id(MonoAppContext* context); 127 int mono_context_get_domain_id(MonoAppContext* context); 128 MonoJitInfo* mono_jit_info_table_find(MonoDomain* domain, char* addr); 129 void* mono_jit_info_get_code_start(MonoJitInfo* ji); 130 int mono_jit_info_get_code_size(MonoJitInfo* ji); 131 MonoMethod* mono_jit_info_get_method(MonoJitInfo* ji); 132 MonoImage* mono_get_corlib(); 133 MonoClass* mono_get_object_class(); 134 MonoClass* mono_get_byte_class(); 135 MonoClass* mono_get_void_class(); 136 MonoClass* mono_get_boolean_class(); 137 MonoClass* mono_get_sbyte_class(); 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 MonoClass* mono_get_intptr_class(); 143 MonoClass* mono_get_uintptr_class(); 144 alias da_mono_get_int64_class = MonoClass* function(); 145 alias da_mono_get_uint64_class = MonoClass* function(); 146 MonoClass* mono_get_single_class(); 147 MonoClass* mono_get_double_class(); 148 MonoClass* mono_get_char_class(); 149 MonoClass* mono_get_string_class(); 150 MonoClass* mono_get_enum_class(); 151 MonoClass* mono_get_array_class(); 152 MonoClass* mono_get_thread_class(); 153 MonoClass* mono_get_exception_class(); 154 void mono_security_enable_core_clr(); 155 void mono_security_set_core_clr_platform_callback( 156 MonoCoreClrPlatformCB callback); 157 // metadata/assembly.h 158 void mono_assemblies_init(); 159 void mono_assemblies_cleanup(); 160 MonoAssembly* mono_assembly_open(const(char)* filename, 161 MonoImageOpenStatus* status); 162 MonoAssembly* mono_assembly_open_full(const(char)* filename, 163 MonoImageOpenStatus* status, mono_bool refonly); 164 MonoAssembly* mono_assembly_load(MonoAssemblyName* aname, 165 const(char)* basedir, MonoImageOpenStatus* status); 166 MonoAssembly* mono_assembly_load_full(MonoAssemblyName* aname, 167 const(char)* basedir, MonoImageOpenStatus* status, mono_bool refonly); 168 MonoAssembly* mono_assembly_load_from(MonoImage* image, 169 const(char)* fname, MonoImageOpenStatus* status); 170 MonoAssembly* mono_assembly_load_from_full(MonoImage* image, 171 const(char)* fname, MonoImageOpenStatus* status, mono_bool refonly); 172 MonoAssembly* mono_assembly_load_with_partial_name( 173 const(char)* name, MonoImageOpenStatus* status); 174 MonoAssembly* mono_assembly_loaded(MonoAssemblyName* aname); 175 MonoAssembly* mono_assembly_loaded_full(MonoAssemblyName* aname, 176 mono_bool refonly); 177 void mono_assembly_get_assemblyref(MonoImage* image, 178 int index, MonoAssemblyName* aname); 179 void mono_assembly_load_reference(MonoImage* image, int index); 180 void mono_assembly_load_references(MonoImage* image, 181 MonoImageOpenStatus* status); 182 MonoImage* mono_assembly_load_module(MonoAssembly* assembly, uint idx); 183 void mono_assembly_close(MonoAssembly* assembly); 184 void mono_assembly_setrootdir(const(char)* root_dir); 185 const(char)* mono_assembly_getrootdir(); 186 char* mono_native_getrootdir(); 187 void mono_assembly_foreach(MonoFunc func, void* user_data); 188 void mono_assembly_set_main(MonoAssembly* assembly); 189 MonoAssembly* mono_assembly_get_main(); 190 MonoImage* mono_assembly_get_image(MonoAssembly* assembly); 191 MonoAssemblyName* mono_assembly_get_name(MonoAssembly* assembly); 192 mono_bool mono_assembly_fill_assembly_name(MonoImage* image, 193 MonoAssemblyName* aname); 194 mono_bool mono_assembly_names_equal(MonoAssemblyName* l, 195 MonoAssemblyName* r); 196 char* mono_stringify_assembly_name(MonoAssemblyName* aname); 197 void mono_install_assembly_load_hook(MonoAssemblyLoadFunc func, 198 void* user_data); 199 void mono_install_assembly_search_hook( 200 MonoAssemblySearchFunc func, void* user_data); 201 void mono_install_assembly_refonly_search_hook( 202 MonoAssemblySearchFunc func, void* user_data); 203 MonoAssembly* mono_assembly_invoke_search_hook(MonoAssemblyName* aname); 204 void mono_install_assembly_postload_search_hook( 205 MonoAssemblySearchFunc func, void* user_data); 206 void mono_install_assembly_postload_refonly_search_hook( 207 MonoAssemblySearchFunc func, void* user_data); 208 void mono_install_assembly_preload_hook( 209 MonoAssemblyPreLoadFunc func, void* user_data); 210 void mono_install_assembly_refonly_preload_hook( 211 MonoAssemblyPreLoadFunc func, void* user_data); 212 void mono_assembly_invoke_load_hook(MonoAssembly* ass); 213 MonoAssemblyName* mono_assembly_name_new(const(char)* name); 214 const(char)* mono_assembly_name_get_name(MonoAssemblyName* aname); 215 const(char)* mono_assembly_name_get_culture(MonoAssemblyName* aname); 216 ushort mono_assembly_name_get_version(MonoAssemblyName* aname, 217 ushort* minor, ushort* build, ushort* revision); 218 mono_byte* mono_assembly_name_get_pubkeytoken(MonoAssemblyName* aname); 219 void mono_assembly_name_free(MonoAssemblyName* aname); 220 void mono_register_bundled_assemblies( 221 const(MonoBundledAssembly*)* assemblies); 222 void mono_register_config_for_assembly( 223 const(char)* assembly_name, const(char)* config_xml); 224 void mono_register_symfile_for_assembly( 225 const(char)* assembly_name, const(mono_byte)* raw_contents, int size); 226 void mono_register_machine_config(const(char)* config_xml); 227 void mono_set_rootdir(); 228 void mono_set_dirs(const(char)* assembly_dir, const(char)* config_dir); 229 void mono_set_assemblies_path(const(char)* path); 230 // metadata/attrdefs.h 231 // metadata/blob.h 232 // metadata/class.h 233 MonoClass* mono_class_get(MonoImage* image, uint type_token); 234 MonoClass* mono_class_get_full(MonoImage* image, 235 uint type_token, MonoGenericContext* context); 236 mono_bool mono_class_init(MonoClass* klass); 237 MonoVTable* mono_class_vtable(MonoDomain* domain, MonoClass* klass); 238 MonoClass* mono_class_from_name(MonoImage* image, 239 const(char)* name_space, const(char)* name); 240 MonoClass* mono_class_from_name_case(MonoImage* image, 241 const(char)* name_space, const(char)* name); 242 MonoMethod* mono_class_get_method_from_name_flags( 243 MonoClass* klass, const(char)* name, int param_count, int flags); 244 MonoClass* mono_class_from_typeref(MonoImage* image, uint type_token); 245 MonoClass* mono_class_from_typeref_checked(MonoImage* image, 246 uint type_token, MonoError* error); 247 MonoClass* mono_class_from_generic_parameter( 248 MonoGenericParam* param, MonoImage* image, mono_bool is_mvar); 249 MonoType* mono_class_inflate_generic_type(MonoType* type, 250 MonoGenericContext* context); 251 MonoMethod* mono_class_inflate_generic_method( 252 MonoMethod* method, MonoGenericContext* context); 253 MonoMethod* mono_get_inflated_method(MonoMethod* method); 254 MonoClassField* mono_field_from_token(MonoImage* image, 255 uint token, MonoClass** retklass, MonoGenericContext* context); 256 MonoClass* mono_bounded_array_class_get( 257 MonoClass* element_class, uint rank, mono_bool bounded); 258 MonoClass* mono_array_class_get(MonoClass* element_class, uint rank); 259 MonoClass* mono_ptr_class_get(MonoType* type); 260 MonoClassField* mono_class_get_field(MonoClass* klass, uint field_token); 261 MonoClassField* mono_class_get_field_from_name(MonoClass* klass, 262 const(char)* name); 263 uint mono_class_get_field_token(MonoClassField* field); 264 uint mono_class_get_event_token(MonoEvent* event); 265 MonoProperty* mono_class_get_property_from_name( 266 MonoClass* klass, const(char)* name); 267 uint mono_class_get_property_token(MonoProperty* prop); 268 int mono_array_element_size(MonoClass* ac); 269 int mono_class_instance_size(MonoClass* klass); 270 int mono_class_array_element_size(MonoClass* klass); 271 int mono_class_data_size(MonoClass* klass); 272 int mono_class_value_size(MonoClass* klass, uint* align_); 273 int mono_class_min_align(MonoClass* klass); 274 MonoClass* mono_class_from_mono_type(MonoType* type); 275 mono_bool mono_class_is_subclass_of(MonoClass* klass, 276 MonoClass* klassc, mono_bool check_interfaces); 277 mono_bool mono_class_is_assignable_from(MonoClass* klass, MonoClass* oklass); 278 void* mono_ldtoken(MonoImage* image, uint token, 279 MonoClass** retclass, MonoGenericContext* context); 280 char* mono_type_get_name(MonoType* type); 281 MonoType* mono_type_get_underlying_type(MonoType* type); 282 MonoImage* mono_class_get_image(MonoClass* klass); 283 MonoClass* mono_class_get_element_class(MonoClass* klass); 284 mono_bool mono_class_is_valuetype(MonoClass* klass); 285 mono_bool mono_class_is_enum(MonoClass* klass); 286 MonoType* mono_class_enum_basetype(MonoClass* klass); 287 MonoClass* mono_class_get_parent(MonoClass* klass); 288 MonoClass* mono_class_get_nesting_type(MonoClass* klass); 289 int mono_class_get_rank(MonoClass* klass); 290 uint mono_class_get_flags(MonoClass* klass); 291 const(char)* mono_class_get_name(MonoClass* klass); 292 const(char)* mono_class_get_namespace(MonoClass* klass); 293 MonoType* mono_class_get_type(MonoClass* klass); 294 uint mono_class_get_type_token(MonoClass* klass); 295 MonoType* mono_class_get_byref_type(MonoClass* klass); 296 int mono_class_num_fields(MonoClass* klass); 297 int mono_class_num_methods(MonoClass* klass); 298 int mono_class_num_properties(MonoClass* klass); 299 int mono_class_num_events(MonoClass* klass); 300 MonoClassField* mono_class_get_fields(MonoClass* klass, void** iter); 301 MonoMethod* mono_class_get_methods(MonoClass* klass, void** iter); 302 MonoProperty* mono_class_get_properties(MonoClass* klass, void** iter); 303 MonoEvent* mono_class_get_events(MonoClass* klass, void** iter); 304 MonoClass* mono_class_get_interfaces(MonoClass* klass, void** iter); 305 MonoClass* mono_class_get_nested_types(MonoClass* klass, void** iter); 306 mono_bool mono_class_is_delegate(MonoClass* klass); 307 mono_bool mono_class_implements_interface(MonoClass* klass, 308 MonoClass* iface); 309 const(char)* mono_field_get_name(MonoClassField* field); 310 MonoType* mono_field_get_type(MonoClassField* field); 311 MonoClass* mono_field_get_parent(MonoClassField* field); 312 uint mono_field_get_flags(MonoClassField* field); 313 uint mono_field_get_offset(MonoClassField* field); 314 const(char)* mono_field_get_data(MonoClassField* field); 315 const(char)* mono_property_get_name(MonoProperty* prop); 316 MonoMethod* mono_property_get_set_method(MonoProperty* prop); 317 MonoMethod* mono_property_get_get_method(MonoProperty* prop); 318 MonoClass* mono_property_get_parent(MonoProperty* prop); 319 uint mono_property_get_flags(MonoProperty* prop); 320 const(char)* mono_event_get_name(MonoEvent* event); 321 MonoMethod* mono_event_get_add_method(MonoEvent* event); 322 MonoMethod* mono_event_get_remove_method(MonoEvent* event); 323 MonoMethod* mono_event_get_raise_method(MonoEvent* event); 324 MonoClass* mono_event_get_parent(MonoEvent* event); 325 uint mono_event_get_flags(MonoEvent* event); 326 MonoMethod* mono_class_get_method_from_name(MonoClass* klass, 327 const(char)* name, int param_count); 328 char* mono_class_name_from_token(MonoImage* image, uint type_token); 329 mono_bool mono_method_can_access_field(MonoMethod* method, 330 MonoClassField* field); 331 mono_bool mono_method_can_access_method(MonoMethod* method, 332 MonoMethod* called); 333 // metadata/debug-helpers.h 334 char* mono_disasm_code_one(MonoDisHelper* dh, 335 MonoMethod* method, const(mono_byte)* ip, const(mono_byte*)* endp); 336 char* mono_disasm_code(MonoDisHelper* dh, 337 MonoMethod* method, const(mono_byte)* ip, const(mono_byte)* end); 338 char* mono_type_full_name(MonoType* type); 339 char* mono_signature_get_desc(MonoMethodSignature* sig, 340 mono_bool include_namespace); 341 char* mono_context_get_desc(MonoGenericContext* context); 342 MonoMethodDesc* mono_method_desc_new(const(char)* name, 343 mono_bool include_namespace); 344 MonoMethodDesc* mono_method_desc_from_method(MonoMethod* method); 345 void mono_method_desc_free(MonoMethodDesc* desc); 346 mono_bool mono_method_desc_match(MonoMethodDesc* desc, MonoMethod* method); 347 mono_bool mono_method_desc_full_match(MonoMethodDesc* desc, 348 MonoMethod* method); 349 MonoMethod* mono_method_desc_search_in_class( 350 MonoMethodDesc* desc, MonoClass* klass); 351 MonoMethod* mono_method_desc_search_in_image( 352 MonoMethodDesc* desc, MonoImage* image); 353 char* mono_method_full_name(MonoMethod* method, mono_bool signature); 354 char* mono_field_full_name(MonoClassField* field); 355 // metadata/debug-mono-symfile.h 356 MonoSymbolFile* mono_debug_open_mono_symbols(MonoDebugHandle* handle, 357 const(ubyte)* raw_contents, int size, mono_bool in_the_debugger); 358 void mono_debug_close_mono_symbol_file(MonoSymbolFile* symfile); 359 mono_bool mono_debug_symfile_is_loaded(MonoSymbolFile* symfile); 360 MonoDebugSourceLocation* mono_debug_symfile_lookup_location( 361 MonoDebugMethodInfo* minfo, uint offset); 362 void mono_debug_symfile_free_location(MonoDebugSourceLocation* location); 363 MonoDebugMethodInfo* mono_debug_symfile_lookup_method( 364 MonoDebugHandle* handle, MonoMethod* method); 365 MonoDebugLocalsInfo* mono_debug_symfile_lookup_locals( 366 MonoDebugMethodInfo* minfo); 367 int mono_debug_image_has_debug_info(MonoImage* image); 368 // metadata/environment.h 369 int mono_environment_exitcode_get(); 370 void mono_environment_exitcode_set(int value); 371 // metadata/exception.h 372 MonoException* mono_exception_from_name(MonoImage* image, 373 const(char)* name_space, const(char)* name); 374 MonoException* mono_exception_from_token(MonoImage* image, uint token); 375 MonoException* mono_exception_from_name_two_strings(MonoImage* image, 376 const(char)* name_space, const(char)* name, MonoString* a1, MonoString* a2); 377 MonoException* mono_exception_from_name_msg(MonoImage* image, 378 const(char)* name_space, const(char)* name, const(char)* msg); 379 MonoException* mono_exception_from_token_two_strings( 380 MonoImage* image, uint token, MonoString* a1, MonoString* a2); 381 MonoException* mono_exception_from_name_domain(MonoDomain* domain, 382 MonoImage* image, const(char)* name_space, const(char)* name); 383 MonoException* mono_get_exception_divide_by_zero(); 384 MonoException* mono_get_exception_security(); 385 MonoException* mono_get_exception_arithmetic(); 386 MonoException* mono_get_exception_overflow(); 387 MonoException* mono_get_exception_null_reference(); 388 MonoException* mono_get_exception_execution_engine(const(char)* msg); 389 MonoException* mono_get_exception_thread_abort(); 390 MonoException* mono_get_exception_thread_state(const(char)* msg); 391 MonoException* mono_get_exception_thread_interrupted(); 392 MonoException* mono_get_exception_serialization(const(char)* msg); 393 MonoException* mono_get_exception_invalid_cast(); 394 MonoException* mono_get_exception_invalid_operation(const(char)* msg); 395 MonoException* mono_get_exception_index_out_of_range(); 396 MonoException* mono_get_exception_array_type_mismatch(); 397 MonoException* mono_get_exception_type_load( 398 MonoString* class_name, char* assembly_name); 399 MonoException* mono_get_exception_missing_method( 400 const(char)* class_name, const(char)* member_name); 401 MonoException* mono_get_exception_missing_field( 402 const(char)* class_name, const(char)* member_name); 403 MonoException* mono_get_exception_not_implemented(const(char)* msg); 404 MonoException* mono_get_exception_not_supported(const(char)* msg); 405 MonoException* mono_get_exception_argument_null(const(char)* arg); 406 MonoException* mono_get_exception_argument(const(char)* arg, 407 const(char)* msg); 408 MonoException* mono_get_exception_argument_out_of_range(const(char)* arg); 409 MonoException* mono_get_exception_io(const(char)* msg); 410 MonoException* mono_get_exception_file_not_found(MonoString* fname); 411 alias da_mono_get_exception_file_not_found2 = MonoException* function( 412 const(char)* msg, MonoString* fname); 413 MonoException* mono_get_exception_type_initialization( 414 const(char)* type_name, MonoException* inner); 415 MonoException* mono_get_exception_synchronization_lock(const(char)* msg); 416 MonoException* mono_get_exception_cannot_unload_appdomain(const(char)* msg); 417 MonoException* mono_get_exception_appdomain_unloaded(); 418 MonoException* mono_get_exception_bad_image_format(const(char)* msg); 419 alias da_mono_get_exception_bad_image_format2 = MonoException* function( 420 const(char)* msg, MonoString* fname); 421 MonoException* mono_get_exception_stack_overflow(); 422 MonoException* mono_get_exception_out_of_memory(); 423 MonoException* mono_get_exception_field_access(); 424 MonoException* mono_get_exception_method_access(); 425 MonoException* mono_get_exception_reflection_type_load( 426 MonoArray* types, MonoArray* exceptions); 427 MonoException* mono_get_exception_runtime_wrapped( 428 MonoObject* wrapped_exception); 429 void mono_install_unhandled_exception_hook( 430 MonoUnhandledExceptionFunc func, void* user_data); 431 void mono_invoke_unhandled_exception_hook(MonoObject* exc); 432 // metadata/image.h 433 void mono_images_init(); 434 void mono_images_cleanup(); 435 MonoImage* mono_image_open(const(char)* fname, MonoImageOpenStatus* status); 436 MonoImage* mono_image_open_full(const(char)* fname, 437 MonoImageOpenStatus* status, mono_bool refonly); 438 MonoImage* mono_pe_file_open(const(char)* fname, 439 MonoImageOpenStatus* status); 440 MonoImage* mono_image_open_from_data(char* data, 441 uint data_len, mono_bool need_copy, MonoImageOpenStatus* status); 442 MonoImage* mono_image_open_from_data_full(char* data, 443 uint data_len, mono_bool need_copy, MonoImageOpenStatus* status, mono_bool refonly); 444 MonoImage* mono_image_open_from_data_with_name(char* data, uint data_len, 445 mono_bool need_copy, MonoImageOpenStatus* status, mono_bool refonly, const(char)* name); 446 void mono_image_fixup_vtable(MonoImage* image); 447 MonoImage* mono_image_loaded(const(char)* name); 448 MonoImage* mono_image_loaded_full(const(char)* name, mono_bool refonly); 449 MonoImage* mono_image_loaded_by_guid(const(char)* guid); 450 MonoImage* mono_image_loaded_by_guid_full(const(char)* guid, 451 mono_bool refonly); 452 void mono_image_init(MonoImage* image); 453 void mono_image_close(MonoImage* image); 454 void mono_image_addref(MonoImage* image); 455 const(char)* mono_image_strerror(MonoImageOpenStatus status); 456 int mono_image_ensure_section(MonoImage* image, const(char)* section); 457 int mono_image_ensure_section_idx(MonoImage* image, int section); 458 uint mono_image_get_entry_point(MonoImage* image); 459 const(char)* mono_image_get_resource(MonoImage* image, 460 uint offset, uint* size); 461 MonoImage* mono_image_load_file_for_image(MonoImage* image, int fileidx); 462 MonoImage* mono_image_load_module(MonoImage* image, int idx); 463 const(char)* mono_image_get_name(MonoImage* image); 464 const(char)* mono_image_get_filename(MonoImage* image); 465 const(char)* mono_image_get_guid(MonoImage* image); 466 MonoAssembly* mono_image_get_assembly(MonoImage* image); 467 mono_bool mono_image_is_dynamic(MonoImage* image); 468 char* mono_image_rva_map(MonoImage* image, uint rva); 469 const(MonoTableInfo)* mono_image_get_table_info( 470 MonoImage* image, int table_id); 471 int mono_image_get_table_rows(MonoImage* image, int table_id); 472 int mono_table_info_get_rows(const(MonoTableInfo)* table); 473 void* mono_image_lookup_resource(MonoImage* image, 474 uint res_id, uint lang_id, mono_unichar2* name); 475 const(char)* mono_image_get_public_key(MonoImage* image, uint* size); 476 const(char)* mono_image_get_strong_name(MonoImage* image, uint* size); 477 uint mono_image_strong_name_position(MonoImage* image, uint* size); 478 void mono_image_add_to_name_cache(MonoImage* image, 479 const(char)* nspace, const(char)* name, uint idx); 480 mono_bool mono_image_has_authenticode_entry(MonoImage* image); 481 // metadata/loader.h 482 MonoMethod* mono_get_method(MonoImage* image, uint token, MonoClass* klass); 483 MonoMethod* mono_get_method_full(MonoImage* image, 484 uint token, MonoClass* klass, MonoGenericContext* context); 485 MonoMethod* mono_get_method_constrained(MonoImage* image, uint token, 486 MonoClass* constrained_class, MonoGenericContext* context, MonoMethod** cil_method); 487 void mono_free_method(MonoMethod* method); 488 MonoMethodSignature* mono_method_get_signature_full( 489 MonoMethod* method, MonoImage* image, uint token, MonoGenericContext* context); 490 MonoMethodSignature* mono_method_get_signature( 491 MonoMethod* method, MonoImage* image, uint token); 492 MonoMethodSignature* mono_method_signature(MonoMethod* method); 493 MonoMethodHeader* mono_method_get_header(MonoMethod* method); 494 const(char)* mono_method_get_name(MonoMethod* method); 495 MonoClass* mono_method_get_class(MonoMethod* method); 496 uint mono_method_get_token(MonoMethod* method); 497 uint mono_method_get_flags(MonoMethod* method, uint* iflags); 498 uint mono_method_get_index(MonoMethod* method); 499 MonoImage* mono_load_image(const(char)* fname, MonoImageOpenStatus* status); 500 void mono_add_internal_call(const(char)* name, const(void)* method); 501 void* mono_lookup_internal_call(MonoMethod* method); 502 void* mono_lookup_internal_call_full(MonoMethod* method, 503 mono_bool* uses_handles); 504 const(char)* mono_lookup_icall_symbol(MonoMethod* m); 505 void mono_dllmap_insert(MonoImage* assembly, 506 const(char)* dll, const(char)* func, const(char)* tdll, const(char)* tfunc); 507 void* mono_lookup_pinvoke_call(MonoMethod* method, 508 const(char*)* exc_class, const(char*)* exc_arg); 509 void mono_method_get_param_names(MonoMethod* method, const(char*)* names); 510 uint mono_method_get_param_token(MonoMethod* method, int idx); 511 void mono_method_get_marshal_info(MonoMethod* method, 512 MonoMarshalSpec** mspecs); 513 mono_bool mono_method_has_marshal_info(MonoMethod* method); 514 MonoMethod* mono_method_get_last_managed(); 515 void mono_stack_walk(MonoStackWalk func, void* user_data); 516 void mono_stack_walk_no_il(MonoStackWalk func, void* user_data); 517 void mono_stack_walk_async_safe(MonoStackWalkAsyncSafe func, 518 void* initial_sig_context, void* user_data); 519 MonoMethodHeader* mono_method_get_header_checked( 520 MonoMethod* method, MonoError* error); 521 // metadata/metadata.h 522 void mono_metadata_init(); 523 void mono_metadata_decode_row(const(MonoTableInfo)* t, 524 int idx, uint* res, int res_size); 525 uint mono_metadata_decode_row_col(const(MonoTableInfo)* t, int idx, uint col); 526 int mono_metadata_compute_size(MonoImage* meta, 527 int tableindex, uint* result_bitfield); 528 const(char)* mono_metadata_locate(MonoImage* meta, int table, int idx); 529 const(char)* mono_metadata_locate_token(MonoImage* meta, uint token); 530 const(char)* mono_metadata_string_heap(MonoImage* meta, uint table_index); 531 const(char)* mono_metadata_blob_heap(MonoImage* meta, uint table_index); 532 const(char)* mono_metadata_user_string(MonoImage* meta, uint table_index); 533 const(char)* mono_metadata_guid_heap(MonoImage* meta, uint table_index); 534 uint mono_metadata_typedef_from_field(MonoImage* meta, uint table_index); 535 uint mono_metadata_typedef_from_method(MonoImage* meta, uint table_index); 536 uint mono_metadata_nested_in_typedef(MonoImage* meta, uint table_index); 537 uint mono_metadata_nesting_typedef(MonoImage* meta, 538 uint table_index, uint start_index); 539 MonoClass** mono_metadata_interfaces_from_typedef( 540 MonoImage* meta, uint table_index, uint* count); 541 uint mono_metadata_events_from_typedef(MonoImage* meta, 542 uint table_index, uint* end_idx); 543 uint mono_metadata_methods_from_event(MonoImage* meta, 544 uint table_index, uint* end); 545 uint mono_metadata_properties_from_typedef(MonoImage* meta, 546 uint table_index, uint* end); 547 uint mono_metadata_methods_from_property(MonoImage* meta, 548 uint table_index, uint* end); 549 uint mono_metadata_packing_from_typedef(MonoImage* meta, 550 uint table_index, uint* packing, uint* size); 551 const(char)* mono_metadata_get_marshal_info(MonoImage* meta, 552 uint idx, mono_bool is_field); 553 uint mono_metadata_custom_attrs_from_index(MonoImage* meta, uint cattr_index); 554 MonoMarshalSpec* mono_metadata_parse_marshal_spec( 555 MonoImage* image, const(char)* ptr); 556 void mono_metadata_free_marshal_spec(MonoMarshalSpec* spec); 557 uint mono_metadata_implmap_from_method(MonoImage* meta, uint method_idx); 558 void mono_metadata_field_info(MonoImage* meta, 559 uint table_index, uint* offset, uint* rva, MonoMarshalSpec** marshal_spec); 560 uint mono_metadata_get_constant_index(MonoImage* meta, uint token, uint hint); 561 uint mono_metadata_decode_value(const(char)* ptr, const(char*)* rptr); 562 int mono_metadata_decode_signed_value(const(char)* ptr, const(char*)* rptr); 563 uint mono_metadata_decode_blob_size(const(char)* ptr, const(char*)* rptr); 564 void mono_metadata_encode_value(uint value, char* bug, char** endbuf); 565 mono_bool mono_type_is_byref(MonoType* type); 566 int mono_type_get_type(MonoType* type); 567 MonoMethodSignature* mono_type_get_signature(MonoType* type); 568 MonoClass* mono_type_get_class(MonoType* type); 569 MonoArrayType* mono_type_get_array_type(MonoType* type); 570 MonoType* mono_type_get_ptr_type(MonoType* type); 571 MonoClass* mono_type_get_modifiers(MonoType* type, 572 mono_bool* is_required, void** iter); 573 mono_bool mono_type_is_struct(MonoType* type); 574 mono_bool mono_type_is_void(MonoType* type); 575 mono_bool mono_type_is_pointer(MonoType* type); 576 mono_bool mono_type_is_reference(MonoType* type); 577 mono_bool mono_type_is_generic_parameter(MonoType* type); 578 MonoType* mono_signature_get_return_type(MonoMethodSignature* sig); 579 MonoType* mono_signature_get_params(MonoMethodSignature* sig, void** iter); 580 uint mono_signature_get_param_count(MonoMethodSignature* sig); 581 uint mono_signature_get_call_conv(MonoMethodSignature* sig); 582 int mono_signature_vararg_start(MonoMethodSignature* sig); 583 mono_bool mono_signature_is_instance(MonoMethodSignature* sig); 584 mono_bool mono_signature_explicit_this(MonoMethodSignature* sig); 585 mono_bool mono_signature_param_is_out(MonoMethodSignature* sig, 586 int param_num); 587 uint mono_metadata_parse_typedef_or_ref(MonoImage* m, 588 const(char)* ptr, const(char*)* rptr); 589 int mono_metadata_parse_custom_mod(MonoImage* m, 590 MonoCustomMod* dest, const(char)* ptr, const(char*)* rptr); 591 MonoArrayType* mono_metadata_parse_array(MonoImage* m, 592 const(char)* ptr, const(char*)* rptr); 593 void mono_metadata_free_array(MonoArrayType* array); 594 MonoType* mono_metadata_parse_type(MonoImage* m, 595 MonoParseTypeMode mode, short opt_attrs, const(char)* ptr, const(char*)* rptr); 596 MonoType* mono_metadata_parse_param(MonoImage* m, 597 const(char)* ptr, const(char*)* rptr); 598 MonoType* mono_metadata_parse_ret_type(MonoImage* m, 599 const(char)* ptr, const(char*)* rptr); 600 MonoType* mono_metadata_parse_field_type(MonoImage* m, 601 short field_flags, const(char)* ptr, const(char*)* rptr); 602 MonoType* mono_type_create_from_typespec(MonoImage* image, uint type_spec); 603 void mono_metadata_free_type(MonoType* type); 604 int mono_type_size(MonoType* type, int* alignment); 605 int mono_type_stack_size(MonoType* type, int* alignment); 606 mono_bool mono_type_generic_inst_is_valuetype(MonoType* type); 607 mono_bool mono_metadata_generic_class_is_valuetype(MonoGenericClass* gclass); 608 uint mono_metadata_generic_class_hash(MonoGenericClass* gclass); 609 mono_bool mono_metadata_generic_class_equal( 610 MonoGenericClass* g1, MonoGenericClass* g2); 611 uint mono_metadata_type_hash(MonoType* t1); 612 mono_bool mono_metadata_type_equal(MonoType* t1, MonoType* t2); 613 MonoMethodSignature* mono_metadata_signature_alloc( 614 MonoImage* image, uint nparams); 615 MonoMethodSignature* mono_metadata_signature_dup(MonoMethodSignature* sig); 616 MonoMethodSignature* mono_metadata_parse_signature( 617 MonoImage* image, uint token); 618 MonoMethodSignature* mono_metadata_parse_method_signature( 619 MonoImage* m, int def, const(char)* ptr, const(char*)* rptr); 620 void mono_metadata_free_method_signature(MonoMethodSignature* method); 621 mono_bool mono_metadata_signature_equal( 622 MonoMethodSignature* sig1, MonoMethodSignature* sig2); 623 uint mono_signature_hash(MonoMethodSignature* sig); 624 MonoMethodHeader* mono_metadata_parse_mh(MonoImage* m, const(char)* ptr); 625 void mono_metadata_free_mh(MonoMethodHeader* mh); 626 const(ubyte)* mono_method_header_get_code( 627 MonoMethodHeader* header, uint* code_size, uint* max_stack); 628 MonoType** mono_method_header_get_locals( 629 MonoMethodHeader* header, uint* num_locals, mono_bool* init_locals); 630 int mono_method_header_get_num_clauses(MonoMethodHeader* header); 631 int mono_method_header_get_clauses(MonoMethodHeader* header, 632 MonoMethod* method, void** iter, MonoExceptionClause* clause); 633 uint mono_type_to_unmanaged(MonoType* type, 634 MonoMarshalSpec* mspec, mono_bool as_field, mono_bool unicode, MonoMarshalConv* conv); 635 uint mono_metadata_token_from_dor(uint dor_index); 636 char* mono_guid_to_string(const(ubyte)* guid); 637 char* mono_guid_to_string_minimal(const(ubyte)* guid); 638 uint mono_metadata_declsec_from_index(MonoImage* meta, uint idx); 639 uint mono_metadata_translate_token_index(MonoImage* image, 640 int table, uint idx); 641 void mono_metadata_decode_table_row(MonoImage* image, 642 int table, int idx, uint* res, int res_size); 643 uint mono_metadata_decode_table_row_col(MonoImage* image, 644 int table, int idx, uint col); 645 // metadata/mono-config.h 646 const(char)* mono_config_get_os(); 647 const(char)* mono_config_get_cpu(); 648 const(char)* mono_config_get_wordsize(); 649 const(char)* mono_get_config_dir(); 650 void mono_set_config_dir(const(char)* dir); 651 const(char)* mono_get_machine_config(); 652 void mono_config_cleanup(); 653 void mono_config_parse(const(char)* filename); 654 void mono_config_for_assembly(MonoImage* assembly); 655 void mono_config_parse_memory(const(char)* buffer); 656 const(char)* mono_config_string_for_assembly_file(const(char)* filename); 657 void mono_config_set_server_mode(mono_bool server_mode); 658 mono_bool mono_config_is_server_mode(); 659 // metadata/mono-debug.h 660 void mono_debug_init(MonoDebugFormat format); 661 void mono_debug_open_image_from_memory(MonoImage* image, 662 const(mono_byte)* raw_contents, int size); 663 void mono_debug_cleanup(); 664 void mono_debug_close_image(MonoImage* image); 665 void mono_debug_domain_unload(MonoDomain* domain); 666 void mono_debug_domain_create(MonoDomain* domain); 667 MonoDebugMethodAddress* mono_debug_add_method( 668 MonoMethod* method, MonoDebugMethodJitInfo* jit, MonoDomain* domain); 669 void mono_debug_remove_method(MonoMethod* method, MonoDomain* domain); 670 MonoDebugMethodInfo* mono_debug_lookup_method(MonoMethod* method); 671 MonoDebugMethodAddressList* mono_debug_lookup_method_addresses( 672 MonoMethod* method); 673 MonoDebugMethodJitInfo* mono_debug_find_method( 674 MonoMethod* method, MonoDomain* domain); 675 void mono_debug_free_method_jit_info(MonoDebugMethodJitInfo* jit); 676 void mono_debug_add_delegate_trampoline(void* code, int size); 677 MonoDebugLocalsInfo* mono_debug_lookup_locals(MonoMethod* method); 678 MonoDebugMethodAsyncInfo* mono_debug_lookup_method_async_debug_info( 679 MonoMethod* method); 680 MonoDebugSourceLocation* mono_debug_method_lookup_location( 681 MonoDebugMethodInfo* minfo, int il_offset); 682 MonoDebugSourceLocation* mono_debug_lookup_source_location( 683 MonoMethod* method, uint address, MonoDomain* domain); 684 int mono_debug_il_offset_from_address(MonoMethod* method, 685 MonoDomain* domain, uint native_offset); 686 void mono_debug_free_source_location(MonoDebugSourceLocation* location); 687 char* mono_debug_print_stack_frame(MonoMethod* method, 688 uint native_offset, MonoDomain* domain); 689 int mono_debugger_method_has_breakpoint(MonoMethod* method); 690 int mono_debugger_insert_breakpoint(const(char)* method_name, 691 mono_bool include_namespace); 692 void mono_set_is_debugger_attached(mono_bool attached); 693 mono_bool mono_is_debugger_attached(); 694 // metadata/mono-gc.h 695 void mono_gc_collect(int generation); 696 int mono_gc_max_generation(); 697 int mono_gc_get_generation(MonoObject* object); 698 int mono_gc_collection_count(int generation); 699 long mono_gc_get_used_size(); 700 long mono_gc_get_heap_size(); 701 MonoBoolean mono_gc_pending_finalizers(); 702 void mono_gc_finalize_notify(); 703 int mono_gc_invoke_finalizers(); 704 int mono_gc_walk_heap(int flags, MonoGCReferences callback, void* data); 705 // metadata/object.h 706 mono_unichar2* mono_string_chars(MonoString* s); 707 int mono_string_length(MonoString* s); 708 MonoObject* mono_object_new(MonoDomain* domain, MonoClass* klass); 709 MonoObject* mono_object_new_specific(MonoVTable* vtable); 710 MonoObject* mono_object_new_fast(MonoVTable* vtable); 711 MonoObject* mono_object_new_alloc_specific(MonoVTable* vtable); 712 MonoObject* mono_object_new_from_token(MonoDomain* domain, 713 MonoImage* image, uint token); 714 MonoArray* mono_array_new(MonoDomain* domain, MonoClass* eclass, uintptr_t n); 715 MonoArray* mono_array_new_full(MonoDomain* domain, 716 MonoClass* array_class, uintptr_t* lengths, intptr_t* lower_bounds); 717 MonoArray* mono_array_new_specific(MonoVTable* vtable, uintptr_t n); 718 MonoArray* mono_array_clone(MonoArray* array); 719 char* mono_array_addr_with_size(MonoArray* array, int size, uintptr_t idx); 720 uintptr_t mono_array_length(MonoArray* array); 721 MonoString* mono_string_empty(MonoDomain* domain); 722 MonoString* mono_string_empty_wrapper(); 723 alias da_mono_string_new_utf16 = MonoString* function(MonoDomain* domain, 724 const(mono_unichar2)* text, int len); 725 MonoString* mono_string_new_size(MonoDomain* domain, int len); 726 MonoString* mono_ldstr(MonoDomain* domain, MonoImage* image, uint str_index); 727 MonoString* mono_string_is_interned(MonoString* str); 728 MonoString* mono_string_intern(MonoString* str); 729 MonoString* mono_string_new(MonoDomain* domain, const(char)* text); 730 MonoString* mono_string_new_wrapper(const(char)* text); 731 MonoString* mono_string_new_len(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 mono_bool mono_string_equal(MonoString* s1, MonoString* s2); 742 uint mono_string_hash(MonoString* s); 743 int mono_object_hash(MonoObject* obj); 744 MonoString* mono_object_to_string(MonoObject* obj, MonoObject** exc); 745 MonoObject* mono_value_box(MonoDomain* domain, MonoClass* klass, void* val); 746 void mono_value_copy(void* dest, void* src, MonoClass* klass); 747 void mono_value_copy_array(MonoArray* dest, 748 int dest_idx, void* src, int count); 749 MonoDomain* mono_object_get_domain(MonoObject* obj); 750 MonoClass* mono_object_get_class(MonoObject* obj); 751 void* mono_object_unbox(MonoObject* obj); 752 MonoObject* mono_object_clone(MonoObject* obj); 753 MonoObject* mono_object_isinst(MonoObject* obj, MonoClass* klass); 754 MonoObject* mono_object_isinst_mbyref(MonoObject* obj, MonoClass* klass); 755 MonoObject* mono_object_castclass_mbyref(MonoObject* obj, MonoClass* klass); 756 mono_bool mono_monitor_try_enter(MonoObject* obj, uint ms); 757 mono_bool mono_monitor_enter(MonoObject* obj); 758 alias da_mono_monitor_enter_v4 = void function(MonoObject* obj, char* lock_taken); 759 uint mono_object_get_size(MonoObject* o); 760 void mono_monitor_exit(MonoObject* obj); 761 void mono_raise_exception(MonoException* ex); 762 void mono_runtime_object_init(MonoObject* this_obj); 763 void mono_runtime_class_init(MonoVTable* vtable); 764 MonoMethod* mono_object_get_virtual_method(MonoObject* obj, 765 MonoMethod* method); 766 MonoObject* mono_runtime_invoke(MonoMethod* method, 767 void* obj, void** params, MonoObject** exc); 768 MonoMethod* mono_get_delegate_invoke(MonoClass* klass); 769 MonoMethod* mono_get_delegate_begin_invoke(MonoClass* klass); 770 MonoMethod* mono_get_delegate_end_invoke(MonoClass* klass); 771 MonoObject* mono_runtime_delegate_invoke(MonoObject* delegate_, 772 void** params, MonoObject** exc); 773 MonoObject* mono_runtime_invoke_array(MonoMethod* method, 774 void* obj, MonoArray* params, MonoObject** exc); 775 void* mono_method_get_unmanaged_thunk(MonoMethod* method); 776 MonoArray* mono_runtime_get_main_args(); 777 void mono_runtime_exec_managed_code(MonoDomain* domain, 778 MonoMainThreadFunc main_func, void* main_args); 779 int mono_runtime_run_main(MonoMethod* method, int argc, 780 char** argv, MonoObject** exc); 781 int mono_runtime_exec_main(MonoMethod* method, 782 MonoArray* args, MonoObject** exc); 783 int mono_runtime_set_main_args(int argc, char** argv); 784 void* mono_load_remote_field(MonoObject* this_obj, 785 MonoClass* klass, MonoClassField* field, void** res); 786 MonoObject* mono_load_remote_field_new(MonoObject* this_obj, 787 MonoClass* klass, MonoClassField* field); 788 void mono_store_remote_field(MonoObject* this_obj, 789 MonoClass* klass, MonoClassField* field, void* val); 790 void mono_store_remote_field_new(MonoObject* this_obj, 791 MonoClass* klass, MonoClassField* field, MonoObject* arg); 792 void mono_unhandled_exception(MonoObject* exc); 793 void mono_print_unhandled_exception(MonoObject* exc); 794 void* mono_compile_method(MonoMethod* method); 795 void mono_field_set_value(MonoObject* obj, 796 MonoClassField* field, void* value); 797 void mono_field_static_set_value(MonoVTable* vt, 798 MonoClassField* field, void* value); 799 void mono_field_get_value(MonoObject* obj, 800 MonoClassField* field, void* value); 801 void mono_field_static_get_value(MonoVTable* vt, 802 MonoClassField* field, void* value); 803 MonoObject* mono_field_get_value_object(MonoDomain* domain, 804 MonoClassField* field, MonoObject* obj); 805 void mono_property_set_value(MonoProperty* prop, 806 void* obj, void** params, MonoObject** exc); 807 MonoObject* mono_property_get_value(MonoProperty* prop, 808 void* obj, void** params, MonoObject** exc); 809 uint mono_gchandle_new(MonoObject* obj, mono_bool pinned); 810 uint mono_gchandle_new_weakref(MonoObject* obj, mono_bool track_resurrection); 811 MonoObject* mono_gchandle_get_target(uint gchandle); 812 void mono_gchandle_free(uint gchandle); 813 MonoReferenceQueue* mono_gc_reference_queue_new( 814 mono_reference_queue_callback callback); 815 void mono_gc_reference_queue_free(MonoReferenceQueue* queue); 816 mono_bool mono_gc_reference_queue_add(MonoReferenceQueue* queue, 817 MonoObject* obj, void* user_data); 818 void mono_gc_wbarrier_set_field(MonoObject* obj, 819 void* field_ptr, MonoObject* value); 820 void mono_gc_wbarrier_set_arrayref(MonoArray* arr, 821 void* slot_ptr, MonoObject* value); 822 void mono_gc_wbarrier_arrayref_copy(void* dest_ptr, void* src_ptr, int count); 823 void mono_gc_wbarrier_generic_store(void* ptr, MonoObject* value); 824 void mono_gc_wbarrier_generic_store_atomic(void* ptr, MonoObject* value); 825 void mono_gc_wbarrier_generic_nostore(void* ptr); 826 void mono_gc_wbarrier_value_copy(void* dest, void* src, 827 int count, MonoClass* klass); 828 void mono_gc_wbarrier_object_copy(MonoObject* obj, MonoObject* src); 829 // metadata/opcodes.h 830 const(char)* mono_opcode_name(int opcode); 831 MonoOpcodeEnum mono_opcode_value(const(mono_byte*)* ip, 832 const(mono_byte)* end); 833 // metadata/profiler.h 834 void mono_profiler_install(MonoProfiler* prof, 835 MonoProfileFunc shutdown_callback); 836 void mono_profiler_set_events(MonoProfileFlags events); 837 MonoProfileFlags mono_profiler_get_events(); 838 void mono_profiler_install_appdomain( 839 MonoProfileAppDomainFunc start_load, MonoProfileAppDomainResult end_load, 840 MonoProfileAppDomainFunc start_unload, MonoProfileAppDomainFunc end_unload); 841 void mono_profiler_install_appdomain_name( 842 MonoProfileAppDomainFriendlyNameFunc domain_name_cb); 843 void mono_profiler_install_context(MonoProfileContextFunc load, 844 MonoProfileContextFunc unload); 845 void mono_profiler_install_assembly(MonoProfileAssemblyFunc start_load, 846 MonoProfileAssemblyResult end_load, MonoProfileAssemblyFunc start_unload, 847 MonoProfileAssemblyFunc end_unload); 848 void mono_profiler_install_module(MonoProfileModuleFunc start_load, 849 MonoProfileModuleResult end_load, MonoProfileModuleFunc start_unload, 850 MonoProfileModuleFunc end_unload); 851 void mono_profiler_install_class(MonoProfileClassFunc start_load, 852 MonoProfileClassResult end_load, MonoProfileClassFunc start_unload, 853 MonoProfileClassFunc end_unload); 854 void mono_profiler_install_jit_compile( 855 MonoProfileMethodFunc start, MonoProfileMethodResult end); 856 void mono_profiler_install_jit_end(MonoProfileJitResult end); 857 void mono_profiler_install_method_free(MonoProfileMethodFunc callback); 858 void mono_profiler_install_method_invoke( 859 MonoProfileMethodFunc start, MonoProfileMethodFunc end); 860 void mono_profiler_install_enter_leave( 861 MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave); 862 void mono_profiler_install_thread(MonoProfileThreadFunc start, 863 MonoProfileThreadFunc end); 864 void mono_profiler_install_thread_name( 865 MonoProfileThreadNameFunc thread_name_cb); 866 void mono_profiler_install_transition(MonoProfileMethodResult callback); 867 void mono_profiler_install_allocation(MonoProfileAllocFunc callback); 868 void mono_profiler_install_monitor(MonoProfileMonitorFunc callback); 869 void mono_profiler_install_statistical(MonoProfileStatFunc callback); 870 void mono_profiler_install_statistical_call_chain(MonoProfileStatCallChainFunc callback, 871 int call_chain_depth, MonoProfilerCallChainStrategy call_chain_strategy); 872 void mono_profiler_install_exception(MonoProfileExceptionFunc throw_callback, 873 MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback); 874 void mono_profiler_install_coverage_filter( 875 MonoProfileCoverageFilterFunc callback); 876 void mono_profiler_coverage_get(MonoProfiler* prof, 877 MonoMethod* method, MonoProfileCoverageFunc func); 878 void mono_profiler_install_gc(MonoProfileGCFunc callback, 879 MonoProfileGCResizeFunc heap_resize_callback); 880 void mono_profiler_install_gc_moves(MonoProfileGCMoveFunc callback); 881 void mono_profiler_install_gc_roots( 882 MonoProfileGCHandleFunc handle_callback, MonoProfileGCRootFunc roots_callback); 883 void mono_profiler_install_gc_finalize(MonoProfileGCFinalizeFunc begin, 884 MonoProfileGCFinalizeObjectFunc begin_obj, 885 MonoProfileGCFinalizeObjectFunc end_obj, MonoProfileGCFinalizeFunc end); 886 void mono_profiler_install_runtime_initialized( 887 MonoProfileFunc runtime_initialized_callback); 888 void mono_profiler_install_code_chunk_new(MonoProfilerCodeChunkNew callback); 889 void mono_profiler_install_code_chunk_destroy( 890 MonoProfilerCodeChunkDestroy callback); 891 void mono_profiler_install_code_buffer_new( 892 MonoProfilerCodeBufferNew callback); 893 void mono_profiler_install_iomap(MonoProfileIomapFunc callback); 894 void mono_profiler_load(const(char)* desc); 895 void mono_profiler_set_statistical_mode( 896 MonoProfileSamplingMode mode, long sampling_frequency_hz); 897 // metadata/reflection.h 898 int mono_reflection_parse_type(char* name, MonoTypeNameParse* info); 899 MonoType* mono_reflection_get_type(MonoImage* image, 900 MonoTypeNameParse* info, mono_bool ignorecase, mono_bool* type_resolve); 901 void mono_reflection_free_type_info(MonoTypeNameParse* info); 902 MonoType* mono_reflection_type_from_name(char* name, MonoImage* image); 903 uint mono_reflection_get_token(MonoObject* obj); 904 MonoReflectionAssembly* mono_assembly_get_object( 905 MonoDomain* domain, MonoAssembly* assembly); 906 MonoReflectionModule* mono_module_get_object(MonoDomain* domain, 907 MonoImage* image); 908 MonoReflectionModule* mono_module_file_get_object( 909 MonoDomain* domain, MonoImage* image, int table_index); 910 MonoReflectionType* mono_type_get_object(MonoDomain* domain, MonoType* type); 911 MonoReflectionMethod* mono_method_get_object(MonoDomain* domain, 912 MonoMethod* method, MonoClass* refclass); 913 MonoReflectionField* mono_field_get_object(MonoDomain* domain, 914 MonoClass* klass, MonoClassField* field); 915 MonoReflectionProperty* mono_property_get_object( 916 MonoDomain* domain, MonoClass* klass, MonoProperty* property); 917 MonoReflectionEvent* mono_event_get_object(MonoDomain* domain, 918 MonoClass* klass, MonoEvent* event); 919 MonoArray* mono_param_get_objects(MonoDomain* domain, MonoMethod* method); 920 MonoReflectionMethodBody* mono_method_body_get_object( 921 MonoDomain* domain, MonoMethod* method); 922 MonoObject* mono_get_dbnull_object(MonoDomain* domain); 923 MonoArray* mono_reflection_get_custom_attrs_by_type( 924 MonoObject* obj, MonoClass* attr_klass, MonoError* error); 925 MonoArray* mono_reflection_get_custom_attrs(MonoObject* obj); 926 MonoArray* mono_reflection_get_custom_attrs_data(MonoObject* obj); 927 MonoArray* mono_reflection_get_custom_attrs_blob( 928 MonoReflectionAssembly* assembly, MonoObject* ctor, 929 MonoArray* ctorArgs, 930 MonoArray* properties, MonoArray* porpValues, MonoArray* fields, 931 MonoArray* fieldValues); 932 MonoCustomAttrInfo* mono_reflection_get_custom_attrs_info(MonoObject* obj); 933 MonoArray* mono_custom_attrs_construct(MonoCustomAttrInfo* cinfo); 934 MonoCustomAttrInfo* mono_custom_attrs_from_index(MonoImage* image, uint idx); 935 MonoCustomAttrInfo* mono_custom_attrs_from_method(MonoMethod* method); 936 MonoCustomAttrInfo* mono_custom_attrs_from_class(MonoClass* klass); 937 MonoCustomAttrInfo* mono_custom_attrs_from_assembly(MonoAssembly* assembly); 938 MonoCustomAttrInfo* mono_custom_attrs_from_property( 939 MonoClass* klass, MonoProperty* property); 940 MonoCustomAttrInfo* mono_custom_attrs_from_event( 941 MonoClass* klass, MonoEvent* event); 942 MonoCustomAttrInfo* mono_custom_attrs_from_field( 943 MonoClass* klass, MonoClassField* field); 944 MonoCustomAttrInfo* mono_custom_attrs_from_param( 945 MonoMethod* method, uint param); 946 mono_bool mono_custom_attrs_has_attr(MonoCustomAttrInfo* ainfo, 947 MonoClass* attr_klass); 948 MonoObject* mono_custom_attrs_get_attr( 949 MonoCustomAttrInfo* ainfo, MonoClass* attr_klass); 950 void mono_custom_attrs_free(MonoCustomAttrInfo* ainfo); 951 uint mono_declsec_flags_from_method(MonoMethod* method); 952 uint mono_declsec_flags_from_class(MonoClass* klass); 953 uint mono_declsec_flags_from_assembly(MonoAssembly* assembly); 954 MonoBoolean mono_declsec_get_demands(MonoMethod* callee, 955 MonoDeclSecurityActions* demands); 956 MonoBoolean mono_declsec_get_linkdemands(MonoMethod* callee, 957 MonoDeclSecurityActions* klass, MonoDeclSecurityActions* cmethod); 958 MonoBoolean mono_declsec_get_inheritdemands_class( 959 MonoClass* klass, MonoDeclSecurityActions* demands); 960 MonoBoolean mono_declsec_get_inheritdemands_method( 961 MonoMethod* callee, MonoDeclSecurityActions* demands); 962 MonoBoolean mono_declsec_get_method_action(MonoMethod* method, 963 uint action, MonoDeclSecurityEntry* entry); 964 MonoBoolean mono_declsec_get_class_action(MonoClass* klass, 965 uint action, MonoDeclSecurityEntry* entry); 966 MonoBoolean mono_declsec_get_assembly_action( 967 MonoAssembly* assembly, uint action, MonoDeclSecurityEntry* entry); 968 MonoType* mono_reflection_type_get_type(MonoReflectionType* reftype); 969 MonoAssembly* mono_reflection_assembly_get_assembly( 970 MonoReflectionAssembly* refassembly); 971 // metadata/row-indexes.h 972 // metadata/sgen-bridge.h 973 void mono_gc_register_bridge_callbacks(MonoGCBridgeCallbacks* callbacks); 974 void mono_gc_wait_for_bridge_processing(); 975 // metadata/threads.h 976 void mono_thread_init(MonoThreadStartCB start_cb, 977 MonoThreadAttachCB attach_cb); 978 void mono_thread_cleanup(); 979 void mono_thread_manage(); 980 MonoThread* mono_thread_current(); 981 void mono_thread_set_main(MonoThread* thread); 982 MonoThread* mono_thread_get_main(); 983 void mono_thread_stop(MonoThread* thread); 984 void mono_thread_new_init(intptr_t tid, void* stack_start, void* func); 985 void mono_thread_create(MonoDomain* domain, void* func, void* arg); 986 MonoThread* mono_thread_attach(MonoDomain* domain); 987 void mono_thread_detach(MonoThread* thread); 988 void mono_thread_exit(); 989 alias da_mono_thread_get_name_utf8 = char* function(MonoThread* thread); 990 int mono_thread_get_managed_id(MonoThread* thread); 991 void mono_thread_set_manage_callback(MonoThread* thread, 992 MonoThreadManageCallback func); 993 void mono_threads_set_default_stacksize(uint stacksize); 994 uint mono_threads_get_default_stacksize(); 995 void mono_threads_request_thread_dump(); 996 mono_bool mono_thread_is_foreign(MonoThread* thread); 997 mono_bool mono_thread_detach_if_exiting(); 998 // metadata/tokentype.h 999 // metadata/verify.h 1000 void* mono_method_verify(MonoMethod* method, int level); 1001 void mono_free_verify_list(void* list); 1002 char* mono_verify_corlib(); 1003 // jit/jit.h 1004 MonoDomain* mono_jit_init(const(char)* file); 1005 MonoDomain* mono_jit_init_version(const(char)* root_domain_name, 1006 const(char)* runtime_version); 1007 int mono_jit_exec(MonoDomain* domain, 1008 MonoAssembly* assembly, int argc, char** argv); 1009 void mono_jit_cleanup(MonoDomain* domain); 1010 mono_bool mono_jit_set_trace_options(const(char)* options); 1011 void mono_set_signal_chaining(mono_bool chain_signals); 1012 void mono_set_crash_chaining(mono_bool chain_signals); 1013 void mono_jit_set_aot_only(mono_bool aot_only); 1014 void mono_jit_set_aot_mode(MonoAotMode mode); 1015 void mono_set_break_policy(MonoBreakPolicyFunc policy_callback); 1016 void mono_jit_parse_options(int argc, char** argv); 1017 char* mono_get_runtime_build_info(); 1018 MonoJitInfo* mono_get_jit_info_from_method(MonoDomain* domain, 1019 MonoMethod* method); 1020 void* mono_aot_get_method(MonoDomain* domain, MonoMethod* method); 1021 }