mscoree_private.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_VTableFixup
struct	CLRRuntimeInfo
struct	RuntimeHost
struct	CorProcess
struct	CorDebug
struct	parsed_config_file
struct	supported_runtime

Macros
#define	WINE_MONO_VERSION   "9.4.0"
#define	WINE_PRELOAD_CONTINUE   0
#define	WINE_PRELOAD_SKIP_PRIVATE_PATH   1
#define	WINE_PRELOAD_SKIP_GAC   2
#define	WINE_PRELOAD_SET_GAC   4

Typedefs
typedef struct _VTableFixup	VTableFixup
typedef struct tagASSEMBLY	ASSEMBLY
typedef BOOL(WINAPI *	NativeEntryPointFunc) (HINSTANCE, DWORD, LPVOID)
typedef struct _MonoDomain	MonoDomain
typedef struct _MonoAssembly	MonoAssembly
typedef struct _MonoAssemblyName	MonoAssemblyName
typedef struct _MonoType	MonoType
typedef struct _MonoImage	MonoImage
typedef struct _MonoClass	MonoClass
typedef struct _MonoObject	MonoObject
typedef struct _MonoString	MonoString
typedef struct _MonoMethod	MonoMethod
typedef struct _MonoProfiler	MonoProfiler
typedef struct _MonoThread	MonoThread
typedef struct RuntimeHost	RuntimeHost
typedef struct CLRRuntimeInfo	CLRRuntimeInfo
typedef struct CorProcess	CorProcess
typedef struct CorDebug	CorDebug
typedef struct parsed_config_file	parsed_config_file
typedef struct supported_runtime	supported_runtime
typedef MonoAssembly *(CDECL *	MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, char **assemblies_path, void *user_data)
typedef MonoAssembly *(CDECL *	WineMonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, char **assemblies_path, int *flags, void *user_data)
typedef void(CDECL *	MonoProfileFunc) (MonoProfiler *prof)
typedef void(CDECL *	MonoPrintCallback) (const char *string, INT is_stdout)
typedef void(*	MonoLogCallback) (const char *log_domain, const char *log_level, const char *message, INT fatal, void *user_data)

Enumerations
enum	MonoImageOpenStatus { MONO_IMAGE_OK , MONO_IMAGE_ERROR_ERRNO , MONO_IMAGE_MISSING_ASSEMBLYREF , MONO_IMAGE_IMAGE_INVALID }
enum	MonoAotMode {   MONO_AOT_MODE_NONE , MONO_AOT_MODE_NORMAL , MONO_AOT_MODE_HYBRID , MONO_AOT_MODE_FULL ,   MONO_AOT_MODE_LLVMONLY , MONO_AOT_MODE_INTERP , MONO_AOT_MODE_INTERP_LLVMONLY , MONO_AOT_MODE_LLVMONLY_INTERP ,   MONO_AOT_MODE_INTERP_ONLY }

Functions
char *	WtoA (const WCHAR *wstr) __WINE_DEALLOC(free) __WINE_MALLOC
HRESULT	CLRMetaHost_CreateInstance (REFIID riid, void **ppobj)
HRESULT	CLRMetaHostPolicy_CreateInstance (REFIID riid, void **ppobj)
HRESULT WINAPI	CLRMetaHost_GetVersionFromFile (ICLRMetaHost *iface, LPCWSTR pwzFilePath, LPWSTR pwzBuffer, DWORD *pcchBuffer)
HRESULT	assembly_create (ASSEMBLY **out, LPCWSTR file)
HRESULT	assembly_from_hmodule (ASSEMBLY **out, HMODULE hmodule)
HRESULT	assembly_release (ASSEMBLY *assembly)
HRESULT	assembly_get_runtime_version (ASSEMBLY *assembly, LPSTR *version)
HRESULT	assembly_get_vtable_fixups (ASSEMBLY *assembly, VTableFixup **fixups, DWORD *count)
HRESULT	assembly_get_native_entrypoint (ASSEMBLY *assembly, NativeEntryPointFunc *func)
HRESULT	get_runtime_info (LPCWSTR exefile, LPCWSTR version, LPCWSTR config_file, IStream *config_stream, DWORD startup_flags, DWORD runtimeinfo_flags, BOOL legacy, ICLRRuntimeInfo **result)
BOOL	get_mono_path (LPWSTR path, BOOL skip_local)
MonoDomain *	get_root_domain (void)
HRESULT	ICLRRuntimeInfo_GetRuntimeHost (ICLRRuntimeInfo *iface, RuntimeHost **result)
HRESULT	MetaDataDispenser_CreateInstance (IUnknown **ppUnk)
HRESULT	parse_config_file (LPCWSTR filename, parsed_config_file *result)
HRESULT	parse_config_stream (IStream *stream, parsed_config_file *result)
void	free_parsed_config_file (parsed_config_file *file)
MonoImage *CDECL *	mono_assembly_get_image (MonoAssembly *assembly)
MonoAssembly *CDECL *	mono_assembly_load_from (MonoImage *image, const char *fname, MonoImageOpenStatus *status)
const char *CDECL *	mono_assembly_name_get_name (MonoAssemblyName *aname)
MonoAssembly *CDECL *	mono_assembly_open (const char *filename, MonoImageOpenStatus *status)
	void (CDECL *mono_callspec_set_assembly)(MonoAssembly *assembly)
