mono_feature_disable_mdb='yes'
mono_feature_disable_com='yes'
mono_feature_disable_gac='yes'
+ mono_feature_disable_perfcounters='yes'
+ mono_feature_disable_sockets='yes'
disable_mono_native=yes
support_boehm=no
elif test x$with_runtime_preset = xnet_4_x; then
gchar *filename;
} RuntimeConfig;
+#ifndef ENABLE_NETCORE
static gunichar2 process_guid [36];
static gboolean process_guid_set = FALSE;
+#endif
static gboolean no_exec = FALSE;
return TRUE;
}
+#ifndef ENABLE_NETCORE
MonoObjectHandle
ves_icall_System_AppDomain_GetData (MonoAppDomainHandle ad, MonoStringHandle name, MonoError *error)
{
return domain->throw_unobserved_task_exceptions;
}
+#endif
static char*
get_attribute_value (const gchar **attribute_names,
g_free (config_file_path);
}
+#ifndef ENABLE_NETCORE
MonoAppDomainHandle
ves_icall_System_AppDomain_createDomain (MonoStringHandle friendly_name, MonoAppDomainSetupHandle setup, MonoError *error)
{
#endif
return ad;
}
+#endif
static gboolean
add_assembly_to_array (MonoDomain *domain, MonoArrayHandle dest, int dest_idx, MonoAssembly* assm, MonoError *error)
fail:
return MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
}
-
#endif
+#ifndef ENABLE_NETCORE
MonoReflectionAssemblyHandle
ves_icall_System_Reflection_Assembly_LoadFrom (MonoStringHandle fname, MonoBoolean refOnly, MonoStackCrawlMark *stack_mark, MonoError *error)
{
g_free (name);
return result;
}
+#endif
static
MonoAssembly *
return ass;
}
+#ifndef ENABLE_NETCORE
MonoReflectionAssemblyHandle
ves_icall_System_AppDomain_LoadAssembly (MonoAppDomainHandle ad, MonoStringHandle assRef, MonoObjectHandle evidence, MonoBoolean refOnly, MonoStackCrawlMark *stack_mark, MonoError *error)
{
mono_domain_unlock (mono_root_domain);
return newguid;
}
+#endif
/**
* mono_domain_is_unloading:
#include <mono/utils/mono-proclib.h>
#include <mono/utils/w32api.h>
#include <mono/utils/mono-errno.h>
+#include <mono/metadata/console-io.h>
+#include <mono/metadata/exception.h>
+#include "icall-decl.h"
+
+#ifndef ENABLE_NETCORE
/* On solaris, curses.h must come before both termios.h and term.h */
#ifdef HAVE_CURSES_H
# include <sys/ioctl.h>
#endif
-#include <mono/metadata/console-io.h>
-#include <mono/metadata/exception.h>
-#include "icall-decl.h"
-
static gboolean setup_finished;
static gboolean atexit_called;
/* static void console_restore_signal_handlers (void); */
static void console_set_signal_handlers (void);
-
static GENERATE_TRY_GET_CLASS_WITH_CACHE (console, "System", "Console");
-
void
mono_console_init (void)
{
return TRUE;
}
+
+#else /* ENABLE_NETCORE */
+
+void
+mono_console_init (void)
+{
+}
+
+void
+mono_console_handle_async_ops (void)
+{
+}
+
+#endif
exitcode=value;
}
+#ifndef ENABLE_NETCORE
/* note: we better manipulate the string in managed code (easier and safer) */
MonoStringHandle
ves_icall_System_Environment_GetOSVersionString (MonoError *error)
#endif
return mono_string_new_handle (mono_domain_get (), "0.0.0.0", error);
}
-
+#endif
return ret;
}
+#ifndef ENABLE_NETCORE
MonoBoolean
ves_icall_System_RuntimeType_IsTypeExportedToWindowsRuntime (MonoError *error)
{
mono_error_set_not_implemented (error, "%s", "System.RuntimeType.IsWindowsRuntimeObjectType");
return FALSE;
}
+#endif /* ENABLE_NETCORE */
void
ves_icall_RuntimeMethodInfo_GetPInvoke (MonoReflectionMethodHandle ref_method, int* flags, MonoStringHandleOut entry_point, MonoStringHandleOut dll_name, MonoError *error)
#ifndef HOST_WIN32
+#ifndef ENABLE_NETCORE
void
ves_icall_System_Environment_BroadcastSettingChange (MonoError *error)
{
}
+#endif
#endif
}
#endif
+#ifndef ENABLE_NETCORE
gint32
ves_icall_System_Runtime_Versioning_VersioningHelper_GetRuntimeId (MonoError *error)
{
return 9;
}
+#endif
#ifndef DISABLE_REMOTING
MonoBoolean
#else /* DISABLE_REMOTING */
+#ifndef ENABLE_NETCORE
void
ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionTypeHandle type, MonoBoolean enable, MonoError *error)
{
g_assert_not_reached ();
}
+#endif
#endif
+#ifndef ENABLE_NETCORE
MonoObjectHandle
ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionTypeHandle type, MonoError *error)
{
}
}
-#if !ENABLE_NETCORE
-
MonoStringHandle
ves_icall_System_IO_get_temp_path (MonoError *error)
{
return mono_string_new_handle (mono_domain_get (), g_get_tmp_dir (), error);
}
-#endif
+#endif /* ENABLE_NETCORE */
#if defined(ENABLE_MONODROID) || defined(ENABLE_MONOTOUCH) || defined(TARGET_WASM)
return mono_compile_method_checked (method, error);
}
+#ifndef ENABLE_NETCORE
+
MonoStringHandle
ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (MonoError *error)
{
return get_bundled_machine_config (error);
}
-
MonoStringHandle
ves_icall_System_Configuration_DefaultConfig_get_bundled_machine_config (MonoError *error)
{
return get_bundled_machine_config (error);
}
-
MonoStringHandle
ves_icall_System_Web_Util_ICalls_get_machine_install_dir (MonoError *error)
{
return TRUE;
}
+#endif /* ENABLE_NETCORE */
+
MonoBoolean
ves_icall_System_Diagnostics_Debugger_IsAttached_internal (MonoError *error)
{
}
#endif /* !HOST_WIN32 */
+#ifndef ENABLE_NETCORE
void
ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (const gunichar2 *message, MonoError *error)
{
mono_icall_write_windows_debug_string (message);
}
+#endif
/* Only used for value types */
MonoObjectHandle
}
}
+#ifndef ENABLE_NETCORE
/*
* used by System.Runtime.InteropServices.RuntimeInformation.(OS|Process)Architecture;
* which use them in different ways for filling in an enum
error_init (error);
return mono_string_new_handle (mono_domain_get (), mono_config_get_os (), error);
}
+#endif /* ENABLE_NETCORE */
int
ves_icall_Interop_Sys_DoubleToString(double value, char *format, char *buffer, int bufferLength)
}
#endif /* !HOST_WIN32 */
+#ifndef ENABLE_NETCORE
gint32
ves_icall_Microsoft_Win32_NativeMethods_WaitForInputIdle (gpointer handle, gint32 milliseconds, MonoError *error)
{
return FALSE;
#endif
}
+#endif /* ENABLE_NETCORE */
#ifndef DISABLE_COM
return res;
}
+#ifndef ENABLE_NETCORE
gpointer
ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArrayHandle arrayobj, int index, MonoError *error)
{
int esize = mono_array_element_size (mono_handle_class (arrayobj));
return mono_array_addr_with_size_fast (MONO_HANDLE_RAW (arrayobj), esize, index);
}
+#endif
MonoDelegateHandle
ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn, MonoReflectionTypeHandle type, MonoError *error)
#else
+#ifndef ENABLE_NETCORE
+
void*
mono_perfcounter_get_impl (const gunichar2 *category, gint32 category_length,
const gunichar2 *counter, gint32 counter_length,
g_assert_not_reached ();
}
+#endif /* ENABLE_NETCORE */
+
#endif
#include <mono/utils/strenc.h>
#include "reflection-internals.h"
#include "icall-decl.h"
+
+#ifndef ENABLE_NETCORE
+
#ifndef HOST_WIN32
#ifdef HAVE_GRP_H
#include <grp.h>
{
mono_invoke_protected_memory_method (data, scope, "Protect", &mono_method_securestring_encrypt, error);
}
+
+#else
+
+MONO_EMPTY_SOURCE_FILE (mono_security);
+
+#endif /* ENABLE_NETCORE */
#include "utils/mono-rand.h"
#include "icall-decl.h"
+#ifndef ENABLE_NETCORE
+
MonoBoolean
ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngOpen (MonoError *error)
{
{
mono_rand_close (handle);
}
+
+#else
+
+MONO_EMPTY_SOURCE_FILE (rand);
+
+#endif /* ENABLE_NETCORE */
MONO_PROFILER_RAISE (context_loaded, (MONO_HANDLE_RAW (ctx)));
}
+#ifndef ENABLE_NETCORE
void
ves_icall_System_Runtime_Remoting_Contexts_Context_RegisterContext (MonoAppContextHandle ctx, MonoError *error)
{
mono_threads_register_app_context (ctx, error);
}
+#endif
void
mono_threads_release_app_context (MonoAppContext* ctx, MonoError *error)
MONO_PROFILER_RAISE (context_unloaded, (ctx));
}
+#ifndef ENABLE_NETCORE
void
ves_icall_System_Runtime_Remoting_Contexts_Context_ReleaseContext (MonoAppContextHandle ctx, MonoError *error)
{
mono_threads_release_app_context (MONO_HANDLE_RAW (ctx), error); /* FIXME use handles in mono_threads_release_app_context */
}
+#endif
void mono_thread_init (MonoThreadStartCB start_cb,
MonoThreadAttachCB attach_cb)
dump_thread (MonoInternalThread *thread, ThreadDumpUserData *ud, FILE* output_file)
{
GString* text = g_string_new (0);
- char *name;
- GError *gerror = NULL;
int i;
ud->thread = thread;
mono_w32handle_close (handle);
}
+#ifndef ENABLE_NETCORE
gpointer
ves_icall_System_Threading_Events_OpenEvent_icall (const gunichar2 *name, gint32 name_length,
gint32 rights, gint32 *win32error, MonoError *error)
g_free (utf8_name);
return handle;
}
+#endif
gpointer
mono_w32event_open (const gchar *utf8_name, gint32 rights G_GNUC_UNUSED, gint32 *win32error)
}
#endif
+#ifndef ENABLE_NETCORE
guint32
ves_icall_System_IO_DriveInfo_GetDriveType (const gunichar2 *root_path_name, gint32 root_path_name_length, MonoError *error)
{
return (drive_type);
}
+#endif
#if defined (HOST_DARWIN) || defined (__linux__) || defined(HOST_BSD) || defined(__FreeBSD_kernel__) || defined(__HAIKU__) || defined(_AIX)
static gchar*
#include "object-internals.h"
#include "icall-decl.h"
+#ifndef ENABLE_NETCORE
+
#ifndef MAXPATHLEN
#define MAXPATHLEN 242
#endif
return copy_lang (lang_out, lang_len, name);
}
+
+#else /* ENABLE_NETCORE */
+
+void
+mono_w32process_init (void)
+{
+}
+
+void
+mono_w32process_cleanup (void)
+{
+}
+
+void
+mono_w32process_set_cli_launcher (gchar *path)
+{
+}
+
+void
+mono_w32process_signal_finished (void)
+{
+}
+
+#endif /* ENABLE_NETCORE */
#endif // G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
+#ifndef ENABLE_NETCORE
void
ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (MonoObjectHandle this_obj,
const gunichar2 *filename, int filename_length, MonoError *error)
process_set_field_utf16 (this_obj, str, "filename", filename, filename_length, error);
}
+#endif
#if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
HANDLE_FUNCTION_RETURN ();
}
+#ifndef ENABLE_NETCORE
/* Returns an array of System.Diagnostics.ProcessModule */
MonoArrayHandle
ves_icall_System_Diagnostics_Process_GetModules_internal (MonoObjectHandle this_obj, HANDLE process, MonoError *error)
return len ? mono_string_new_utf16_handle (mono_domain_get (), name, len, error) : NULL_HANDLE_STRING;
}
+#endif /* ENABLE_NETCORE */
#endif // G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) && defined(HOST_WIN32)
}
}
+#ifndef ENABLE_NETCORE
MonoBoolean
ves_icall_System_Net_Sockets_Socket_SupportPortReuse (MonoProtocolType proto, MonoError *error)
{
return FALSE;
#endif
}
+#endif
gboolean
mono_w32socket_duplicate (gpointer handle, gint32 targetProcessId, gpointer *duplicate_handle)