#include <windows.h>
#include <shlobj.h>
#endif
-#include "decimal.h"
+#include "decimal-ms.h"
extern MonoString* ves_icall_System_Environment_GetOSVersionString (void) MONO_INTERNAL;
gchar *endptr = NULL;
*result = 0.0;
- MONO_ARCH_SAVE_REGS;
-
if (*ptr){
/* mono_strtod () is not thread-safe */
mono_mutex_lock (&mono_strtod_mutex);
gint32 esize;
gpointer *ea;
- MONO_ARCH_SAVE_REGS;
-
ao = (MonoArray *)this;
ac = (MonoClass *)ao->obj.vtable->klass;
MonoArray *ao, *io;
gint32 i, pos, *ind;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (idxs);
io = (MonoArray *)idxs;
gint64 i64 = 0;
gdouble r64 = 0;
- MONO_ARCH_SAVE_REGS;
-
if (value)
vc = value->vtable->klass;
else
MonoClass *ac, *ic;
gint32 i, pos, *ind;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (idxs);
ic = idxs->obj.vtable->klass;
uintptr_t *sizes, i;
gboolean bounded = FALSE;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (type);
MONO_CHECK_ARG_NULL (lengths);
uintptr_t *sizes, i;
gboolean bounded = FALSE;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (type);
MONO_CHECK_ARG_NULL (lengths);
ICALL_EXPORT gint32
ves_icall_System_Array_GetRank (MonoObject *this)
{
- MONO_ARCH_SAVE_REGS;
-
return this->vtable->klass->rank;
}
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
uintptr_t length;
- MONO_ARCH_SAVE_REGS;
-
if ((dimension < 0) || (dimension >= rank))
mono_raise_exception (mono_get_exception_index_out_of_range ());
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
- MONO_ARCH_SAVE_REGS;
-
if ((dimension < 0) || (dimension >= rank))
mono_raise_exception (mono_get_exception_index_out_of_range ());
{
gint32 rank = ((MonoObject *)this)->vtable->klass->rank;
- MONO_ARCH_SAVE_REGS;
-
if ((dimension < 0) || (dimension >= rank))
mono_raise_exception (mono_get_exception_index_out_of_range ());
gint32 esize;
gpointer *ea;
- MONO_ARCH_SAVE_REGS;
-
ao = (MonoArray *)this;
ac = (MonoClass *)ao->obj.vtable->klass;
gint32 esize;
gpointer *ea;
- MONO_ARCH_SAVE_REGS;
-
ao = (MonoArray *)this;
ac = (MonoClass *)ao->obj.vtable->klass;
ec = ac->element_class;
ICALL_EXPORT gint
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void)
{
- MONO_ARCH_SAVE_REGS;
-
return offsetof (MonoString, chars);
}
ICALL_EXPORT MonoObject *
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj)
{
- MONO_ARCH_SAVE_REGS;
-
if ((obj == NULL) || (! (obj->vtable->klass->valuetype)))
return obj;
else
ICALL_EXPORT MonoObject *
ves_icall_System_Object_MemberwiseClone (MonoObject *this)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_object_clone (this);
}
MonoClassField* field;
gpointer iter;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_object_class (this);
if (mono_class_num_fields (klass) == 0)
gpointer iter;
int count = 0;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (that);
if (this->vtable != that->vtable)
ICALL_EXPORT MonoReflectionType *
ves_icall_System_Object_GetType (MonoObject *obj)
{
- MONO_ARCH_SAVE_REGS;
-
#ifndef DISABLE_REMOTING
if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
ICALL_EXPORT void
mono_type_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
{
- MONO_ARCH_SAVE_REGS;
-
mtype->type = &obj->vtable->klass->byval_arg;
g_assert (mtype->type->type);
}
ICALL_EXPORT gint32
ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance)
{
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (obj);
return mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE);
MonoReflectionMethod *method,
MonoArray *opt_param_types)
{
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (method);
return mono_image_create_method_token (
ICALL_EXPORT void
ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
{
- MONO_ARCH_SAVE_REGS;
-
mono_image_create_pefile (mb, file);
}
ICALL_EXPORT void
ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
{
- MONO_ARCH_SAVE_REGS;
-
mono_image_build_metadata (mb);
}
ICALL_EXPORT void
ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token)
{
- MONO_ARCH_SAVE_REGS;
-
mono_image_register_token (mb->dynamic_image, token, obj);
}
char *temp_str = g_strdup (str);
gboolean type_resolve = FALSE;
- MONO_ARCH_SAVE_REGS;
-
/* mono_reflection_parse_type() mangles the string */
if (!mono_reflection_parse_type (temp_str, &info)) {
mono_reflection_free_type_info (&info);
{
MonoDomain *domain = mono_domain_get ();
- MONO_ARCH_SAVE_REGS;
-
return mono_type_get_object (domain, handle);
}
ICALL_EXPORT MonoBoolean
ves_icall_System_Type_EqualsInternal (MonoReflectionType *type, MonoReflectionType *c)
{
- MONO_ARCH_SAVE_REGS;
-
if (c && type->type && c->type)
return mono_metadata_type_equal (type->type, c->type);
else
{
int t = type->type->type;
- MONO_ARCH_SAVE_REGS;
-
if (type->type->byref)
return TYPECODE_OBJECT;
MonoClass *klass;
MonoClass *klassc;
- MONO_ARCH_SAVE_REGS;
-
g_assert (type != NULL);
domain = ((MonoObject *)type)->vtable->domain;
MonoClass *klass;
MonoClass *klassc;
- MONO_ARCH_SAVE_REGS;
-
g_assert (type != NULL);
domain = ((MonoObject *)type)->vtable->domain;
MonoError error;
MonoDomain *domain = mono_domain_get ();
MonoMethodSignature* sig;
- MONO_ARCH_SAVE_REGS;
sig = mono_method_signature_checked (method, &error);
if (!mono_error_ok (&error))
ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
{
MonoClass *parent;
- MONO_ARCH_SAVE_REGS;
parent = declaring? field->field->parent: field->klass;
MonoType *type;
gchar *v;
- MONO_ARCH_SAVE_REGS;
-
if (field->klass->image->assembly->ref_only)
mono_raise_exception (mono_get_exception_invalid_operation (
"It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods."));
MonoType *t;
MonoError error;
- MONO_ARCH_SAVE_REGS;
-
mono_class_init (field->parent);
t = mono_field_get_type_checked (field, &error);
{
MonoDomain *domain = mono_object_domain (property);
- MONO_ARCH_SAVE_REGS;
-
if ((req_info & PInfo_ReflectedType) != 0)
MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->klass->byval_arg));
if ((req_info & PInfo_DeclaringType) != 0)
{
MonoDomain *domain = mono_object_domain (event);
- MONO_ARCH_SAVE_REGS;
-
MONO_STRUCT_SETREF (info, reflected_type, mono_type_get_object (domain, &event->klass->byval_arg));
MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &event->event->parent->byval_arg));
int i = 0, len, ioffset;
MonoDomain *domain;
- MONO_ARCH_SAVE_REGS;
mono_class_init_or_throw (class);
mono_class_init_or_throw (iclass);
{
MonoClass *class;
- MONO_ARCH_SAVE_REGS;
-
if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY)
return mono_type_get_object (mono_object_domain (type), &type->type->data.klass->byval_arg);
ICALL_EXPORT MonoBoolean
ves_icall_type_ispointer (MonoReflectionType *type)
{
- MONO_ARCH_SAVE_REGS;
-
return type->type->type == MONO_TYPE_PTR;
}
ICALL_EXPORT MonoBoolean
ves_icall_type_isprimitive (MonoReflectionType *type)
{
- MONO_ARCH_SAVE_REGS;
-
return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U)));
}
ICALL_EXPORT MonoBoolean
ves_icall_type_isbyref (MonoReflectionType *type)
{
- MONO_ARCH_SAVE_REGS;
-
return type->type->byref;
}
MonoDomain *domain = mono_domain_get ();
MonoClass *class;
- MONO_ARCH_SAVE_REGS;
-
if (type->type->byref)
return NULL;
if (type->type->type == MONO_TYPE_VAR) {
MonoDomain *domain = mono_object_domain (type);
MonoVTable *array_vtable = mono_class_vtable_full (domain, mono_array_class_get_cached (mono_defaults.systemtype_class, 1), TRUE);
int i;
- MONO_ARCH_SAVE_REGS;
klass = mono_class_from_mono_type (type->type);
ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type)
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
if (!IS_MONOTYPE (type))
return FALSE;
ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
if (type->type->byref)
return NULL;
ves_icall_Type_get_IsGenericInstance (MonoReflectionType *type)
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
if (type->type->byref)
return FALSE;
ves_icall_Type_get_IsGenericType (MonoReflectionType *type)
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
if (!IS_MONOTYPE (type))
return FALSE;
ICALL_EXPORT gint32
ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
{
- MONO_ARCH_SAVE_REGS;
-
if (!IS_MONOTYPE (type))
return -1;
ICALL_EXPORT GenericParameterAttributes
ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
{
- MONO_ARCH_SAVE_REGS;
-
g_assert (IS_MONOTYPE (type));
g_assert (is_generic_parameter (type->type));
return mono_generic_param_info (type->type->data.generic_param)->flags;
MonoArray *res;
int i, count;
- MONO_ARCH_SAVE_REGS;
-
g_assert (IS_MONOTYPE (type));
domain = mono_object_domain (type);
ICALL_EXPORT MonoBoolean
ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType *type)
{
- MONO_ARCH_SAVE_REGS;
return is_generic_parameter (type->type);
}
ICALL_EXPORT MonoBoolean
ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb)
{
- MONO_ARCH_SAVE_REGS;
return is_generic_parameter (tb->type.type);
}
MonoMethod *method;
gpointer iter;
- MONO_ARCH_SAVE_REGS;
-
domain = ((MonoObject *)type)->vtable->domain;
klass = mono_class_from_mono_type (type->type);
MonoMethod *method;
MonoType *type = ref_type->type;
- MONO_ARCH_SAVE_REGS;
-
if (type->byref || (type->type != MONO_TYPE_MVAR && type->type != MONO_TYPE_VAR))
mono_raise_exception (mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments"));
if (type->type == MONO_TYPE_VAR)
MonoMethodInflated *imethod;
MonoMethod *result;
- MONO_ARCH_SAVE_REGS;
-
if (method->method->is_generic)
return method;
ICALL_EXPORT gboolean
ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_method_signature (method->method)->generic_param_count != 0;
}
ICALL_EXPORT gboolean
ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
{
- MONO_ARCH_SAVE_REGS;
-
return method->method->is_generic;
}
MonoArray *res;
MonoDomain *domain;
int count, i;
- MONO_ARCH_SAVE_REGS;
domain = mono_object_domain (method);
int pcount;
void *obj = this;
- MONO_ARCH_SAVE_REGS;
-
*exc = NULL;
if (mono_security_core_clr_enabled ())
MonoObject *result;
int i, j, outarg_count = 0;
- MONO_ARCH_SAVE_REGS;
-
if (m->klass == mono_defaults.object_class) {
-
if (!strcmp (m->name, "FieldGetter")) {
MonoClass *k = this->vtable->klass;
MonoString *name;
MonoType *etype;
guint64 val;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (enumType);
MONO_CHECK_ARG_NULL (value);
gpointer src;
int size;
- MONO_ARCH_SAVE_REGS;
-
if (!this)
return NULL;
MonoType *etype;
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (type->type);
mono_class_init_or_throw (klass);
gpointer iter;
MonoClassField *field;
- MONO_ARCH_SAVE_REGS;
-
mono_class_init_or_throw (enumc);
MONO_STRUCT_SETREF (info, utype, mono_type_get_object (domain, mono_class_enum_basetype (enumc)));
MonoClassField *field;
MonoPtrArray tmp_array;
- MONO_ARCH_SAVE_REGS;
-
domain = ((MonoObject *)type)->vtable->domain;
if (type->type->byref)
return mono_array_new (domain, mono_defaults.field_info_class, 0);
gpointer iter = NULL;
MonoPtrArray tmp_array;
- MONO_ARCH_SAVE_REGS;
-
mono_ptr_array_init (tmp_array, 4); /*FIXME, guestimating*/
domain = ((MonoObject *)type)->vtable->domain;
GHashTable *properties = NULL;
MonoPtrArray tmp_array;
- MONO_ARCH_SAVE_REGS;
-
mono_ptr_array_init (tmp_array, 8); /*This the average for ASP.NET types*/
if (!System_Reflection_PropertyInfo)
gchar *event_name;
int (*compare_func) (const char *s1, const char *s2);
- MONO_ARCH_SAVE_REGS;
-
event_name = mono_string_to_utf8 (name);
if (type->type->byref)
return NULL;
GHashTable *events = NULL;
MonoPtrArray tmp_array;
- MONO_ARCH_SAVE_REGS;
-
mono_ptr_array_init (tmp_array, 4);
if (!System_Reflection_EventInfo)
char *str;
gpointer iter;
- MONO_ARCH_SAVE_REGS;
-
if (name == NULL)
mono_raise_exception (mono_get_exception_argument_null ("name"));
gpointer iter;
MonoPtrArray tmp_array;
- MONO_ARCH_SAVE_REGS;
-
domain = ((MonoObject *)type)->vtable->domain;
if (type->type->byref)
return mono_array_new (domain, mono_defaults.monotype_class, 0);
MonoTypeNameParse info;
gboolean type_resolve;
- MONO_ARCH_SAVE_REGS;
-
/* On MS.NET, this does not fire a TypeResolve event */
type_resolve = TRUE;
str = mono_string_to_utf8 (name);
gchar *absolute;
gchar *dirname;
- MONO_ARCH_SAVE_REGS;
-
if (g_path_is_absolute (mass->image->name)) {
absolute = g_strdup (mass->image->name);
dirname = g_path_get_dirname (absolute);
{
MonoAssembly *mass = assembly->assembly;
- MONO_ARCH_SAVE_REGS;
-
return mass->in_gac;
}
MonoAssembly *res;
MonoImageOpenStatus status;
- MONO_ARCH_SAVE_REGS;
-
name = mono_string_to_utf8 (mname);
res = mono_assembly_load_with_partial_name (name, &status);
MonoDomain *domain = mono_object_domain (assembly);
MonoString *res;
- MONO_ARCH_SAVE_REGS;
-
res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image));
return res;
ICALL_EXPORT MonoBoolean
ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly *assembly)
{
- MONO_ARCH_SAVE_REGS;
-
return assembly->assembly->ref_only;
}
{
MonoDomain *domain = mono_object_domain (assembly);
- MONO_ARCH_SAVE_REGS;
-
return mono_string_new (domain, assembly->assembly->image->version);
}
MonoMethod *method;
guint32 token = mono_image_get_entry_point (assembly->assembly->image);
- MONO_ARCH_SAVE_REGS;
-
if (!token)
return NULL;
method = mono_get_method_checked (assembly->assembly->image, token, NULL, NULL, &error);
int i;
const char *val;
- MONO_ARCH_SAVE_REGS;
-
for (i = 0; i < table->rows; ++i) {
val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME));
mono_array_setref (result, i, mono_string_new (mono_object_domain (assembly), val));
MonoImage *image = assembly->assembly->image;
MonoTableInfo *t;
- MONO_ARCH_SAVE_REGS;
-
if (!System_Reflection_AssemblyName)
System_Reflection_AssemblyName = mono_class_from_name (
mono_defaults.corlib, "System.Reflection", "AssemblyName");
const char *val;
MonoImage *module;
- MONO_ARCH_SAVE_REGS;
-
for (i = 0; i < table->rows; ++i) {
mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
const char *val;
char *n;
- MONO_ARCH_SAVE_REGS;
-
n = mono_string_to_utf8 (name);
for (i = 0; i < table->rows; ++i) {
mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
const char *val;
char *n;
- MONO_ARCH_SAVE_REGS;
-
/* check hash if needed */
if (name) {
n = mono_string_to_utf8 (name);
{
MonoMethod *dest = NULL;
- MONO_ARCH_SAVE_REGS;
-
mono_stack_walk_no_il (get_executing, &dest);
g_assert (dest);
return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly);
{
MonoDomain* domain = mono_domain_get ();
- MONO_ARCH_SAVE_REGS;
-
if (!domain->entry_assembly)
return NULL;
MonoMethod *m;
MonoMethod *dest;
- MONO_ARCH_SAVE_REGS;
-
dest = NULL;
mono_stack_walk_no_il (get_executing, &dest);
m = dest;
gchar *codebase;
MonoBoolean assembly_ref = 0;
- MONO_ARCH_SAVE_REGS;
-
MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name));
aname->major = name->major;
aname->minor = name->minor;
gchar *absolute;
MonoAssembly *mass = assembly->assembly;
- MONO_ARCH_SAVE_REGS;
-
if (g_path_is_absolute (mass->image->name)) {
fill_reflection_assembly_name (mono_object_domain (assembly),
aname, &mass->aname, mass->image->name, TRUE,
gboolean res;
MonoImage *image;
MonoAssemblyName name;
- char *dirname
-
- MONO_ARCH_SAVE_REGS;
+ char *dirname;
filename = mono_string_to_utf8 (fname);
GList *list = NULL;
int i, len, ex_count;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_object_domain (assembly);
g_assert (!assembly_is_dynamic (assembly->assembly));
MonoDomain *domain = mono_object_domain (module);
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
g_assert (module->image);
if (image_is_dynamic (module->image) && ((MonoDynamicImage*)(module->image))->initial_image)
{
MonoDomain *domain = mono_object_domain (module);
- MONO_ARCH_SAVE_REGS;
-
g_assert (module->image);
return mono_string_new (domain, module->image->guid);
}
MonoArray *exceptions;
int i;
- MONO_ARCH_SAVE_REGS;
-
if (!module->image)
return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0);
else {
char *str = mono_string_to_utf8 (smodifiers);
char *p;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (tb->type.type);
p = str;
/* logic taken from mono_reflection_parse_type(): keep in sync */
MonoType *type;
MonoBoolean res;
- MONO_ARCH_SAVE_REGS;
-
type = t->type;
res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY);
{
MonoClass *klass, *aklass;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (type->type);
check_for_invalid_type (klass);
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (type->type);
mono_class_init_or_throw (klass);
check_for_invalid_type (klass);
gpointer func;
MonoMethod *method = info->method;
- MONO_ARCH_SAVE_REGS;
-
mono_class_init_or_throw (delegate_class);
mono_assert (delegate_class->parent == mono_defaults.multicastdelegate_class);
gmtoff_st = gmtoff_ds = transitioned = 0;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (data);
MONO_CHECK_ARG_NULL (names);
ICALL_EXPORT gint32
ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_array_get_byte_length (array);
}
ICALL_EXPORT gint8
ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_array_get (array, gint8, idx);
}
ICALL_EXPORT void
ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value)
{
- MONO_ARCH_SAVE_REGS;
-
mono_array_set (array, gint8, idx, value);
}
{
guint8 *src_buf, *dest_buf;
- MONO_ARCH_SAVE_REGS;
-
/* This is called directly from the class libraries without going through the managed wrapper */
MONO_CHECK_ARG_NULL (src);
MONO_CHECK_ARG_NULL (dest);
MonoType *type;
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
res = mono_object_new (domain, mono_defaults.transparent_proxy_class);
tp = (MonoTransparentProxy*) res;
MonoString*
ves_icall_System_Environment_get_UserName (void)
{
- MONO_ARCH_SAVE_REGS;
-
/* using glib is more portable */
return mono_string_new (mono_domain_get (), g_get_user_name ());
}
ICALL_EXPORT MonoString *
ves_icall_System_Environment_get_NewLine (void)
{
- MONO_ARCH_SAVE_REGS;
-
#if defined (HOST_WIN32)
return mono_string_new (mono_domain_get (), "\r\n");
#else
const gchar *value;
gchar *utf8_name;
- MONO_ARCH_SAVE_REGS;
-
if (name == NULL)
return NULL;
gchar **e, **parts;
int n;
- MONO_ARCH_SAVE_REGS;
-
n = 0;
for (e = environ; *e != 0; ++ e)
++ n;
MonoError error;
#endif
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
utf16_name = mono_string_to_utf16 (name);
if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
ICALL_EXPORT void
ves_icall_System_Environment_Exit (int result)
{
- MONO_ARCH_SAVE_REGS;
-
mono_environment_exitcode_set (result);
/* FIXME: There are some cleanup hangs that should be worked out, but
MonoDomain *domain = mono_domain_get ();
gint len;
- MONO_ARCH_SAVE_REGS;
-
- buf [0] = '\0';
+ buf [0] = '\0';
ptr = buf;
while (size > initial_size) {
ICALL_EXPORT MonoString *
ves_icall_System_Environment_InternalGetHome (void)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_string_new (mono_domain_get (), g_get_home_dir ());
}
* returns the code page as a string
*/
ICALL_EXPORT MonoString*
-ves_icall_System_Text_Encoding_InternalCodePage (gint32 *int_code_page)
+ves_icall_System_Text_EncodingHelper_InternalCodePage (gint32 *int_code_page)
{
const char *cset;
const char *p;
int i;
*int_code_page = -1;
- MONO_ARCH_SAVE_REGS;
g_get_charset (&cset);
c = codepage = strdup (cset);
MonoReflectionMethod *method,
MonoArray *out_args)
{
- MONO_ARCH_SAVE_REGS;
-
mono_message_init (mono_object_domain (this), this, method, out_args);
}
ICALL_EXPORT MonoBoolean
ves_icall_IsTransparentProxy (MonoObject *proxy)
{
- MONO_ARCH_SAVE_REGS;
-
if (!proxy)
return 0;
MonoClass *klass;
MonoVTable* vtable;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (type->type);
vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE);
MonoClass *klass;
MonoDomain *domain;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_object_domain (type);
klass = mono_class_from_mono_type (type->type);
mono_class_init_or_throw (klass);
ICALL_EXPORT MonoString *
ves_icall_System_IO_get_temp_path (void)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_string_new (mono_domain_get (), g_get_tmp_dir ());
}
ULARGE_INTEGER wapi_total_number_of_bytes;
ULARGE_INTEGER wapi_total_number_of_free_bytes;
- MONO_ARCH_SAVE_REGS;
-
*error = ERROR_SUCCESS;
result = GetDiskFreeSpaceEx (mono_string_chars (path_name), &wapi_free_bytes_avail, &wapi_total_number_of_bytes,
&wapi_total_number_of_free_bytes);
ICALL_EXPORT guint32
ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name)
{
- MONO_ARCH_SAVE_REGS;
-
return GetDriveType (mono_string_chars (root_path_name));
}
#endif
ICALL_EXPORT gpointer
ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod *method)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_compile_method (method);
}
MonoString *mcpath;
gchar *path;
- MONO_ARCH_SAVE_REGS;
-
path = g_build_path (G_DIR_SEPARATOR_S, mono_get_config_dir (), "mono", mono_get_runtime_info ()->framework_version, "machine.config", NULL);
#if defined (HOST_WIN32)
gsize len;
gchar *module;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_domain_get ();
file = domain->setup->configuration_file;
if (!file)
{
const gchar *machine_config;
- MONO_ARCH_SAVE_REGS;
-
machine_config = mono_get_machine_config ();
if (!machine_config)
MonoString *ipath;
gchar *path;
- MONO_ARCH_SAVE_REGS;
-
path = g_path_get_dirname (mono_get_config_dir ());
#if defined (HOST_WIN32)
MonoPEResourceDataEntry *entry;
MonoImage *image;
- MONO_ARCH_SAVE_REGS;
-
if (!assembly || !result || !size)
return FALSE;
MonoClass *klass;
MonoDomain *domain;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_object_domain (type);
klass = mono_class_from_mono_type (type->type);
mono_class_init_or_throw (klass);
MonoMethod *result = NULL;
int slot;
- MONO_ARCH_SAVE_REGS;
-
if (method->klass == NULL)
return m;
ICALL_EXPORT void
mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start)
{
- MONO_ARCH_SAVE_REGS;
-
iter->sig = *(MonoMethodSignature**)argsp;
g_assert (iter->sig->sentinelpos <= iter->sig->param_count);
guint32 i, arg_size;
gint32 align;
MonoTypedRef res;
- MONO_ARCH_SAVE_REGS;
i = iter->sig->sentinelpos + iter->next_arg;
guint32 i, arg_size;
gint32 align;
MonoTypedRef res;
- MONO_ARCH_SAVE_REGS;
i = iter->sig->sentinelpos + iter->next_arg;
mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter)
{
gint i;
- MONO_ARCH_SAVE_REGS;
i = iter->sig->sentinelpos + iter->next_arg;
ICALL_EXPORT MonoObject*
mono_TypedReference_ToObject (MonoTypedRef tref)
{
- MONO_ARCH_SAVE_REGS;
-
if (MONO_TYPE_IS_REFERENCE (tref.type)) {
MonoObject** objp = tref.value;
return *objp;
ICALL_EXPORT MonoObject*
mono_TypedReference_ToObjectInternal (MonoType *type, gpointer value, MonoClass *klass)
{
- MONO_ARCH_SAVE_REGS;
-
if (MONO_TYPE_IS_REFERENCE (type)) {
MonoObject** objp = value;
return *objp;
ICALL_EXPORT void
ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method)
{
- MONO_ARCH_SAVE_REGS;
prelink_method (method->method);
}
MonoClass *klass = mono_class_from_mono_type (type->type);
MonoMethod* m;
gpointer iter = NULL;
- MONO_ARCH_SAVE_REGS;
mono_class_init_or_throw (klass);
*decHexDigits = Formatter_DecHexDigits;
}
+/* These parameters are "readonly" in corlib/System/Globalization/TextInfo.cs */
ICALL_EXPORT void
-get_category_data (int version,
- guint8 const **category_data,
- guint16 const **category_astral_index)
-{
- *category_astral_index = NULL;
-
-#ifndef DISABLE_NET_4_0
- if (version == 4) {
- *category_data = CategoryData_v4;
-#ifndef DISABLE_ASTRAL
- *category_astral_index = CategoryData_v4_astral_index;
-#endif
- return;
- }
-#endif
-
- *category_data = CategoryData_v2;
-#ifndef DISABLE_ASTRAL
- *category_astral_index = CategoryData_v2_astral_index;
-#endif
-}
-
-/* These parameters are "readonly" in corlib/System/Globalization/CharUnicodeInfo.cs */
-ICALL_EXPORT void
-ves_icall_System_Globalization_CharUnicodeInfo_GetDataTablePointers (int category_data_version,
- guint8 const **category_data,
- guint16 const **category_astral_index,
- guint8 const **numeric_data,
- gdouble const **numeric_data_values,
+ves_icall_System_Globalization_TextInfo_GetDataTablePointersLite (
guint16 const **to_lower_data_low,
guint16 const **to_lower_data_high,
guint16 const **to_upper_data_low,
guint16 const **to_upper_data_high)
{
- get_category_data (category_data_version, category_data, category_astral_index);
- *numeric_data = NumericData;
- *numeric_data_values = NumericDataValues;
*to_lower_data_low = ToLowerDataLow;
*to_lower_data_high = ToLowerDataHigh;
*to_upper_data_low = ToUpperDataLow;
projects / mono.git / blobdiff