MonoClass *CDECL *	mono_class_from_mono_type (MonoType *type)
MonoClass *CDECL *	mono_class_from_name (MonoImage *image, const char *name_space, const char *name)
MonoMethod *CDECL *	mono_class_get_method_from_name (MonoClass *klass, const char *name, int param_count)
MonoDomain *CDECL *	mono_domain_get (void)
MonoDomain *CDECL *	mono_domain_get_by_id (int id)
	BOOL (CDECL *mono_domain_set)(MonoDomain *domain
MonoImage *CDECL *	mono_get_corlib (void)
	int (CDECL *mono_jit_exec)(MonoDomain *domain
MonoDomain *CDECL *	mono_jit_init_version (const char *domain_name, const char *runtime_version)
MonoImage *CDECL *	mono_image_open_from_module_handle (HMODULE module_handle, char *fname, UINT has_entry_point, MonoImageOpenStatus *status)
void *CDECL *	mono_marshal_get_vtfixup_ftnptr (MonoImage *image, DWORD token, WORD type)
MonoDomain *CDECL *	mono_object_get_domain (MonoObject *obj)
MonoMethod *CDECL *	mono_object_get_virtual_method (MonoObject *obj, MonoMethod *method)
MonoObject *CDECL *	mono_object_new (MonoDomain *domain, MonoClass *klass)
void *CDECL *	mono_object_unbox (MonoObject *obj)
MonoType *CDECL *	mono_reflection_type_from_name (char *name, MonoImage *image)
MonoObject *CDECL *	mono_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject **exc)
MonoString *CDECL *	mono_string_new (MonoDomain *domain, const char *str)
MonoThread *CDECL *	mono_thread_attach (MonoDomain *domain)
void	expect_no_runtimes (void)
HRESULT	RuntimeHost_Construct (CLRRuntimeInfo *runtime_version, RuntimeHost **result)
void	RuntimeHost_ExitProcess (RuntimeHost *This, INT exitcode)
HRESULT	RuntimeHost_GetInterface (RuntimeHost *This, REFCLSID clsid, REFIID riid, void **ppv)
HRESULT	RuntimeHost_GetIUnknownForObject (RuntimeHost *This, MonoObject *obj, IUnknown **ppUnk)
HRESULT	RuntimeHost_CreateManagedInstance (RuntimeHost *This, LPCWSTR name, MonoDomain *domain, MonoObject **result)
HRESULT WINAPI	CLRMetaHost_ExitProcess (ICLRMetaHost *iface, INT32 iExitCode)
HRESULT WINAPI	CLRMetaHost_GetRuntime (ICLRMetaHost *iface, LPCWSTR pwzVersion, REFIID iid, LPVOID *ppRuntime)
HRESULT	CorDebug_Create (ICLRRuntimeHost *runtimehost, IUnknown **ppUnk)
HRESULT	create_monodata (REFCLSID clsid, LPVOID *ppObj)
HRESULT	get_file_from_strongname (WCHAR *stringnameW, WCHAR *assemblies_path, int path_length)
void	runtimehost_init (void)
void	runtimehost_uninit (void)
void CDECL	mono_print_handler_fn (const char *string, INT is_stdout)
void CDECL	mono_log_handler_fn (const char *log_domain, const char *log_level, const char *message, INT fatal, void *user_data)

Variables
WCHAR **	private_path
BOOL	is_mono_started
BOOL	force
const char *	base_dir
const char const char *	config_file_name
MonoAssembly *	assembly
MonoAssembly int	argc
MonoAssembly int char *	argv []

Macro Definition Documentation

WINE_MONO_VERSION

#define WINE_MONO_VERSION   "9.4.0"

Definition at line 48 of file mscoree_private.h.

WINE_PRELOAD_CONTINUE

#define WINE_PRELOAD_CONTINUE   0

Definition at line 146 of file mscoree_private.h.

WINE_PRELOAD_SET_GAC

#define WINE_PRELOAD_SET_GAC   4

Definition at line 149 of file mscoree_private.h.

WINE_PRELOAD_SKIP_GAC

#define WINE_PRELOAD_SKIP_GAC   2

Definition at line 148 of file mscoree_private.h.

WINE_PRELOAD_SKIP_PRIVATE_PATH

#define WINE_PRELOAD_SKIP_PRIVATE_PATH   1

Definition at line 147 of file mscoree_private.h.

Typedef Documentation

ASSEMBLY

typedef struct tagASSEMBLY ASSEMBLY

Definition at line 37 of file mscoree_private.h.

CLRRuntimeInfo

typedef struct CLRRuntimeInfo CLRRuntimeInfo

CorDebug

typedef struct CorDebug CorDebug

CorProcess

typedef struct CorProcess CorProcess

MonoAssembly

typedef struct _MonoAssembly MonoAssembly

Definition at line 52 of file mscoree_private.h.

MonoAssemblyName

typedef struct _MonoAssemblyName MonoAssemblyName

Definition at line 53 of file mscoree_private.h.

MonoAssemblyPreLoadFunc

typedef MonoAssembly *(CDECL * MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, char **assemblies_path, void *user_data)

Definition at line 144 of file mscoree_private.h.

MonoClass

typedef struct _MonoClass MonoClass

Definition at line 56 of file mscoree_private.h.

MonoDomain

typedef struct _MonoDomain MonoDomain

Definition at line 51 of file mscoree_private.h.

MonoImage

typedef struct _MonoImage MonoImage

Definition at line 55 of file mscoree_private.h.

MonoLogCallback

typedef void(* MonoLogCallback) (const char *log_domain, const char *log_level, const char *message, INT fatal, void *user_data)

Definition at line 156 of file mscoree_private.h.

MonoMethod

typedef struct _MonoMethod MonoMethod

Definition at line 59 of file mscoree_private.h.

MonoObject

typedef struct _MonoObject MonoObject

Definition at line 57 of file mscoree_private.h.

MonoPrintCallback

typedef void(CDECL * MonoPrintCallback) (const char *string, INT is_stdout)

Definition at line 155 of file mscoree_private.h.

MonoProfileFunc

typedef void(CDECL * MonoProfileFunc) (MonoProfiler *prof)

Definition at line 153 of file mscoree_private.h.

MonoProfiler

typedef struct _MonoProfiler MonoProfiler

Definition at line 60 of file mscoree_private.h.

MonoString

typedef struct _MonoString MonoString

Definition at line 58 of file mscoree_private.h.

MonoThread

typedef struct _MonoThread MonoThread

Definition at line 61 of file mscoree_private.h.

MonoType

typedef struct _MonoType MonoType

Definition at line 54 of file mscoree_private.h.

NativeEntryPointFunc

typedef BOOL(WINAPI * NativeEntryPointFunc) (HINSTANCE, DWORD, LPVOID)

Definition at line 39 of file mscoree_private.h.

parsed_config_file

typedef struct parsed_config_file parsed_config_file

RuntimeHost

typedef struct RuntimeHost RuntimeHost

Definition at line 63 of file mscoree_private.h.

supported_runtime

typedef struct supported_runtime supported_runtime

VTableFixup

typedef struct _VTableFixup VTableFixup

WineMonoAssemblyPreLoadFunc

typedef MonoAssembly *(CDECL * WineMonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, char **assemblies_path, int *flags, void *user_data)

Definition at line 151 of file mscoree_private.h.

Enumeration Type Documentation

MonoAotMode

enum MonoAotMode

Enumerator
MONO_AOT_MODE_NONE
MONO_AOT_MODE_NORMAL
MONO_AOT_MODE_HYBRID
MONO_AOT_MODE_FULL
MONO_AOT_MODE_LLVMONLY
MONO_AOT_MODE_INTERP
MONO_AOT_MODE_INTERP_LLVMONLY
MONO_AOT_MODE_LLVMONLY_INTERP
MONO_AOT_MODE_INTERP_ONLY

Definition at line 158 of file mscoree_private.h.

             {
    MONO_AOT_MODE_NONE,
    MONO_AOT_MODE_NORMAL,
    MONO_AOT_MODE_HYBRID,
    MONO_AOT_MODE_FULL,
    MONO_AOT_MODE_LLVMONLY,
    MONO_AOT_MODE_INTERP,
    MONO_AOT_MODE_INTERP_LLVMONLY,
    MONO_AOT_MODE_LLVMONLY_INTERP,
    MONO_AOT_MODE_INTERP_ONLY
} MonoAotMode;

MonoImageOpenStatus

enum MonoImageOpenStatus

Enumerator
MONO_IMAGE_OK
MONO_IMAGE_ERROR_ERRNO
MONO_IMAGE_MISSING_ASSEMBLYREF
MONO_IMAGE_IMAGE_INVALID

Definition at line 137 of file mscoree_private.h.

             {
    MONO_IMAGE_OK,
    MONO_IMAGE_ERROR_ERRNO,
    MONO_IMAGE_MISSING_ASSEMBLYREF,
    MONO_IMAGE_IMAGE_INVALID
} MonoImageOpenStatus;

Function Documentation

assembly_create()

HRESULT assembly_create	(	ASSEMBLY **	out,
		LPCWSTR	file
	)

Definition at line 641 of file assembly.c.

{
    ASSEMBLY *assembly;
    HRESULT hr;
 
    *out = NULL;
 
    if (!(assembly = heap_alloc_zero(sizeof(*assembly)))) return E_OUTOFMEMORY;
 
    assembly->path = strdupW(file);
    if (!assembly->path)
    {
        hr = E_OUTOFMEMORY;
        goto failed;
    }
 
    assembly->hfile = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ,
                                  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (assembly->hfile == INVALID_HANDLE_VALUE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto failed;
    }
 
    assembly->hmap = CreateFileMappingW(assembly->hfile, NULL, PAGE_READONLY,
                                        0, 0, NULL);
    if (!assembly->hmap)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto failed;
    }
 
    assembly->data = MapViewOfFile(assembly->hmap, FILE_MAP_READ, 0, 0, 0);
    if (!assembly->data)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto failed;
    }
 
    hr = parse_pe_header(assembly);
    if (FAILED(hr)) goto failed;
 
    hr = parse_clr_metadata(assembly);
    if (FAILED(hr)) goto failed;
 
    *out = assembly;
    return S_OK;
 
