static MonoBoolean construct_culture (MonoCultureInfo *this_obj, const CultureInfoEntry *ci, MonoError *error) { MonoDomain *domain = mono_domain_get (); error_init (error); this_obj->lcid = ci->lcid; MONO_OBJECT_SETREF (this_obj, name, mono_string_new (domain, idx2string (ci->name))); MONO_OBJECT_SETREF (this_obj, englishname, mono_string_new (domain, idx2string (ci->englishname))); MONO_OBJECT_SETREF (this_obj, nativename, mono_string_new (domain, idx2string (ci->nativename))); MONO_OBJECT_SETREF (this_obj, win3lang, mono_string_new (domain, idx2string (ci->win3lang))); MONO_OBJECT_SETREF (this_obj, iso3lang, mono_string_new (domain, idx2string (ci->iso3lang))); MONO_OBJECT_SETREF (this_obj, iso2lang, mono_string_new (domain, idx2string (ci->iso2lang))); // It's null for neutral cultures if (ci->territory > 0) MONO_OBJECT_SETREF (this_obj, territory, mono_string_new (domain, idx2string (ci->territory))); MonoArray *native_calendar_names = create_names_array_idx (ci->native_calendar_names, NUM_CALENDARS, error); return_val_if_nok (error, FALSE); MONO_OBJECT_SETREF (this_obj, native_calendar_names, native_calendar_names); this_obj->parent_lcid = ci->parent_lcid; this_obj->datetime_index = ci->datetime_format_index; this_obj->number_index = ci->number_format_index; this_obj->calendar_type = ci->calendar_type; this_obj->text_info_data = &ci->text_info; return TRUE; }
gpointer ves_icall_System_Threading_Mutex_CreateMutex_internal (MonoBoolean owned, MonoStringHandle name, MonoBoolean *created, MonoError *error) { gpointer mutex; *created = TRUE; /* Need to blow away any old errors here, because code tests * for ERROR_ALREADY_EXISTS on success (!) to see if a mutex * was freshly created */ mono_w32error_set_last (ERROR_SUCCESS); if (MONO_HANDLE_IS_NULL (name)) { mutex = mutex_create (owned); } else { gchar *utf8_name = mono_string_handle_to_utf8 (name, error); return_val_if_nok (error, NULL); mutex = namedmutex_create (owned, utf8_name); if (mono_w32error_get_last () == ERROR_ALREADY_EXISTS) *created = FALSE; g_free (utf8_name); } return mutex; }
MonoException * mono_get_exception_runtime_wrapped_checked (MonoObject *wrapped_exception, MonoError *error) { MonoClass *klass; MonoObject *o; MonoMethod *method; MonoDomain *domain = mono_domain_get (); gpointer params [16]; klass = mono_class_load_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", "RuntimeWrappedException"); o = mono_object_new_checked (domain, klass, error); mono_error_assert_ok (error); g_assert (o != NULL); method = mono_class_get_method_from_name (klass, ".ctor", 1); g_assert (method); params [0] = wrapped_exception; mono_runtime_invoke_checked (method, o, params, error); return_val_if_nok (error, NULL); return (MonoException *)o; }
static MonoArray* create_names_array_idx_dynamic (const guint16 *names, int ml, MonoError *error) { MonoArray *ret; MonoDomain *domain; int i, len = 0; error_init (error); if (names == NULL) return NULL; domain = mono_domain_get (); for (i = 0; i < ml; i++) { if (names [i] == 0) break; len++; } ret = mono_array_new_cached (mono_domain_get (), mono_get_string_class (), len, error); return_val_if_nok (error, NULL); for(i = 0; i < len; i++) mono_array_setref (ret, i, mono_string_new (domain, pattern2string (names [i]))); return ret; }
gpointer ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoStringHandle name, gint32 rights G_GNUC_UNUSED, gint32 *err, MonoError *error) { gchar *utf8_name = mono_string_handle_to_utf8 (name, error); return_val_if_nok (error, NULL); gpointer handle = mono_w32mutex_open (utf8_name, rights, err); g_free (utf8_name); return handle; }
guint32 mono_dynstream_insert_mstring (MonoDynamicStream *sh, MonoString *str, MonoError *error) { MONO_REQ_GC_UNSAFE_MODE; mono_error_init (error); char *name = mono_string_to_utf8_checked (str, error); return_val_if_nok (error, -1); guint32 idx; idx = mono_dynstream_insert_string (sh, name); g_free (name); return idx; }
gpointer ves_icall_System_Security_Principal_WindowsIdentity_GetUserToken (MonoStringHandle username, MonoError *error) { gpointer token = (gpointer)-2; error_init (error); #if defined (HAVE_PWD_H) && !defined (HOST_WASM) #ifdef HAVE_GETPWNAM_R struct passwd pwd; size_t fbufsize; gchar *fbuf; gint32 retval; #endif struct passwd *p; gchar *utf8_name; gboolean result; utf8_name = mono_string_handle_to_utf8 (username, error); return_val_if_nok (error, NULL); #ifdef HAVE_GETPWNAM_R #ifdef _SC_GETPW_R_SIZE_MAX fbufsize = mono_sysconf (_SC_GETPW_R_SIZE_MAX); #else fbufsize = MONO_SYSCONF_DEFAULT_SIZE; #endif fbuf = (gchar *)g_malloc0 (fbufsize); retval = getpwnam_r (utf8_name, &pwd, fbuf, fbufsize, &p); result = ((retval == 0) && (p == &pwd)); #else /* default to non thread-safe but posix compliant function */ p = getpwnam (utf8_name); result = (p != NULL); #endif if (result) { token = GINT_TO_POINTER (p->pw_uid); } #ifdef HAVE_GETPWNAM_R g_free (fbuf); #endif g_free (utf8_name); #endif /* HAVE_PWD_H */ return token; }
static MonoException * create_exception_two_strings (MonoClass *klass, MonoString *a1, MonoString *a2, MonoError *error) { MonoDomain *domain = mono_domain_get (); MonoMethod *method = NULL; MonoObject *o; int count = 1; gpointer args [2]; gpointer iter; MonoMethod *m; if (a2 != NULL) count++; o = mono_object_new_checked (domain, klass, error); mono_error_assert_ok (error); iter = NULL; while ((m = mono_class_get_methods (klass, &iter))) { MonoMethodSignature *sig; if (strcmp (".ctor", mono_method_get_name (m))) continue; sig = mono_method_signature (m); if (sig->param_count != count) continue; if (sig->params [0]->type != MONO_TYPE_STRING) continue; if (count == 2 && sig->params [1]->type != MONO_TYPE_STRING) continue; method = m; break; } args [0] = a1; args [1] = a2; mono_runtime_invoke_checked (method, o, args, error); return_val_if_nok (error, NULL); return (MonoException *) o; }
static MonoArray* create_names_array_idx (const guint16 *names, int ml, MonoError *error) { MonoArray *ret; MonoDomain *domain; int i; error_init (error); if (names == NULL) return NULL; domain = mono_domain_get (); ret = mono_array_new_cached (mono_domain_get (), mono_get_string_class (), ml, error); return_val_if_nok (error, NULL); for(i = 0; i < ml; i++) mono_array_setref (ret, i, mono_string_new (domain, dtidx2string (names [i]))); return ret; }
static MonoArray* create_group_sizes_array (const gint *gs, gint ml, MonoError *error) { MonoArray *ret; int i, len = 0; error_init (error); for (i = 0; i < ml; i++) { if (gs [i] == -1) break; len++; } ret = mono_array_new_cached (mono_domain_get (), mono_get_int32_class (), len, error); return_val_if_nok (error, NULL); for(i = 0; i < len; i++) mono_array_set (ret, gint32, i, gs [i]); return ret; }
MonoException * mono_get_exception_reflection_type_load_checked (MonoArray *types, MonoArray *exceptions, MonoError *error) { MonoClass *klass; gpointer args [2]; MonoObject *exc; MonoMethod *method; gpointer iter; klass = mono_class_load_from_name (mono_get_corlib (), "System.Reflection", "ReflectionTypeLoadException"); mono_class_init (klass); /* Find the Type[], Exception[] ctor */ iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_SZARRAY && sig->params [1]->type == MONO_TYPE_SZARRAY) break; } method = NULL; } g_assert (method); args [0] = types; args [1] = exceptions; exc = mono_object_new_checked (mono_domain_get (), klass, error); mono_error_assert_ok (error); mono_runtime_invoke_checked (method, exc, args, error); return_val_if_nok (error, NULL); return (MonoException *) exc; }
MonoException * mono_get_exception_type_initialization_checked (const gchar *type_name, MonoException *inner, MonoError *error) { MonoClass *klass; gpointer args [2]; MonoObject *exc; MonoMethod *method; gpointer iter; klass = mono_class_load_from_name (mono_get_corlib (), "System", "TypeInitializationException"); mono_class_init (klass); iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (!strcmp (".ctor", mono_method_get_name (method))) { MonoMethodSignature *sig = mono_method_signature (method); if (sig->param_count == 2 && sig->params [0]->type == MONO_TYPE_STRING && mono_class_from_mono_type (sig->params [1]) == mono_defaults.exception_class) break; } method = NULL; } g_assert (method); args [0] = mono_string_new (mono_domain_get (), type_name); args [1] = inner; exc = mono_object_new_checked (mono_domain_get (), klass, error); mono_error_assert_ok (error); mono_runtime_invoke_checked (method, exc, args, error); return_val_if_nok (error, NULL); return (MonoException *) exc; }