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;
}
/* note: we better manipulate the string in managed code (easier and safer) */
MonoString*
ves_icall_System_Environment_GetOSVersionString (void)
{
#ifdef PLATFORM_WIN32
OSVERSIONINFO verinfo;
MONO_ARCH_SAVE_REGS;
verinfo.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
if (GetVersionEx (&verinfo)) {
char version [64];
/* maximum string length is 35 bytes
3 x 10 bytes per number, 1 byte for 0, 3 x 1 byte for dots, 1 for NULL */
sprintf (version, "%ld.%ld.%ld.0",
verinfo.dwMajorVersion,
verinfo.dwMinorVersion,
verinfo.dwBuildNumber);
return mono_string_new (mono_domain_get (), version);
}
#elif defined(HAVE_SYS_UTSNAME_H)
struct utsname name;
MONO_ARCH_SAVE_REGS;
if (uname (&name) >= 0) {
return mono_string_new (mono_domain_get (), name.release);
}
#endif
return mono_string_new (mono_domain_get (), "0.0.0.0");
}
/**
* mono_get_exception_missing_field:
* @class_name: the class where the lookup was performed
* @member_name: the name of the missing method.
*
* Returns: a new instance of the `System.MissingFieldException`
*/
MonoException *
mono_get_exception_missing_field (const char *class_name, const char *member_name)
{
MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
"MissingFieldException", s1, s2);
}
void JniManager::toProcessRequest(jobject obj, MonoObject* processRequest)
{
JNIEnv* env = getEnv();
MonoDomain* monoDomain = getMonoDomain();
string c_assemblyName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyName, "()Ljava/lang/String;"));
string c_assemblyPath = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyPath, "()Ljava/lang/String;"));
string c_methodName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getMethodName, "()Ljava/lang/String;"));
MonoString* assemblyName = mono_string_new(monoDomain, c_assemblyName.c_str());
MonoString* assemblyPath = mono_string_new(monoDomain, c_assemblyPath.c_str());
MonoString* methodName = mono_string_new(monoDomain, c_methodName.c_str());
bool fullTrust = env->CallBooleanMethod(obj, getFullTrust);
bool isSingleton = env->CallBooleanMethod(obj, getIsSingleton);
bool log = env->CallBooleanMethod(obj, getLog);
bool notifyEvents = env->CallBooleanMethod(obj, getNotifyEvents);
MonoObject* exception = NULL;
void* args[1];
args[0] = assemblyName;
mono_runtime_invoke(setAssemblyNameField, processRequest, args, &exception);
args[0] = assemblyPath;
mono_runtime_invoke(setAssemblyPathField, processRequest, args, &exception);
args[0] = methodName;
mono_runtime_invoke(setMethodNameField, processRequest, args, &exception);
args[0] = &fullTrust;
mono_runtime_invoke(setFullTrustField, processRequest, args, &exception);
args[0] = &log;
mono_runtime_invoke(setLogField, processRequest, args, &exception);
args[0] = &isSingleton;
mono_runtime_invoke(setIsSingletonField, processRequest, args, &exception);
args[0] = ¬ifyEvents;
mono_runtime_invoke(setNotifyEventsField, processRequest, args, &exception);
if (exception)
{
const char* message = mono_string_to_utf8(mono_object_to_string(exception, NULL));
throwException(message);
}
jobject javaMethodArguments = env->CallObjectMethod(obj, getMethodArguments);
setProperties(env, javaMethodArguments, addMethodArgumentsProperty, processRequest);
//request->MethodArguments = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getMethodArguments));
//request->InboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInboundProperties));
//request->InvocationProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInvocationProperties));
//request->OutboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getOutboundProperties));
//request->SessionProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getSessionProperties));
}
void SecurityElement::AddAttribute(const char *name, const char *value)
{
MonoType *__parameter_types__[2];
void *__parameters__[2];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[1] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), name);
__parameters__[1] = mono_string_new(Global::GetDomain(), value);
Global::InvokeMethod("mscorlib", "System.Security", "SecurityElement", 0, NULL, "AddAttribute", __native_object__, 2, __parameter_types__, __parameters__, NULL);
}
mscorlib::System::Globalization::CultureInfo CultureInfo::GetCultureInfo(const char *name, const char *altName)
{
MonoType *__parameter_types__[2];
void *__parameters__[2];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[1] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), name);
__parameters__[1] = mono_string_new(Global::GetDomain(), altName);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Globalization", "CultureInfo", 0, NULL, "GetCultureInfo", NullMonoObject, 2, __parameter_types__, __parameters__, NULL);
return mscorlib::System::Globalization::CultureInfo(__result__);
}
/**
* mono_get_exception_missing_field:
* @class_name: the class where the lookup was performed
* @member_name: the name of the missing method.
*
* Returns: a new instance of the `System.MissingFieldException`
*/
MonoException *
mono_get_exception_missing_field (const char *class_name, const char *member_name)
{
MonoString *s1 = mono_string_new (mono_domain_get (), class_name);
MonoString *s2 = mono_string_new (mono_domain_get (), member_name);
MonoError error;
MonoException *ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System",
"MissingFieldException", s1, s2, &error);
mono_error_assert_ok (&error);
return ret;
}
void Debugger::Log(mscorlib::System::Int32 level, const char *category, const char *message)
{
MonoType *__parameter_types__[3];
void *__parameters__[3];
__parameter_types__[0] = Global::GetType(typeid(level).name());
__parameter_types__[1] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[2] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = &level;
__parameters__[1] = mono_string_new(Global::GetDomain(), category);
__parameters__[2] = mono_string_new(Global::GetDomain(), message);
Global::InvokeMethod("mscorlib", "System.Diagnostics", "Debugger", 0, NULL, "Log", NullMonoObject, 3, __parameter_types__, __parameters__, NULL);
}
mscorlib::System::String ContractHelper::RaiseContractFailedEvent(mscorlib::System::Diagnostics::Contracts::ContractFailureKind::__ENUM__ failureKind, const char *userMessage, const char *conditionText, mscorlib::System::Exception innerException)
{
MonoType *__parameter_types__[4];
void *__parameters__[4];
__parameter_types__[0] = Global::GetType(typeid(failureKind).name());
__parameter_types__[1] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[2] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[3] = Global::GetType(typeid(innerException).name());
mscorlib::System::Int32 __param_failureKind__ = failureKind;
__parameters__[0] = &__param_failureKind__;
__parameters__[1] = mono_string_new(Global::GetDomain(), userMessage);
__parameters__[2] = mono_string_new(Global::GetDomain(), conditionText);
__parameters__[3] = (MonoObject*)innerException;
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Diagnostics.Contracts.Internal", "ContractHelper", 0, NULL, "RaiseContractFailedEvent", NullMonoObject, 4, __parameter_types__, __parameters__, NULL);
return mscorlib::System::String(__result__);
}
static MonoArray*
create_names_array_idx (const guint16 *names, int ml)
{
MonoArray *ret;
MonoDomain *domain;
int i, len = 0;
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);
for(i = 0; i < len; i++)
mono_array_setref (ret, i, mono_string_new (domain, idx2string (names [i])));
return ret;
}
MonoArray *
list_serial_devices (void)
{
MonoArray *array;
#if defined(linux)
/* Linux serial files are of the form ttyS[0-9]+ */
GSList *l, *list = NULL;
GDir* dir = g_dir_open ("/dev", 0, NULL);
const char *filename;
int i = 0;
while ((filename = g_dir_read_name (dir))) {
if (filename) {
if (!strncmp (filename, "ttyS", 4))
list = g_slist_append (list, g_strconcat ("/dev/", filename, NULL));
}
}
g_dir_close (dir);
array = mono_array_new (mono_domain_get (), mono_get_string_class (), g_slist_length (list));
for (l = list; l; l = l->next) {
mono_array_set (array, gpointer, i++, mono_string_new (mono_domain_get (), (char*)l->data));
g_free (l->data);
}
g_slist_free (list);
#else
#warning "list_serial_devices isn't ported to this OS"
#endif
return array;
}
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;
}
/**
* mono_get_exception_type_initialization:
* @type_name: the name of the type that failed to initialize.
* @inner: the inner exception.
*
* Returns: a new instance of the System.TypeInitializationException
*/
MonoException *
mono_get_exception_type_initialization (const gchar *type_name, MonoException *inner)
{
MonoClass *klass;
gpointer args [2];
MonoObject *exc;
MonoMethod *method;
gpointer iter;
klass = mono_class_from_name (mono_get_corlib (), "System", "TypeInitializationException");
g_assert (klass);
mono_class_init (klass);
/* TypeInitializationException only has 1 ctor with 2 args */
iter = NULL;
while ((method = mono_class_get_methods (klass, &iter))) {
if (!strcmp (".ctor", mono_method_get_name (method)) && mono_method_signature (method)->param_count == 2)
break;
method = NULL;
}
g_assert (method);
args [0] = mono_string_new (mono_domain_get (), type_name);
args [1] = inner;
exc = mono_object_new (mono_domain_get (), klass);
mono_runtime_invoke (method, exc, args, NULL);
return (MonoException *) exc;
}
MonoObject* MonoEmbedding::GetClrFuncReflectionWrapFunc(const char* assemblyFile, const char* typeName, const char* methodName, MonoException ** exc)
{
static MonoMethod* method;
void* params[3];
if (!method)
{
method = mono_class_get_method_from_name(MonoEmbedding::GetClass(), "GetFunc", 3);
}
params[0] = mono_string_new(mono_domain_get(), assemblyFile);
params[1] = mono_string_new(mono_domain_get(), typeName);
params[2] = mono_string_new(mono_domain_get(), methodName);
MonoObject* action = mono_runtime_invoke(method, NULL, params, (MonoObject**)exc);
return action;
}
/**
* mono_get_exception_file_not_found2:
* @msg: an informative message for the user.
* @fname: the name of the file not found.
*
* Returns: a new instance of the `System.IO.FileNotFoundException`
*/
MonoException *
mono_get_exception_file_not_found2 (const char *msg, MonoString *fname)
{
MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL;
return mono_exception_from_name_two_strings (
mono_get_corlib (), "System.IO", "FileNotFoundException", s, fname);
}
/**
* mono_get_exception_bad_image_format2:
* @msg: an informative message for the user.
* @fname: The full name of the file with the invalid image.
*
* Returns: a new instance of the `System.BadImageFormatException`
*/
MonoException *
mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname)
{
MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL;
return mono_exception_from_name_two_strings (
mono_get_corlib (), "System", "BadImageFormatException", s, fname);
}
/**
* mono_get_exception_type_load:
* @class_name: the name of the class that could not be loaded
* @assembly_name: the assembly where the class was looked up.
*
* Returns: a new instance of the `System.TypeLoadException`
*/
MonoException *
mono_get_exception_type_load (MonoString *class_name, char *assembly_name)
{
MonoString *s = assembly_name ? mono_string_new (mono_domain_get (), assembly_name) : mono_string_new (mono_domain_get (), "");
return mono_exception_from_name_two_strings (mono_get_corlib (), "System",
"TypeLoadException", class_name, s);
}
void BinaryWriter::Write(const char *value)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), value);
Global::InvokeMethod("mscorlib", "System.IO", "BinaryWriter", 0, NULL, "Write", __native_object__, 1, __parameter_types__, __parameters__, NULL);
}
void ContractHelper::TriggerFailure(mscorlib::System::Diagnostics::Contracts::ContractFailureKind::__ENUM__ kind, const char *displayMessage, const char *userMessage, const char *conditionText, mscorlib::System::Exception innerException)
{
MonoType *__parameter_types__[5];
void *__parameters__[5];
__parameter_types__[0] = Global::GetType(typeid(kind).name());
__parameter_types__[1] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[2] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[3] = Global::GetType("mscorlib", "System", "String");
__parameter_types__[4] = Global::GetType(typeid(innerException).name());
mscorlib::System::Int32 __param_kind__ = kind;
__parameters__[0] = &__param_kind__;
__parameters__[1] = mono_string_new(Global::GetDomain(), displayMessage);
__parameters__[2] = mono_string_new(Global::GetDomain(), userMessage);
__parameters__[3] = mono_string_new(Global::GetDomain(), conditionText);
__parameters__[4] = (MonoObject*)innerException;
Global::InvokeMethod("mscorlib", "System.Diagnostics.Contracts.Internal", "ContractHelper", 0, NULL, "TriggerFailure", NullMonoObject, 5, __parameter_types__, __parameters__, NULL);
}
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;
}
static void
monitor_thread (gpointer unused)
{
ThreadPool *pools [2];
MonoInternalThread *thread;
guint32 ms;
gboolean need_one;
int i;
pools [0] = &async_tp;
pools [1] = &async_io_tp;
thread = mono_thread_internal_current ();
ves_icall_System_Threading_Thread_SetName_internal (thread, mono_string_new (mono_domain_get (), "Threadpool monitor"));
while (1) {
ms = 500;
i = 10; //number of spurious awakes we tolerate before doing a round of rebalancing.
do {
guint32 ts;
ts = mono_msec_ticks ();
if (SleepEx (ms, TRUE) == 0)
break;
ms -= (mono_msec_ticks () - ts);
if (mono_runtime_is_shutting_down ())
break;
if (THREAD_WANTS_A_BREAK (thread))
mono_thread_interruption_checkpoint ();
} while (ms > 0 && i--);
if (mono_runtime_is_shutting_down ())
break;
if (suspended)
continue;
for (i = 0; i < 2; i++) {
ThreadPool *tp;
tp = pools [i];
if (tp->waiting > 0)
continue;
need_one = (mono_cq_count (tp->queue) > 0);
if (!need_one && !tp->is_io) {
EnterCriticalSection (&wsqs_lock);
for (i = 0; wsqs != NULL && i < wsqs->len; i++) {
MonoWSQ *wsq;
wsq = g_ptr_array_index (wsqs, i);
if (mono_wsq_count (wsq) != 0) {
need_one = TRUE;
break;
}
}
LeaveCriticalSection (&wsqs_lock);
}
if (need_one)
threadpool_start_thread (tp);
}
}
}
mscorlib::System::Security::SecurityElement SecurityElement::SearchForChildByTag(const char *tag)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), tag);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security", "SecurityElement", 0, NULL, "SearchForChildByTag", __native_object__, 1, __parameter_types__, __parameters__, NULL);
return mscorlib::System::Security::SecurityElement(__result__);
}
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");
}
mscorlib::System::String SecurityElement::Attribute(const char *name)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), name);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security", "SecurityElement", 0, NULL, "Attribute", __native_object__, 1, __parameter_types__, __parameters__, NULL);
return mscorlib::System::String(__result__);
}
mscorlib::System::String SecurityElement::Escape(const char *str)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), str);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security", "SecurityElement", 0, NULL, "Escape", NullMonoObject, 1, __parameter_types__, __parameters__, NULL);
return mscorlib::System::String(__result__);
}
mscorlib::System::String IdnMapping::GetAscii(const char *unicode)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), unicode);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Globalization", "IdnMapping", 0, NULL, "GetAscii", __native_object__, 1, __parameter_types__, __parameters__, NULL);
return mscorlib::System::String(__result__);
}
static void *
init_perf_counter (const char *category, const char *counter)
{
MonoString *category_str;
MonoString *counter_str;
MonoString *machine;
MonoDomain *root;
MonoBoolean custom;
int type;
if (category == NULL || counter == NULL)
return NULL;
root = mono_get_root_domain ();
category_str = mono_string_new (root, category);
counter_str = mono_string_new (root, counter);
machine = mono_string_new (root, ".");
return mono_perfcounter_get_impl (category_str, counter_str, NULL, machine, &type, &custom);
}
mscorlib::System::Boolean SecurityElement::IsValidText(const char *text)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), text);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Security", "SecurityElement", 0, NULL, "IsValidText", NullMonoObject, 1, __parameter_types__, __parameters__, NULL);
return *(mscorlib::System::Boolean*)mono_object_unbox(__result__);
}
mscorlib::System::Runtime::Remoting::Metadata::W3cXsd2001::SoapNegativeInteger SoapNegativeInteger::Parse(const char *value)
{
MonoType *__parameter_types__[1];
void *__parameters__[1];
__parameter_types__[0] = Global::GetType("mscorlib", "System", "String");
__parameters__[0] = mono_string_new(Global::GetDomain(), value);
MonoObject *__result__ = Global::InvokeMethod("mscorlib", "System.Runtime.Remoting.Metadata.W3cXsd2001", "SoapNegativeInteger", 0, NULL, "Parse", NullMonoObject, 1, __parameter_types__, __parameters__, NULL);
return mscorlib::System::Runtime::Remoting::Metadata::W3cXsd2001::SoapNegativeInteger(__result__);
}
MonoBoolean
ves_icall_System_Globalization_CalendarData_fill_calendar_data (MonoCalendarData *this_obj, MonoString *name, gint32 calendar_index)
{
MonoDomain *domain;
const DateTimeFormatEntry *dfe;
const CultureInfoNameEntry *ne;
const CultureInfoEntry *ci;
char *n;
n = mono_string_to_utf8 (name);
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)));
MONO_OBJECT_SETREF (this_obj, ShortDatePatterns, create_names_array_idx_dynamic (dfe->short_date_patterns,
NUM_SHORT_DATE_PATTERNS));
MONO_OBJECT_SETREF (this_obj, YearMonthPatterns, create_names_array_idx_dynamic (dfe->year_month_patterns,
NUM_YEAR_MONTH_PATTERNS));
MONO_OBJECT_SETREF (this_obj, LongDatePatterns, create_names_array_idx_dynamic (dfe->long_date_patterns,
NUM_LONG_DATE_PATTERNS));
MONO_OBJECT_SETREF (this_obj, MonthDayPattern, mono_string_new (domain, idx2string (dfe->month_day_pattern)));
MONO_OBJECT_SETREF (this_obj, DayNames, create_names_array_idx (dfe->day_names, NUM_DAYS));
MONO_OBJECT_SETREF (this_obj, AbbreviatedDayNames, create_names_array_idx (dfe->abbreviated_day_names,
NUM_DAYS));
MONO_OBJECT_SETREF (this_obj, SuperShortDayNames, create_names_array_idx (dfe->shortest_day_names, NUM_DAYS));
MONO_OBJECT_SETREF (this_obj, MonthNames, create_names_array_idx (dfe->month_names, NUM_MONTHS));
MONO_OBJECT_SETREF (this_obj, AbbreviatedMonthNames, create_names_array_idx (dfe->abbreviated_month_names,
NUM_MONTHS));
MONO_OBJECT_SETREF (this_obj, GenitiveMonthNames, create_names_array_idx (dfe->month_genitive_names, NUM_MONTHS));
MONO_OBJECT_SETREF (this_obj, GenitiveAbbreviatedMonthNames, create_names_array_idx (dfe->abbreviated_month_genitive_names, NUM_MONTHS));
return TRUE;
}