failed:
    assembly_release(assembly);
    return hr;
}

Referenced by CLRMetaHost_GetVersionFromFile(), and IAssemblyCacheImpl_InstallAssembly().

assembly_from_hmodule()

HRESULT assembly_from_hmodule	(	ASSEMBLY **	out,
		HMODULE	hmodule
	)

Definition at line 244 of file assembly.c.

{
    ASSEMBLY *assembly;
    HRESULT hr;
 
    *out = NULL;
 
    assembly = calloc(1, sizeof(ASSEMBLY));
    if (!assembly)
        return E_OUTOFMEMORY;
 
    assembly->is_mapped_file = FALSE;
 
    assembly->data = (BYTE*)hmodule;
 
    hr = parse_headers(assembly);
    if (SUCCEEDED(hr))
        *out = assembly;
    else
        assembly_release(assembly);
 
    return hr;
}

Referenced by _CorDllMain(), and FixupVTable().

assembly_get_native_entrypoint()

HRESULT assembly_get_native_entrypoint	(	ASSEMBLY *	assembly,
		NativeEntryPointFunc *	func
	)

Definition at line 303 of file assembly.c.

{
    if (assembly->corhdr->Flags & COMIMAGE_FLAGS_NATIVE_ENTRYPOINT)
    {
        *func = assembly_rva_to_va(assembly, assembly->corhdr->EntryPointRVA);
        return S_OK;
    }
    else
    {
        *func = NULL;
        return S_FALSE;
    }
}

Referenced by _CorDllMain().

assembly_get_runtime_version()

HRESULT assembly_get_runtime_version	(	ASSEMBLY *	assembly,
		LPSTR *	version
	)

Definition at line 865 of file assembly.c.

{
    *version = assembly->metadatahdr->Version;
    return S_OK;
}

Referenced by CLRMetaHost_GetVersionFromFile(), and IAssemblyCacheImpl_InstallAssembly().

assembly_get_vtable_fixups()

HRESULT assembly_get_vtable_fixups	(	ASSEMBLY *	assembly,
		VTableFixup **	fixups,
		DWORD *	count
	)

Definition at line 293 of file assembly.c.

{
    ULONG size;
 
    size = assembly_datadir_get_data(assembly, &assembly->corhdr->VTableFixups, (void**)fixups);
    *count = size / sizeof(VTableFixup);
 
    return S_OK;
}

Referenced by FixupVTable_Assembly().

assembly_release()

HRESULT assembly_release

(

ASSEMBLY *

assembly

)

Definition at line 694 of file assembly.c.

{
    if (!assembly)
        return S_OK;
 
    heap_free(assembly->metadatahdr);
    heap_free(assembly->path);
    UnmapViewOfFile(assembly->data);
    CloseHandle(assembly->hmap);
    CloseHandle(assembly->hfile);
    heap_free(assembly);
 
    return S_OK;
}

Referenced by _CorDllMain(), assembly_create(), assembly_from_hmodule(), CLRMetaHost_GetVersionFromFile(), FixupVTable(), and IAssemblyCacheImpl_InstallAssembly().

BOOL()

BOOL

(

CDECL *

mono_domain_set

)

CLRMetaHost_CreateInstance()

HRESULT CLRMetaHost_CreateInstance	(	REFIID	riid,
		void **	ppobj
	)

Definition at line 1281 of file metahost.c.

{
    return ICLRMetaHost_QueryInterface(&GlobalCLRMetaHost.ICLRMetaHost_iface, riid, ppobj);
}

Referenced by CLRCreateInstance().

CLRMetaHost_ExitProcess()

HRESULT WINAPI CLRMetaHost_ExitProcess	(	ICLRMetaHost *	iface,
		INT32	iExitCode
	)

Definition at line 1244 of file metahost.c.

{
    TRACE("%i\n", iExitCode);
 
    EnterCriticalSection(&runtime_list_cs);
 
    if (is_mono_started && !is_mono_shutdown)
    {
        /* search for a runtime and call System.Environment.Exit() */
        int i;
 
        for (i=0; i<NUM_RUNTIMES; i++)
            if (runtimes[i].loaded_runtime)
                RuntimeHost_ExitProcess(runtimes[i].loaded_runtime, iExitCode);
    }
 
    ExitProcess(iExitCode);
}

Referenced by CorExitProcess().

CLRMetaHost_GetRuntime()

HRESULT WINAPI CLRMetaHost_GetRuntime	(	ICLRMetaHost *	iface,
		LPCWSTR	pwzVersion,
		REFIID	iid,
		LPVOID *	ppRuntime
	)

Definition at line 1149 of file metahost.c.

{
    TRACE("%s %s %p\n", debugstr_w(pwzVersion), debugstr_guid(iid), ppRuntime);
 
    return get_runtime(pwzVersion, FALSE, iid, ppRuntime);
}

Referenced by CreateDebuggingInterfaceFromVersion(), and get_runtime_info().

CLRMetaHost_GetVersionFromFile()

HRESULT WINAPI CLRMetaHost_GetVersionFromFile	(	ICLRMetaHost *	iface,
		LPCWSTR	pwzFilePath,
		LPWSTR	pwzBuffer,
		DWORD *	pcchBuffer
	)

Definition at line 1157 of file metahost.c.

