string_vt = mono_class_vtable (domain, mono_defaults.string_class);
string_empty_fld = mono_class_get_field_from_name (mono_defaults.string_class, "Empty");
g_assert (string_empty_fld);
- MonoString *empty_str = mono_string_intern_checked (mono_string_new (domain, ""), &error);
+ MonoString *empty_str = mono_string_new_checked (domain, "", &error);
+ mono_error_assert_ok (&error);
+ empty_str = mono_string_intern_checked (empty_str, &error);
mono_error_assert_ok (&error);
mono_field_static_set_value (string_vt, string_empty_fld, empty_str);
domain->empty_string = empty_str;
/*
* Create an instance early since we can't do it when there is no memory.
*/
- arg = mono_string_new (domain, "Out of memory");
+ arg = mono_string_new_checked (domain, "Out of memory", &error);
+ mono_error_assert_ok (&error);
domain->out_of_memory_ex = mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "OutOfMemoryException", arg, NULL, &error);
mono_error_assert_ok (&error);
* These two are needed because the signal handlers might be executing on
* an alternate stack, and Boehm GC can't handle that.
*/
- arg = mono_string_new (domain, "A null value was found where an object instance was required");
+ arg = mono_string_new_checked (domain, "A null value was found where an object instance was required", &error);
+ mono_error_assert_ok (&error);
domain->null_reference_ex = mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "NullReferenceException", arg, NULL, &error);
mono_error_assert_ok (&error);
- arg = mono_string_new (domain, "The requested operation caused a stack overflow.");
+ arg = mono_string_new_checked (domain, "The requested operation caused a stack overflow.", &error);
+ mono_error_assert_ok (&error);
domain->stack_overflow_ex = mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL, &error);
mono_error_assert_ok (&error);
void
mono_domain_set_config (MonoDomain *domain, const char *base_dir, const char *config_file_name)
{
- MONO_OBJECT_SETREF (domain->setup, application_base, mono_string_new (domain, base_dir));
- MONO_OBJECT_SETREF (domain->setup, configuration_file, mono_string_new (domain, config_file_name));
+ HANDLE_FUNCTION_ENTER ();
+ MonoError error;
+ mono_domain_set_config_checked (domain, base_dir, config_file_name, &error);
+ mono_error_cleanup (&error);
+ HANDLE_FUNCTION_RETURN ();
+}
+
+gboolean
+mono_domain_set_config_checked (MonoDomain *domain, const char *base_dir, const char *config_file_name, MonoError *error)
+{
+ error_init (error);
+ MonoAppDomainSetupHandle setup = MONO_HANDLE_NEW (MonoAppDomainSetup, domain->setup);
+ MonoStringHandle base_dir_str = mono_string_new_handle (domain, base_dir, error);
+ if (!is_ok (error))
+ goto leave;
+ MONO_HANDLE_SET (setup, application_base, base_dir_str);
+ MonoStringHandle config_file_name_str = mono_string_new_handle (domain, config_file_name, error);
+ if (!is_ok (error))
+ goto leave;
+ MONO_HANDLE_SET (setup, configuration_file, config_file_name_str);
+leave:
+ return is_ok (error);
}
static MonoAppDomainSetupHandle
}
}
- if (name)
- *params = (MonoObject*)mono_string_new (mono_domain_get (), name);
- else
+ if (name) {
+ *params = (MonoObject*)mono_string_new_checked (mono_domain_get (), name, error);
+ return_val_if_nok (error, NULL);
+ } else
*params = tb;
ret = (MonoReflectionAssembly *) mono_runtime_invoke_checked (method, domain->domain, params, error);
internal = mono_thread_internal_current ();
- mono_thread_set_name_internal (internal, mono_string_new (mono_domain_get (), "Domain unloader"), TRUE, FALSE, &error);
+ MonoString *thread_name_str = mono_string_new_checked (mono_domain_get (), "Domain unloader", &error);
+ if (is_ok (&error))
+ mono_thread_set_name_internal (internal, thread_name_str, TRUE, FALSE, &error);
if (!is_ok (&error)) {
data->failure_reason = g_strdup (mono_error_get_message (&error));
mono_error_cleanup (&error);
MONO_API MonoDomain *
mono_domain_create_appdomain (char *friendly_name, char *configuration_file);
+MONO_RT_EXTERNAL_ONLY
MONO_API void
mono_domain_set_config (MonoDomain *domain, const char *base_dir, const char *config_file_name);
}
if (args) {
- mono_array_set (main_args, MonoString*, 0, mono_string_new (domain, args));
+ MonoString *args_str = mono_string_new_checked (domain, args, &error);
+ if (!is_ok (&error)) {
+ g_print ("Could not allocate main method arg string due to %s\n", mono_error_get_message (&error));
+ mono_error_cleanup (&error);
+ g_free (agent);
+ return 1;
+ }
+ mono_array_set (main_args, MonoString*, 0, args_str);
}
MonoInternalThread *internal;
internal = mono_thread_internal_current ();
- mono_thread_set_name_internal (internal, mono_string_new (mono_domain_get (), "Attach receiver"), TRUE, FALSE, &error);
+ MonoString *attach_str = mono_string_new_checked (mono_domain_get (), "Attach receiver", &error);
+ mono_error_assert_ok (&error);
+ mono_thread_set_name_internal (internal, attach_str, TRUE, FALSE, &error);
mono_error_assert_ok (&error);
/* Ask the runtime to not abort this thread */
//internal->flags |= MONO_THREAD_FLAG_DONT_MANAGE;
void
mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception);
+gboolean
+mono_domain_set_config_checked (MonoDomain *domain, const char *base_dir, const char *config_file_name, MonoError *error);
+
MonoTryBlockHoleTableJitInfo*
mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji);
#include <mono/metadata/appdomain.h>
#include <mono/metadata/environment.h>
#include <mono/metadata/exception.h>
+#include <mono/metadata/handle.h>
#include <mono/utils/mono-compiler.h>
#include <mono/utils/w32api.h>
-extern MonoString* ves_icall_System_Environment_GetOSVersionString (void);
+extern MonoStringHandle ves_icall_System_Environment_GetOSVersionString (MonoError *error);
#if !defined(HOST_WIN32) && defined(HAVE_SYS_UTSNAME_H)
#include <sys/utsname.h>
}
/* note: we better manipulate the string in managed code (easier and safer) */
-MonoString*
-ves_icall_System_Environment_GetOSVersionString (void)
+MonoStringHandle
+ves_icall_System_Environment_GetOSVersionString (MonoError *error)
{
+ error_init (error);
#ifdef HOST_WIN32
OSVERSIONINFOEX verinfo;
verinfo.dwMinorVersion,
verinfo.dwBuildNumber,
verinfo.wServicePackMajor << 16);
- return mono_string_new (mono_domain_get (), version);
+ return mono_string_new_handle (mono_domain_get (), version, error);
}
#elif defined(HAVE_SYS_UTSNAME_H)
struct utsname name;
if (uname (&name) >= 0) {
- return mono_string_new (mono_domain_get (), name.release);
+ return mono_string_new_handle (mono_domain_get (), name.release, error);
}
#endif
- return mono_string_new (mono_domain_get (), "0.0.0.0");
+ return mono_string_new_handle (mono_domain_get (), "0.0.0.0", error);
}
mono_exception_from_name_msg (MonoImage *image, const char *name_space,
const char *name, const char *msg)
{
+ MonoError error;
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));
+ if (msg) {
+ MonoString *msg_str = mono_string_new_checked (mono_object_get_domain ((MonoObject*)ex), msg, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (ex, message, msg_str);
+ }
return ex;
}
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 (), "");
-
MonoError error;
+ MonoString *s = NULL;
+ if (assembly_name) {
+ s = mono_string_new_checked (mono_domain_get (), assembly_name, &error);
+ mono_error_assert_ok (&error);
+ } else
+ s = mono_string_empty (mono_domain_get ());
+
MonoException *ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System",
"TypeLoadException", class_name, s, &error);
mono_error_assert_ok (&error);
MonoException *
mono_get_exception_missing_method (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;
+ MonoString *s1 = mono_string_new_checked (mono_domain_get (), class_name, &error);
+ mono_error_assert_ok (&error);
+ MonoString *s2 = mono_string_new_checked (mono_domain_get (), member_name, &error);
+ mono_error_assert_ok (&error);
+
MonoException *ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System",
"MissingMethodException", s1, s2, &error);
mono_error_assert_ok (&error);
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;
+ MonoString *s1 = mono_string_new_checked (mono_domain_get (), class_name, &error);
+ mono_error_assert_ok (&error);
+ MonoString *s2 = mono_string_new_checked (mono_domain_get (), member_name, &error);
+ mono_error_assert_ok (&error);
+
MonoException *ret = mono_exception_from_name_two_strings_checked (mono_get_corlib (), "System",
"MissingFieldException", s1, s2, &error);
mono_error_assert_ok (&error);
mono_get_corlib (), "System", "ArgumentNullException");
if (arg) {
+ MonoError error;
MonoArgumentException *argex = (MonoArgumentException *)ex;
- MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
+ MonoString *arg_str = mono_string_new_checked (mono_object_get_domain ((MonoObject*)ex), arg, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (argex, param_name, arg_str);
}
return ex;
mono_get_corlib (), "System", "ArgumentException", msg);
if (arg) {
+ MonoError error;
MonoArgumentException *argex = (MonoArgumentException *)ex;
- MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
+ MonoString *arg_str = mono_string_new_checked (mono_object_get_domain ((MonoObject*)ex), arg, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (argex, param_name, arg_str);
}
return ex;
mono_get_corlib (), "System", "ArgumentOutOfRangeException");
if (arg) {
+ MonoError error;
MonoArgumentException *argex = (MonoArgumentException *)ex;
- MONO_OBJECT_SETREF (argex, param_name, mono_string_new (mono_object_get_domain ((MonoObject*)ex), arg));
+ MonoString *arg_str = mono_string_new_checked (mono_object_get_domain ((MonoObject*)ex), arg, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (argex, param_name, arg_str);
}
return ex;
MonoException *
mono_get_exception_file_not_found2 (const char *msg, MonoString *fname)
{
- MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL;
-
MonoError error;
+ MonoString *s = NULL;
+ if (msg) {
+ s = mono_string_new_checked (mono_domain_get (), msg, &error);
+ mono_error_assert_ok (&error);
+ }
+
MonoException *ret = mono_exception_from_name_two_strings_checked (
mono_get_corlib (), "System.IO", "FileNotFoundException", s, fname, &error);
mono_error_assert_ok (&error);
MonoMethod *method;
gpointer iter;
+ error_init (error);
+
klass = mono_class_load_from_name (mono_get_corlib (), "System", "TypeInitializationException");
mono_class_init (klass);
}
g_assert (method);
- args [0] = mono_string_new (mono_domain_get (), type_name);
+ MonoString *type_name_str = mono_string_new_checked (mono_domain_get (), type_name, error);
+ mono_error_assert_ok (error);
+ args [0] = type_name_str;
args [1] = inner;
exc = mono_object_new_checked (mono_domain_get (), klass, error);
MonoException *
mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname)
{
- MonoString *s = msg ? mono_string_new (mono_domain_get (), msg) : NULL;
-
MonoError error;
+ MonoString *s = NULL;
+
+ if (msg) {
+ s = mono_string_new_checked (mono_domain_get (), msg, &error);
+ mono_error_assert_ok (&error);
+ }
+
MonoException *ret = mono_exception_from_name_two_strings_checked (
mono_get_corlib (), "System", "BadImageFormatException", s, fname, &error);
mono_error_assert_ok (&error);
gint *code,
gint *reqnum)
{
+ MonoError error;
FAMEvent ev;
if (FAMNextEvent (conn, &ev) == 1) {
- *filename = mono_string_new (mono_domain_get (), ev.filename);
+ *filename = mono_string_new_checked (mono_domain_get (), ev.filename, &error);
*code = ev.code;
*reqnum = ev.fr.reqnum;
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
return TRUE;
}
MonoError error;
gboolean wait = TRUE;
- mono_thread_set_name_internal (mono_thread_internal_current (), mono_string_new (mono_get_root_domain (), "Finalizer"), FALSE, FALSE, &error);
+ MonoString *finalizer = mono_string_new_checked (mono_get_root_domain (), "Finalizer", &error);
+ mono_error_assert_ok (&error);
+ mono_thread_set_name_internal (mono_thread_internal_current (), finalizer, FALSE, FALSE, &error);
mono_error_assert_ok (&error);
/* Register a hazard free queue pump callback */
ICALL_TYPE(DEFAULTC, "System.Configuration.DefaultConfig", DEFAULTC_1)
HANDLES(ICALL(DEFAULTC_1, "get_bundled_machine_config", ves_icall_System_Configuration_DefaultConfig_get_bundled_machine_config))
-ICALL(DEFAULTC_2, "get_machine_config_path", ves_icall_System_Configuration_DefaultConfig_get_machine_config_path)
+HANDLES(ICALL(DEFAULTC_2, "get_machine_config_path", ves_icall_System_Configuration_DefaultConfig_get_machine_config_path))
/* Note that the below icall shares the same function as DefaultConfig uses */
ICALL_TYPE(INTCFGHOST, "System.Configuration.InternalConfigurationHost", INTCFGHOST_1)
-ICALL(INTCFGHOST_1, "get_bundled_app_config", get_bundled_app_config)
+HANDLES(ICALL(INTCFGHOST_1, "get_bundled_app_config", ves_icall_System_Configuration_InternalConfigurationHost_get_bundled_app_config))
HANDLES(ICALL(INTCFGHOST_2, "get_bundled_machine_config", ves_icall_System_Configuration_InternalConfigurationHost_get_bundled_machine_config))
ICALL_TYPE(CONSOLE, "System.ConsoleDriver", CONSOLE_1)
ICALL(ENV_3, "GetEnvironmentVariableNames", ves_icall_System_Environment_GetEnvironmentVariableNames)
ICALL(ENV_31, "GetIs64BitOperatingSystem", ves_icall_System_Environment_GetIs64BitOperatingSystem)
ICALL(ENV_4, "GetLogicalDrivesInternal", ves_icall_System_Environment_GetLogicalDrives )
-ICALL(ENV_5, "GetMachineConfigPath", ves_icall_System_Configuration_DefaultConfig_get_machine_config_path)
-ICALL(ENV_51, "GetNewLine", ves_icall_System_Environment_get_NewLine)
-ICALL(ENV_6, "GetOSVersionString", ves_icall_System_Environment_GetOSVersionString)
+HANDLES(ICALL(ENV_5, "GetMachineConfigPath", ves_icall_System_Configuration_DefaultConfig_get_machine_config_path))
+HANDLES(ICALL(ENV_51, "GetNewLine", ves_icall_System_Environment_get_NewLine))
+HANDLES(ICALL(ENV_6, "GetOSVersionString", ves_icall_System_Environment_GetOSVersionString))
ICALL(ENV_6a, "GetPageSize", mono_pagesize)
-ICALL(ENV_7, "GetWindowsFolderPath", ves_icall_System_Environment_GetWindowsFolderPath)
+HANDLES(ICALL(ENV_7, "GetWindowsFolderPath", ves_icall_System_Environment_GetWindowsFolderPath))
ICALL(ENV_8, "InternalSetEnvironmentVariable", ves_icall_System_Environment_InternalSetEnvironmentVariable)
ICALL(ENV_9, "get_ExitCode", mono_environment_exitcode_get)
ICALL(ENV_10, "get_HasShutdownStarted", ves_icall_System_Environment_get_HasShutdownStarted)
-ICALL(ENV_11, "get_MachineName", ves_icall_System_Environment_get_MachineName)
+HANDLES(ICALL(ENV_11, "get_MachineName", ves_icall_System_Environment_get_MachineName))
ICALL(ENV_13, "get_Platform", ves_icall_System_Environment_get_Platform)
ICALL(ENV_14, "get_ProcessorCount", mono_cpu_count)
ICALL(ENV_15, "get_TickCount", ves_icall_System_Environment_get_TickCount)
-ICALL(ENV_16, "get_UserName", ves_icall_System_Environment_get_UserName)
+HANDLES(ICALL(ENV_16, "get_UserName", ves_icall_System_Environment_get_UserName))
HANDLES(ICALL(ENV_16b, "get_bundled_machine_config", ves_icall_System_Environment_get_bundled_machine_config))
ICALL(ENV_16m, "internalBroadcastSettingChange", ves_icall_System_Environment_BroadcastSettingChange)
HANDLES(ICALL(ENV_17, "internalGetEnvironmentVariable_native", ves_icall_System_Environment_GetEnvironmentVariable_native))
ICALL_TYPE(CULINF, "System.Globalization.CultureInfo", CULINF_5)
ICALL(CULINF_5, "construct_internal_locale_from_lcid", ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_lcid)
ICALL(CULINF_6, "construct_internal_locale_from_name", ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_name)
-ICALL(CULINF_7, "get_current_locale_name", ves_icall_System_Globalization_CultureInfo_get_current_locale_name)
+HANDLES(ICALL(CULINF_7, "get_current_locale_name", ves_icall_System_Globalization_CultureInfo_get_current_locale_name))
ICALL(CULINF_9, "internal_get_cultures", ves_icall_System_Globalization_CultureInfo_internal_get_cultures)
//ICALL(CULINF_10, "internal_is_lcid_neutral", ves_icall_System_Globalization_CultureInfo_internal_is_lcid_neutral)
ICALL(MARSHAL_12, "OffsetOf", ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf)
ICALL(MARSHAL_13, "Prelink", ves_icall_System_Runtime_InteropServices_Marshal_Prelink)
ICALL(MARSHAL_14, "PrelinkAll", ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll)
-ICALL(MARSHAL_15, "PtrToStringAnsi(intptr)", ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi)
+HANDLES(ICALL(MARSHAL_15, "PtrToStringAnsi(intptr)", ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi))
ICALL(MARSHAL_16, "PtrToStringAnsi(intptr,int)", ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len)
ICALL(MARSHAL_17, "PtrToStringBSTR", ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR)
ICALL(MARSHAL_18, "PtrToStringUni(intptr)", ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni)
ICALL(STRING_11, "InternalIsInterned", ves_icall_System_String_InternalIsInterned)
ICALL_TYPE(TENC, "System.Text.EncodingHelper", TENC_1)
-ICALL(TENC_1, "InternalCodePage", ves_icall_System_Text_EncodingHelper_InternalCodePage)
+HANDLES(ICALL(TENC_1, "InternalCodePage", ves_icall_System_Text_EncodingHelper_InternalCodePage))
ICALL_TYPE(UNORM, "System.Text.Normalization", UNORM_1)
ICALL(UNORM_1, "load_normalization_resource", ves_icall_System_Text_Normalization_load_normalization_resource)
ICALL(VALUET_2, "InternalGetHashCode", ves_icall_System_ValueType_InternalGetHashCode)
ICALL_TYPE(WEBIC, "System.Web.Util.ICalls", WEBIC_1)
-ICALL(WEBIC_1, "GetMachineConfigPath", ves_icall_System_Configuration_DefaultConfig_get_machine_config_path)
-ICALL(WEBIC_2, "GetMachineInstallDirectory", ves_icall_System_Web_Util_ICalls_get_machine_install_dir)
+HANDLES(ICALL(WEBIC_1, "GetMachineConfigPath", ves_icall_System_Configuration_DefaultConfig_get_machine_config_path))
+HANDLES(ICALL(WEBIC_2, "GetMachineInstallDirectory", ves_icall_System_Web_Util_ICalls_get_machine_install_dir))
HANDLES(ICALL(WEBIC_3, "GetUnmanagedResourcesPtr", ves_icall_get_resources_ptr))
#ifndef DISABLE_COM
gpointer
mono_icall_module_get_hinstance (MonoReflectionModuleHandle module);
-MonoString *
-mono_icall_get_machine_name (void);
+MonoStringHandle
+mono_icall_get_machine_name (MonoError *error);
int
mono_icall_get_platform (void);
-MonoString *
-mono_icall_get_new_line (void);
+MonoStringHandle
+mono_icall_get_new_line (MonoError *error);
MonoBoolean
mono_icall_is_64bit_os (void);
MonoArray *
-mono_icall_get_environment_variable_names (void);
+mono_icall_get_environment_variable_names (MonoError *error);
void
mono_icall_set_environment_variable (MonoString *name, MonoString *value);
-MonoString *
-mono_icall_get_windows_folder_path (int folder);
+MonoStringHandle
+mono_icall_get_windows_folder_path (int folder, MonoError *error);
void
mono_icall_broadcast_setting_change (void);
#include <windows.h>
#include "mono/metadata/icall-windows-internals.h"
-MonoString *
-mono_icall_get_machine_name (void)
+MonoStringHandle
+mono_icall_get_machine_name (MonoError *error)
{
g_unsupported_api ("GetComputerName");
- return mono_string_new (mono_domain_get (), "mono");
+ return mono_string_new_handle (mono_domain_get (), "mono", error);
}
-MonoString *
-mono_icall_get_windows_folder_path (int folder)
+MonoStringHandle
+mono_icall_get_windows_folder_path (int folder, MonoError *error)
{
+ error_init (error);
g_unsupported_api ("SHGetFolderPath");
- return mono_string_new (mono_domain_get (), "");
+ return mono_string_new_handle (mono_domain_get (), "", error);
}
MonoArray *
}
#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
-MonoString *
-mono_icall_get_machine_name (void)
+MonoStringHandle
+mono_icall_get_machine_name (MonoError *error)
{
gunichar2 *buf;
guint32 len;
- MonoString *result;
+ MonoStringHandle result;
len = MAX_COMPUTERNAME_LENGTH + 1;
buf = g_new (gunichar2, len);
result = NULL;
if (GetComputerName (buf, (PDWORD) &len)) {
- MonoError error;
- result = mono_string_new_utf16_checked (mono_domain_get (), buf, len, &error);
- mono_error_set_pending_exception (&error);
- }
+ result = mono_string_new_utf16_handle (mono_domain_get (), buf, len, error);
+ } else
+ result = MONO_HANDLE_NEW (MonoString, NULL);
g_free (buf);
return result;
return 2;
}
-MonoString *
-mono_icall_get_new_line (void)
+MonoStringHandle
+mono_icall_get_new_line (MonoError *error)
{
- return mono_string_new (mono_domain_get (), "\r\n");
+ error_init (error);
+ return mono_string_new_handle (mono_domain_get (), "\r\n", error);
}
MonoBoolean
}
MonoArray *
-mono_icall_get_environment_variable_names (void)
+mono_icall_get_environment_variable_names (MonoError *error)
{
- MonoError error;
MonoArray *names;
MonoDomain *domain;
MonoString *str;
WCHAR* equal_str;
int n = 0;
+ error_init (error);
env_strings = GetEnvironmentStrings();
if (env_strings) {
}
domain = mono_domain_get ();
- names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ names = mono_array_new_checked (domain, mono_defaults.string_class, n, error);
+ return_val_if_nok (error, NULL);
if (env_strings) {
n = 0;
if (*env_string != '=') {
equal_str = wcschr(env_string, '=');
g_assert(equal_str);
- str = mono_string_new_utf16_checked (domain, env_string, (gint32)(equal_str - env_string), &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ str = mono_string_new_utf16_checked (domain, env_string, (gint32)(equal_str - env_string), error);
+ if (!is_ok (error))
+ goto cleanup;
mono_array_setref (names, n, str);
n++;
env_string++;
}
- FreeEnvironmentStrings (env_strings);
}
+cleanup:
+ if (env_strings)
+ FreeEnvironmentStrings (env_strings);
+ if (!is_ok (error))
+ return NULL;
return names;
}
}
#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
-MonoString *
-mono_icall_get_windows_folder_path (int folder)
+MonoStringHandle
+mono_icall_get_windows_folder_path (int folder, MonoError *error)
{
+ error_init (error);
#ifndef CSIDL_FLAG_CREATE
#define CSIDL_FLAG_CREATE 0x8000
#endif
int len = 0;
while (path [len])
++ len;
- MonoError error;
- MonoString *res = mono_string_new_utf16_checked (mono_domain_get (), path, len, &error);
- mono_error_set_pending_exception (&error);
- return res;
+ return mono_string_new_utf16_handle (mono_domain_get (), path, len, error);
}
- return mono_string_new (mono_domain_get (), "");
+ return mono_string_new_handle (mono_domain_get (), "", error);
}
#endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */
#include <sys/utsname.h>
#endif
-extern MonoString* ves_icall_System_Environment_GetOSVersionString (void);
+extern MonoStringHandle ves_icall_System_Environment_GetOSVersionString (MonoError *error);
ICALL_EXPORT MonoReflectionAssemblyHandle ves_icall_System_Reflection_Assembly_GetCallingAssembly (MonoError *error);
/* System.Environment */
-MonoString*
-ves_icall_System_Environment_get_UserName (void)
+MonoStringHandle
+ves_icall_System_Environment_get_UserName (MonoError *error)
{
+ error_init (error);
/* using glib is more portable */
- return mono_string_new (mono_domain_get (), g_get_user_name ());
+ return mono_string_new_handle (mono_domain_get (), g_get_user_name (), error);
}
#ifndef HOST_WIN32
-static MonoString *
-mono_icall_get_machine_name (void)
+static MonoStringHandle
+mono_icall_get_machine_name (MonoError *error)
{
+ error_init (error);
#if !defined(DISABLE_SOCKETS)
- MonoString *result;
+ MonoStringHandle result;
char *buf;
int n;
#if defined _SC_HOST_NAME_MAX
if (gethostname (buf, n) == 0){
buf [n] = 0;
- result = mono_string_new (mono_domain_get (), buf);
+ result = mono_string_new_handle (mono_domain_get (), buf, error);
} else
- result = NULL;
+ result = MONO_HANDLE_CAST (MonoString, NULL_HANDLE);
g_free (buf);
return result;
#else
- return mono_string_new (mono_domain_get (), "mono");
+ return mono_string_new_handle (mono_domain_get (), "mono", error);
#endif
}
#endif /* !HOST_WIN32 */
-ICALL_EXPORT MonoString *
-ves_icall_System_Environment_get_MachineName (void)
+ICALL_EXPORT MonoStringHandle
+ves_icall_System_Environment_get_MachineName (MonoError *error)
{
- return mono_icall_get_machine_name ();
+ error_init (error);
+ return mono_icall_get_machine_name (error);
}
#ifndef HOST_WIN32
}
#ifndef HOST_WIN32
-static inline MonoString *
-mono_icall_get_new_line (void)
+static inline MonoStringHandle
+mono_icall_get_new_line (MonoError *error)
{
- return mono_string_new (mono_domain_get (), "\n");
+ error_init (error);
+ return mono_string_new_handle (mono_domain_get (), "\n", error);
}
#endif /* !HOST_WIN32 */
-ICALL_EXPORT MonoString *
-ves_icall_System_Environment_get_NewLine (void)
+ICALL_EXPORT MonoStringHandle
+ves_icall_System_Environment_get_NewLine (MonoError *error)
{
- return mono_icall_get_new_line ();
+ return mono_icall_get_new_line (error);
}
#ifndef HOST_WIN32
#ifndef HOST_WIN32
static MonoArray *
-mono_icall_get_environment_variable_names (void)
+mono_icall_get_environment_variable_names (MonoError *error)
{
- MonoError error;
MonoArray *names;
MonoDomain *domain;
MonoString *str;
gchar **e, **parts;
int n;
+ error_init (error);
n = 0;
for (e = environ; *e != 0; ++ e)
++ n;
domain = mono_domain_get ();
- names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ names = mono_array_new_checked (domain, mono_defaults.string_class, n, error);
+ return_val_if_nok (error, NULL);
n = 0;
for (e = environ; *e != 0; ++ e) {
parts = g_strsplit (*e, "=", 2);
if (*parts != 0) {
- str = mono_string_new (domain, *parts);
+ str = mono_string_new_checked (domain, *parts, error);
+ if (!is_ok (error)) {
+ g_strfreev (parts);
+ return NULL;
+ }
mono_array_setref (names, n, str);
}
ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetEnvironmentVariableNames (void)
{
- return mono_icall_get_environment_variable_names ();
+ MonoError error;
+ MonoArray *result = mono_icall_get_environment_variable_names (&error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
#ifndef HOST_WIN32
}
#ifndef HOST_WIN32
-static inline MonoString *
-mono_icall_get_windows_folder_path (int folder)
+static inline MonoStringHandle
+mono_icall_get_windows_folder_path (int folder, MonoError *error)
{
+ error_init (error);
g_warning ("ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
- return mono_string_new (mono_domain_get (), "");
+ return mono_string_new_handle (mono_domain_get (), "", error);
}
#endif /* !HOST_WIN32 */
-ICALL_EXPORT MonoString*
-ves_icall_System_Environment_GetWindowsFolderPath (int folder)
+ICALL_EXPORT MonoStringHandle
+ves_icall_System_Environment_GetWindowsFolderPath (int folder, MonoError *error)
{
- return mono_icall_get_windows_folder_path (folder);
+ return mono_icall_get_windows_folder_path (folder, error);
}
#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
* 1 at entry, and we can not compute a suitable code page number,
* returns the code page as a string
*/
-ICALL_EXPORT MonoString*
-ves_icall_System_Text_EncodingHelper_InternalCodePage (gint32 *int_code_page)
+ICALL_EXPORT MonoStringHandle
+ves_icall_System_Text_EncodingHelper_InternalCodePage (gint32 *int_code_page, MonoError *error)
{
+ error_init (error);
const char *cset;
const char *p;
char *c;
g_free (codepage);
if (want_name && *int_code_page == -1)
- return mono_string_new (mono_domain_get (), cset);
+ return mono_string_new_handle (mono_domain_get (), cset, error);
else
- return NULL;
+ return MONO_HANDLE_CAST (MonoString, NULL_HANDLE);
}
ICALL_EXPORT MonoBoolean
return result;
}
-ICALL_EXPORT MonoString *
-ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
+ICALL_EXPORT MonoStringHandle
+ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (MonoError *error)
{
- MonoString *mcpath;
+ error_init (error);
gchar *path;
path = g_build_path (G_DIR_SEPARATOR_S, mono_get_config_dir (), "mono", mono_get_runtime_info ()->framework_version, "machine.config", NULL);
mono_icall_make_platform_path (path);
- mcpath = mono_string_new (mono_domain_get (), path);
+ MonoStringHandle mcpath = mono_string_new_handle (mono_domain_get (), path, error);
g_free (path);
- g_assert (mcpath);
+ mono_error_assert_ok (error);
return mcpath;
}
-/* this is an icall */
-static MonoString *
-get_bundled_app_config (void)
+static MonoStringHandle
+ves_icall_System_Configuration_InternalConfigurationHost_get_bundled_app_config (MonoError *error)
{
- MonoError error;
+ error_init (error);
const gchar *app_config;
MonoDomain *domain;
- MonoString *file;
gchar *config_file_name, *config_file_path;
gsize len, config_file_path_length, config_ext_length;
gchar *module;
domain = mono_domain_get ();
- file = domain->setup->configuration_file;
- if (!file || file->length == 0)
+ MonoStringHandle file = MONO_HANDLE_NEW (MonoString, domain->setup->configuration_file);
+ if (MONO_HANDLE_IS_NULL (file) || MONO_HANDLE_GETVAL (file, length) == 0)
return NULL;
// Retrieve config file and remove the extension
- config_file_name = mono_string_to_utf8_checked (file, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ config_file_name = mono_string_handle_to_utf8 (file, error);
+ return_val_if_nok (error, MONO_HANDLE_CAST (MonoString, NULL_HANDLE));
+
config_file_path = mono_portability_find_file (config_file_name, TRUE);
if (!config_file_path)
config_file_path = config_file_name;
config_file_path_length = strlen (config_file_path);
config_ext_length = strlen (".config");
- if (config_file_path_length <= config_ext_length)
- return NULL;
+ if (config_file_path_length <= config_ext_length) {
+ if (config_file_name != config_file_path)
+ g_free (config_file_name);
+ return MONO_HANDLE_CAST (MonoString, NULL_HANDLE);
+ }
len = config_file_path_length - config_ext_length;
module = (gchar *)g_malloc0 (len + 1);
g_free (config_file_path);
if (!app_config)
- return NULL;
+ return MONO_HANDLE_CAST (MonoString, NULL_HANDLE);
- return mono_string_new (mono_domain_get (), app_config);
+ return mono_string_new_handle (mono_domain_get (), app_config, error);
}
static MonoStringHandle
}
-ICALL_EXPORT MonoString *
-ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void)
+ICALL_EXPORT MonoStringHandle
+ves_icall_System_Web_Util_ICalls_get_machine_install_dir (MonoError *error)
{
- MonoString *ipath;
+ error_init (error);
gchar *path;
path = g_path_get_dirname (mono_get_config_dir ());
mono_icall_make_platform_path (path);
- ipath = mono_string_new (mono_domain_get (), path);
+ MonoStringHandle ipath = mono_string_new_handle (mono_domain_get (), path, error);
g_free (path);
return ipath;
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])));
+ for(i = 0; i < ml; i++) {
+ MonoString *s = mono_string_new_checked (domain, dtidx2string (names [i]), error);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (ret, i, s);
+ }
return ret;
}
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])));
+ for(i = 0; i < len; i++) {
+ MonoString *s = mono_string_new_checked (domain, pattern2string (names [i]), error);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (ret, i, s);
+ }
return ret;
}
domain = mono_domain_get ();
- MONO_OBJECT_SETREF (this_obj, NativeName, mono_string_new (domain, idx2string (ci->nativename)));
+ MonoString *native_name = mono_string_new_checked (domain, idx2string (ci->nativename), &error);
+ return_val_and_set_pending_if_nok (&error, FALSE);
+ MONO_OBJECT_SETREF (this_obj, NativeName, native_name);
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);
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)));
+ MonoString *month_day_pattern = mono_string_new_checked (domain, pattern2string (dfe->month_day_pattern), &error);
+ return_val_and_set_pending_if_nok (&error, FALSE);
+ MONO_OBJECT_SETREF (this_obj, MonthDayPattern, 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);
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)));
+#define SET_STR(obj,field,domain,expr,err) do { \
+ MonoString *_tmp_str = mono_string_new_checked ((domain), (expr), (err)); \
+ if (mono_error_set_pending_exception ((err))) \
+ return; \
+ MONO_OBJECT_SETREF((obj), field, _tmp_str); \
+ } while (0)
+
+ SET_STR (this_obj, AMDesignator, domain, idx2string (dfe->am_designator), &error);
+ SET_STR (this_obj, PMDesignator, domain, idx2string (dfe->pm_designator), &error);
+ SET_STR (this_obj, TimeSeparator, domain, idx2string (dfe->time_separator), &error);
+#undef SET_STR
MonoArray *long_time_patterns = create_names_array_idx_dynamic (dfe->long_time_patterns,
NUM_LONG_TIME_PATTERNS, &error);
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)));
+
+#define SET_STR(obj,field,domain,expr,err) do { \
+ MonoString *_tmp_str = mono_string_new_checked ((domain), (expr), (err)); \
+ if (mono_error_set_pending_exception ((err))) \
+ return; \
+ MONO_OBJECT_SETREF((obj), field, _tmp_str); \
+ } while (0)
+
+ SET_STR (number, currencyDecimalSeparator, domain, idx2string (nfe->currency_decimal_separator), &error);
+ SET_STR (number, currencyGroupSeparator, domain, idx2string (nfe->currency_group_separator), &error);
+
MonoArray *currency_sizes_arr = create_group_sizes_array (nfe->currency_group_sizes,
GROUP_SIZE, &error);
if (mono_error_set_pending_exception (&error))
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)));
+
+ SET_STR (number, currencySymbol, domain, idx2string (nfe->currency_symbol), &error);
+ SET_STR (number, naNSymbol, domain, idx2string (nfe->nan_symbol), &error);
+ SET_STR (number, negativeInfinitySymbol, domain, idx2string (nfe->negative_infinity_symbol), &error);
+ SET_STR (number, negativeSign, domain, idx2string (nfe->negative_sign), &error);
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)));
+ SET_STR (number, numberDecimalSeparator, domain, idx2string (nfe->number_decimal_separator), &error);
+ SET_STR (number, numberGroupSeparator, domain, idx2string (nfe->number_group_separator), &error);
MonoArray *number_sizes_arr = create_group_sizes_array (nfe->number_group_sizes,
GROUP_SIZE, &error);
if (mono_error_set_pending_exception (&error))
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)));
+ SET_STR (number, percentSymbol, domain, idx2string (nfe->percent_symbol), &error);
+ SET_STR (number, perMilleSymbol, domain, idx2string (nfe->per_mille_symbol), &error);
+ SET_STR (number, positiveInfinitySymbol, domain, idx2string (nfe->positive_infinity_symbol), &error);
+ SET_STR (number, positiveSign, domain, idx2string (nfe->positive_sign), &error);
+#undef SET_STR
}
static MonoBoolean
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)));
+
+#define SET_STR(obj,field,domain,expr,err) do { \
+ MonoString *_tmp_str = mono_string_new_checked ((domain), (expr), (err)); \
+ return_val_if_nok (err, FALSE); \
+ MONO_OBJECT_SETREF((obj), field, _tmp_str); \
+ } while (0)
+
+ SET_STR (this_obj, name, domain, idx2string (ci->name), error);
+ SET_STR (this_obj, englishname, domain, idx2string (ci->englishname), error);
+ SET_STR (this_obj, nativename, domain, idx2string (ci->nativename), error);
+ SET_STR (this_obj, win3lang, domain, idx2string (ci->win3lang), error);
+ SET_STR (this_obj, iso3lang, domain, idx2string (ci->iso3lang), error);
+ SET_STR (this_obj, iso2lang, domain, idx2string (ci->iso2lang), error);
// It's null for neutral cultures
- if (ci->territory > 0)
- MONO_OBJECT_SETREF (this_obj, territory, mono_string_new (domain, idx2string (ci->territory)));
+ if (ci->territory > 0) {
+ SET_STR (this_obj, territory, domain, idx2string (ci->territory), error);
+ }
MonoArray *native_calendar_names = create_names_array_idx (ci->native_calendar_names, NUM_CALENDARS, error);
return_val_if_nok (error, FALSE);
this_obj->number_index = ci->number_format_index;
this_obj->calendar_type = ci->calendar_type;
this_obj->text_info_data = &ci->text_info;
+#undef SET_STR
return TRUE;
}
static MonoBoolean
-construct_region (MonoRegionInfo *this_obj, const RegionInfoEntry *ri)
+construct_region (MonoRegionInfo *this_obj, const RegionInfoEntry *ri, MonoError *error)
{
MonoDomain *domain = mono_domain_get ();
+ error_init (error);
+
+#define SET_STR(obj,field,domain,expr,err) do { \
+ MonoString *_tmp_str = mono_string_new_checked ((domain), (expr), (err)); \
+ return_val_if_nok (err, FALSE); \
+ MONO_OBJECT_SETREF((obj), field, _tmp_str); \
+ } while (0)
+
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)));
+ SET_STR (this_obj, iso2name, domain, idx2string (ri->iso2name), error);
+ SET_STR (this_obj, iso3name, domain, idx2string (ri->iso3name), error);
+ SET_STR (this_obj, win3name, domain, idx2string (ri->win3name), error);
+ SET_STR (this_obj, english_name, domain, idx2string (ri->english_name), error);
+ SET_STR (this_obj, native_name, domain, idx2string (ri->native_name), error);
+ SET_STR (this_obj, currency_symbol, domain, idx2string (ri->currency_symbol), error);
+ SET_STR (this_obj, iso_currency_symbol, domain, idx2string (ri->iso_currency_symbol), error);
+ SET_STR (this_obj, currency_english_name, domain, idx2string (ri->currency_english_name), error);
+ SET_STR (this_obj, currency_native_name, domain, idx2string (ri->currency_native_name), error);
+#undef SET_STR
+
return TRUE;
}
return ret;
}
-MonoString*
-ves_icall_System_Globalization_CultureInfo_get_current_locale_name (void)
+MonoStringHandle
+ves_icall_System_Globalization_CultureInfo_get_current_locale_name (MonoError *error)
{
+ error_init (error);
gchar *locale;
- MonoString* ret;
MonoDomain *domain;
locale = get_current_locale_name ();
if (locale == NULL)
- return NULL;
+ return MONO_HANDLE_CAST (MonoString, NULL_HANDLE);
domain = mono_domain_get ();
- ret = mono_string_new (domain, locale);
+ MonoStringHandle ret = mono_string_new_handle (domain, locale, error);
g_free (locale);
return ret;
ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid (MonoRegionInfo *this_obj,
gint lcid)
{
+ MonoError error;
const RegionInfoEntry *ri;
ri = region_info_entry_from_lcid (lcid);
if(ri == NULL)
return FALSE;
- return construct_region (this_obj, ri);
+ MonoBoolean result = construct_region (this_obj, ri, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoBoolean
}
g_free (n);
- return construct_region (this_obj, ®ion_entries [ne->region_entry_index]);
+ MonoBoolean result = construct_region (this_obj, ®ion_entries [ne->region_entry_index], &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoArray*
extern void ves_icall_System_Globalization_CultureData_fill_culture_data (MonoCultureData *this_obj, gint32 datetime_index);
extern void ves_icall_System_Globalization_CultureData_fill_number_data (MonoNumberFormatInfo* number, gint32 number_index);
extern void ves_icall_System_Globalization_CultureInfo_construct_internal_locale (MonoCultureInfo *this_obj, MonoString *locale);
-extern MonoString* ves_icall_System_Globalization_CultureInfo_get_current_locale_name (void);
+extern MonoStringHandle ves_icall_System_Globalization_CultureInfo_get_current_locale_name (MonoError *error);
extern MonoBoolean ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_lcid (MonoCultureInfo *this_obj, gint lcid);
extern MonoBoolean ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_name (MonoCultureInfo *this_obj, MonoString *name);
extern MonoArray *ves_icall_System_Globalization_CultureInfo_internal_get_cultures (MonoBoolean neutral, MonoBoolean specific, MonoBoolean installed);
if (is_ok (&inner_error)) {
char *tmp;
tmp = g_strdup_printf ("%s\nException Rethrown at:\n", strace);
- g_free (strace);
- MONO_OBJECT_SETREF (((MonoException*)exc), stack_trace, mono_string_new (domain, tmp));
+ g_free (strace);
+ MonoString *tmp_str = mono_string_new_checked (domain, tmp, &inner_error);
g_free (tmp);
- } else
+ if (is_ok (&inner_error))
+ MONO_OBJECT_SETREF (((MonoException*)exc), stack_trace, tmp_str);
+ };
+ if (!is_ok (&inner_error))
mono_error_cleanup (&inner_error); /* no stack trace, but at least throw the original exception */
}
mono_set_pending_exception ((MonoException*)exc);
memcpy (dest_addr, src, length * element_size);
}
-MonoString *
-ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr)
+MonoStringHandle
+ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr, MonoError *error)
{
+ error_init (error);
if (ptr == NULL)
- return NULL;
+ return MONO_HANDLE_CAST (MonoString, NULL_HANDLE);
else
- return mono_string_new (mono_domain_get (), ptr);
+ return mono_string_new_handle (mono_domain_get (), ptr, error);
}
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src, gint32 start_index,
MonoArray *dest, gint32 length);
-MonoString *
-ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr);
+MonoStringHandle
+ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr, MonoError *error);
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len);
return TRUE;
}
+/* this is an icall */
MonoString*
mono_perfcounter_category_help (MonoString *category, MonoString *machine)
{
+ MonoError error;
+ MonoString *result = NULL;
const CategoryDesc *cdesc;
+ error_init (&error);
/* no support for counters on other machines */
if (mono_string_compare_ascii (machine, "."))
return NULL;
SharedCategory *scat = find_custom_category (category);
if (!scat)
return NULL;
- return mono_string_new (mono_domain_get (), custom_category_help (scat));
+ result = mono_string_new_checked (mono_domain_get (), custom_category_help (scat), &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ return result;
}
- return mono_string_new (mono_domain_get (), cdesc->help);
+ result = mono_string_new_checked (mono_domain_get (), cdesc->help, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ return result;
}
/*
return FALSE;
}
+/* this is an icall */
MonoArray*
mono_perfcounter_category_names (MonoString *machine)
{
for (i = 0; i < NUM_CATEGORIES; ++i) {
const CategoryDesc *cdesc = &predef_categories [i];
- mono_array_setref (res, i, mono_string_new (domain, cdesc->name));
+ MonoString *name = mono_string_new_checked (domain, cdesc->name, &error);
+ if (!is_ok (&error))
+ goto leave;
+ mono_array_setref (res, i, name);
}
for (tmp = custom_categories; tmp; tmp = tmp->next) {
SharedCategory *scat = (SharedCategory *)tmp->data;
- mono_array_setref (res, i, mono_string_new (domain, scat->name));
+ MonoString *name = mono_string_new_checked (domain, scat->name, &error);
+ if (!is_ok (&error))
+ goto leave;
+ mono_array_setref (res, i, name);
i++;
}
+leave:
perfctr_unlock ();
g_slist_free (custom_categories);
+ mono_error_set_pending_exception (&error);
return res;
}
return NULL;
for (i = cdesc->first_counter; i < cdesc [1].first_counter; ++i) {
const CounterDesc *desc = &predef_counters [i];
- mono_array_setref (res, i - cdesc->first_counter, mono_string_new (domain, desc->name));
+ MonoString *name = mono_string_new_checked (domain, desc->name, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+ mono_array_setref (res, i - cdesc->first_counter, name);
}
return res;
}
}
for (i = 0; i < scat->num_counters; ++i) {
- mono_array_setref (res, i, mono_string_new (domain, p + 1));
+ MonoString *str = mono_string_new_checked (domain, p + 1, &error);
+ if (!is_ok (&error))
+ goto leave;
+ mono_array_setref (res, i, str);
p += 2; /* skip counter type */
p += strlen (p) + 1; /* skip counter name */
p += strlen (p) + 1; /* skip counter help */
}
- perfctr_unlock ();
- return res;
- }
+ } else
+ res = mono_array_new_checked (domain, mono_get_string_class (), 0, &error);
+leave:
perfctr_unlock ();
- res = mono_array_new_checked (domain, mono_get_string_class (), 0, &error);
mono_error_set_pending_exception (&error);
return res;
}
sprintf (buf, "%d", GPOINTER_TO_INT (array [i]));
p = buf;
}
- mono_array_setref (res, i, mono_string_new (domain, p));
+ MonoString *str = mono_string_new_checked (domain, p, error);
if (p != buf)
g_free (p);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (res, i, str);
}
return res;
}
return_val_if_nok (error, NULL);
for (i = 0; i < count; ++i) {
char* p = (char *)array[i];
- mono_array_setref (res, i, mono_string_new (domain, p));
+ MonoString *str = mono_string_new_checked (domain, p, error);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (res, i, str);
}
return res;
buf [i] = GINT_TO_POINTER (i - 1); /* -1 => _Total */
array = get_string_array (buf, count, FALSE, error);
g_free (buf);
- mono_array_setref (array, 0, mono_string_new (mono_domain_get (), "_Total"));
+ MonoString *total = mono_string_new_checked (mono_domain_get (), "_Total", error);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (array, 0, total);
return array;
}
}
for (tmp = list; tmp; tmp = tmp->next) {
SharedInstance *inst = (SharedInstance *)tmp->data;
- mono_array_setref (array, i, mono_string_new (mono_domain_get (), inst->instance_name));
+ MonoString *str = mono_string_new_checked (mono_domain_get (), inst->instance_name, error);
+ if (!is_ok (error)) {
+ g_slist_free (list);
+ return NULL;
+ }
+ mono_array_setref (array, i, str);
i++;
}
g_slist_free (list);
#if defined(PLATFORM_MACOSX) || defined(PLATFORM_BSD)
+#include <config.h>
#include <sys/socket.h>
#include <net/if.h>
#include <net/if_dl.h>
return FALSE;
// Second sysctl call to retrieve data into appropriately sized buffer
- if (sysctl(mib, G_N_ELEMENTS(mib), buf, &needed, NULL, 0) < 0)
+ if (sysctl(mib, G_N_ELEMENTS(mib), buf, &needed, NULL, 0) < 0) {
+ g_free (buf);
return FALSE;
+ }
lim = buf + needed;
for (next = buf; next < lim; next += rtm->rtm_msglen) {
num_gws++;
}
- *gw_addr_list = mono_array_new(domain, mono_get_string_class (), num_gws);
+ *gw_addr_list = mono_array_new_checked (domain, mono_get_string_class (), num_gws, &error);
+ if (!is_ok (&error))
+ goto leave;
for (next = buf; next < lim; next += rtm->rtm_msglen) {
rtm = (struct rt_msghdr *)next;
// snprintf output truncated
continue;
- addr_string = mono_string_new (domain, addr);
+ addr_string = mono_string_new_checked (domain, addr, &error);
+ if (!is_ok (&error))
+ goto leave;
mono_array_setref (*gw_addr_list, gwnum, addr_string);
gwnum++;
}
+leave:
g_free (buf);
- return TRUE;
+ return is_ok (&error);
}
in_addr_t gateway_from_rtm(struct rt_msghdr *rtm)
result = mono_string_new_utf16_checked (mono_domain_get (), uniname, size, &error);
}
else
- result = mono_string_new (mono_domain_get (), "");
+ result = mono_string_new_checked (mono_domain_get (), "", &error);
if (uniname)
g_free (uniname);
result = mono_string_new_utf16_checked (mono_domain_get (), uniname, size, &error);
}
else
- result = mono_string_new (mono_domain_get (), "");
+ result = mono_string_new_checked (mono_domain_get (), "", &error);
if (uniname)
g_free (uniname);
res = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, num_main_args, error);
return_val_if_nok (error, NULL);
- for (i = 0; i < num_main_args; ++i)
- mono_array_setref (res, i, mono_string_new (domain, main_args [i]));
+ for (i = 0; i < num_main_args; ++i) {
+ MonoString *arg = mono_string_new_checked (domain, main_args [i], error);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (res, i, arg);
+ }
return res;
}
* main_args array.
*/
gchar *str = mono_utf8_from_external (argv [i]);
- MonoString *arg = mono_string_new (domain, str);
+ MonoString *arg = mono_string_new_checked (domain, str, &error);
+ mono_error_assert_ok (&error);
mono_array_setref (args, i, arg);
g_free (str);
}
if (!domain->entry_assembly) {
gchar *str;
+ MonoError error;
MonoAssembly *assembly;
assembly = method->klass->image->assembly;
domain->entry_assembly = assembly;
/* Domains created from another domain already have application_base and configuration_file set */
if (domain->setup->application_base == NULL) {
- MONO_OBJECT_SETREF (domain->setup, application_base, mono_string_new (domain, assembly->basedir));
+ MonoString *basedir = mono_string_new_checked (domain, assembly->basedir, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (domain->setup, application_base, basedir);
}
if (domain->setup->configuration_file == NULL) {
str = g_strconcat (assembly->image->name, ".config", NULL);
- MONO_OBJECT_SETREF (domain->setup, configuration_file, mono_string_new (domain, str));
+ MonoString *config_file = mono_string_new_checked (domain, str, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (domain->setup, configuration_file, config_file);
g_free (str);
mono_domain_set_options_from_config (domain);
}
MonoDomain *domain = mono_domain_get ();
- if (text)
- return mono_string_new (domain, text);
+ if (text) {
+ MonoError error;
+ MonoString *result = mono_string_new_checked (domain, text, &error);
+ mono_error_assert_ok (&error);
+ return result;
+ }
return NULL;
}
return_val_if_nok (error, NULL);
full_name = mono_type_get_full_name (klass);
- mono_array_setref (msg->args, 0, mono_string_new (domain, full_name));
- mono_array_setref (msg->args, 1, mono_string_new (domain, mono_field_get_name (field)));
+ MonoString *full_name_str = mono_string_new_checked (domain, full_name, error);
g_free (full_name);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (msg->args, 0, full_name_str);
+ MonoString *field_name = mono_string_new_checked (domain, mono_field_get_name (field), error);
+ return_val_if_nok (error, NULL);
+ mono_array_setref (msg->args, 1, field_name);
mono_remoting_invoke ((MonoObject *)(tp->rp), msg, &exc, &out_args, error);
return_val_if_nok (error, NULL);
MONO_API MonoString*
mono_string_intern (MonoString *str);
+MONO_RT_EXTERNAL_ONLY
MONO_API MonoString*
mono_string_new (MonoDomain *domain, const char *text);
G_BEGIN_DECLS
/* System.Environment */
-extern MonoString* ves_icall_System_Environment_get_UserName (void);
+extern MonoStringHandle ves_icall_System_Environment_get_UserName (MonoError *error);
/* System.Security.Principal.WindowsIdentity */
rmb->call_conv = mb->call_conv;
rmb->code = NULL;
rmb->type = mb->type;
- rmb->name = mono_string_new (mono_domain_get (), name);
+ rmb->name = mono_string_new_checked (mono_domain_get (), name, error);
+ return_val_if_nok (error, FALSE);
rmb->table_idx = &mb->table_idx;
rmb->init_locals = mb->init_locals;
rmb->skip_visibility = FALSE;
domains_unlock ();
- mono_thread_set_name_internal (thread, mono_string_new (mono_get_root_domain (), "Threadpool worker"), FALSE, TRUE, &error);
+ MonoString *thread_name = mono_string_new_checked (mono_get_root_domain (), "Threadpool worker", &error);
+ mono_error_assert_ok (&error);
+ mono_thread_set_name_internal (thread, thread_name, FALSE, TRUE, &error);
mono_error_assert_ok (&error);
mono_thread_clr_state (thread, (MonoThreadState)~ThreadState_Background);
sf->il_offset = location->il_offset;
if (location && location->source_file) {
- MONO_OBJECT_SETREF (sf, filename, mono_string_new (domain, location->source_file));
+ MonoString *filename = mono_string_new_checked (domain, location->source_file, error);
+ if (!is_ok (error))
+ goto leave;
+ MONO_OBJECT_SETREF (sf, filename, filename);
sf->line = location->row;
sf->column = location->column;
}
if (mono_error_set_pending_exception (&error))
goto leave;
for (i = 0; i < names->len; i++) {
- mono_array_setref (result, i, mono_string_new (domain, (const char *)g_ptr_array_index (names, i)));
+ MonoString *name = mono_string_new_checked (domain, (const char *)g_ptr_array_index (names, i), &error);
+ if (mono_error_set_pending_exception (&error))
+ goto leave;
+ mono_array_setref (result, i, name);
g_free (g_ptr_array_index (names, i));
}
leave:
} IncrementalFind;
static gboolean
-incremental_find_check_match (IncrementalFind *handle, WIN32_FIND_DATA *data, MonoString **result)
+incremental_find_check_match (IncrementalFind *handle, WIN32_FIND_DATA *data, MonoString **result, MonoError *error)
{
+ error_init (error);
gchar *utf8_result;
gchar *full_name;
full_name = g_build_filename (handle->utf8_path, utf8_result, NULL);
g_free (utf8_result);
- *result = mono_string_new (mono_domain_get (), full_name);
+ *result = mono_string_new_checked (mono_domain_get (), full_name, error);
g_free (full_name);
+ if (!is_ok (error))
+ return FALSE;
return TRUE;
}
ifh->domain = mono_domain_get ();
*handle = ifh;
- while (incremental_find_check_match (ifh, &data, &result) == 0){
+ while (incremental_find_check_match (ifh, &data, &result, &error) == 0){
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (mono_w32file_find_next (find_handle, &data) == FALSE){
int e = mono_w32error_get_last ();
if (e != ERROR_NO_MORE_FILES)
}
}
*result_attr = data.dwFileAttributes;
-
+
return result;
}
/* FIXME make gc suspendable */
MonoString *
-ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_attr, gint32 *error)
+ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_attr, gint32 *ioerror)
{
+ MonoError error;
IncrementalFind *ifh = (IncrementalFind *)handle;
WIN32_FIND_DATA data;
MonoString *result;
- *error = ERROR_SUCCESS;
+ error_init (&error);
+ *ioerror = ERROR_SUCCESS;
do {
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
if (mono_w32file_find_next (ifh->find_handle, &data) == FALSE){
int e = mono_w32error_get_last ();
if (e != ERROR_NO_MORE_FILES)
- *error = e;
+ *ioerror = e;
return NULL;
}
- } while (incremental_find_check_match (ifh, &data, &result) == 0);
+ } while (incremental_find_check_match (ifh, &data, &result, &error) == 0);
*result_attr = data.dwFileAttributes;
return result;
}
static void
-process_set_field_string_char (MonoObject *obj, const gchar *fieldname, const gchar *val)
+process_set_field_string_char (MonoObject *obj, const gchar *fieldname, const gchar *val, MonoError *error)
{
MonoDomain *domain;
MonoClass *klass;
MonoClassField *field;
MonoString *string;
+ error_init (error);
LOGDEBUG (g_message ("%s: Setting field %s to [%s]", __func__, fieldname, val));
domain = mono_object_domain (obj);
field = mono_class_get_field_from_name (klass, fieldname);
g_assert (field);
- string = mono_string_new (domain, val);
+ string = mono_string_new_checked (domain, val, error);
+ return_if_nok (error);
mono_gc_wbarrier_generic_store (((char *)obj) + field->offset, (MonoObject*)string);
}
filename = g_strdup_printf ("[In Memory] %s", modulename);
process_get_assembly_fileversion (filever, assembly);
- process_set_field_string_char (filever, "filename", filename);
+ process_set_field_string_char (filever, "filename", filename, error);
+ return_val_if_nok (error, NULL);
process_set_field_object (item, "version_info", filever);
process_set_field_intptr (item, "baseaddr", assembly->image->raw_data);
process_set_field_int (item, "memory_size", assembly->image->raw_data_len);
- process_set_field_string_char (item, "filename", filename);
- process_set_field_string_char (item, "modulename", modulename);
+ process_set_field_string_char (item, "filename", filename, error);
+ return_val_if_nok (error, NULL);
+ process_set_field_string_char (item, "modulename", modulename, error);
+ return_val_if_nok (error, NULL);
g_free (filename);
MonoAddress maddr;
mono_address_init (&maddr, AF_INET, &local_in [i]);
if (mono_networking_addr_to_str (&maddr, addr, sizeof (addr))) {
- addr_string = mono_string_new (domain, addr);
+ addr_string = mono_string_new_checked (domain, addr, error);
+ if (!is_ok (error))
+ goto leave;
mono_array_setref (*h_addr_list, addr_index, addr_string);
addr_index++;
}
MonoAddress maddr;
mono_address_init (&maddr, AF_INET6, &local_in6 [i]);
if (mono_networking_addr_to_str (&maddr, addr, sizeof (addr))) {
- addr_string = mono_string_new (domain, addr);
+ addr_string = mono_string_new_checked (domain, addr, error);
+ if (!is_ok (error))
+ goto leave;
mono_array_setref (*h_addr_list, addr_index, addr_string);
addr_index++;
}
mono_address_init (&maddr, ai->family, &ai->address);
if (mono_networking_addr_to_str (&maddr, buffer, sizeof (buffer)))
- addr_string = mono_string_new (domain, buffer);
+ addr_string = mono_string_new_checked (domain, buffer, error);
else
- addr_string = mono_string_new (domain, "");
+ addr_string = mono_string_new_checked (domain, "", error);
+ if (!is_ok (error))
+ goto leave2;
mono_array_setref (*h_addr_list, addr_index, addr_string);
if (!i) {
i++;
if (ai->canonical_name != NULL) {
- *h_name = mono_string_new (domain, ai->canonical_name);
+ *h_name = mono_string_new_checked (domain, ai->canonical_name, error);
} else {
- *h_name = mono_string_new (domain, buffer);
+ *h_name = mono_string_new_checked (domain, buffer, error);
}
+ if (!is_ok (error))
+ goto leave2;
}
addr_index++;
MonoBoolean
ves_icall_System_Net_Dns_GetHostName_internal (MonoString **h_name)
{
+ MonoError error;
gchar hostname [NI_MAXHOST] = { 0 };
int ret;
if (ret == -1)
return FALSE;
- *h_name = mono_string_new (mono_domain_get (), hostname);
+ *h_name = mono_string_new_checked (mono_domain_get (), hostname, &error);
+ mono_error_set_pending_exception (&error);
return TRUE;
}
MonoError error;
MonoInternalThread *internal = mono_thread_internal_current ();
- mono_thread_set_name_internal (internal, mono_string_new (mono_domain_get (), "AOT compiler"), TRUE, FALSE, &error);
+ MonoString *str = mono_string_new_checked (mono_domain_get (), "AOT compiler", &error);
+ mono_error_assert_ok (&error);
+ mono_thread_set_name_internal (internal, str, TRUE, FALSE, &error);
mono_error_assert_ok (&error);
for (i = 0; i < methods->len; ++i)
case CMD_APPDOMAIN_CREATE_STRING: {
char *s;
MonoString *o;
+ MonoError error;
domain = decode_domainid (p, &p, end, NULL, &err);
if (err != ERR_NONE)
return err;
s = decode_string (p, &p, end);
- o = mono_string_new (domain, s);
+ o = mono_string_new_checked (domain, s, &error);
+ if (!is_ok (&error)) {
+ DEBUG_PRINTF (1, "[dbg] Failed to allocate String object '%s': %s\n", s, mono_error_get_message (&error));
+ mono_error_cleanup (&error);
+ return ERR_INVALID_OBJECT;
+ }
buffer_add_objid (buf, (MonoObject*)o);
break;
}
debugger_thread_id = mono_native_thread_id_get ();
MonoInternalThread *internal = mono_thread_internal_current ();
- mono_thread_set_name_internal (internal, mono_string_new (mono_domain_get (), "Debugger agent"), TRUE, FALSE, &error);
+ MonoString *str = mono_string_new_checked (mono_domain_get (), "Debugger agent", &error);
+ mono_error_assert_ok (&error);
+ mono_thread_set_name_internal (internal, str, TRUE, FALSE, &error);
mono_error_assert_ok (&error);
internal->state |= ThreadState_Background;
if (args) {
main_args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, 1, &error);
- if (main_args)
- mono_array_set (main_args, MonoString*, 0, mono_string_new (domain, args));
+ if (main_args) {
+ MonoString *str = mono_string_new_checked (domain, args, &error);
+ if (str)
+ mono_array_set (main_args, MonoString*, 0, str);
+ }
} else {
main_args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, 0, &error);
}
if (context == NULL)
return;
stack_trace = dump_frame (context->current_frame);
- ex->stack_trace = mono_string_new (mono_domain_get(), stack_trace);
+ ex->stack_trace = mono_string_new_checked (mono_domain_get(), stack_trace, &error);
+ mono_error_cleanup (&error); /* FIXME: don't swallow the error */
g_free (stack_trace);
if (context->current_env == NULL || strcmp(ex->object.vtable->klass->name, "ExecutionEngineException") == 0) {
char *strace = mono_string_to_utf8_checked (ex->stack_trace, &error);
static void
fill_in_trace (MonoException *exception, MonoInvocation *frame)
{
+ MonoError error;
char *stack_trace = dump_frame (frame);
MonoDomain *domain = mono_domain_get();
- (exception)->stack_trace = mono_string_new (domain, stack_trace);
+ (exception)->stack_trace = mono_string_new_checked (domain, stack_trace, &error);
+ mono_error_cleanup (&error); /* FIXME: don't swallow the error */
(exception)->trace_ips = get_trace_ips (domain, frame);
g_free (stack_trace);
}
if (need_file_info) {
if (column)
*column = 0;
- if (file)
- *file = mono_string_new (mono_domain_get (), "unknown");
+ if (file) {
+ *file = mono_string_new_checked (mono_domain_get (), "unknown", &error);
+ mono_error_cleanup (&error); /* FIXME: don't swallow the error */
+ }
}
return TRUE;
filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line, domain);
- sf->filename = filename? mono_string_new (domain, filename): NULL;
+ sf->filename = NULL;
+ if (filename) {
+ sf->filename = mono_string_new_checked (domain, filename, &error);
+ mono_error_cleanup (&error); /* FIXME: don't swallow the error */
+ }
sf->column = 0;
g_free (filename);
sf->method = NULL;
s = mono_method_get_name_full (method, TRUE, FALSE, MONO_TYPE_NAME_FORMAT_REFLECTION);
- MONO_OBJECT_SETREF (sf, internal_method_name, mono_string_new (domain, s));
+ MonoString *name = mono_string_new_checked (domain, s, &error);
g_free (s);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ MONO_OBJECT_SETREF (sf, internal_method_name, name);
}
else {
MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, &error);
if (need_file_info) {
if (location && location->source_file) {
- MONO_OBJECT_SETREF (sf, filename, mono_string_new (domain, location->source_file));
+ MonoString *filename = mono_string_new_checked (domain, location->source_file, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return NULL;
+ }
+ MONO_OBJECT_SETREF (sf, filename, filename);
sf->line = location->row;
sf->column = location->column;
} else {
if (need_file_info) {
if (location) {
- mono_gc_wbarrier_generic_store (file, (MonoObject*) mono_string_new (domain, location->source_file));
+ MonoString *filename = mono_string_new_checked (domain, location->source_file, &error);
+ if (!is_ok (&error)) {
+ mono_error_set_pending_exception (&error);
+ return FALSE;
+ }
+ mono_gc_wbarrier_generic_store (file, (MonoObject*)filename);
*line = location->row;
*column = location->column;
} else {
g_assert (ctx != NULL);
if (!obj) {
MonoException *ex = mono_get_exception_null_reference ();
- MONO_OBJECT_SETREF (ex, message, mono_string_new (domain, "Object reference not set to an instance of an object"));
+ MonoString *msg = mono_string_new_checked (domain, "Object reference not set to an instance of an object", &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (ex, message, msg);
obj = (MonoObject *)ex;
}
char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
char *msg = g_strdup_printf ("Unable to cast object of type '%s' to type '%s'.", from_name, to_name);
- mono_ex->message = mono_string_new (domain, msg);
+ mono_ex->message = mono_string_new_checked (domain, msg, &error);
g_free (from_name);
g_free (to_name);
+ if (!is_ok (&error)) {
+ mono_runtime_printf_err ("Error creating class cast exception message '%s'\n", msg);
+ mono_error_assert_ok (&error);
+ }
g_free (msg);
}
if (!strcmp (mono_ex->object.vtable->klass->name, "ArrayTypeMismatchException")) {
char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
char *msg = g_strdup_printf ("Source array of type '%s' cannot be cast to destination array type '%s'.", from_name, to_name);
- mono_ex->message = mono_string_new (domain, msg);
+ mono_ex->message = mono_string_new_checked (domain, msg, &error);
g_free (from_name);
g_free (to_name);
+ if (!is_ok (&error)) {
+ mono_runtime_printf_err ("Error creating array type mismatch exception message '%s'\n", msg);
+ mono_error_assert_ok (&error);
+ }
g_free (msg);
}
}
}
+/* Used by mono_error_prepare_exception - it sets its own error on mono_string_new_checked failure. */
+static MonoString*
+string_new_cleanup (MonoDomain *domain, const char *text)
+{
+ MonoError ignored_err;
+ MonoString *result = mono_string_new_checked (domain, text, &ignored_err);
+ mono_error_cleanup (&ignored_err);
+ return result;
+}
+
static MonoString*
get_type_name_as_mono_string (MonoErrorInternal *error, MonoDomain *domain, MonoError *error_out)
{
MonoString* res = NULL;
if (error->type_name) {
- res = mono_string_new (domain, error->type_name);
+ res = string_new_cleanup (domain, error->type_name);
} else {
MonoClass *klass = get_class (error);
if (klass) {
char *name = mono_type_full_name (&klass->byval_arg);
if (name) {
- res = mono_string_new (domain, name);
+ res = string_new_cleanup (domain, name);
g_free (name);
}
}
static void
set_message_on_exception (MonoException *exception, MonoErrorInternal *error, MonoError *error_out)
{
- MonoString *msg = mono_string_new (mono_domain_get (), error->full_message);
+ MonoString *msg = string_new_cleanup (mono_domain_get (), error->full_message);
if (msg)
MONO_OBJECT_SETREF (exception, message, msg);
else
if (!mono_error_ok (error_out))
break;
- method_name = mono_string_new (domain, error->member_name);
+ method_name = string_new_cleanup (domain, error->member_name);
if (!method_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate method name");
break;
if (!mono_error_ok (error_out))
break;
- field_name = mono_string_new (domain, error->member_name);
+ field_name = string_new_cleanup (domain, error->member_name);
if (!field_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate field name");
break;
break;
if (error->assembly_name) {
- assembly_name = mono_string_new (domain, error->assembly_name);
+ assembly_name = string_new_cleanup (domain, error->assembly_name);
if (!assembly_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
break;
case MONO_ERROR_FILE_NOT_FOUND:
case MONO_ERROR_BAD_IMAGE:
if (error->assembly_name) {
- msg = mono_string_new (domain, error->full_message);
+ msg = string_new_cleanup (domain, error->full_message);
if (!msg) {
mono_error_set_out_of_memory (error_out, "Could not allocate message");
break;
}
if (error->assembly_name) {
- assembly_name = mono_string_new (domain, error->assembly_name);
+ assembly_name = string_new_cleanup (domain, error->assembly_name);
if (!assembly_name) {
mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
break;
projects / mono.git / commitdiff