Mark it external only.
Runtime should use mono_array_new_checked.
The icall is ves_icall_array_new.
}
mono_domain_assemblies_unlock (domain);
- res = mono_array_new (domain, mono_class_get_assembly_class (), assemblies->len);
+ res = mono_array_new_checked (domain, mono_class_get_assembly_class (), assemblies->len, &error);
+ if (!is_ok (&error))
+ goto leave;
for (i = 0; i < assemblies->len; ++i) {
ass = (MonoAssembly *)g_ptr_array_index (assemblies, i);
MonoReflectionAssembly *ass_obj = mono_assembly_get_object_checked (domain, ass, &error);
if (!method)
g_error ("No entry point method found in %s due to %s", image->name, mono_error_get_message (&error));
- if (!args)
- args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
+ if (!args) {
+ args = (MonoArray *) mono_array_new_checked (ad->data, mono_defaults.string_class, 0, &error);
+ mono_error_assert_ok (&error);
+ }
return mono_runtime_exec_main (method, (MonoArray *)args, NULL);
}
return 1;
}
+
+ main_args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, (args == NULL) ? 0 : 1, &error);
+ if (main_args == NULL) {
+ g_print ("Could not allocate main method args due to %s\n", mono_error_get_message (&error));
+ mono_error_cleanup (&error);
+ g_free (agent);
+ return 1;
+ }
+
if (args) {
- main_args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 1);
mono_array_set (main_args, MonoString*, 0, mono_string_new (domain, args));
- } else {
- main_args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 0);
}
+
pa [0] = main_args;
mono_runtime_try_invoke (method, NULL, pa, exc, &error);
if (!is_ok (&error)) {
MonoBoolean
ves_icall_System_ConsoleDriver_TtySetup (MonoString *keypad, MonoString *teardown, MonoArray **control_chars, int **size)
{
+ MonoError error;
+
int dims;
dims = terminal_get_dimensions ();
/* 17 is the number of entries set in set_control_chars() above.
* NCCS is the total size, but, by now, we only care about those 17 values*/
- mono_gc_wbarrier_generic_store (control_chars, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.byte_class, 17));
+ MonoArray *control_chars_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, 17, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
+ mono_gc_wbarrier_generic_store (control_chars, (MonoObject*) control_chars_arr);
if (tcgetattr (STDIN_FILENO, &initial_attr) == -1)
return FALSE;
ves_icall_System_IO_MonoIO_GetFileSystemEntries (MonoString *path,
MonoString *path_with_pattern,
gint attrs, gint mask,
- gint32 *error)
+ gint32 *ioerror)
{
+ MonoError error;
MonoDomain *domain = mono_domain_get ();
MonoArray *result;
int i;
GPtrArray *names;
- *error = ERROR_SUCCESS;
+ *ioerror = ERROR_SUCCESS;
MONO_PREPARE_BLOCKING;
- names = get_filesystem_entries (mono_string_chars (path), mono_string_chars (path_with_pattern), attrs, mask, error);
+ names = get_filesystem_entries (mono_string_chars (path), mono_string_chars (path_with_pattern), attrs, mask, ioerror);
MONO_FINISH_BLOCKING;
if (!names) {
// If there's no array and no error, then return an empty array.
- if (*error == ERROR_SUCCESS)
- return mono_array_new (domain, mono_defaults.string_class, 0);
+ if (*ioerror == ERROR_SUCCESS) {
+ MonoArray *arr = mono_array_new_checked (domain, mono_defaults.string_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return arr;
+ }
return NULL;
}
- result = mono_array_new (domain, mono_defaults.string_class, names->len);
+ result = mono_array_new_checked (domain, mono_defaults.string_class, names->len, &error);
+ 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)));
g_free (g_ptr_array_index (names, i));
}
+leave:
g_ptr_array_free (names, TRUE);
return result;
}
MonoArray *
ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
{
+ MonoError error;
MonoArray *chars;
MonoDomain *domain;
int i, n;
domain = mono_domain_get ();
n = sizeof (invalid_path_chars) / sizeof (gunichar2);
- chars = mono_array_new (domain, mono_defaults.char_class, n);
+ chars = mono_array_new_checked (domain, mono_defaults.char_class, n, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < n; ++ i)
mono_array_set (chars, gunichar2, i, invalid_path_chars [i]);
ICALL_TYPE(ENV, "System.Environment", ENV_1)
ICALL(ENV_1, "Exit", ves_icall_System_Environment_Exit)
-ICALL(ENV_2, "GetCommandLineArgs", mono_runtime_get_main_args)
+ICALL(ENV_2, "GetCommandLineArgs", ves_icall_System_Environment_GetCoomandLineArgs)
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 )
if (values) {
int i;
- mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count));
+ MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return 0;
+ mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr);
for (i = 0; i < count; ++i)
mono_array_setref (*fields, i, values [i]);
} else {
if (values) {
int i;
- mono_gc_wbarrier_generic_store (fields, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.object_class, count));
+ MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
+ mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr);
for (i = 0; i < count; ++i)
mono_array_setref_fast (*fields, i, values [i]);
return FALSE;
int i, n = 0;
while (event->event->other [n])
n++;
- MONO_STRUCT_SETREF (info, other_methods, mono_array_new (domain, mono_defaults.method_info_class, n));
+ MonoArray *info_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, n, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ MONO_STRUCT_SETREF (info, other_methods, info_arr);
for (i = 0; i < n; i++) {
rm = mono_method_get_object_checked (domain, event->event->other [i], NULL, &error);
len = mono_class_num_methods (iclass);
domain = mono_object_domain (type);
- mono_gc_wbarrier_generic_store (targets, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len));
- mono_gc_wbarrier_generic_store (methods, (MonoObject*) mono_array_new (domain, mono_defaults.method_info_class, len));
+ MonoArray *targets_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ mono_gc_wbarrier_generic_store (targets, (MonoObject*) targets_arr);
+ MonoArray *methods_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+ mono_gc_wbarrier_generic_store (methods, (MonoObject*) methods_arr);
iter = NULL;
while ((method = mono_class_get_methods (iclass, &iter))) {
member = mono_method_get_object_checked (domain, method, iclass, &error);
}
static MonoArray*
-create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count)
+create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count, MonoError *error)
{
- MonoArray *res;
- res = mono_array_new (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count);
- return res;
+ return mono_array_new_checked (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count, error);
}
ICALL_EXPORT MonoArray*
if (klass->generic_container) {
MonoGenericContainer *container = klass->generic_container;
- res = create_type_array (domain, runtimeTypeArray, container->type_argc);
+ res = create_type_array (domain, runtimeTypeArray, container->type_argc, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < container->type_argc; ++i) {
pklass = mono_class_from_generic_parameter_internal (mono_generic_container_get_param (container, i));
}
} else if (klass->generic_class) {
MonoGenericInst *inst = klass->generic_class->context.class_inst;
- res = create_type_array (domain, runtimeTypeArray, inst->type_argc);
+ res = create_type_array (domain, runtimeTypeArray, inst->type_argc, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < inst->type_argc; ++i) {
rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
if (mono_error_set_pending_exception (&error))
for (count = 0, ptr = param_info->constraints; ptr && *ptr; ptr++, count++)
;
- res = mono_array_new (domain, mono_defaults.monotype_class, count);
+ res = mono_array_new_checked (domain, mono_defaults.monotype_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < count; i++) {
rt = mono_type_get_object_checked (domain, ¶m_info->constraints [i]->byval_arg, &error);
if (mono_error_set_pending_exception (&error))
if (inst) {
count = inst->type_argc;
- res = mono_array_new (domain, mono_defaults.systemtype_class, count);
+ res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < count; i++) {
rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
}
count = mono_method_signature (method->method)->generic_param_count;
- res = mono_array_new (domain, mono_defaults.systemtype_class, count);
+ res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < count; i++) {
MonoGenericContainer *container = mono_method_get_generic_container (method->method);
do {
MonoClassField* field = mono_class_get_field_from_name (k, str);
if (field) {
+ g_free (str);
MonoClass *field_klass = mono_class_from_mono_type (field->type);
if (field_klass->valuetype) {
result = mono_value_box_checked (domain, field_klass, (char *)this_arg + field->offset, &error);
- mono_error_set_pending_exception (&error);
- /* fallthru to cleanup */
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
} else
result = (MonoObject *)*((gpointer *)((char *)this_arg + field->offset));
- out_args = mono_array_new (domain, mono_defaults.object_class, 1);
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
mono_array_setref (out_args, 0, result);
- g_free (str);
return NULL;
}
k = k->parent;
do {
MonoClassField* field = mono_class_get_field_from_name (k, str);
if (field) {
+ g_free (str);
MonoClass *field_klass = mono_class_from_mono_type (field->type);
MonoObject *val = (MonoObject *)mono_array_get (params, gpointer, 2);
mono_gc_wbarrier_set_field (this_arg, (char*)this_arg + field->offset, val);
}
- out_args = mono_array_new (domain, mono_defaults.object_class, 0);
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, 0, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
- g_free (str);
return NULL;
}
outarg_count++;
}
- out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count);
-
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, outarg_count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
/* handle constructors only for objects already allocated */
if (!strcmp (method->method->name, ".ctor"))
g_assert (this_arg);
base_type = mono_class_enum_basetype (enumc)->type;
nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0;
- *names = mono_array_new (domain, mono_defaults.string_class, nvalues);
- *values = mono_array_new (domain, mono_defaults.uint64_class, nvalues);
+ *names = mono_array_new_checked (domain, mono_defaults.string_class, nvalues, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
+ *values = mono_array_new_checked (domain, mono_defaults.uint64_class, nvalues, &error);
+ if (mono_error_set_pending_exception (&error))
+ return FALSE;
iter = NULL;
while ((field = mono_class_get_fields (enumc, &iter))) {
MonoPtrArray tmp_array;
domain = ((MonoObject *)type)->vtable->domain;
- if (type->type->byref)
- return mono_array_new (domain, mono_defaults.field_info_class, 0);
+ if (type->type->byref) {
+ MonoArray *result = mono_array_new_checked (domain, mono_defaults.field_info_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+ }
klass = startklass = mono_class_from_mono_type (type->type);
refklass = mono_class_from_mono_type (reftype->type);
mono_error_init (&error);
domain = ((MonoObject *)type)->vtable->domain;
- if (type->type->byref)
- return mono_array_new (domain, mono_defaults.monotype_class, 0);
+ if (type->type->byref) {
+ MonoArray *result = mono_array_new_checked (domain, mono_defaults.monotype_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+ }
klass = mono_class_from_mono_type (type->type);
/*
ICALL_EXPORT MonoArray*
ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
{
+ MonoError error;
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
- MonoArray *result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, table->rows);
+ MonoArray *result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, table->rows, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
int i;
const char *val;
t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF];
count = t->rows;
- result = mono_array_new (domain, mono_class_get_assembly_name_class (), count);
+ result = mono_array_new_checked (domain, mono_class_get_assembly_name_class (), count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
if (count > 0 && !create_culture) {
MonoMethodDesc *desc = mono_method_desc_new (
if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) {
/* public key token isn't copied - the class library will
automatically generate it from the public key if required */
- MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
- memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
+ MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ MONO_OBJECT_SETREF (aname, publicKey, pkey);
+ memcpy (mono_array_addr (pkey, guint8, 0), pkey_ptr, pkey_len);
} else {
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
- memcpy (mono_array_addr (aname->keyToken, guint8, 0), pkey_ptr, pkey_len);
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
+ memcpy (mono_array_addr (keyToken, guint8, 0), pkey_ptr, pkey_len);
}
} else {
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
}
/* note: this function doesn't return the codebase on purpose (i.e. it can
ICALL_EXPORT MonoObject*
ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules)
{
+ MonoError error;
MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
MonoArray *result = NULL;
int i, count;
count ++;
}
- result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, count);
+ result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
+
count = 0;
for (i = 0; i < table->rows; ++i) {
real_module_count ++;
klass = mono_class_get_module_class ();
- res = mono_array_new (domain, klass, 1 + real_module_count + file_count);
+ res = mono_array_new_checked (domain, klass, 1 + real_module_count + file_count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
MonoReflectionModule *image_obj = mono_module_get_object_checked (domain, image, &error);
if (mono_error_set_pending_exception (&error))
pkey_ptr = (char*)name->public_key;
pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
- MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len));
+ MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, error);
+ return_if_nok (error);
+ MONO_OBJECT_SETREF (aname, publicKey, pkey);
memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
} else if (default_publickey) {
- MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, 0));
+ MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error);
+ return_if_nok (error);
+ MONO_OBJECT_SETREF (aname, publicKey, pkey);
aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
}
int i, j;
char *p;
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 8));
- p = mono_array_addr (aname->keyToken, char, 0);
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 8, error);
+ return_if_nok (error);
+
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
+ p = mono_array_addr (keyToken, char, 0);
for (i = 0, j = 0; i < 8; i++) {
*p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4;
p++;
}
} else if (default_token) {
- MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0));
+ MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error);
+ return_if_nok (error);
+ MONO_OBJECT_SETREF (aname, keyToken, keyToken);
}
}
} else {
count = tdef->rows - 1;
}
- res = mono_array_new (domain, mono_defaults.monotype_class, count);
- *exceptions = mono_array_new (domain, mono_defaults.exception_class, count);
+ res = mono_array_new_checked (domain, mono_defaults.monotype_class, count, error);
+ return_val_if_nok (error, NULL);
+ *exceptions = mono_array_new_checked (domain, mono_defaults.exception_class, count, error);
+ return_val_if_nok (error, NULL);
count = 0;
for (i = 1; i < tdef->rows; ++i) {
if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) {
len1 = mono_array_length (res);
len2 = mono_array_length (res2);
- res3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
+ res3 = mono_array_new_checked (domain, mono_defaults.monotype_class, len1 + len2, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_memcpy_refs (res3, 0, res, 0, len1);
mono_array_memcpy_refs (res3, len1, res2, 0, len2);
res = res3;
- ex3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2);
+ ex3 = mono_array_new_checked (domain, mono_defaults.monotype_class, len1 + len2, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1);
mono_array_memcpy_refs (ex3, len1, ex2, 0, len2);
exceptions = ex3;
MonoArray *exl = NULL;
int j, length = g_list_length (list) + ex_count;
- exl = mono_array_new (domain, mono_defaults.exception_class, length);
+ exl = mono_array_new_checked (domain, mono_defaults.exception_class, length, &error);
+ if (mono_error_set_pending_exception (&error)) {
+ g_list_free (list);
+ return NULL;
+ }
/* Types for which mono_class_get_checked () succeeded */
for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) {
MonoException *exc = mono_class_get_exception_for_failure ((MonoClass *)tmp->data);
MonoArray *exceptions;
int i;
- if (!module->image)
- return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0);
- else {
+ if (!module->image) {
+ MonoArray *arr = mono_array_new_checked (mono_object_domain (module), mono_defaults.monotype_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return arr;
+ } else {
MonoArray *res;
res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE, &error);
}
ICALL_EXPORT MonoArray*
-ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *error)
+ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error)
{
+ MonoError error;
int table = mono_metadata_token_table (token);
int idx = mono_metadata_token_index (token);
MonoTableInfo *tables = image->tables;
const char *ptr;
MonoArray *res;
- *error = ResolveTokenError_OutOfRange;
+ *resolve_error = ResolveTokenError_OutOfRange;
/* FIXME: Support other tables ? */
if (table != MONO_TABLE_STANDALONESIG)
ptr = mono_metadata_blob_heap (image, sig);
len = mono_metadata_decode_blob_size (ptr, &ptr);
- res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, len);
+ res = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, len, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
memcpy (mono_array_addr (res, guint8, 0), ptr, len);
return res;
}
#endif
#endif
+ICALL_EXPORT MonoArray *
+ves_icall_System_Environment_GetCoomandLineArgs (void)
+{
+ MonoError error;
+ MonoArray *result = mono_runtime_get_main_args_checked (&error);
+ mono_error_set_pending_exception (&error);
+ return result;
+}
+
ICALL_EXPORT MonoArray *
ves_icall_System_Environment_GetEnvironmentVariableNames (void)
{
#ifdef HOST_WIN32
+ MonoError error;
MonoArray *names;
MonoDomain *domain;
MonoString *str;
}
domain = mono_domain_get ();
- names = mono_array_new (domain, mono_defaults.string_class, n);
+ names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
if (env_strings) {
n = 0;
return names;
#else
+ MonoError error;
MonoArray *names;
MonoDomain *domain;
MonoString *str;
++ n;
domain = mono_domain_get ();
- names = mono_array_new (domain, mono_defaults.string_class, n);
+ names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
n = 0;
for (e = environ; *e != 0; ++ e) {
} while (*dname);
dname = ptr;
- result = mono_array_new (domain, mono_defaults.string_class, ndrives);
+ result = mono_array_new_checked (domain, mono_defaults.string_class, ndrives, &error);
+ if (mono_error_set_pending_exception (&error))
+ goto leave;
+
ndrives = 0;
do {
len = 0;
while (*u16) { u16++; len ++; }
drivestr = mono_string_new_utf16_checked (domain, dname, len, &error);
if (mono_error_set_pending_exception (&error))
- return NULL;
+ goto leave;
mono_array_setref (result, ndrives++, drivestr);
while (*dname++);
} while (*dname);
+leave:
if (ptr != buf)
g_free (ptr);
if (klass->rank >= 1) {
g_assert (klass->rank == 1);
- return (MonoObject *) mono_array_new (domain, klass->element_class, 0);
+ ret = (MonoObject *) mono_array_new_checked (domain, klass->element_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return ret;
} else {
MonoVTable *vtable = mono_class_vtable_full (domain, klass, &error);
if (!is_ok (&error)) {
}
if (!count)
return NULL;
- res = mono_array_new (mono_domain_get (), mono_defaults.systemtype_class, count);
+ res = mono_array_new_checked (mono_domain_get (), mono_defaults.systemtype_class, count, error);
+ return_val_if_nok (error, NULL);
count = 0;
for (i = 0; i < type->num_mods; ++i) {
if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
if (neutral)
len++;
- ret = mono_array_new (domain, klass, len);
+ ret = mono_array_new_checked (domain, klass, len, &error);
+ if (!is_ok (&error))
+ goto fail;
if (len == 0)
return ret;
void ves_icall_System_Globalization_CompareInfo_assign_sortkey (MonoCompareInfo *this_obj, MonoSortKey *key, MonoString *source, gint32 options)
{
+ MonoError error;
MonoArray *arr;
gint32 keylen, i;
keylen=mono_string_length (source);
- arr=mono_array_new (mono_domain_get (), mono_get_byte_class (),
- keylen);
+ arr=mono_array_new_checked (mono_domain_get (), mono_get_byte_class (),
+ keylen, &error);
+ if (mono_error_set_pending_exception (&error))
+ return;
+
for(i=0; i<keylen; i++) {
mono_array_set (arr, guint8, i, mono_string_chars (source)[i]);
}
MonoArray*
mono_perfcounter_category_names (MonoString *machine)
{
+ MonoError error;
int i;
MonoArray *res;
MonoDomain *domain = mono_domain_get ();
GSList *custom_categories, *tmp;
/* no support for counters on other machines */
- if (mono_string_compare_ascii (machine, "."))
- return mono_array_new (domain, mono_get_string_class (), 0);
+ if (mono_string_compare_ascii (machine, ".")) {
+ res = mono_array_new_checked (domain, mono_get_string_class (), 0, &error);
+ mono_error_set_pending_exception (&error);
+ return res;
+ }
perfctr_lock ();
custom_categories = get_custom_categories ();
- res = mono_array_new (domain, mono_get_string_class (), NUM_CATEGORIES + g_slist_length (custom_categories));
+ res = mono_array_new_checked (domain, mono_get_string_class (), NUM_CATEGORIES + g_slist_length (custom_categories), &error);
+ if (mono_error_set_pending_exception (&error)) {
+ perfctr_unlock ();
+ return NULL;
+ }
+
for (i = 0; i < NUM_CATEGORIES; ++i) {
const CategoryDesc *cdesc = &predef_categories [i];
mono_array_setref (res, i, mono_string_new (domain, cdesc->name));
MonoArray*
mono_perfcounter_counter_names (MonoString *category, MonoString *machine)
{
+ MonoError error;
int i;
SharedCategory *scat;
const CategoryDesc *cdesc;
MonoArray *res;
MonoDomain *domain = mono_domain_get ();
/* no support for counters on other machines */
- if (mono_string_compare_ascii (machine, "."))
- return mono_array_new (domain, mono_get_string_class (), 0);
+ if (mono_string_compare_ascii (machine, ".")) {
+ res = mono_array_new_checked (domain, mono_get_string_class (), 0, &error);
+ mono_error_set_pending_exception (&error);
+ return res;
+ }
cdesc = find_category (category);
if (cdesc) {
- res = mono_array_new (domain, mono_get_string_class (), cdesc [1].first_counter - cdesc->first_counter);
+ res = mono_array_new_checked (domain, mono_get_string_class (), cdesc [1].first_counter - cdesc->first_counter, &error);
+ if (mono_error_set_pending_exception (&error))
+ 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));
if (scat) {
char *p = custom_category_counters (scat);
int i;
- res = mono_array_new (domain, mono_get_string_class (), scat->num_counters);
+ res = mono_array_new_checked (domain, mono_get_string_class (), scat->num_counters, &error);
+ if (mono_error_set_pending_exception (&error)) {
+ perfctr_unlock ();
+ return NULL;
+ }
+
for (i = 0; i < scat->num_counters; ++i) {
mono_array_setref (res, i, mono_string_new (domain, p + 1));
p += 2; /* skip counter type */
return res;
}
perfctr_unlock ();
- return mono_array_new (domain, mono_get_string_class (), 0);
+ res = mono_array_new_checked (domain, mono_get_string_class (), 0, &error);
+ mono_error_set_pending_exception (&error);
+ return res;
}
static MonoArray*
-get_string_array (void **array, int count, gboolean is_process)
+get_string_array (void **array, int count, gboolean is_process, MonoError *error)
{
int i;
MonoDomain *domain = mono_domain_get ();
- MonoArray * res = mono_array_new (mono_domain_get (), mono_get_string_class (), count);
+ mono_error_init (error);
+ MonoArray * res = mono_array_new_checked (mono_domain_get (), mono_get_string_class (), count, error);
+ return_val_if_nok (error, NULL);
for (i = 0; i < count; ++i) {
char buf [128];
char *p;
}
static MonoArray*
-get_string_array_of_strings (void **array, int count)
+get_string_array_of_strings (void **array, int count, MonoError *error)
{
int i;
MonoDomain *domain = mono_domain_get ();
- MonoArray * res = mono_array_new (mono_domain_get (), mono_get_string_class (), count);
+ mono_error_init (error);
+ MonoArray * res = mono_array_new_checked (mono_domain_get (), mono_get_string_class (), count, error);
+ 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));
}
static MonoArray*
-get_mono_instances (void)
+get_mono_instances (MonoError *error)
{
int count = 64;
int res;
void **buf = NULL;
MonoArray *array;
+ mono_error_init (error);
do {
count *= 2;
g_free (buf);
buf = g_new (void*, count);
res = mono_shared_area_instances (buf, count);
} while (res == count);
- array = get_string_array (buf, res, TRUE);
+ array = get_string_array (buf, res, TRUE, error);
g_free (buf);
return array;
}
static MonoArray*
-get_cpu_instances (void)
+get_cpu_instances (MonoError *error)
{
void **buf = NULL;
int i, count;
MonoArray *array;
-
+ mono_error_init (error);
count = mono_cpu_count () + 1; /* +1 for "_Total" */
buf = g_new (void*, count);
for (i = 0; i < count; ++i)
buf [i] = GINT_TO_POINTER (i - 1); /* -1 => _Total */
- array = get_string_array (buf, count, FALSE);
+ array = get_string_array (buf, count, FALSE, error);
g_free (buf);
mono_array_setref (array, 0, mono_string_new (mono_domain_get (), "_Total"));
return array;
}
static MonoArray*
-get_processes_instances (void)
+get_processes_instances (MonoError *error)
{
MonoArray *array;
int count = 0;
void **buf = mono_process_list (&count);
+ mono_error_init (error);
if (!buf)
- return get_string_array (NULL, 0, FALSE);
- array = get_string_array (buf, count, TRUE);
+ return get_string_array (NULL, 0, FALSE, error);
+ array = get_string_array (buf, count, TRUE, error);
g_free (buf);
return array;
}
static MonoArray*
-get_networkinterface_instances (void)
+get_networkinterface_instances (MonoError *error)
{
MonoArray *array;
int count = 0;
+ mono_error_init (error);
void **buf = mono_networkinterface_list (&count);
if (!buf)
- return get_string_array_of_strings (NULL, 0);
- array = get_string_array_of_strings (buf, count);
+ return get_string_array_of_strings (NULL, 0, error);
+ array = get_string_array_of_strings (buf, count, error);
g_strfreev ((char **) buf);
return array;
}
static MonoArray*
-get_custom_instances (MonoString *category)
+get_custom_instances (MonoString *category, MonoError *error)
{
SharedCategory *scat;
+ mono_error_init (error);
scat = find_custom_category (category);
if (scat) {
GSList *list = get_custom_instances_list (scat);
GSList *tmp;
int i = 0;
- MonoArray *array = mono_array_new (mono_domain_get (), mono_get_string_class (), g_slist_length (list));
+ MonoArray *array = mono_array_new_checked (mono_domain_get (), mono_get_string_class (), g_slist_length (list), error);
+ if (!is_ok (error)) {
+ g_slist_free (list);
+ return NULL;
+ }
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));
g_slist_free (list);
return array;
}
- return mono_array_new (mono_domain_get (), mono_get_string_class (), 0);
+ return mono_array_new_checked (mono_domain_get (), mono_get_string_class (), 0, error);
}
MonoArray*
mono_perfcounter_instance_names (MonoString *category, MonoString *machine)
{
+ MonoError error;
const CategoryDesc* cat;
- if (mono_string_compare_ascii (machine, "."))
- return mono_array_new (mono_domain_get (), mono_get_string_class (), 0);
+ MonoArray *result = NULL;
+ if (mono_string_compare_ascii (machine, ".")) {
+ result = mono_array_new_checked (mono_domain_get (), mono_get_string_class (), 0, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+ }
+
cat = find_category (category);
- if (!cat)
- return get_custom_instances (category);
+ if (!cat) {
+ MonoArray *result = get_custom_instances (category, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+ }
switch (cat->instance_type) {
case MonoInstance:
- return get_mono_instances ();
+ result = get_mono_instances (&error);
+ break;
case CPUInstance:
- return get_cpu_instances ();
+ result = get_cpu_instances (&error);
+ break;
case ProcessInstance:
- return get_processes_instances ();
+ result = get_processes_instances (&error);
+ break;
case NetworkInterfaceInstance:
- return get_networkinterface_instances ();
+ result = get_networkinterface_instances (&error);
+ break;
case ThreadInstance:
default:
- return mono_array_new (mono_domain_get (), mono_get_string_class (), 0);
+ result = mono_array_new_checked (mono_domain_get (), mono_get_string_class (), 0, &error);
}
+ mono_error_set_pending_exception (&error);
+ return result;
}
typedef struct {
MonoArray*
ves_icall_System_Security_Principal_WindowsIdentity_GetRoles (gpointer token)
{
+ MonoError error;
MonoArray *array = NULL;
MonoDomain *domain = mono_domain_get ();
#ifdef HOST_WIN32
- MonoError error;
gint32 size = 0;
GetTokenInformation (token, TokenGroups, NULL, size, (PDWORD)&size);
int i=0;
int num = tg->GroupCount;
- array = mono_array_new (domain, mono_get_string_class (), num);
+ array = mono_array_new_checked (domain, mono_get_string_class (), num, &error);
+ if (mono_error_set_pending_exception (&error)) {
+ g_free (tg);
+ return NULL;
+ }
for (i=0; i < num; i++) {
gint32 size = 0;
#endif
if (!array) {
/* return empty array of string, i.e. string [0] */
- array = mono_array_new (domain, mono_get_string_class (), 0);
+ array = mono_array_new_checked (domain, mono_get_string_class (), 0, &error);
+ mono_error_set_pending_exception (&error);
}
return array;
}
gboolean
mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res);
+MonoArray*
+mono_array_new_checked (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error);
+
MonoArray*
mono_array_new_full_checked (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds, MonoError *error);
MonoArray*
mono_array_new_specific_checked (MonoVTable *vtable, uintptr_t n, MonoError *error);
+MonoArray*
+ves_icall_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n);
+
MonoArray*
ves_icall_array_new_specific (MonoVTable *vtable, uintptr_t n);
mono_error_set_pending_exception (MonoError *error);
MonoArray *
-mono_glist_to_array (GList *list, MonoClass *eclass);
+mono_glist_to_array (GList *list, MonoClass *eclass, MonoError *error);
MonoObject *
mono_object_new_checked (MonoDomain *domain, MonoClass *klass, MonoError *error);
mono_runtime_invoke_checked (MonoMethod *method, void *obj, void **params, MonoError *error);
+MonoArray*
+mono_runtime_get_main_args_checked (MonoError *error);
+
#endif /* __MONO_OBJECT_INTERNALS_H__ */
mono_runtime_get_main_args (void)
{
MONO_REQ_GC_UNSAFE_MODE;
+ MonoError error;
+ MonoArray *result = mono_runtime_get_main_args_checked (&error);
+ mono_error_assert_ok (&error);
+ return result;
+}
+/**
+ * mono_runtime_get_main_args:
+ * @error: set on error
+ *
+ * Returns: a MonoArray with the arguments passed to the main
+ * program. On failure returns NULL and sets @error.
+ */
+MonoArray*
+mono_runtime_get_main_args_checked (MonoError *error)
+{
MonoArray *res;
int i;
MonoDomain *domain = mono_domain_get ();
- res = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, num_main_args);
+ mono_error_init (error);
+
+ 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]));
{
MONO_REQ_GC_UNSAFE_MODE;
+ MonoError error;
int i;
MonoArray *args = NULL;
MonoDomain *domain = mono_domain_get ();
}
if (sig->param_count) {
- args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, argc);
+ args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, argc, &error);
+ mono_error_assert_ok (&error);
for (i = 0; i < argc; ++i) {
/* The encodings should all work, given that
* we've checked all these args for the
g_free (str);
}
} else {
- args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 0);
+ args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, 0, &error);
+ mono_error_assert_ok (&error);
}
mono_assembly_set_main (method->klass->image->assembly);
MONO_REQ_GC_UNSAFE_MODE;
MonoError error;
+ MonoArray *result = mono_array_new_checked (domain, eclass, n, &error);
+ mono_error_cleanup (&error);
+ return result;
+}
+
+/**
+ * mono_array_new_checked:
+ * @domain: domain where the object is created
+ * @eclass: element class
+ * @n: number of array elements
+ * @error: set on error
+ *
+ * This routine creates a new szarray with @n elements of type @eclass.
+ * On failure returns NULL and sets @error.
+ */
+MonoArray *
+mono_array_new_checked (MonoDomain *domain, MonoClass *eclass, uintptr_t n, MonoError *error)
+{
MonoClass *ac;
- MonoArray *arr;
+
+ mono_error_init (error);
ac = mono_array_class_get (eclass, 1);
g_assert (ac);
- MonoVTable *vtable = mono_class_vtable_full (domain, ac, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ MonoVTable *vtable = mono_class_vtable_full (domain, ac, error);
+ return_val_if_nok (error, NULL);
- arr = mono_array_new_specific_checked (vtable, n, &error);
- mono_error_raise_exception (&error); /* FIXME don't raise here */
+ return mono_array_new_specific_checked (vtable, n, error);
+}
+
+MonoArray*
+ves_icall_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n)
+{
+ MonoError error;
+ MonoArray *arr = mono_array_new_checked (domain, eclass, n, &error);
+ mono_error_set_pending_exception (&error);
return arr;
}
msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
return_val_if_nok (error, NULL);
- out_args = mono_array_new (domain, mono_defaults.object_class, 1);
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, error);
+ return_val_if_nok (error, NULL);
MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
return_val_if_nok (error, NULL);
mono_message_init (domain, msg, rm, out_args);
msg = (MonoMethodMessage *)mono_object_new_checked (domain, mono_defaults.mono_method_message_class, error);
return_val_if_nok (error, NULL);
- out_args = mono_array_new (domain, mono_defaults.object_class, 1);
+ out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, error);
+ return_val_if_nok (error, NULL);
MonoReflectionMethod *rm = mono_method_get_object_checked (domain, getter, NULL, error);
return_val_if_nok (error, NULL);
MonoArray *
-mono_glist_to_array (GList *list, MonoClass *eclass)
+mono_glist_to_array (GList *list, MonoClass *eclass, MonoError *error)
{
MonoDomain *domain = mono_domain_get ();
MonoArray *res;
int len, i;
+ mono_error_init (error);
if (!list)
return NULL;
len = g_list_length (list);
- res = mono_array_new (domain, eclass, len);
+ res = mono_array_new_checked (domain, eclass, len, error);
+ return_val_if_nok (error, NULL);
for (i = 0; list; list = list->next, i++)
mono_array_set (res, gpointer, i, list->data);
MONO_API MonoObject *
mono_object_new_from_token (MonoDomain *domain, MonoImage *image, uint32_t token);
+MONO_RT_EXTERNAL_ONLY
MONO_API MonoArray*
mono_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n);
MONO_API void*
mono_method_get_unmanaged_thunk (MonoMethod *method);
+MONO_RT_EXTERNAL_ONLY
MONO_API MonoArray*
mono_runtime_get_main_args (void);
}
count = module_count + assembly_count;
- temp_arr = mono_array_new (mono_domain_get (), mono_class_get_process_module_class (), count);
+ temp_arr = mono_array_new_checked (mono_domain_get (), mono_class_get_process_module_class (), count, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < module_count; i++) {
if (GetModuleBaseName (process, mods[i], modname, MAX_PATH) &&
arr = temp_arr;
} else {
/* shorter version of the array */
- arr = mono_array_new (mono_domain_get (), mono_class_get_process_module_class (), num_added);
+ arr = mono_array_new_checked (mono_domain_get (), mono_class_get_process_module_class (), num_added, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = 0; i < num_added; i++)
mono_array_setref (arr, i, mono_array_get (temp_arr, MonoObject*, i));
ves_icall_System_Diagnostics_Process_GetProcesses_internal (void)
{
#if !defined(HOST_WIN32)
+ MonoError error;
MonoArray *procs;
gpointer *pidarray;
int i, count;
mono_set_pending_exception (mono_get_exception_not_supported ("This system does not support EnumProcesses"));
return NULL;
}
- procs = mono_array_new (mono_domain_get (), mono_get_int32_class (), count);
+ procs = mono_array_new_checked (mono_domain_get (), mono_get_int32_class (), count, &error);
+ if (mono_error_set_pending_exception (&error)) {
+ g_free (pidarray);
+ return NULL;
+ }
if (sizeof (guint32) == sizeof (gpointer)) {
memcpy (mono_array_addr (procs, guint32, 0), pidarray, count * sizeof (gint32));
} else {
return procs;
#else
+ MonoError error;
MonoArray *procs;
gboolean ret;
DWORD needed;
} while (TRUE);
count = needed / sizeof (guint32);
- procs = mono_array_new (mono_domain_get (), mono_get_int32_class (), count);
+ procs = mono_array_new_checked (mono_domain_get (), mono_get_int32_class (), count, &error);
+ if (mono_error_set_pending_exception (&error)) {
+ g_free (pids);
+ return NULL;
+ }
+
memcpy (mono_array_addr (procs, guint32, 0), pids, needed);
g_free (pids);
pids = NULL;
*end = p;
return NULL;
}
- arr = mono_array_new (mono_domain_get(), tklass, alen);
+ arr = mono_array_new_checked (mono_domain_get(), tklass, alen, error);
+ return_val_if_nok (error, NULL);
basetype = tklass->byval_arg.type;
if (basetype == MONO_TYPE_VALUETYPE && tklass->enumtype)
basetype = mono_class_enum_basetype (tklass)->type;
if (len < 2 || read16 (p) != 0x0001) /* Prolog */
return;
- typedargs = mono_array_new (domain, mono_get_object_class (), mono_method_signature (method)->param_count);
-
+ typedargs = mono_array_new_checked (domain, mono_get_object_class (), mono_method_signature (method)->param_count, error);
+ return_if_nok (error);
+
/* skip prolog */
p += 2;
for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
named = p;
num_named = read16 (named);
- namedargs = mono_array_new (domain, mono_get_object_class (), num_named);
+ namedargs = mono_array_new_checked (domain, mono_get_object_class (), num_named, error);
+ return_if_nok (error);
named += 2;
attrklass = method->klass;
int i;
mono_error_init (error);
- result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, cinfo->num_attrs);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.customattribute_data_class, cinfo->num_attrs, error);
+ return_val_if_nok (error, NULL);
for (i = 0; i < cinfo->num_attrs; ++i) {
attr = create_custom_attr_data (cinfo->image, &cinfo->attrs [i], error);
return_val_if_nok (error, NULL);
if (!cinfo->cached)
mono_custom_attrs_free (cinfo);
return_val_if_nok (error, NULL);
- } else
- result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, 0);
+ } else
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.customattribute_data_class, 0, error);
return result;
}
g_assert (p - buffer <= buflen);
buflen = p - buffer;
- result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
+ if (!is_ok (error))
+ goto leave;
p = mono_array_addr (result, char, 0);
memcpy (p, buffer, buflen);
leave:
}
buflen = buf.p - buf.buf;
- result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
+ if (!is_ok (error)) goto fail;
memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
sigbuffer_free (&buf);
return result;
}
buflen = buf.p - buf.buf;
- result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
+ result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
+ if (!is_ok (error)) goto fail;
memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
sigbuffer_free (&buf);
}
static gboolean
-addrinfo_to_IPHostEntry(MonoAddressInfo *info, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gboolean add_local_ips)
+addrinfo_to_IPHostEntry (MonoAddressInfo *info, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list, gboolean add_local_ips, MonoError *error)
{
gint32 count, i;
MonoAddressEntry *ai = NULL;
int addr_index;
MonoDomain *domain = mono_domain_get ();
+ mono_error_init (error);
addr_index = 0;
- *h_aliases = mono_array_new (domain, mono_get_string_class (), 0);
+ *h_aliases = mono_array_new_checked (domain, mono_get_string_class (), 0, error);
+ return_val_if_nok (error, FALSE);
if (add_local_ips) {
local_in = (struct in_addr *) mono_get_local_interfaces (AF_INET, &nlocal_in);
local_in6 = (struct in6_addr *) mono_get_local_interfaces (AF_INET6, &nlocal_in6);
if (nlocal_in || nlocal_in6) {
char addr [INET6_ADDRSTRLEN];
- *h_addr_list = mono_array_new (domain, mono_get_string_class (), nlocal_in + nlocal_in6);
+ *h_addr_list = mono_array_new_checked (domain, mono_get_string_class (), nlocal_in + nlocal_in6, error);
+ if (!is_ok (error))
+ goto leave;
+
if (nlocal_in) {
MonoString *addr_string;
int i;
}
}
+ leave:
g_free (local_in);
g_free (local_in6);
if (info)
mono_free_address_info (info);
- return TRUE;
+ return is_ok (error);;
}
g_free (local_in);
count++;
}
- *h_addr_list = mono_array_new (domain, mono_get_string_class (), count);
+ *h_addr_list = mono_array_new_checked (domain, mono_get_string_class (), count, error);
+ if (!is_ok (error))
+ goto leave2;
for (ai = info->entries, i = 0; ai != NULL; ai = ai->next) {
MonoAddress maddr;
addr_index++;
}
+leave2:
if (info)
mono_free_address_info (info);
- return TRUE;
+ return is_ok (error);
}
static int
g_free(hostname);
- if (add_info_ok)
- return addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, add_local_ips);
+ if (add_info_ok) {
+ MonoBoolean result = addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, add_local_ips, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
+ }
return FALSE;
}
if (mono_get_address_info (hostname, 0, hint | MONO_HINT_CANONICAL_NAME | MONO_HINT_CONFIGURED_ONLY, &info) != 0)
return FALSE;
- return addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, FALSE);
+ MonoBoolean result = addrinfo_to_IPHostEntry (info, h_name, h_aliases, h_addr_list, FALSE, &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoBoolean
/* If the array is already in the requested domain, we just return it,
otherwise we return a copy in that domain. */
static MonoArray*
-byte_array_to_domain (MonoArray *arr, MonoDomain *domain)
+byte_array_to_domain (MonoArray *arr, MonoDomain *domain, MonoError *error)
{
MonoArray *copy;
+ mono_error_init (error);
if (!arr)
return NULL;
if (mono_object_domain (arr) == domain)
return arr;
- copy = mono_array_new (domain, mono_defaults.byte_class, arr->max_length);
+ copy = mono_array_new_checked (domain, mono_defaults.byte_class, arr->max_length, error);
memmove (mono_array_addr (copy, guint8, 0), mono_array_addr (arr, guint8, 0), arr->max_length);
return copy;
}
MonoArray*
ves_icall_System_Threading_Thread_ByteArrayToRootDomain (MonoArray *arr)
{
- return byte_array_to_domain (arr, mono_get_root_domain ());
+ MonoError error;
+ MonoArray *result = byte_array_to_domain (arr, mono_get_root_domain (), &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoArray*
ves_icall_System_Threading_Thread_ByteArrayToCurrentDomain (MonoArray *arr)
{
- return byte_array_to_domain (arr, mono_domain_get ());
+ MonoError error;
+ MonoArray *result = byte_array_to_domain (arr, mono_domain_get (), &error);
+ mono_error_set_pending_exception (&error);
+ return result;
}
MonoThread *
ud.frames = g_new0 (MonoStackFrameInfo, 256);
ud.max_frames = 256;
- *out_threads = mono_array_new (domain, mono_defaults.thread_class, nthreads);
- *out_stack_frames = mono_array_new (domain, mono_defaults.array_class, nthreads);
+ *out_threads = mono_array_new_checked (domain, mono_defaults.thread_class, nthreads, &error);
+ if (!is_ok (&error))
+ goto leave;
+ *out_stack_frames = mono_array_new_checked (domain, mono_defaults.array_class, nthreads, &error);
+ if (!is_ok (&error))
+ goto leave;
for (tindex = 0; tindex < nthreads; ++tindex) {
MonoInternalThread *thread = thread_array [tindex];
mono_array_setref_fast (*out_threads, tindex, mono_thread_current_for_thread (thread));
- thread_frames = mono_array_new (domain, mono_defaults.stack_frame_class, ud.nframes);
+ thread_frames = mono_array_new_checked (domain, mono_defaults.stack_frame_class, ud.nframes, &error);
+ if (!is_ok (&error))
+ goto leave;
mono_array_setref_fast (*out_stack_frames, tindex, thread_frames);
for (i = 0; i < ud.nframes; ++i) {
MONO_INST_NEW (cfg, iargs [2], OP_MOVE);
iargs [2]->dreg = ins->sreg1;
- dest = mono_emit_jit_icall (cfg, mono_array_new, iargs);
+ dest = mono_emit_jit_icall (cfg, ves_icall_array_new, iargs);
dest->dreg = ins->dreg;
} else {
MonoClass *array_class = mono_array_class_get (ins->inst_newa_class, 1);
method = mono_get_method_checked (image, entry, NULL, NULL, &error);
if (method == NULL){
- g_print ("The entry point method of assembly '%s' could not be loaded due to %s\n", agent, &error);
+ g_print ("The entry point method of assembly '%s' could not be loaded due to %s\n", agent, mono_error_get_message (&error));
mono_error_cleanup (&error);
g_free (agent);
return 1;
mono_thread_set_main (mono_thread_current ());
if (args) {
- main_args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 1);
- mono_array_set (main_args, MonoString*, 0, mono_string_new (domain, 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));
} else {
- main_args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 0);
+ main_args = (MonoArray*)mono_array_new_checked (domain, mono_defaults.string_class, 0, &error);
}
-
+ if (!main_args) {
+ g_print ("Could not allocate array for main args of assembly '%s' due to %s\n", agent, mono_error_get_message (&error));
+ mono_error_cleanup (&error);
+ g_free (agent);
+ return 1;
+ }
+
g_free (agent);
pa [0] = main_args;
EMIT_NEW_CLASSCONST (cfg, iargs [1], klass);
iargs [2] = sp [0];
- ins = mono_emit_jit_icall (cfg, mono_array_new, iargs);
+ ins = mono_emit_jit_icall (cfg, ves_icall_array_new, iargs);
} else {
/* Decompose later since it is needed by abcrem */
MonoClass *array_type = mono_array_class_get (klass, 1);
if (ta == NULL) {
/* Exception is not thrown yet */
- return mono_array_new (domain, mono_defaults.stack_frame_class, 0);
+ res = mono_array_new_checked (domain, mono_defaults.stack_frame_class, 0, &error);
+ mono_error_set_pending_exception (&error);
+ return res;
}
len = mono_array_length (ta) >> 1;
- res = mono_array_new (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0);
+ res = mono_array_new_checked (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0, &error);
+ if (mono_error_set_pending_exception (&error))
+ return NULL;
for (i = skip; i < len; i++) {
MonoJitInfo *ji;
#define MAX_UNMANAGED_BACKTRACE 128
static MonoArray*
-build_native_trace (void)
+build_native_trace (MonoError *error)
{
+ mono_error_init (error);
/* This puppy only makes sense on mobile, IOW, ARM. */
#if defined (HAVE_BACKTRACE_SYMBOLS) && defined (TARGET_ARM)
MonoArray *res;
if (!size)
return NULL;
- res = mono_array_new (mono_domain_get (), mono_defaults.int_class, size);
+ res = mono_array_new_checked (mono_domain_get (), mono_defaults.int_class, size, error);
+ return_val_if_nok (error, NULL);
for (i = 0; i < size; i++)
mono_array_set (res, gpointer, i, native_trace [i]);
{
if (mono_ex && !initial_trace_ips) {
*trace_ips = g_list_reverse (*trace_ips);
- MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_glist_to_array (*trace_ips, mono_defaults.int_class));
- MONO_OBJECT_SETREF (mono_ex, native_trace_ips, build_native_trace ());
+ MonoError error;
+ MonoArray *ips_arr = mono_glist_to_array (*trace_ips, mono_defaults.int_class, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
+ MONO_OBJECT_SETREF (mono_ex, native_trace_ips, build_native_trace (&error));
+ mono_error_assert_ok (&error);
if (dynamic_methods) {
/* These methods could go away anytime, so save a reference to them in the exception object */
GSList *l;
trace = g_list_append (trace, l->data);
trace = g_list_append (trace, NULL);
}
- MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_glist_to_array (trace, mono_defaults.int_class));
+ MonoArray *ips_arr = mono_glist_to_array (trace, mono_defaults.int_class, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
g_list_free (l);
g_list_free (trace);
#endif
MonoObject *
mono_llvm_load_exception (void)
{
+ MonoError error;
MonoJitTlsData *jit_tls = mono_get_jit_tls ();
MonoException *mono_ex = (MonoException*)mono_gchandle_get_target (jit_tls->thrown_exc);
// FIXME: Does this work correctly for rethrows?
// We may be discarding useful information
// when this gets GC'ed
- MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_glist_to_array (trace_ips, mono_defaults.int_class));
+ MonoArray *ips_arr = mono_glist_to_array (trace_ips, mono_defaults.int_class, &error);
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
g_list_free (trace_ips);
// FIXME:
//MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
} else {
- MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_array_new (mono_domain_get (), mono_defaults.int_class, 0));
- MONO_OBJECT_SETREF (mono_ex, stack_trace, mono_array_new (mono_domain_get (), mono_defaults.stack_frame_class, 0));
+ MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_array_new_checked (mono_domain_get (), mono_defaults.int_class, 0, &error));
+ mono_error_assert_ok (&error);
+ MONO_OBJECT_SETREF (mono_ex, stack_trace, mono_array_new_checked (mono_domain_get (), mono_defaults.stack_frame_class, 0, &error));
+ mono_error_assert_ok (&error);
}
return &mono_ex->object;
register_icall (mono_helper_stelem_ref_check, "mono_helper_stelem_ref_check", "void object object", FALSE);
register_icall (ves_icall_object_new, "ves_icall_object_new", "object ptr ptr", FALSE);
register_icall (ves_icall_object_new_specific, "ves_icall_object_new_specific", "object ptr", FALSE);
- register_icall (mono_array_new, "mono_array_new", "object ptr ptr int32", FALSE);
+ register_icall (ves_icall_array_new, "ves_icall_array_new", "object ptr ptr int32", FALSE);
register_icall (ves_icall_array_new_specific, "ves_icall_array_new_specific", "object ptr int32", FALSE);
register_icall (ves_icall_runtime_class_init, "ves_icall_runtime_class_init", "void ptr", FALSE);
register_icall (mono_ldftn, "mono_ldftn", "ptr ptr", FALSE);
projects / mono.git / commitdiff