{
    ASSEMBLY *assembly;
    HRESULT hr;
    LPSTR version;
    ULONG buffer_size=*pcchBuffer;
 
    TRACE("%s %p %p\n", debugstr_w(pwzFilePath), pwzBuffer, pcchBuffer);
 
    hr = assembly_create(&assembly, pwzFilePath);
 
    if (SUCCEEDED(hr))
    {
        hr = assembly_get_runtime_version(assembly, &version);
 
        if (SUCCEEDED(hr))
        {
            *pcchBuffer = MultiByteToWideChar(CP_UTF8, 0, version, -1, NULL, 0);
 
            if (pwzBuffer)
            {
                if (buffer_size >= *pcchBuffer)
                    MultiByteToWideChar(CP_UTF8, 0, version, -1, pwzBuffer, buffer_size);
                else
                    hr = E_NOT_SUFFICIENT_BUFFER;
            }
        }
 
        assembly_release(assembly);
    }
 
    return hr;
}

Referenced by get_runtime_info(), and GetFileVersion().

CLRMetaHostPolicy_CreateInstance()

HRESULT CLRMetaHostPolicy_CreateInstance	(	REFIID	riid,
		void **	ppobj
	)

Definition at line 1385 of file metahost.c.

{
    return ICLRMetaHostPolicy_QueryInterface(&GlobalCLRMetaHostPolicy.ICLRMetaHostPolicy_iface, riid, ppobj);
}

Referenced by CLRCreateInstance().

CorDebug_Create()

HRESULT CorDebug_Create	(	ICLRRuntimeHost *	runtimehost,
		IUnknown **	ppUnk
	)

Definition at line 763 of file cordebug.c.

{
    CorDebug *This;
 
    This = malloc(sizeof *This);
    if ( !This )
        return E_OUTOFMEMORY;
 
    This->ICorDebug_iface.lpVtbl = &cordebug_vtbl;
    This->ICorDebugProcessEnum_iface.lpVtbl = &processenum_vtbl;
    This->ref = 1;
    This->pCallback = NULL;
    This->pCallback2 = NULL;
    This->runtimehost = runtimehost;
 
    list_init(&This->processes);
 
    if(This->runtimehost)
        ICLRRuntimeHost_AddRef(This->runtimehost);
 
    *ppUnk = (IUnknown*)&This->ICorDebug_iface;
 
    return S_OK;
}

Referenced by RuntimeHost_GetInterface().

create_monodata()

HRESULT create_monodata	(	REFCLSID	clsid,
		LPVOID *	ppObj
	)

Definition at line 1732 of file corruntimehost.c.

{
    static const WCHAR wszFileSlash[] = L"file:///";
    static const WCHAR wszCLSIDSlash[] = L"CLSID\\";
    static const WCHAR wszInprocServer32[] = L"\\InprocServer32";
    WCHAR path[CHARS_IN_GUID + ARRAY_SIZE(wszCLSIDSlash) + ARRAY_SIZE(wszInprocServer32) - 1];
    MonoDomain *domain;
    MonoAssembly *assembly;
    ICLRRuntimeInfo *info = NULL;
    RuntimeHost *host;
    HRESULT hr;
    HKEY key, subkey;
    LONG res;
    int offset = 0;
    HANDLE file = INVALID_HANDLE_VALUE;
    DWORD numKeys, keyLength;
    WCHAR codebase[MAX_PATH + 8];
    WCHAR classname[350], subkeyName[256];
    WCHAR filename[MAX_PATH];
    DWORD dwBufLen;
 
    lstrcpyW(path, wszCLSIDSlash);
    StringFromGUID2(clsid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
    lstrcatW(path, wszInprocServer32);
 
    TRACE("Registry key: %s\n", debugstr_w(path));
 
    res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key);
    if (res != ERROR_FILE_NOT_FOUND)
    {
        res = RegOpenKeyExW( key, L"Server", 0, KEY_READ, &subkey );
        if (res == ERROR_SUCCESS)
        {
            /* Not a managed class, just chain through LoadLibraryShim */
            HMODULE module;
            HRESULT (WINAPI *pDllGetClassObject)(REFCLSID,REFIID,LPVOID*);
            IClassFactory *classfactory;
 
            dwBufLen = sizeof( filename );
            res = RegGetValueW( subkey, NULL, NULL, RRF_RT_REG_SZ, NULL, filename, &dwBufLen );
 
            RegCloseKey( subkey );
 
            if (res != ERROR_SUCCESS)
            {
                WARN("Can't read default value from Server subkey.\n");
                hr = CLASS_E_CLASSNOTAVAILABLE;
                goto cleanup;
            }
 
            hr = LoadLibraryShim( filename, L"v4.0.30319", NULL, &module);
            if (FAILED(hr))
            {
                WARN("Can't load %s.\n", debugstr_w(filename));
                goto cleanup;
            }
 
            pDllGetClassObject = (void*)GetProcAddress( module, "DllGetClassObject" );
            if (!pDllGetClassObject)
            {
                WARN("Can't get DllGetClassObject from %s.\n", debugstr_w(filename));
                hr = CLASS_E_CLASSNOTAVAILABLE;
                goto cleanup;
            }
 
            hr = pDllGetClassObject( clsid, &IID_IClassFactory, (void**)&classfactory );
            if (SUCCEEDED(hr))
            {
                hr = IClassFactory_CreateInstance( classfactory, NULL, &IID_IUnknown, ppObj );
 
                IClassFactory_Release( classfactory );
            }
 
            goto cleanup;
        }
 
        dwBufLen = sizeof( classname );
        res = RegGetValueW( key, NULL, L"Class", RRF_RT_REG_SZ, NULL, classname, &dwBufLen);
        if(res != ERROR_SUCCESS)
        {
            WARN("Class value cannot be found.\n");
            hr = CLASS_E_CLASSNOTAVAILABLE;
            goto cleanup;
        }
 
        TRACE("classname (%s)\n", debugstr_w(classname));
 
        dwBufLen = sizeof( codebase );
        res = RegGetValueW( key, NULL, L"CodeBase", RRF_RT_REG_SZ, NULL, codebase, &dwBufLen);
        if(res == ERROR_SUCCESS)
        {
            /* Strip file:/// */
            if(wcsncmp(codebase, wszFileSlash, lstrlenW(wszFileSlash)) == 0)
                offset = lstrlenW(wszFileSlash);
 
            lstrcpyW(filename, codebase + offset);
 
            file = CreateFileW(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
        }
 
        if (file != INVALID_HANDLE_VALUE)
            CloseHandle(file);
        else
        {
            WCHAR assemblyname[MAX_PATH + 8];
 
            hr = CLASS_E_CLASSNOTAVAILABLE;
            WARN("CodeBase value cannot be found, trying Assembly.\n");
            /* get the last subkey of InprocServer32 */
            res = RegQueryInfoKeyW(key, 0, 0, 0, &numKeys, 0, 0, 0, 0, 0, 0, 0);
            if (res != ERROR_SUCCESS)
                goto cleanup;
            if (numKeys > 0)
            {
                numKeys--;
                keyLength = ARRAY_SIZE(subkeyName);
                res = RegEnumKeyExW(key, numKeys, subkeyName, &keyLength, 0, 0, 0, 0);
                if (res != ERROR_SUCCESS)
                    goto cleanup;
                res = RegOpenKeyExW(key, subkeyName, 0, KEY_READ, &subkey);
                if (res != ERROR_SUCCESS)
                    goto cleanup;
                dwBufLen = sizeof( assemblyname );
                res = RegGetValueW(subkey, NULL, L"Assembly", RRF_RT_REG_SZ, NULL, assemblyname, &dwBufLen);
                RegCloseKey(subkey);
                if (res != ERROR_SUCCESS)
                    goto cleanup;
            }
            else
            {
                dwBufLen = sizeof( assemblyname );
                res = RegGetValueW(key, NULL, L"Assembly", RRF_RT_REG_SZ, NULL, assemblyname, &dwBufLen);
                if (res != ERROR_SUCCESS)
                    goto cleanup;
            }
 
            hr = get_file_from_strongname(assemblyname, filename, MAX_PATH);
            if (FAILED(hr))
            {
                /*
                 * The registry doesn't have a CodeBase entry or the file isn't there, and it's not in the GAC.
                 *
                 * Use the Assembly Key to retrieve the filename.
                 *    Assembly : REG_SZ : AssemblyName, Version=X.X.X.X, Culture=neutral, PublicKeyToken=null
                 */
                WCHAR *ns;
 
                WARN("Attempt to load from the application directory.\n");
                GetModuleFileNameW(NULL, filename, MAX_PATH);
                ns = wcsrchr(filename, '\\');
                *(ns+1) = '\0';
 
                ns = wcschr(assemblyname, ',');
                *(ns) = '\0';
                lstrcatW(filename, assemblyname);
                *(ns) = '.';
                lstrcatW(filename, L".dll");
            }
        }
    }
    else
    {
        if (!try_create_registration_free_com(clsid, classname, ARRAY_SIZE(classname), filename, ARRAY_SIZE(filename)))
            return CLASS_E_CLASSNOTAVAILABLE;
 
        TRACE("classname (%s)\n", debugstr_w(classname));
    }
 
    TRACE("filename (%s)\n", debugstr_w(filename));
 
    *ppObj = NULL;
 
 
    hr = get_runtime_info(filename, NULL, NULL, NULL, 0, 0, FALSE, &info);
    if (SUCCEEDED(hr))
    {
        hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host);
 
        if (SUCCEEDED(hr))
            hr = RuntimeHost_GetDefaultDomain(host, NULL, &domain);
 
        if (SUCCEEDED(hr))
        {
            MonoImage *image;
            MonoClass *klass;
            MonoObject *result;
            MonoDomain *prev_domain;
            MonoImageOpenStatus status;
            IUnknown *unk = NULL;
            char *filenameA, *ns;
            char *classA;
 
            hr = CLASS_E_CLASSNOTAVAILABLE;
 
            prev_domain = domain_attach(domain);
 
            filenameA = WtoA(filename);
            assembly = mono_assembly_open(filenameA, &status);
            free(filenameA);
            if (!assembly)
            {
                ERR("Cannot open assembly %s, status=%i\n", debugstr_w(filename), status);
                domain_restore(prev_domain);
                goto cleanup;
            }
 
            image = mono_assembly_get_image(assembly);
            if (!image)
            {
                ERR("Couldn't get assembly image\n");
                domain_restore(prev_domain);
                goto cleanup;
            }
 
            classA = WtoA(classname);
            ns = strrchr(classA, '.');
            *ns = '\0';
 
            klass = mono_class_from_name(image, classA, ns+1);
            free(classA);
            if (!klass)
            {
                ERR("Couldn't get class from image\n");
                domain_restore(prev_domain);
                goto cleanup;
            }
 
            /*
             * Use the default constructor for the .NET class.
             */
            result = mono_object_new(domain, klass);
            mono_runtime_object_init(result);
 
            hr = RuntimeHost_GetIUnknownForObject(host, result, &unk);
            if (SUCCEEDED(hr))
            {
                hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj);
 
                IUnknown_Release(unk);
            }
            else
                hr = CLASS_E_CLASSNOTAVAILABLE;
 
            domain_restore(prev_domain);
        }
        else
            hr = CLASS_E_CLASSNOTAVAILABLE;
    }
    else
        hr = CLASS_E_CLASSNOTAVAILABLE;
 
