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)));
}
