MonoDomain *data;
char *shadow_location;
- MONO_ARCH_SAVE_REGS;
-
adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
/* FIXME: pin all those objects */
MonoObject *o;
char *str;
- MONO_ARCH_SAVE_REGS;
-
g_assert (ad != NULL);
add = ad->data;
g_assert (add != NULL);
{
MonoDomain *add;
- MONO_ARCH_SAVE_REGS;
-
g_assert (ad != NULL);
add = ad->data;
g_assert (add != NULL);
MonoAppDomainSetup *
ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
{
- MONO_ARCH_SAVE_REGS;
-
g_assert (ad != NULL);
g_assert (ad->data != NULL);
MonoString *
ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
{
- MONO_ARCH_SAVE_REGS;
-
g_assert (ad != NULL);
g_assert (ad->data != NULL);
{
MonoDomain *add = mono_domain_get ();
- MONO_ARCH_SAVE_REGS;
-
return add->domain;
}
{
MonoDomain *root = mono_get_root_domain ();
- MONO_ARCH_SAVE_REGS;
-
return root->domain;
}
int i;
GPtrArray *assemblies;
- MONO_ARCH_SAVE_REGS;
-
if (!System_Reflection_Assembly)
System_Reflection_Assembly = mono_class_from_name (
mono_defaults.corlib, "System.Reflection", "Assembly");
MonoImageOpenStatus status = MONO_IMAGE_OK;
MonoAssembly *ass;
- MONO_ARCH_SAVE_REGS;
-
if (fname == NULL) {
MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
mono_raise_exception (exc);
gchar *name;
gboolean parsed;
- MONO_ARCH_SAVE_REGS;
-
g_assert (assRef != NULL);
name = mono_string_to_utf8 (assRef);
{
MonoDomain * domain = mono_domain_get_by_id (domain_id);
- MONO_ARCH_SAVE_REGS;
-
if (NULL == domain) {
MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
mono_raise_exception (exc);
MonoImage *image;
MonoMethod *method;
- MONO_ARCH_SAVE_REGS;
-
g_assert (refass);
image = refass->assembly->image;
g_assert (image);
gint32
ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad)
{
- MONO_ARCH_SAVE_REGS;
-
return ad->data->domain_id;
}
{
MonoDomain *old_domain = mono_domain_get();
- MONO_ARCH_SAVE_REGS;
-
if (!mono_domain_set (ad->data, FALSE))
mono_raise_exception (mono_get_exception_appdomain_unloaded ());
MonoDomain *current_domain = mono_domain_get ();
MonoDomain *domain = mono_domain_get_by_id (domainid);
- MONO_ARCH_SAVE_REGS;
-
if (!domain || !mono_domain_set (domain, FALSE))
mono_raise_exception (mono_get_exception_appdomain_unloaded ());
void
ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad)
{
- MONO_ARCH_SAVE_REGS;
-
mono_thread_push_appdomain_ref (ad->data);
}
{
MonoDomain *domain = mono_domain_get_by_id (domain_id);
- MONO_ARCH_SAVE_REGS;
-
if (!domain)
/*
* Raise an exception to prevent the managed code from executing a pop
void
ves_icall_System_AppDomain_InternalPopDomainRef (void)
{
- MONO_ARCH_SAVE_REGS;
-
mono_thread_pop_appdomain_ref ();
}
MonoAppContext *
ves_icall_System_AppDomain_InternalGetContext ()
{
- MONO_ARCH_SAVE_REGS;
-
return mono_context_get ();
}
MonoAppContext *
ves_icall_System_AppDomain_InternalGetDefaultContext ()
{
- MONO_ARCH_SAVE_REGS;
-
return mono_domain_get ()->default_context;
}
{
MonoAppContext *old_context = mono_context_get ();
- MONO_ARCH_SAVE_REGS;
-
mono_context_set (mc);
return old_context;
MonoDomain *domain = mono_domain_get ();
MonoClass *klass = mono_class_from_mono_type (handle);
- MONO_ARCH_SAVE_REGS;
-
mono_class_init (klass);
return mono_type_get_object (domain, handle);
}
guint32
ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m)
{
- MONO_ARCH_SAVE_REGS;
-
#ifndef DISABLE_COM
return cominterop_get_com_slot_for_method (m->method);
#else
MonoDomain *domain;
MonoObject *obj;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_object_domain (type);
klass = mono_class_from_mono_type (type->type);
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_string_from_bstr(ptr);
}
gpointer
ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (MonoString* ptr)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_string_to_bstr(ptr);
}
void
ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (gpointer ptr)
{
- MONO_ARCH_SAVE_REGS;
-
mono_free_bstr (ptr);
}
MonoBoolean
ves_icall_System_ConsoleDriver_Isatty (HANDLE handle)
{
- MONO_ARCH_SAVE_REGS;
-
return (GetFileType (handle) == FILE_TYPE_CHAR);
}
MonoBoolean
ves_icall_System_ConsoleDriver_Isatty (HANDLE handle)
{
- MONO_ARCH_SAVE_REGS;
-
return isatty (GPOINTER_TO_INT (handle));
}
gboolean callset = FALSE;
gboolean check;
- MONO_ARCH_SAVE_REGS;
-
if (tcgetattr (STDIN_FILENO, &attr) == -1)
return FALSE;
div_t divvy;
int ret, nbytes;
- MONO_ARCH_SAVE_REGS;
-
do {
FD_ZERO (&rfds);
FD_SET (STDIN_FILENO, &rfds);
{
int unused;
- MONO_ARCH_SAVE_REGS;
-
if (!setup_finished)
return;
MONO_SIG_HANDLER_FUNC (static, sigint_handler)
{
int save_errno;
- MONO_ARCH_SAVE_REGS;
if (in_sigint)
return;
{
int dims;
- MONO_ARCH_SAVE_REGS;
-
dims = terminal_get_dimensions ();
if (dims == -1){
int cols = 0, rows = 0;
{
DWORD mode;
- MONO_ARCH_SAVE_REGS;
-
return GetConsoleMode (handle, &mode) != 0;
}
MonoDecimalCompareResult
mono_decimal_compare (MonoDecimal *left, MonoDecimal *right)
{
- MONO_ARCH_SAVE_REGS;
-
uint32_t left_sign;
uint32_t right_sign;
void
mono_decimal_init_single (MonoDecimal *_this, float value)
{
- MONO_ARCH_SAVE_REGS;
if (VarDecFromR4 (value, _this) == MONO_DECIMAL_OVERFLOW)
mono_raise_exception (mono_get_exception_overflow ());
_this->reserved = 0;
void
mono_decimal_init_double (MonoDecimal *_this, double value)
{
- MONO_ARCH_SAVE_REGS;
if (VarDecFromR8 (value, _this) == MONO_DECIMAL_OVERFLOW)
mono_raise_exception (mono_get_exception_overflow ());
_this->reserved = 0;
{
MonoDecimal decRes;
- MONO_ARCH_SAVE_REGS;
-
VarDecInt(d, &decRes);
// copy decRes into d
{
double dbl;
- MONO_ARCH_SAVE_REGS;
if (VarR8FromDec(d, &dbl) != MONO_DECIMAL_OK)
return 0;
{
MonoDecimal decRes;
- MONO_ARCH_SAVE_REGS;
-
MonoDecimalStatus status = VarDecMul(d1, d2, &decRes);
if (status != MONO_DECIMAL_OK)
mono_raise_exception (mono_get_exception_overflow ());
void
mono_decimal_round (MonoDecimal *d, int32_t decimals)
{
- MONO_ARCH_SAVE_REGS;
-
MonoDecimal decRes;
// GC is only triggered for throwing, no need to protect result
double
mono_decimal_to_double (MonoDecimal d)
{
- MONO_ARCH_SAVE_REGS;
-
double result = 0.0;
// Note: this can fail if the input is an invalid decimal, but for compatibility we should return 0
VarR8FromDec(&d, &result);
int32_t
mono_decimal_to_int32 (MonoDecimal d)
{
- MONO_ARCH_SAVE_REGS;
-
MonoDecimal result;
// The following can not return an error, it only returns INVALID_ARG if the decimals is < 0
float
mono_decimal_to_float (MonoDecimal d)
{
- MONO_ARCH_SAVE_REGS;
-
float result = 0.0f;
// Note: this can fail if the input is an invalid decimal, but for compatibility we should return 0
VarR4FromDec(&d, &result);
void
mono_decimal_truncate (MonoDecimal *d)
{
- MONO_ARCH_SAVE_REGS;
-
MonoDecimal decRes;
VarDecFix(d, &decRes);
int scale, hi_prod, cur;
SPLIT64 sdlTmp;
- MONO_ARCH_SAVE_REGS;
g_assert(sign == 0 || sign == DECIMAL_NEG);
leftOriginal = left;
int scale, cur_scale;
gboolean unscale;
- MONO_ARCH_SAVE_REGS;
-
scale = DECIMAL_SCALE(*left) - DECIMAL_SCALE(*right);
unscale = FALSE;
divisor[0] = DECIMAL_LO32(*right);
int
mono_decimal_from_number (void *from, MonoDecimal *target)
{
- MONO_ARCH_SAVE_REGS;
CLRNumber *number = (CLRNumber *) from;
g_assert(number != NULL);
g_assert(target != NULL);
#ifdef HOST_WIN32
OSVERSIONINFOEX verinfo;
- MONO_ARCH_SAVE_REGS;
-
verinfo.dwOSVersionInfoSize = sizeof (OSVERSIONINFOEX);
if (GetVersionEx ((OSVERSIONINFO*)&verinfo)) {
char version [128];
#elif defined(HAVE_SYS_UTSNAME_H)
struct utsname name;
- MONO_ARCH_SAVE_REGS;
-
if (uname (&name) >= 0) {
return mono_string_new (mono_domain_get (), name.release);
}
#ifndef _MONO_METADATA_EXCEPTION_H_
#define _MONO_METADATA_EXCEPTION_H_
-/* here for compat: should not be used anymore */
-#define MONO_ARCH_SAVE_REGS
-
#include <mono/metadata/object.h>
#include <mono/metadata/image.h>
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=CreateDirectory (mono_string_chars (path), NULL);
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=RemoveDirectory (mono_string_chars (path));
gchar *utf8_path, *utf8_result, *full_name;
gint32 attributes;
- MONO_ARCH_SAVE_REGS;
-
result = NULL;
*error = ERROR_SUCCESS;
gunichar2 *buf;
int len, res_len;
- MONO_ARCH_SAVE_REGS;
-
len = MAX_PATH + 1; /*FIXME this is too smal under most unix systems.*/
buf = g_new (gunichar2, len);
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=SetCurrentDirectory (mono_string_chars (path));
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=MoveFile (mono_string_chars (path), mono_string_chars (dest));
gunichar2 *utf16_sourceFileName = NULL, *utf16_destinationFileName = NULL, *utf16_destinationBackupFileName = NULL;
guint32 replaceFlags = REPLACEFILE_WRITE_THROUGH;
- MONO_ARCH_SAVE_REGS;
-
if (sourceFileName)
utf16_sourceFileName = mono_string_chars (sourceFileName);
if (destinationFileName)
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=CopyFile (mono_string_chars (path), mono_string_chars (dest), !overwrite);
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=DeleteFile (mono_string_chars (path));
{
gint32 ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=get_file_attributes (mono_string_chars (path));
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=SetFileAttributes (mono_string_chars (path),
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=GetFileType (handle);
gboolean result;
WIN32_FILE_ATTRIBUTE_DATA data;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
result = get_file_attributes_ex (mono_string_chars (path), &data);
int attributes, attrs;
gunichar2 *chars = mono_string_chars (filename);
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
if (options != 0){
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=CloseHandle (handle);
gboolean result;
guint32 n;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
MONO_CHECK_ARG_NULL (dest);
gboolean result;
guint32 n;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
MONO_CHECK_ARG_NULL (src);
{
gint32 offset_hi;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
offset_hi = offset >> 32;
{
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
ret=FlushFileBuffers (handle);
gint64 length;
guint32 length_hi;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
length = GetFileSize (handle, &length_hi);
gint32 length_hi;
gboolean result;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
/* save file pointer */
const FILETIME *last_access_filetime;
const FILETIME *last_write_filetime;
- MONO_ARCH_SAVE_REGS;
-
*error=ERROR_SUCCESS;
if (creation_time < 0)
HANDLE
ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
{
- MONO_ARCH_SAVE_REGS;
-
return GetStdHandle (STD_OUTPUT_HANDLE);
}
HANDLE
ves_icall_System_IO_MonoIO_get_ConsoleInput ()
{
- MONO_ARCH_SAVE_REGS;
-
return GetStdHandle (STD_INPUT_HANDLE);
}
HANDLE
ves_icall_System_IO_MonoIO_get_ConsoleError ()
{
- MONO_ARCH_SAVE_REGS;
-
return GetStdHandle (STD_ERROR_HANDLE);
}
SECURITY_ATTRIBUTES attr;
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
attr.nLength=sizeof(SECURITY_ATTRIBUTES);
attr.bInheritHandle=TRUE;
attr.lpSecurityDescriptor=NULL;
/* This is only used on Windows */
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
ret=DuplicateHandle (source_process_handle, source_handle, target_process_handle, target_handle, access, inherit, options);
if(ret==FALSE) {
/* FIXME: throw an exception? */
MonoDomain *domain;
int i, n;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_domain_get ();
n = sizeof (invalid_path_chars) / sizeof (gunichar2);
chars = mono_array_new (domain, mono_defaults.char_class, n);
void *iter;
char *err;
- MONO_ARCH_SAVE_REGS;
-
inotify_instance = ves_icall_System_IO_InotifyWatcher_GetInotifyInstance ();
if (inotify_instance != -1) {
close (inotify_instance);
{
FAMEvent ev;
- MONO_ARCH_SAVE_REGS;
-
if (FAMNextEvent (conn, &ev) == 1) {
*filename = mono_string_new (mono_domain_get (), ev.filename);
*code = ev.code;
char *str, *path;
int retval;
- MONO_ARCH_SAVE_REGS;
-
if (name == NULL)
return -1;
gint64
ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection)
{
- MONO_ARCH_SAVE_REGS;
-
if (forceCollection)
mono_gc_collect (mono_gc_max_generation ());
return mono_gc_get_used_size ();
void
ves_icall_System_GC_KeepAlive (MonoObject *obj)
{
- MONO_ARCH_SAVE_REGS;
-
/*
* Does nothing.
*/
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 ());
}
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);
const CultureInfoEntry *ci;
char *n;
- MONO_ARCH_SAVE_REGS;
-
n = mono_string_to_utf8 (name);
ne = mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
sizeof (CultureInfoNameEntry), culture_name_locator);
MonoDomain *domain;
const DateTimeFormatEntry *dfe;
- MONO_ARCH_SAVE_REGS;
-
g_assert (datetime_index >= 0);
dfe = &datetime_format_entries [datetime_index];
MonoNumberFormatInfo *number;
const NumberFormatEntry *nfe;
- MONO_ARCH_SAVE_REGS;
-
g_assert (this->number_format != 0);
if (this->number_index < 0)
return;
const RegionInfoEntry *entry;
const CultureInfoEntry *ne;
- MONO_ARCH_SAVE_REGS;
-
ne = mono_binary_search (&lcid, culture_entries, NUM_CULTURE_ENTRIES, sizeof (CultureInfoEntry), culture_lcid_locator);
if (ne == NULL)
MonoString* ret;
MonoDomain *domain;
- MONO_ARCH_SAVE_REGS;
-
locale = get_current_locale_name ();
if (locale == NULL)
return NULL;
{
const CultureInfoEntry *ci;
- MONO_ARCH_SAVE_REGS;
-
ci = culture_info_entry_from_lcid (lcid);
if(ci == NULL)
return FALSE;
const CultureInfoNameEntry *ne;
char *n;
- MONO_ARCH_SAVE_REGS;
-
n = mono_string_to_utf8 (name);
ne = mono_binary_search (n, culture_name_entries, NUM_CULTURE_ENTRIES,
sizeof (CultureInfoNameEntry), culture_name_locator);
gchar *locale;
gboolean ret;
- MONO_ARCH_SAVE_REGS;
-
locale = mono_string_to_utf8 (name);
ret = construct_culture_from_specific_name (ci, locale);
g_free (locale);
{
const RegionInfoEntry *ri;
- MONO_ARCH_SAVE_REGS;
-
ri = region_info_entry_from_lcid (lcid);
if(ri == NULL)
return FALSE;
const RegionInfoNameEntry *ne;
char *n;
- MONO_ARCH_SAVE_REGS;
-
n = mono_string_to_utf8 (name);
ne = mono_binary_search (n, region_name_entries, NUM_REGION_ENTRIES,
sizeof (RegionInfoNameEntry), region_name_locator);
gint i, len;
gboolean is_neutral;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_domain_get ();
len = 0;
int ves_icall_System_Globalization_CompareInfo_internal_compare (MonoCompareInfo *this, MonoString *str1, gint32 off1, gint32 len1, MonoString *str2, gint32 off2, gint32 len2, gint32 options)
{
- MONO_ARCH_SAVE_REGS;
-
/* Do a normal ascii string compare, as we only know the
* invariant locale if we dont have ICU
*/
MonoArray *arr;
gint32 keylen, i;
- MONO_ARCH_SAVE_REGS;
-
keylen=mono_string_length (source);
arr=mono_array_new (mono_domain_get (), mono_get_byte_class (),
int ves_icall_System_Globalization_CompareInfo_internal_index (MonoCompareInfo *this, MonoString *source, gint32 sindex, gint32 count, MonoString *value, gint32 options, MonoBoolean first)
{
- MONO_ARCH_SAVE_REGS;
-
return(string_invariant_indexof (source, sindex, count, value, first));
}
int ves_icall_System_Globalization_CompareInfo_internal_index_char (MonoCompareInfo *this, MonoString *source, gint32 sindex, gint32 count, gunichar2 value, gint32 options, MonoBoolean first)
{
- MONO_ARCH_SAVE_REGS;
-
return(string_invariant_indexof_char (source, sindex, count, value,
first));
}
int ves_icall_System_Threading_Thread_current_lcid (void)
{
- MONO_ARCH_SAVE_REGS;
-
/* Invariant */
return(0x007F);
}
MonoString *ves_icall_System_String_InternalReplace_Str_Comp (MonoString *this, MonoString *old, MonoString *new, MonoCompareInfo *comp)
{
- MONO_ARCH_SAVE_REGS;
-
/* Do a normal ascii string compare and replace, as we only
* know the invariant locale if we dont have ICU
*/
int element_size;
void *source_addr;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (src);
MONO_CHECK_ARG_NULL (dest);
int element_size;
void *dest_addr;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (src);
MONO_CHECK_ARG_NULL (dest);
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr)
{
- MONO_ARCH_SAVE_REGS;
-
if (ptr == NULL)
return NULL;
else
MonoString *
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len)
{
- MONO_ARCH_SAVE_REGS;
-
if (ptr == NULL) {
mono_raise_exception (mono_get_exception_argument_null ("ptr"));
g_assert_not_reached ();
int len = 0;
guint16 *t = ptr;
- MONO_ARCH_SAVE_REGS;
-
if (ptr == NULL)
return NULL;
{
MonoDomain *domain = mono_domain_get ();
- MONO_ARCH_SAVE_REGS;
-
if (ptr == NULL) {
mono_raise_exception (mono_get_exception_argument_null ("ptr"));
g_assert_not_reached ();
guint32
ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void)
{
- MONO_ARCH_SAVE_REGS;
-
return (GPOINTER_TO_INT (mono_native_tls_get_value (last_error_tls_id)));
}
MonoType *type;
guint32 layout;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (rtype);
type = rtype->type;
MonoMethod *method;
gpointer pa [3];
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (obj);
MONO_CHECK_ARG_NULL (dst);
{
MonoType *t;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (src);
MONO_CHECK_ARG_NULL (dst);
MonoDomain *domain = mono_domain_get ();
MonoObject *res;
- MONO_ARCH_SAVE_REGS;
-
if (src == NULL)
return NULL;
MONO_CHECK_ARG_NULL (type);
char *fname;
int match_index = -1;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (type);
MONO_CHECK_ARG_NULL (field_name);
gpointer
ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string)
{
- MONO_ARCH_SAVE_REGS;
-
if (string == NULL)
return NULL;
else {
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
MONO_CHECK_ARG_NULL (src);
MONO_CHECK_ARG_NULL (type);
{
gpointer res;
- MONO_ARCH_SAVE_REGS;
-
if ((gulong)size == 0)
/* This returns a valid pointer for size 0 on MS.NET */
size = 4;
void
ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr)
{
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
GlobalFree (ptr);
#else
void*
ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size)
{
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
return CoTaskMemAlloc (size);
#else
void
ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr)
{
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
CoTaskMemFree (ptr);
#else
gpointer
ves_icall_System_Runtime_InteropServices_Marshal_ReAllocCoTaskMem (gpointer ptr, int size)
{
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
return CoTaskMemRealloc (ptr, size);
#else
{
gpointer token = NULL;
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
/* Note: This isn't a copy of the Token - we must not close it!!!
* http://www.develop.com/kbrown/book/html/whatis_windowsprincipal.html
gint32 size = 0;
#ifdef HOST_WIN32
- MONO_ARCH_SAVE_REGS;
-
GetTokenInformation (token, TokenUser, NULL, size, (PDWORD)&size);
if (size > 0) {
TOKEN_USER *tu = g_malloc0 (size);
#else
gchar *uname = GetTokenName ((uid_t) GPOINTER_TO_INT (token));
- MONO_ARCH_SAVE_REGS;
-
if (uname) {
size = strlen (uname);
uniname = g_utf8_to_utf16 (uname, size, NULL, NULL, NULL);
#ifdef HOST_WIN32
gpointer token = NULL;
- MONO_ARCH_SAVE_REGS;
-
/* TODO: MS has something like this working in Windows 2003 (client and
* server) but works only for domain accounts (so it's quite limiting).
* http://www.develop.com/kbrown/book/html/howto_logonuser.html
gchar *utf8_name;
gboolean result;
- MONO_ARCH_SAVE_REGS;
-
utf8_name = mono_unicode_to_external (mono_string_chars (username));
#ifdef HAVE_GETPWNAM_R
#ifdef HOST_WIN32
gint32 size = 0;
- MONO_ARCH_SAVE_REGS;
-
GetTokenInformation (token, TokenGroups, NULL, size, (PDWORD)&size);
if (size > 0) {
TOKEN_GROUPS *tg = g_malloc0 (size);
{
gboolean result = TRUE;
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
result = (CloseHandle (token) != 0);
#endif
{
gpointer dupe = NULL;
- MONO_ARCH_SAVE_REGS;
-
#ifdef HOST_WIN32
if (DuplicateToken (token, SecurityImpersonation, &dupe) == 0) {
dupe = NULL;
gboolean
ves_icall_System_Security_Principal_WindowsImpersonationContext_SetCurrentToken (gpointer token)
{
- MONO_ARCH_SAVE_REGS;
-
/* Posix version implemented in /mono/mono/io-layer/security.c */
return (ImpersonateLoggedOnUser (token) != 0);
}
gboolean
ves_icall_System_Security_Principal_WindowsImpersonationContext_RevertToSelf (void)
{
- MONO_ARCH_SAVE_REGS;
-
/* Posix version implemented in /mono/mono/io-layer/security.c */
return (RevertToSelf () != 0);
}
gboolean result = FALSE;
#ifdef HOST_WIN32
- MONO_ARCH_SAVE_REGS;
-
/* The convertion from an ID to a string is done in managed code for Windows */
g_warning ("IsMemberOfGroupId should never be called on Win32");
#endif
struct group *g = NULL;
- MONO_ARCH_SAVE_REGS;
-
#ifdef HAVE_GETGRGID_R
#ifdef _SC_GETGR_R_SIZE_MAX
fbufsize = mono_sysconf (_SC_GETGR_R_SIZE_MAX);
gboolean result = FALSE;
#ifdef HOST_WIN32
-
- MONO_ARCH_SAVE_REGS;
-
/* Windows version use a cache built using WindowsIdentity._GetRoles */
g_warning ("IsMemberOfGroupName should never be called on Win32");
#else /* HOST_WIN32 */
gchar *utf8_groupname;
- MONO_ARCH_SAVE_REGS;
-
utf8_groupname = mono_unicode_to_external (mono_string_chars (group));
if (utf8_groupname) {
struct group *g = NULL;
#if HOST_WIN32
gint32 flags;
- MONO_ARCH_SAVE_REGS;
-
/* ACL are nice... unless you have FAT or other uncivilized filesystem */
if (!GetVolumeInformation (mono_string_chars (root), NULL, 0, NULL, NULL, (LPDWORD)&flags, NULL, 0))
return FALSE;
return ((flags & FS_PERSISTENT_ACLS) == FS_PERSISTENT_ACLS);
#else
- MONO_ARCH_SAVE_REGS;
/* we assume some kind of security is applicable outside Windows */
return TRUE;
#endif
{
gboolean ret = FALSE;
- MONO_ARCH_SAVE_REGS;
-
/* no one, but the owner, should have write access to the directory */
#ifdef HOST_WIN32
ret = IsMachineProtected (mono_string_chars (path));
{
gboolean ret = FALSE;
- MONO_ARCH_SAVE_REGS;
-
/* no one, but the user, should have access to the directory */
#ifdef HOST_WIN32
ret = IsUserProtected (mono_string_chars (path));
{
gboolean ret = FALSE;
- MONO_ARCH_SAVE_REGS;
-
/* read/write to owner, read to everyone else */
#ifdef HOST_WIN32
ret = ProtectMachine (mono_string_chars (path));
{
gboolean ret = FALSE;
- MONO_ARCH_SAVE_REGS;
-
/* read/write to user, no access to everyone else */
#ifdef HOST_WIN32
ret = ProtectUser (mono_string_chars (path));
MonoMethod *method;
void *params [2];
- MONO_ARCH_SAVE_REGS;
-
if (system_security_assembly == NULL) {
system_security_assembly = mono_image_loaded ("System.Security");
if (!system_security_assembly) {
MonoClass *klass;
gchar *full_name;
- MONO_ARCH_SAVE_REGS;
-
if (vtable->initialized)
return NULL;
{
MonoVTable *vtable;
- MONO_ARCH_SAVE_REGS;
vtable = mono_class_vtable (domain, klass);
if (!vtable)
return NULL;
{
MonoVTable *vtable;
- MONO_ARCH_SAVE_REGS;
vtable = mono_class_vtable (domain, klass);
if (!vtable)
return NULL;
{
MonoObject *o;
- MONO_ARCH_SAVE_REGS;
-
/* check for is_com_object for COM Interop */
if (mono_vtable_is_remote (vtable) || mono_class_is_com_object (vtable->klass))
{
uintptr_t size;
MonoClass *klass = src->obj.vtable->klass;
- MONO_ARCH_SAVE_REGS;
-
g_assert (klass == dest->obj.vtable->klass);
size = mono_array_length (src);
uintptr_t *sizes;
MonoClass *klass = array->obj.vtable->klass;
- MONO_ARCH_SAVE_REGS;
-
if (array->bounds == NULL) {
size = mono_array_length (array);
o = mono_array_new_full (domain, klass, &size, NULL);
{
MonoClass *ac;
- MONO_ARCH_SAVE_REGS;
-
ac = mono_array_class_get (eclass, 1);
g_assert (ac);
MonoArray *ao;
uintptr_t byte_len;
- MONO_ARCH_SAVE_REGS;
-
if (G_UNLIKELY (n > MONO_ARRAY_MAX_INDEX)) {
arith_overflow ();
return NULL;
{
MonoDomain *domain = mono_domain_get ();
- MONO_ARCH_SAVE_REGS;
-
if (text)
return mono_string_new (domain, text);
MonoString*
mono_ldstr (MonoDomain *domain, MonoImage *image, guint32 idx)
{
- MONO_ARCH_SAVE_REGS;
-
if (image->dynamic) {
MonoString *str = mono_lookup_dynamic_token (image, MONO_TOKEN_STRING | idx, NULL);
return str;
{
HANDLE handle;
- MONO_ARCH_SAVE_REGS;
-
/* GetCurrentProcess returns a pseudo-handle, so use
* OpenProcess instead
*/
guint32
ves_icall_System_Diagnostics_Process_GetPid_internal (void)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_process_current_pid ();
}
void ves_icall_System_Diagnostics_Process_Process_free_internal (MonoObject *this,
HANDLE process)
{
- MONO_ARCH_SAVE_REGS;
-
#ifdef THREAD_DEBUG
g_message ("%s: Closing process %p, handle %p", __func__, this, process);
#endif
void ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (MonoObject *this, MonoString *filename)
{
- MONO_ARCH_SAVE_REGS;
-
STASH_SYS_ASS (this);
process_get_fileversion (this, mono_string_chars (filename));
{
guint32 ret;
- MONO_ARCH_SAVE_REGS;
-
if(ms<0) {
/* Wait forever */
ret=WaitForSingleObjectEx (process, INFINITE, TRUE);
{
guint32 ret;
- MONO_ARCH_SAVE_REGS;
-
if(ms<0) {
/* Wait forever */
ret=WaitForInputIdle (process, INFINITE);
gboolean ret;
FILETIME create_time, exit_time, kernel_time, user_time;
- MONO_ARCH_SAVE_REGS;
-
ret = GetProcessTimes (process, &create_time, &exit_time, &kernel_time,
&user_time);
if (ret)
gboolean ret;
FILETIME create_time, exit_time, kernel_time, user_time;
- MONO_ARCH_SAVE_REGS;
-
ret = GetProcessTimes (process, &create_time, &exit_time, &kernel_time,
&user_time);
if (ret)
{
DWORD code;
- MONO_ARCH_SAVE_REGS;
-
GetExitCodeProcess (process, &code);
LOGDEBUG (g_message ("%s: process exit code is %d", __func__, code));
DWORD needed;
guint32 len;
- MONO_ARCH_SAVE_REGS;
-
ok=EnumProcessModules (process, &mod, sizeof(mod), &needed);
if(ok==FALSE) {
return(NULL);
gpointer *pidarray;
int i, count;
- MONO_ARCH_SAVE_REGS;
-
pidarray = mono_process_list (&count);
if (!pidarray)
mono_raise_exception (mono_get_exception_not_supported ("This system does not support EnumProcesses"));
gboolean ret;
SIZE_T ws_min, ws_max;
- MONO_ARCH_SAVE_REGS;
-
ret=GetProcessWorkingSetSize (process, &ws_min, &ws_max);
*min=(guint32)ws_min;
*max=(guint32)ws_max;
SIZE_T ws_min;
SIZE_T ws_max;
- MONO_ARCH_SAVE_REGS;
-
ret=GetProcessWorkingSetSize (process, &ws_min, &ws_max);
if(ret==FALSE) {
return(FALSE);
MonoBoolean
ves_icall_System_Diagnostics_Process_Kill_internal (HANDLE process, gint32 sig)
{
- MONO_ARCH_SAVE_REGS;
-
/* sig == 1 -> Kill, sig == 2 -> CloseMainWindow */
return TerminateProcess (process, -sig);
{
HANDLE ret;
- MONO_ARCH_SAVE_REGS;
-
LOGDEBUG (g_message ("%s: Duplicating process handle %p", __func__, process));
DuplicateHandle (GetCurrentProcess (), process, GetCurrentProcess (),
void
ves_icall_System_Diagnostics_Process_ProcessHandle_close (HANDLE process)
{
- MONO_ARCH_SAVE_REGS;
-
LOGDEBUG (g_message ("%s: Closing process handle %p", __func__, process));
CloseHandle (process);
char buf [16];
char *b = buf;
- MONO_ARCH_SAVE_REGS;
-
if (!module->dynamic_image)
mono_image_module_basic_init (module);
MonoDynamicImage *image;
MonoDomain *domain = mono_object_domain (assemblyb);
- MONO_ARCH_SAVE_REGS;
-
if (assemblyb->dynamic_assembly)
return;
char *buffer, *p;
guint32 buflen, i;
- MONO_ARCH_SAVE_REGS;
-
if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
/* sig is freed later so allocate it in the heap */
sig = ctor_builder_to_signature (NULL, (MonoReflectionCtorBuilder*)ctor);
MonoError error;
MonoClass *klass, *parent;
- MONO_ARCH_SAVE_REGS;
-
RESOLVE_TYPE (tb->parent);
mono_loader_lock ();
MonoClass *klass;
int count, i;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (tb->type.type);
count = tb->generic_params ? mono_array_length (tb->generic_params) : 0;
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (tb->type.type);
mono_loader_lock ();
MonoType **type_argv;
int count, i;
- MONO_ARCH_SAVE_REGS;
-
/*FIXME but this no longer should happen*/
if (!strcmp (rmethod->object.vtable->klass->name, "MethodBuilder")) {
#ifndef DISABLE_REFLECTION_EMIT
MonoType *gtype;
int i;
- MONO_ARCH_SAVE_REGS;
-
gtype = mono_reflection_type_get_handle ((MonoReflectionType*)type);
klass = mono_class_from_mono_type (gtype);
g_assert (gtype->type == MONO_TYPE_GENERICINST);
MonoReflectionType* res;
int i, j;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_object_domain (tb);
klass = mono_class_from_mono_type (tb->type.type);
MonoClass *pklass;
MonoError error;
- MONO_ARCH_SAVE_REGS;
-
image = &gparam->tbuilder->module->dynamic_image->image;
param = mono_image_new0 (image, MonoGenericParamFull, 1);
MonoDomain *domain = mono_domain_get ();
MonoClass *klass = mono_class_from_mono_type (handle);
- MONO_ARCH_SAVE_REGS;
-
mono_class_init (klass);
return mono_type_get_object (domain, handle);
}
gint32 sock_proto;
gint32 sock_type;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
sock_family=convert_family(family);
void ves_icall_System_Net_Sockets_Socket_Close_internal(SOCKET sock,
gint32 *error)
{
- MONO_ARCH_SAVE_REGS;
-
LOGDEBUG (g_message ("%s: closing 0x%x", __func__, sock));
*error = 0;
gint32 ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal(void)
{
- MONO_ARCH_SAVE_REGS;
-
LOGDEBUG (g_message("%s: returning %d", __func__, WSAGetLastError()));
return(WSAGetLastError());
int ret;
int amount;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
/* FIXME: this might require amount to be unsigned long. */
{
int ret;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
/*
{
SOCKET newsock;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
#ifdef HOST_WIN32
{
{
int ret;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
ret = _wapi_listen (sock, backlog);
int ret;
MonoObject *result;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
salen = get_sockaddr_size (convert_family (af));
int ret;
MonoObject *result;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
salen = get_sockaddr_size (convert_family (af));
socklen_t sa_size;
int ret;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
sa=create_sockaddr_from_object(sockaddr, &sa_size, error);
int ret;
time_t start;
-
- MONO_ARCH_SAVE_REGS;
-
pfds = g_new0 (mono_pollfd, 1);
pfds[0].fd = GPOINTER_TO_INT (sock);
pfds[0].events = (mode == SelectModeRead) ? MONO_POLLIN :
socklen_t sa_size;
int ret;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
sa=create_sockaddr_from_object(sockaddr, &sa_size, error);
LPFN_TRANSMITFILE _wapi_transmitfile = NULL;
gboolean bret;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
LOGDEBUG (g_message("%s: disconnecting from socket %p (reuse %d)", __func__, sock, reuse));
gint32 alen;
int recvflags=0;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
alen = mono_array_length (buffer);
WSABUF *wsabufs;
DWORD recvflags = 0;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
wsabufs = mono_array_addr (buffers, WSABUF, 0);
struct sockaddr *sa;
socklen_t sa_size;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
alen = mono_array_length (buffer);
gint32 alen;
int sendflags=0;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
alen = mono_array_length (buffer);
WSABUF *wsabufs;
DWORD sendflags = 0;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
wsabufs = mono_array_addr (buffers, WSABUF, 0);
struct sockaddr *sa;
socklen_t sa_size;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
alen = mono_array_length (buffer);
time_t start;
uintptr_t socks_size;
- MONO_ARCH_SAVE_REGS;
-
/* *sockets -> READ, null, WRITE, null, ERROR, null */
count = mono_array_length (*sockets);
nfds = count - 3; /* NULL separators */
MonoClass *obj_class;
MonoClassField *field;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
#if !defined(SO_EXCLUSIVEADDRUSE) && defined(SO_REUSEADDR)
guchar *buf;
socklen_t valsize;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
ret=convert_sockopt_level_and_name(level, name, &system_level,
sol_ipv6 = mono_networking_get_ipv6_protocol ();
sol_ip = mono_networking_get_ip_protocol ();
- MONO_ARCH_SAVE_REGS;
-
ret=convert_sockopt_level_and_name(level, name, &system_level,
&system_name);
{
int ret;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
/* Currently, the values for how (recv=0, send=1, both=2) match
gint i_len, o_len;
gint ret;
- MONO_ARCH_SAVE_REGS;
-
*error = 0;
if ((guint32)code == FIONBIO) {
MonoAddressInfo *info = NULL;
char *hostname;
- MONO_ARCH_SAVE_REGS;
-
hostname=mono_string_to_utf8 (host);
if (*hostname == '\0') {
add_local_ips = TRUE;
gchar hostname[256];
int ret;
- MONO_ARCH_SAVE_REGS;
-
ret = gethostname (hostname, sizeof (hostname));
if(ret==-1) {
return(FALSE);
gint32 error;
TRANSMIT_FILE_BUFFERS buffers;
- MONO_ARCH_SAVE_REGS;
-
if (filename == NULL)
return FALSE;
ves_icall_System_String_InternalIntern (MonoString *str)
{
MonoString *res;
- MONO_ARCH_SAVE_REGS;
res = mono_string_intern(str);
if (!res)
MonoString *
ves_icall_System_String_InternalIsInterned (MonoString *str)
{
- MONO_ARCH_SAVE_REGS;
-
return mono_string_is_interned(str);
}
gdouble ves_icall_System_Math_Floor (gdouble x) {
- MONO_ARCH_SAVE_REGS;
return floor(x);
}
gdouble ves_icall_System_Math_Round (gdouble x) {
double int_part, dec_part;
- MONO_ARCH_SAVE_REGS;
+
int_part = floor(x);
dec_part = x - int_part;
if (((dec_part == 0.5) &&
#endif
double p;
- MONO_ARCH_SAVE_REGS;
if (value == HUGE_VAL)
return HUGE_VAL;
if (value == -HUGE_VAL)
gdouble
ves_icall_System_Math_Sin (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return sin (x);
}
gdouble
ves_icall_System_Math_Cos (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return cos (x);
}
gdouble
ves_icall_System_Math_Tan (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return tan (x);
}
gdouble
ves_icall_System_Math_Sinh (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return sinh (x);
}
gdouble
ves_icall_System_Math_Cosh (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return cosh (x);
}
gdouble
ves_icall_System_Math_Tanh (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return tanh (x);
}
gdouble
ves_icall_System_Math_Acos (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
if (x < -1 || x > 1)
return NAN;
gdouble
ves_icall_System_Math_Asin (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
if (x < -1 || x > 1)
return NAN;
gdouble
ves_icall_System_Math_Atan (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return atan (x);
}
ves_icall_System_Math_Atan2 (gdouble y, gdouble x)
{
double result;
- MONO_ARCH_SAVE_REGS;
if ((y == HUGE_VAL && x == HUGE_VAL) ||
(y == HUGE_VAL && x == -HUGE_VAL) ||
gdouble
ves_icall_System_Math_Exp (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
return exp (x);
}
gdouble
ves_icall_System_Math_Log (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
if (x == 0)
return -HUGE_VAL;
else if (x < 0)
gdouble
ves_icall_System_Math_Log10 (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
if (x == 0)
return -HUGE_VAL;
else if (x < 0)
ves_icall_System_Math_Pow (gdouble x, gdouble y)
{
double result;
- MONO_ARCH_SAVE_REGS;
if (isnan(x) || isnan(y)) {
return NAN;
gdouble
ves_icall_System_Math_Sqrt (gdouble x)
{
- MONO_ARCH_SAVE_REGS;
-
if (x < 0)
return NAN;
projects / mono.git / commitdiff