cleanup:
    if(info)
        ICLRRuntimeInfo_Release(info);
 
    RegCloseKey(key);
 
    return hr;
}

Referenced by DllGetClassObject().

expect_no_runtimes()

void expect_no_runtimes

(

void

)

Definition at line 454 of file metahost.c.

{
    if (mono_handle && is_mono_started && !is_mono_shutdown)
    {
        ERR("Process exited with a Mono runtime loaded.\n");
        return;
    }
}

Referenced by DllMain().

free_parsed_config_file()

void free_parsed_config_file

(

parsed_config_file *

file

)

Definition at line 696 of file config.c.

{
    supported_runtime *cursor, *cursor2;
 
    LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &file->supported_runtimes, supported_runtime, entry)
    {
        free(cursor->version);
        list_remove(&cursor->entry);
        free(cursor);
    }
 
    free(file->private_path);
}

Referenced by _CorExeMain(), and get_runtime_info().

get_file_from_strongname()

HRESULT get_file_from_strongname	(	WCHAR *	stringnameW,
		WCHAR *	assemblies_path,
		int	path_length
	)

Definition at line 1687 of file metahost.c.

{
    HRESULT hr=S_OK;
    IAssemblyCache *asmcache;
    ASSEMBLY_INFO info;
    static const WCHAR fusiondll[] = {'f','u','s','i','o','n',0};
    HMODULE hfusion=NULL;
    static HRESULT (WINAPI *pCreateAssemblyCache)(IAssemblyCache**,DWORD);
 
    if (!pCreateAssemblyCache)
    {
        hr = LoadLibraryShim(fusiondll, NULL, NULL, &hfusion);
 
        if (SUCCEEDED(hr))
        {
            pCreateAssemblyCache = (void*)GetProcAddress(hfusion, "CreateAssemblyCache");
            if (!pCreateAssemblyCache)
                hr = E_FAIL;
        }
    }
 
    if (SUCCEEDED(hr))
        hr = pCreateAssemblyCache(&asmcache, 0);
 
    if (SUCCEEDED(hr))
    {
        info.cbAssemblyInfo = sizeof(info);
        info.pszCurrentAssemblyPathBuf = assemblies_path;
        info.cchBuf = path_length;
        assemblies_path[0] = 0;
 
        hr = IAssemblyCache_QueryAssemblyInfo(asmcache, 0, stringnameW, &info);
 
        IAssemblyCache_Release(asmcache);
    }
 
    return hr;
}

Referenced by create_monodata(), and wine_mono_assembly_preload_hook_v2_fn().

get_mono_path()

BOOL get_mono_path	(	LPWSTR	path,
		BOOL	skip_local
	)

Definition at line 874 of file metahost.c.

{
#ifdef __REACTOS__
    return (!skip_local && get_mono_path_local(path)) ||
        get_mono_path_registry(path) ||
        get_mono_path_datadir(path);
#else
    return (!skip_local && get_mono_path_local(path)) ||
        get_mono_path_registry(path) ||
        get_mono_path_datadir(path) ||
        get_mono_path_unix(INSTALL_DATADIR "/wine/mono", path) ||
        (strcmp(INSTALL_DATADIR, "/usr/share") &&
         get_mono_path_unix("/usr/share/wine/mono", path)) ||
        get_mono_path_unix("/opt/wine/mono", path);
#endif
}

