MonoAsyncResult * mono_thread_pool_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate *async_callback, MonoObject *state) { MonoDomain *domain = mono_domain_get (); MonoAsyncResult *ares; ASyncCall *ac; ac = (ASyncCall*)mono_object_new (domain, async_call_klass); MONO_OBJECT_SETREF (ac, msg, msg); MONO_OBJECT_SETREF (ac, state, state); if (async_callback) { ac->cb_method = mono_get_delegate_invoke (((MonoObject *)async_callback)->vtable->klass); MONO_OBJECT_SETREF (ac, cb_target, async_callback); } ares = mono_async_result_new (domain, NULL, ac->state, NULL, (MonoObject*)ac); MONO_OBJECT_SETREF (ares, async_delegate, target); #ifndef DISABLE_SOCKETS if (socket_io_filter (target, state)) { socket_io_add (ares, (MonoSocketAsyncResult *) state); return ares; } #endif threadpool_append_job (&async_tp, (MonoObject *) ares); return ares; }
void ves_icall_System_Globalization_CultureData_fill_culture_data (MonoCultureData *this_obj, gint32 datetime_index) { MonoError error; MonoDomain *domain; const DateTimeFormatEntry *dfe; g_assert (datetime_index >= 0); dfe = &datetime_format_entries [datetime_index]; domain = mono_domain_get (); MONO_OBJECT_SETREF (this_obj, AMDesignator, mono_string_new (domain, idx2string (dfe->am_designator))); MONO_OBJECT_SETREF (this_obj, PMDesignator, mono_string_new (domain, idx2string (dfe->pm_designator))); MONO_OBJECT_SETREF (this_obj, TimeSeparator, mono_string_new (domain, idx2string (dfe->time_separator))); MonoArray *long_time_patterns = create_names_array_idx_dynamic (dfe->long_time_patterns, NUM_LONG_TIME_PATTERNS, &error); if (mono_error_set_pending_exception (&error)) return; MONO_OBJECT_SETREF (this_obj, LongTimePatterns, long_time_patterns); MonoArray *short_time_patterns = create_names_array_idx_dynamic (dfe->short_time_patterns, NUM_SHORT_TIME_PATTERNS, &error); if (mono_error_set_pending_exception (&error)) return; MONO_OBJECT_SETREF (this_obj, ShortTimePatterns, short_time_patterns); this_obj->FirstDayOfWeek = dfe->first_day_of_week; this_obj->CalendarWeekRule = dfe->calendar_week_rule; }
/* Returns the exception thrown when invoking, if any */ static MonoObject * mono_async_invoke (ThreadPool *tp, MonoAsyncResult *ares) { ASyncCall *ac = (ASyncCall *)ares->object_data; MonoObject *res, *exc = NULL; MonoArray *out_args = NULL; HANDLE wait_event = NULL; if (ares->execution_context) { /* use captured ExecutionContext (if available) */ MONO_OBJECT_SETREF (ares, original_context, mono_thread_get_execution_context ()); mono_thread_set_execution_context (ares->execution_context); } else { ares->original_context = NULL; } if (ac == NULL) { /* Fast path from ThreadPool.*QueueUserWorkItem */ void *pa = ares->async_state; mono_runtime_delegate_invoke (ares->async_delegate, &pa, &exc); } else { MonoObject *cb_exc = NULL; ac->msg->exc = NULL; res = mono_message_invoke (ares->async_delegate, ac->msg, &exc, &out_args); MONO_OBJECT_SETREF (ac, res, res); MONO_OBJECT_SETREF (ac, msg->exc, exc); MONO_OBJECT_SETREF (ac, out_args, out_args); mono_monitor_enter ((MonoObject *) ares); ares->completed = 1; if (ares->handle != NULL) wait_event = mono_wait_handle_get_handle ((MonoWaitHandle *) ares->handle); mono_monitor_exit ((MonoObject *) ares); /* notify listeners */ if (wait_event != NULL) SetEvent (wait_event); /* call async callback if cb_method != null*/ if (ac != NULL && ac->cb_method) { void *pa = &ares; cb_exc = NULL; mono_runtime_invoke (ac->cb_method, ac->cb_target, pa, &cb_exc); MONO_OBJECT_SETREF (ac->msg, exc, cb_exc); exc = cb_exc; } else { exc = NULL; } } /* restore original thread execution context if flow isn't suppressed, i.e. non null */ if (ares->original_context) { mono_thread_set_execution_context (ares->original_context); ares->original_context = NULL; } return exc; }
static MonoAsyncResult * create_simple_asyncresult (MonoObject *target, MonoObject *state) { MonoDomain *domain = mono_domain_get (); MonoAsyncResult *ares; /* Don't call mono_async_result_new() to avoid capturing the context */ ares = (MonoAsyncResult *) mono_object_new (domain, mono_defaults.asyncresult_class); MONO_OBJECT_SETREF (ares, async_delegate, target); MONO_OBJECT_SETREF (ares, async_state, state); return ares; }
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; }
/** * mono_mlist_prepend: * @list: the managed list * @data: the object to add to the list * * Allocate a new list node with @data as content and prepend it * to the list @list. @list can be NULL. */ MonoMList* mono_mlist_prepend (MonoMList* list, MonoObject *data) { MonoMList* res = mono_mlist_alloc (data); if (list) MONO_OBJECT_SETREF (res, next, list); return res; }
MonoSecurityFrame* mono_declsec_create_frame (MonoDomain *domain, MonoJitInfo *jinfo) { MonoSecurityFrame *frame = (MonoSecurityFrame*) mono_object_new (domain, mono_defaults.runtimesecurityframe_class); MonoMethodCasInfo *info; MonoMethod *method; method = jinfo_get_method (jinfo); info = mono_jit_info_get_cas_info (jinfo); if (info && !info->cas_inited) { if (mono_method_has_declsec (method)) { /* Cache the stack modifiers into the MonoJitInfo structure to speed up future stack walks */ mono_declsec_cache_stack_modifiers (jinfo); } info->cas_inited = TRUE; } MONO_OBJECT_SETREF (frame, method, mono_method_get_object (domain, method, NULL)); MONO_OBJECT_SETREF (frame, domain, domain->domain); /* stack modifiers on methods have priority on (i.e. replaces) modifiers on class */ if (info && info->cas_method_assert) { mono_declsec_get_method_action (method, SECURITY_ACTION_ASSERT, &frame->assert); } else if (info && info->cas_class_assert) { mono_declsec_get_class_action (method->klass, SECURITY_ACTION_ASSERT, &frame->assert); } if (info && info->cas_method_deny) { mono_declsec_get_method_action (method, SECURITY_ACTION_DENY, &frame->deny); } else if (info && info->cas_class_deny) { mono_declsec_get_class_action (method->klass, SECURITY_ACTION_DENY, &frame->deny); } if (info && info->cas_method_permitonly) { mono_declsec_get_method_action (method, SECURITY_ACTION_PERMITONLY, &frame->permitonly); } else if (info && info->cas_class_permitonly) { mono_declsec_get_class_action (method->klass, SECURITY_ACTION_PERMITONLY, &frame->permitonly); } /* g_warning ("FRAME %s A(%p,%d) D(%p,%d) PO(%p,%d)", method->name, frame->assert.blob, frame->assert.size, frame->deny.blob, frame->deny.size, frame->permitonly.blob,frame->permitonly.size); */ return frame; }
/** * mono_mlist_set_next: * @list: a managed list node * @next: list node that will be next for the @list node. * * Set next node for @list to @next. */ MonoMList * mono_mlist_set_next (MonoMList* list, MonoMList *next) { if (!list) return next; MONO_OBJECT_SETREF (list, next, next); return list; }
static void set_message_on_exception (MonoException *exception, MonoErrorInternal *error, MonoError *error_out) { MonoString *msg = mono_string_new (mono_domain_get (), error->full_message); if (msg) MONO_OBJECT_SETREF (exception, message, msg); else mono_error_set_out_of_memory (error_out, "Could not allocate exception object"); }
MonoException * mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception) { MonoRuntimeWrappedException *ex = (MonoRuntimeWrappedException*) mono_exception_from_name (mono_get_corlib (), "System.Runtime.CompilerServices", "RuntimeWrappedException"); MONO_OBJECT_SETREF (ex, wrapped_exception, wrapped_exception); return (MonoException*)ex; }
/** * mono_mlist_append: * @list: the managed list * @data: the object to add to the list * * Allocate a new list node with @data as content and append it * to the list @list. @list can be NULL. * Since managed lists are singly-linked, this operation takes O(n) time. */ MonoMList* mono_mlist_append (MonoMList* list, MonoObject *data) { MonoMList* res = mono_mlist_alloc (data); if (list) { MonoMList* last = mono_mlist_last (list); MONO_OBJECT_SETREF (last, next, res); return list; } else { return res; } }
static MonoBoolean construct_region (MonoRegionInfo *this_obj, const RegionInfoEntry *ri) { MonoDomain *domain = mono_domain_get (); this_obj->geo_id = ri->geo_id; MONO_OBJECT_SETREF (this_obj, iso2name, mono_string_new (domain, idx2string (ri->iso2name))); MONO_OBJECT_SETREF (this_obj, iso3name, mono_string_new (domain, idx2string (ri->iso3name))); MONO_OBJECT_SETREF (this_obj, win3name, mono_string_new (domain, idx2string (ri->win3name))); MONO_OBJECT_SETREF (this_obj, english_name, mono_string_new (domain, idx2string (ri->english_name))); MONO_OBJECT_SETREF (this_obj, native_name, mono_string_new (domain, idx2string (ri->native_name))); MONO_OBJECT_SETREF (this_obj, currency_symbol, mono_string_new (domain, idx2string (ri->currency_symbol))); MONO_OBJECT_SETREF (this_obj, iso_currency_symbol, mono_string_new (domain, idx2string (ri->iso_currency_symbol))); MONO_OBJECT_SETREF (this_obj, currency_english_name, mono_string_new (domain, idx2string (ri->currency_english_name))); MONO_OBJECT_SETREF (this_obj, currency_native_name, mono_string_new (domain, idx2string (ri->currency_native_name))); return TRUE; }
/** * mono_exception_from_name_msg: * @image: the Mono image where to look for the class * @name_space: the namespace for the class * @name: class name * @msg: the message to embed inside the exception * * Creates an exception and initializes its message field. * * Returns: the initialized exception instance. */ MonoException * mono_exception_from_name_msg (MonoImage *image, const char *name_space, const char *name, const char *msg) { MonoException *ex; ex = mono_exception_from_name (image, name_space, name); if (msg) MONO_OBJECT_SETREF (ex, message, mono_string_new (mono_object_get_domain ((MonoObject*)ex), msg)); return ex; }
void ves_icall_System_Globalization_CompareInfo_assign_sortkey (MonoCompareInfo *this_obj, MonoSortKey *key, MonoString *source, gint32 options) { MonoArray *arr; gint32 keylen, i; keylen=mono_string_length (source); arr=mono_array_new (mono_domain_get (), mono_get_byte_class (), keylen); for(i=0; i<keylen; i++) { mono_array_set (arr, guint8, i, mono_string_chars (source)[i]); } MONO_OBJECT_SETREF (key, key, arr); }
/** * mono_mlist_alloc: * @data: object to use as data * * Allocates a new managed list node with @data as the contents. * A managed list node also represents a singly-linked list. * Managed lists are garbage collected, so there is no free routine * and the user is required to keep references to the managed list * to prevent it from being garbage collected. */ MonoMList* mono_mlist_alloc (MonoObject *data) { MonoError error; MonoMList* res; if (!monolist_item_vtable) { MonoClass *klass = mono_class_from_name (mono_defaults.corlib, "System", "MonoListItem"); monolist_item_vtable = mono_class_vtable (mono_get_root_domain (), klass); g_assert (monolist_item_vtable); } res = (MonoMList*)mono_object_new_fast_checked (monolist_item_vtable, &error); mono_error_raise_exception (&error); MONO_OBJECT_SETREF (res, data, data); return res; }
/** * mono_get_exception_argument_out_of_range: * @arg: the name of the out of range argument. * * Returns: a new instance of the `System.ArgumentOutOfRangeException` */ MonoException * mono_get_exception_argument_out_of_range (const char *arg) { MonoException *ex; ex = mono_exception_from_name ( mono_get_corlib (), "System", "ArgumentOutOfRangeException"); if (arg) { MonoArgumentException *argex = (MonoArgumentException *)ex; MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg)); } return ex; }
void mono_threadpool_ms_enqueue_async_result (MonoDomain *domain, MonoAsyncResult *ares) { static MonoClass *runtime_work_item_class = NULL; MonoRuntimeWorkItem *rwi; g_assert (ares); if (!runtime_work_item_class) runtime_work_item_class = mono_class_from_name (mono_defaults.corlib, "System.Threading", "MonoRuntimeWorkItem"); g_assert (runtime_work_item_class); rwi = (MonoRuntimeWorkItem*) mono_object_new (domain, runtime_work_item_class); MONO_OBJECT_SETREF (rwi, async_result, ares); mono_threadpool_ms_enqueue_work_item (domain, (MonoObject*) rwi); }
/** * mono_mlist_remove_item: * @list: the managed list * @data: the object to remove from the list * * Remove the list node @item from the managed list @list. * Since managed lists are singly-linked, this operation can take O(n) time. */ MonoMList* mono_mlist_remove_item (MonoMList* list, MonoMList *item) { MonoMList* prev; if (list == item) { list = item->next; item->next = NULL; return list; } prev = find_prev (list, item); if (prev) { MONO_OBJECT_SETREF (prev, next, item->next); item->next = NULL; return list; } else { /* not found */ return list; } }
MonoObject * mono_thread_pool_finish (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc) { ASyncCall *ac; HANDLE wait_event; *exc = NULL; *out_args = NULL; /* check if already finished */ mono_monitor_enter ((MonoObject *) ares); if (ares->endinvoke_called) { *exc = (MonoObject *) mono_get_exception_invalid_operation (NULL); mono_monitor_exit ((MonoObject *) ares); return NULL; } ares->endinvoke_called = 1; /* wait until we are really finished */ if (!ares->completed) { if (ares->handle == NULL) { wait_event = CreateEvent (NULL, TRUE, FALSE, NULL); g_assert(wait_event != 0); MONO_OBJECT_SETREF (ares, handle, (MonoObject *) mono_wait_handle_new (mono_object_domain (ares), wait_event)); } else { wait_event = mono_wait_handle_get_handle ((MonoWaitHandle *) ares->handle); } mono_monitor_exit ((MonoObject *) ares); WaitForSingleObjectEx (wait_event, INFINITE, TRUE); } else { mono_monitor_exit ((MonoObject *) ares); } ac = (ASyncCall *) ares->object_data; g_assert (ac != NULL); *exc = ac->msg->exc; /* FIXME: GC add write barrier */ *out_args = ac->out_args; return ac->res; }
static void socket_io_add (MonoAsyncResult *ares, MonoSocketAsyncResult *state) { MonoMList *list; SocketIOData *data = &socket_io_data; int fd; gboolean is_new; int ievt; socket_io_init (&socket_io_data); if (mono_runtime_is_shutting_down () || data->inited == 3 || data->sock_to_state == NULL) return; if (async_tp.pool_status == 2) return; MONO_OBJECT_SETREF (state, ares, ares); fd = GPOINTER_TO_INT (state->handle); EnterCriticalSection (&data->io_lock); if (data->sock_to_state == NULL) { LeaveCriticalSection (&data->io_lock); return; } list = mono_g_hash_table_lookup (data->sock_to_state, GINT_TO_POINTER (fd)); if (list == NULL) { list = mono_mlist_alloc ((MonoObject*)state); is_new = TRUE; } else { list = mono_mlist_append (list, (MonoObject*)state); is_new = FALSE; } mono_g_hash_table_replace (data->sock_to_state, state->handle, list); ievt = get_events_from_list (list); data->modify (data->event_data, fd, state->operation, ievt, is_new); LeaveCriticalSection (&data->io_lock); }
/** * mono_mlist_set_data: * @list: the managed list node * * Set the object content in the list node @list. */ void mono_mlist_set_data (MonoMList* list, MonoObject *data) { MONO_OBJECT_SETREF (list, data, data); }
/* Returns the exception thrown when invoking, if any */ static MonoObject * mono_async_invoke (ThreadPool *tp, MonoAsyncResult *ares) { ASyncCall *ac = (ASyncCall *)ares->object_data; MonoObject *res, *exc = NULL; MonoArray *out_args = NULL; HANDLE wait_event = NULL; MonoInternalThread *thread = mono_thread_internal_current (); if (ares->execution_context) { /* use captured ExecutionContext (if available) */ MONO_OBJECT_SETREF (ares, original_context, mono_thread_get_execution_context ()); mono_thread_set_execution_context (ares->execution_context); } else { ares->original_context = NULL; } if (ac == NULL) { /* Fast path from ThreadPool.*QueueUserWorkItem */ void *pa = ares->async_state; /* The debugger needs this */ thread->async_invoke_method = ((MonoDelegate*)ares->async_delegate)->method; res = mono_runtime_delegate_invoke (ares->async_delegate, &pa, &exc); thread->async_invoke_method = NULL; } else { MonoObject *cb_exc = NULL; ac->msg->exc = NULL; res = mono_message_invoke (ares->async_delegate, ac->msg, &exc, &out_args); MONO_OBJECT_SETREF (ac, res, res); MONO_OBJECT_SETREF (ac, msg->exc, exc); MONO_OBJECT_SETREF (ac, out_args, out_args); mono_monitor_enter ((MonoObject *) ares); ares->completed = 1; if (ares->handle != NULL) wait_event = mono_wait_handle_get_handle ((MonoWaitHandle *) ares->handle); mono_monitor_exit ((MonoObject *) ares); /* notify listeners */ if (wait_event != NULL) SetEvent (wait_event); /* call async callback if cb_method != null*/ if (ac != NULL && ac->cb_method) { void *pa = &ares; cb_exc = NULL; thread->async_invoke_method = ac->cb_method; mono_runtime_invoke (ac->cb_method, ac->cb_target, pa, &cb_exc); thread->async_invoke_method = NULL; exc = cb_exc; } else { exc = NULL; } } /* restore original thread execution context if flow isn't suppressed, i.e. non null */ if (ares->original_context) { mono_thread_set_execution_context (ares->original_context); ares->original_context = NULL; } #if DEBUG InterlockedDecrement (&tp->njobs); #endif if (!tp->is_io) InterlockedIncrement (&tp->nexecuted); if (InterlockedDecrement (&monitor_njobs) == 0) monitor_state = MONITOR_STATE_FALLING_ASLEEP; return exc; }
MonoBoolean ves_icall_System_Globalization_CalendarData_fill_calendar_data (MonoCalendarData *this_obj, MonoString *name, gint32 calendar_index) { MonoError error; MonoDomain *domain; const DateTimeFormatEntry *dfe; const CultureInfoNameEntry *ne; const CultureInfoEntry *ci; char *n; n = mono_string_to_utf8_checked (name, &error); if (mono_error_set_pending_exception (&error)) return FALSE; ne = (const CultureInfoNameEntry *)mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES, sizeof (CultureInfoNameEntry), culture_name_locator); g_free (n); if (ne == NULL) { return FALSE; } ci = &culture_entries [ne->culture_entry_index]; dfe = &datetime_format_entries [ci->datetime_format_index]; domain = mono_domain_get (); MONO_OBJECT_SETREF (this_obj, NativeName, mono_string_new (domain, idx2string (ci->nativename))); MonoArray *short_date_patterns = create_names_array_idx_dynamic (dfe->short_date_patterns, NUM_SHORT_DATE_PATTERNS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, ShortDatePatterns, short_date_patterns); MonoArray *year_month_patterns =create_names_array_idx_dynamic (dfe->year_month_patterns, NUM_YEAR_MONTH_PATTERNS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, YearMonthPatterns, year_month_patterns); MonoArray *long_date_patterns = create_names_array_idx_dynamic (dfe->long_date_patterns, NUM_LONG_DATE_PATTERNS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, LongDatePatterns, long_date_patterns); MONO_OBJECT_SETREF (this_obj, MonthDayPattern, mono_string_new (domain, pattern2string (dfe->month_day_pattern))); MonoArray *day_names = create_names_array_idx (dfe->day_names, NUM_DAYS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, DayNames, day_names); MonoArray *abbr_day_names = create_names_array_idx (dfe->abbreviated_day_names, NUM_DAYS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, AbbreviatedDayNames, abbr_day_names); MonoArray *ss_day_names = create_names_array_idx (dfe->shortest_day_names, NUM_DAYS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, SuperShortDayNames, ss_day_names); MonoArray *month_names = create_names_array_idx (dfe->month_names, NUM_MONTHS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, MonthNames, month_names); MonoArray *abbr_mon_names = create_names_array_idx (dfe->abbreviated_month_names, NUM_MONTHS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, AbbreviatedMonthNames, abbr_mon_names); MonoArray *gen_month_names = create_names_array_idx (dfe->month_genitive_names, NUM_MONTHS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, GenitiveMonthNames, gen_month_names); MonoArray *gen_abbr_mon_names = create_names_array_idx (dfe->abbreviated_month_genitive_names, NUM_MONTHS, &error); return_val_and_set_pending_if_nok (&error, FALSE); MONO_OBJECT_SETREF (this_obj, GenitiveAbbreviatedMonthNames, gen_abbr_mon_names); return TRUE; }
void ves_icall_System_Globalization_CultureData_fill_number_data (MonoNumberFormatInfo* number, gint32 number_index) { MonoError error; MonoDomain *domain; const NumberFormatEntry *nfe; g_assert (number_index >= 0); nfe = &number_format_entries [number_index]; domain = mono_domain_get (); number->currencyDecimalDigits = nfe->currency_decimal_digits; MONO_OBJECT_SETREF (number, currencyDecimalSeparator, mono_string_new (domain, idx2string (nfe->currency_decimal_separator))); MONO_OBJECT_SETREF (number, currencyGroupSeparator, mono_string_new (domain, idx2string (nfe->currency_group_separator))); MonoArray *currency_sizes_arr = create_group_sizes_array (nfe->currency_group_sizes, GROUP_SIZE, &error); if (mono_error_set_pending_exception (&error)) return; MONO_OBJECT_SETREF (number, currencyGroupSizes, currency_sizes_arr); number->currencyNegativePattern = nfe->currency_negative_pattern; number->currencyPositivePattern = nfe->currency_positive_pattern; MONO_OBJECT_SETREF (number, currencySymbol, mono_string_new (domain, idx2string (nfe->currency_symbol))); MONO_OBJECT_SETREF (number, naNSymbol, mono_string_new (domain, idx2string (nfe->nan_symbol))); MONO_OBJECT_SETREF (number, negativeInfinitySymbol, mono_string_new (domain, idx2string (nfe->negative_infinity_symbol))); MONO_OBJECT_SETREF (number, negativeSign, mono_string_new (domain, idx2string (nfe->negative_sign))); number->numberDecimalDigits = nfe->number_decimal_digits; MONO_OBJECT_SETREF (number, numberDecimalSeparator, mono_string_new (domain, idx2string (nfe->number_decimal_separator))); MONO_OBJECT_SETREF (number, numberGroupSeparator, mono_string_new (domain, idx2string (nfe->number_group_separator))); MonoArray *number_sizes_arr = create_group_sizes_array (nfe->number_group_sizes, GROUP_SIZE, &error); if (mono_error_set_pending_exception (&error)) return; MONO_OBJECT_SETREF (number, numberGroupSizes, number_sizes_arr); number->numberNegativePattern = nfe->number_negative_pattern; number->percentNegativePattern = nfe->percent_negative_pattern; number->percentPositivePattern = nfe->percent_positive_pattern; MONO_OBJECT_SETREF (number, percentSymbol, mono_string_new (domain, idx2string (nfe->percent_symbol))); MONO_OBJECT_SETREF (number, perMilleSymbol, mono_string_new (domain, idx2string (nfe->per_mille_symbol))); MONO_OBJECT_SETREF (number, positiveInfinitySymbol, mono_string_new (domain, idx2string (nfe->positive_infinity_symbol))); MONO_OBJECT_SETREF (number, positiveSign, mono_string_new (domain, idx2string (nfe->positive_sign))); }