Referenced by CLRRuntimeInfo_GetRuntimeHost(), and install_wine_mono().

get_root_domain()

MonoDomain * get_root_domain

(

void

)

Definition at line 366 of file metahost.c.

{
    static MonoDomain* root_domain;
 
    if (root_domain != NULL)
        return root_domain;
 
    EnterCriticalSection(&runtime_list_cs);
 
    if (root_domain == NULL)
    {
        char *exe_basename;
 
        exe_basename = get_exe_basename_utf8();
 
        root_domain = mono_jit_init_version(exe_basename, "v4.0.30319");
 
        free(exe_basename);
 
        is_mono_started = TRUE;
    }
 
    LeaveCriticalSection(&runtime_list_cs);
 
    return root_domain;
}

Referenced by RuntimeHost_GetDefaultDomain().

get_runtime_info()

HRESULT get_runtime_info	(	LPCWSTR	exefile,
		LPCWSTR	version,
		LPCWSTR	config_file,
		IStream *	config_stream,
		DWORD	startup_flags,
		DWORD	runtimeinfo_flags,
		BOOL	legacy,
		ICLRRuntimeInfo **	result
	)

Definition at line 1904 of file metahost.c.

{
    static const WCHAR dotconfig[] = {'.','c','o','n','f','i','g',0};
    static const DWORD supported_startup_flags = 0;
    static const DWORD supported_runtime_flags = RUNTIME_INFO_UPGRADE_VERSION;
    int i;
    WCHAR local_version[MAX_PATH];
    ULONG local_version_size = MAX_PATH;
    WCHAR local_config_file[MAX_PATH];
    HRESULT hr;
    parsed_config_file parsed_config;
 
    if (startup_flags & ~supported_startup_flags)
        FIXME("unsupported startup flags %lx\n", startup_flags & ~supported_startup_flags);
 
    if (runtimeinfo_flags & ~supported_runtime_flags)
        FIXME("unsupported runtimeinfo flags %lx\n", runtimeinfo_flags & ~supported_runtime_flags);
 
    if (exefile && !exefile[0])
        exefile = NULL;
 
    if (exefile && !config_file && !config_stream)
    {
        lstrcpyW(local_config_file, exefile);
        lstrcatW(local_config_file, dotconfig);
 
        config_file = local_config_file;
    }
 
    if (config_file || config_stream)
    {
        BOOL found = FALSE;
        if (config_file)
            hr = parse_config_file(config_file, &parsed_config);
        else
            hr = parse_config_stream(config_stream, &parsed_config);
 
        if (SUCCEEDED(hr))
        {
            supported_runtime *entry;
            LIST_FOR_EACH_ENTRY(entry, &parsed_config.supported_runtimes, supported_runtime, entry)
            {
                hr = get_runtime(entry->version, TRUE, &IID_ICLRRuntimeInfo, (void**)result);
                if (SUCCEEDED(hr))
                {
                    found = TRUE;
                    break;
                }
            }
        }
        else
        {
            WARN("failed to parse config file %s, hr=%lx\n", debugstr_w(config_file), hr);
        }
 
        free_parsed_config_file(&parsed_config);
 
        if (found)
            return S_OK;
    }
 
    if (exefile && !version)
    {
        DWORD major, minor, build;
 
        hr = CLRMetaHost_GetVersionFromFile(0, exefile, local_version, &local_version_size);
 
        version = local_version;
 
        if (FAILED(hr)) return hr;
 
        /* When running an executable, specifically when getting the version number from
         * the exe, native accepts a matching major.minor with build <= expected build. */
        if (!parse_runtime_version(version, &major, &minor, &build))
        {
            ERR("Cannot parse %s\n", debugstr_w(version));
            return CLR_E_SHIM_RUNTIME;
        }
 
        if (legacy)
            i = 3;
        else
            i = NUM_RUNTIMES;
 
        while (i--)
        {
            if (runtimes[i].major == major && runtimes[i].minor == minor && runtimes[i].build >= build)
            {
                return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface,
                        &IID_ICLRRuntimeInfo, (void **)result);
            }
        }
    }
 
    if (version)
    {
        hr = CLRMetaHost_GetRuntime(0, version, &IID_ICLRRuntimeInfo, (void**)result);
        if(SUCCEEDED(hr))
            return hr;
    }
 
    if (runtimeinfo_flags & RUNTIME_INFO_UPGRADE_VERSION)
    {
        DWORD major, minor, build;
 
        if (version && !parse_runtime_version(version, &major, &minor, &build))
        {
            ERR("Cannot parse %s\n", debugstr_w(version));
            return CLR_E_SHIM_RUNTIME;
        }
 
        if (legacy)
            i = 3;
        else
            i = NUM_RUNTIMES;
 
        while (i--)
        {
            /* Must be greater or equal to the version passed in. */
            if (!version || ((runtimes[i].major >= major && runtimes[i].minor >= minor && runtimes[i].build >= build) ||
                 (runtimes[i].major >= major && runtimes[i].minor > minor) ||
                 (runtimes[i].major > major)))
            {
                return ICLRRuntimeInfo_QueryInterface(&runtimes[i].ICLRRuntimeInfo_iface,
                        &IID_ICLRRuntimeInfo, (void **)result);
            }
        }
 
        return CLR_E_SHIM_RUNTIME;
    }
 
    return CLR_E_SHIM_RUNTIME;
}

Referenced by _CorExeMain(), ClrCreateManagedInstance(), CorBindToCurrentRuntime(), CorBindToRuntimeEx(), CorBindToRuntimeHost(), create_monodata(), GetCORSystemDirectory(), GetCORVersion(), GetRequestedRuntimeInfo(), metahostpolicy_GetRequestedRuntime(), and ReallyFixupVTable().

ICLRRuntimeInfo_GetRuntimeHost()

HRESULT ICLRRuntimeInfo_GetRuntimeHost	(	ICLRRuntimeInfo *	iface,
		RuntimeHost **	result
	)

Definition at line 703 of file metahost.c.

{
    struct CLRRuntimeInfo *This = impl_from_ICLRRuntimeInfo(iface);
 
    assert(This->ICLRRuntimeInfo_iface.lpVtbl == &CLRRuntimeInfoVtbl);
 
    return CLRRuntimeInfo_GetRuntimeHost(This, result);
}

Referenced by _CorExeMain(), ClrCreateManagedInstance(), create_monodata(), and ReallyFixupVTable().

int()

int

(

CDECL *

mono_jit_exec

)

MetaDataDispenser_CreateInstance()

HRESULT MetaDataDispenser_CreateInstance

(

IUnknown **

ppUnk

)

Definition at line 189 of file metadata.c.

{
    MetaDataDispenser *This;
 
    This = malloc(sizeof(MetaDataDispenser));
 
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IMetaDataDispenserEx_iface.lpVtbl = &MetaDataDispenserVtbl;
    This->ref = 1;
 
    *ppUnk = (IUnknown*)&This->IMetaDataDispenserEx_iface;
 
    return S_OK;
}

Referenced by RuntimeHost_GetInterface().

mono_assembly_get_image()

MonoImage *CDECL * mono_assembly_get_image

(

MonoAssembly *

assembly

)

mono_assembly_load_from()

MonoAssembly *CDECL * mono_assembly_load_from	(	MonoImage *	image,
		const char *	fname,
		MonoImageOpenStatus *	status
	)

mono_assembly_name_get_name()

const char *CDECL * mono_assembly_name_get_name

(

MonoAssemblyName *

aname

)

mono_assembly_open()

MonoAssembly *CDECL * mono_assembly_open	(	const char *	filename,
		MonoImageOpenStatus *	status
	)

mono_class_from_mono_type()

MonoClass *CDECL * mono_class_from_mono_type

(

MonoType *

type

)

mono_class_from_name()

MonoClass *CDECL * mono_class_from_name	(	MonoImage *	image,
		const char *	name_space,
		const char *	name
	)

mono_class_get_method_from_name()

MonoMethod *CDECL * mono_class_get_method_from_name	(	MonoClass *	klass,
		const char *	name,
		int	param_count
	)

mono_domain_get()

MonoDomain *CDECL * mono_domain_get

(

void

)

mono_domain_get_by_id()

MonoDomain *CDECL * mono_domain_get_by_id

(

int

id

)

mono_get_corlib()

MonoImage *CDECL * mono_get_corlib

(

void

)

mono_image_open_from_module_handle()

MonoImage *CDECL * mono_image_open_from_module_handle	(	HMODULE	module_handle,
		char *	fname,
		UINT	has_entry_point,
		MonoImageOpenStatus *	status
	)

mono_jit_init_version()

MonoDomain *CDECL * mono_jit_init_version	(	const char *	domain_name,
		const char *	runtime_version
	)

mono_log_handler_fn()

void CDECL mono_log_handler_fn	(	const char *	log_domain,
		const char *	log_level,
		const char *	message,
		INT	fatal,
		void *	user_data
	)

Definition at line 265 of file mscoree_main.c.

{
    SIZE_T len = (log_domain ? strlen(log_domain) + 2 : 0) + strlen(message) + strlen("\n") + 1;
    char *msg = calloc(len, sizeof(char));
 
    if (msg)
    {
        sprintf(msg, "%s%s%s\n", log_domain ? log_domain : "", log_domain ? ": " : "", message);
        mono_print_handler_fn(msg, 0);
    }
 
    free(msg);
}

Referenced by load_mono().

mono_marshal_get_vtfixup_ftnptr()

void *CDECL * mono_marshal_get_vtfixup_ftnptr	(	MonoImage *	image,
		DWORD	token,
		WORD	type
	)

mono_object_get_domain()

MonoDomain *CDECL * mono_object_get_domain

(

MonoObject *

obj

)

mono_object_get_virtual_method()

MonoMethod *CDECL * mono_object_get_virtual_method	(	MonoObject *	obj,
		MonoMethod *	method
	)

mono_object_new()

MonoObject *CDECL * mono_object_new	(	MonoDomain *	domain,
		MonoClass *	klass
	)

mono_object_unbox()

void *CDECL * mono_object_unbox

(

MonoObject *

obj

)

mono_print_handler_fn()

void CDECL mono_print_handler_fn	(	const char *	string,
		INT	is_stdout
	)

Definition at line 225 of file mscoree_main.c.

{
    struct print_handler_tls *tls = TlsGetValue(print_tls_index);
 
    if (!tls)
    {
        tls = malloc(sizeof(*tls));
        tls->length = 0;
        TlsSetValue(print_tls_index, tls);
    }
 
    while (*string)
    {
        int remaining_buffer = sizeof(tls->buffer) - tls->length;
        int length = strlen(string);
        const char *newline = memchr(string, '\n', min(length, remaining_buffer));
 
        if (newline)
        {
            length = newline - string + 1;
            wine_dbg_printf("%.*s%.*s", tls->length, tls->buffer, length, string);
            tls->length = 0;
            string += length;
        }
        else if (length > remaining_buffer)
        {
            /* this would overflow Wine's debug buffer */
            wine_dbg_printf("%.*s%.*s\n", tls->length, tls->buffer, remaining_buffer, string);
            tls->length = 0;
            string += remaining_buffer;
        }
        else
        {
            memcpy(tls->buffer + tls->length, string, length);
            tls->length += length;
            break;
        }
    }
}

Referenced by load_mono(), and mono_log_handler_fn().

mono_reflection_type_from_name()

MonoType *CDECL * mono_reflection_type_from_name	(	char *	name,
		MonoImage *	image
	)

mono_runtime_invoke()

MonoObject *CDECL * mono_runtime_invoke	(	MonoMethod *	method,
		void *	obj,
		void **	params,
		MonoObject **	exc
	)

mono_string_new()

MonoString *CDECL * mono_string_new	(	MonoDomain *	domain,
		const char *	str
	)

mono_thread_attach()

MonoThread *CDECL * mono_thread_attach

(

MonoDomain *

domain

)

parse_config_file()

HRESULT parse_config_file	(	LPCWSTR	filename,
		parsed_config_file *	result
	)

Definition at line 678 of file config.c.

{
    HRESULT hr;
    IStream *stream;
 
    init_config(result);
 
    hr = CreateConfigStream(filename, &stream);
    if (FAILED(hr))
        return hr;
 
    hr = parse_config_stream(stream, result);
 
    IStream_Release(stream);
 
    return hr;
}

Referenced by _CorExeMain(), and get_runtime_info().

parse_config_stream()

HRESULT parse_config_stream	(	IStream *	stream,
		parsed_config_file *	result
	)

Definition at line 658 of file config.c.

{
    VARIANT var;
    HRESULT hr;
    HRESULT initresult;
 
    init_config(result);
 
    initresult = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
    V_VT(&var) = VT_UNKNOWN;
    V_UNKNOWN(&var) = (IUnknown*)stream;
 
    hr = parse_config(var, result);
 
    if (SUCCEEDED(initresult))
        CoUninitialize();
 
    return hr;
}

Referenced by get_runtime_info(), and parse_config_file().

RuntimeHost_Construct()

HRESULT RuntimeHost_Construct	(	CLRRuntimeInfo *	runtime_version,
		RuntimeHost **	result
	)

Definition at line 1596 of file corruntimehost.c.

{
    RuntimeHost *This;
 
    This = malloc(sizeof *This);
    if ( !This )
        return E_OUTOFMEMORY;
 
    This->ICorRuntimeHost_iface.lpVtbl = &corruntimehost_vtbl;
    This->ICLRRuntimeHost_iface.lpVtbl = &CLRHostVtbl;
 
    This->ref = 1;
    This->version = runtime_version;
    InitializeCriticalSectionEx(&This->lock, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RuntimeHost.lock");
 
    *result = This;
 
    return S_OK;
}

Referenced by CLRRuntimeInfo_GetRuntimeHost().

RuntimeHost_CreateManagedInstance()

HRESULT RuntimeHost_CreateManagedInstance	(	RuntimeHost *	This,
		LPCWSTR	name,
		MonoDomain *	domain,
		MonoObject **	result
	)

Definition at line 976 of file corruntimehost.c.

{
    HRESULT hr=S_OK;
    char *nameA=NULL;
    MonoType *type;
    MonoClass *klass;
    MonoObject *obj;
    MonoDomain *prev_domain;
 
    if (!domain)
        hr = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
 
    if (FAILED(hr))
        return hr;
 
    prev_domain = domain_attach(domain);
 
    if (SUCCEEDED(hr))
    {
        nameA = WtoA(name);
        if (!nameA)
            hr = E_OUTOFMEMORY;
    }
 
    if (SUCCEEDED(hr))
    {
        type = mono_reflection_type_from_name(nameA, NULL);
        if (!type)
        {
            ERR("Cannot find type %s\n", debugstr_w(name));
            hr = E_FAIL;
        }
    }
 
    if (SUCCEEDED(hr))
    {
        klass = mono_class_from_mono_type(type);
        if (!klass)
        {
            ERR("Cannot convert type %s to a class\n", debugstr_w(name));
            hr = E_FAIL;
        }
    }
 
    if (SUCCEEDED(hr))
    {
        obj = mono_object_new(domain, klass);
        if (!obj)
        {
            ERR("Cannot allocate object of type %s\n", debugstr_w(name));
            hr = E_FAIL;
        }
    }
 
    if (SUCCEEDED(hr))
    {
        /* FIXME: Detect exceptions from the constructor? */
        mono_runtime_object_init(obj);
        *result = obj;
    }
 
    domain_restore(prev_domain);
 
    free(nameA);
 
    return hr;
}

Referenced by ClrCreateManagedInstance(), and corruntimehost_CreateDomainSetup().

RuntimeHost_ExitProcess()

void RuntimeHost_ExitProcess	(	RuntimeHost *	This,
		INT	exitcode
	)

Definition at line 474 of file corruntimehost.c.

{
    HRESULT hr;
    void *args[2];
    MonoDomain *domain;
    MonoObject *dummy;
 
    hr = RuntimeHost_GetDefaultDomain(This, NULL, &domain);
    if (FAILED(hr))
    {
        ERR("Cannot get domain, hr=%lx\n", hr);
        return;
    }
 
    args[0] = &exitcode;
    args[1] = NULL;
    RuntimeHost_Invoke(This, domain, NULL, "System", "Environment", "Exit",
        NULL, args, 1, &dummy);
 
    ERR("Process should have exited\n");
}

Referenced by CLRMetaHost_ExitProcess().

RuntimeHost_GetInterface()

HRESULT RuntimeHost_GetInterface	(	RuntimeHost *	This,
		REFCLSID	clsid,
		REFIID	riid,
		void **	ppv
	)

Definition at line 1617 of file corruntimehost.c.

{
    IUnknown *unk;
    HRESULT hr;
 
    if (IsEqualGUID(clsid, &CLSID_CorRuntimeHost))
    {
        unk = (IUnknown*)&This->ICorRuntimeHost_iface;
        IUnknown_AddRef(unk);
    }
    else if (IsEqualGUID(clsid, &CLSID_CLRRuntimeHost))
    {
        unk = (IUnknown*)&This->ICLRRuntimeHost_iface;
        IUnknown_AddRef(unk);
    }
    else if (IsEqualGUID(clsid, &CLSID_CorMetaDataDispenser) ||
             IsEqualGUID(clsid, &CLSID_CorMetaDataDispenserRuntime))
    {
        hr = MetaDataDispenser_CreateInstance(&unk);
        if (FAILED(hr))
            return hr;
    }
    else if (IsEqualGUID(clsid, &CLSID_CLRDebuggingLegacy))
    {
        hr = CorDebug_Create(&This->ICLRRuntimeHost_iface, &unk);
        if (FAILED(hr))
            return hr;
    }
    else
        unk = NULL;
 
    if (unk)
    {
        hr = IUnknown_QueryInterface(unk, riid, ppv);
 
        IUnknown_Release(unk);
 
        return hr;
    }
    else
        FIXME("not implemented for class %s\n", debugstr_guid(clsid));
 
    return CLASS_E_CLASSNOTAVAILABLE;
}

Referenced by CLRRuntimeInfo_GetInterface().

RuntimeHost_GetIUnknownForObject()

HRESULT RuntimeHost_GetIUnknownForObject	(	RuntimeHost *	This,
		MonoObject *	obj,
		IUnknown **	ppUnk
	)

Definition at line 1053 of file corruntimehost.c.

{
    MonoDomain *domain;
    MonoObject *result;
    HRESULT hr;
 
    domain = mono_object_get_domain(obj);
 
    hr = RuntimeHost_Invoke(This, domain, NULL, "System.Runtime.InteropServices", "Marshal", "GetIUnknownForObject",
        NULL, (void**)&obj, 1, &result);
 
    if (SUCCEEDED(hr))
        *ppUnk = *(IUnknown**)mono_object_unbox(result);
    else
        *ppUnk = NULL;
 
    return hr;
}

Referenced by ClrCreateManagedInstance(), corruntimehost_CreateDomainSetup(), create_monodata(), and RuntimeHost_GetIUnknownForDomain().

runtimehost_init()

void runtimehost_init

(

void

)

Definition at line 1577 of file corruntimehost.c.

{
    dll_fixup_heap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0);
    list_init(&dll_fixups);
}

Referenced by DllMain().

runtimehost_uninit()

void runtimehost_uninit

(

void

)

Definition at line 1584 of file corruntimehost.c.

{
    struct dll_fixup *fixup, *fixup2;
 
    HeapDestroy(dll_fixup_heap);
    LIST_FOR_EACH_ENTRY_SAFE(fixup, fixup2, &dll_fixups, struct dll_fixup, entry)
    {
        free(fixup->tokens);
        free(fixup);
    }
}

Referenced by DllMain().

void()

void

(

CDECL *

mono_callspec_set_assembly

)

WtoA()

char * WtoA

(

const WCHAR *

wstr

)

Variable Documentation

argc

MonoAssembly int argc

Definition at line 185 of file mscoree_private.h.

argv

MonoAssembly int char* argv[]

Definition at line 185 of file mscoree_private.h.

assembly

MonoAssembly* assembly

Definition at line 185 of file mscoree_private.h.

base_dir

const char* base_dir

Definition at line 183 of file mscoree_private.h.

config_file_name

const char const char* config_file_name

Definition at line 183 of file mscoree_private.h.

force

BOOL force

Definition at line 182 of file mscoree_private.h.

is_mono_started

BOOL is_mono_started

extern

Definition at line 80 of file metahost.c.

Referenced by CLRMetaHost_ExitProcess(), corruntimehost_CreateDomainEx(), expect_no_runtimes(), and get_root_domain().

private_path

WCHAR** private_path

extern

Definition at line 70 of file corruntimehost.c.

Referenced by _CorExeMain(), and wine_mono_assembly_preload_hook_v2_fn().