src/common/dynlib.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dynlib.cpp
// Purpose:     Dynamic library management
// Author:      Guilhem Lavaux
// Modified by:
// Created:     20/07/98
// RCS-ID:      $Id$
// Copyright:   (c) Guilhem Lavaux
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#ifdef __GNUG__
#   pragma implementation "dynlib.h"
#endif

#include  "wx/wxprec.h"

#ifdef __BORLANDC__
  #pragma hdrstop
#endif

#if wxUSE_DYNLIB_CLASS && !wxUSE_DYNAMIC_LOADER

#if defined(__WINDOWS__)
    #include "wx/msw/private.h"
#endif

#include "wx/dynlib.h"
#include "wx/filefn.h"
#include "wx/intl.h"
#include "wx/log.h"

#if defined(__WXMAC__)
    #include "wx/mac/private.h"
#endif

// ----------------------------------------------------------------------------
// conditional compilation
// ----------------------------------------------------------------------------

#if defined(__WXPM__) || defined(__EMX__)
#  define INCL_DOS
#  include <os2.h>
#  define wxDllOpen(error, lib, handle)     DosLoadModule(error, sizeof(error), lib, &handle)
#  define wxDllGetSymbol(handle, modaddr)   DosQueryProcAddr(handle, 1L, NULL, (PFN*)modaddr)
#  define wxDllClose(handle)                DosFreeModule(handle)
#elif defined(HAVE_DLOPEN)
    // note about dlopen() flags: we use RTLD_NOW to have more Windows-like
    // behaviour (Win won't let you load a library with missing symbols) and
    // RTLD_GLOBAL because it is needed sometimes and probably doesn't hurt
    // otherwise. On True64-Unix RTLD_GLOBAL is not allowed and on VMS the
    // second argument on dlopen is ignored.
#ifdef __VMS
# define wxDllOpen(lib)                dlopen(lib.fn_str(), 0 )
#elif defined( __osf__ )
# define wxDllOpen(lib)                dlopen(lib.fn_str(), RTLD_LAZY )
#else
# define wxDllOpen(lib)                dlopen(lib.fn_str(), RTLD_LAZY | RTLD_GLOBAL)
#endif
#define wxDllGetSymbol(handle, name)  dlsym(handle, name)
#   define wxDllClose                    dlclose
#elif defined(HAVE_SHL_LOAD)
#   define wxDllOpen(lib)                shl_load(lib.fn_str(), BIND_DEFERRED, 0)
#   define wxDllClose                    shl_unload

static inline void *wxDllGetSymbol(shl_t handle, const wxString& name)
{
    void *sym;
    if ( shl_findsym(&handle, name.mb_str(), TYPE_UNDEFINED, &sym) == 0 )
        return sym;
    else
        return 0;
}

#elif defined(__DARWIN__)
/* Porting notes:
 *   The dlopen port is a port from dl_next.xs by Anno Siegel.
 *   dl_next.xs is itself a port from dl_dlopen.xs by Paul Marquess.
 *   The method used here is just to supply the sun style dlopen etc.
 *   functions in terms of Darwin NS*.
 */
void *dlopen(const char *path, int mode /* mode is ignored */);
void *dlsym(void *handle, const char *symbol);
int   dlclose(void *handle);
const char *dlerror(void);

#   define wxDllOpen(lib)                dlopen(lib.fn_str(), 0)
#   define wxDllGetSymbol(handle, name)  dlsym(handle, name)
#   define wxDllClose                    dlclose
#elif defined(__WINDOWS__)
    // using LoadLibraryEx under Win32 to avoid name clash with LoadLibrary
#   ifdef __WIN32__
#ifdef _UNICODE
#      define wxDllOpen(lib)                  ::LoadLibraryExW(lib, 0, 0)
#else
#      define wxDllOpen(lib)                  ::LoadLibraryExA(lib, 0, 0)
#endif
#   else   // Win16
#      define wxDllOpen(lib)                  ::LoadLibrary(lib)
#   endif  // Win32/16
#   define wxDllGetSymbol(handle, name)    ::GetProcAddress(handle, name)
#   define wxDllClose                      ::FreeLibrary
#elif defined(__WXMAC__)
#   define wxDllClose(handle)               CloseConnection(&((CFragConnectionID)handle))
#else
#   error "Don't know how to load shared libraries on this platform."
#endif // OS

// ---------------------------------------------------------------------------
// Global variables
// ---------------------------------------------------------------------------

wxLibraries wxTheLibraries;

// ============================================================================
// implementation
// ============================================================================

// construct the full name from the base shared object name: adds a .dll
// suffix under Windows or .so under Unix
static wxString ConstructLibraryName(const wxString& basename)
{
    wxString fullname;
    fullname << basename << wxDllLoader::GetDllExt();

    return fullname;
}

// ---------------------------------------------------------------------------
// wxLibrary (one instance per dynamic library)
// ---------------------------------------------------------------------------

wxLibrary::wxLibrary(wxDllType handle)
{
    typedef wxClassInfo *(*t_get_first)(void);
    t_get_first get_first;

    m_handle = handle;

    // Some system may use a local heap for library.
    get_first = (t_get_first)GetSymbol("wxGetClassFirst");
    // It is a wxWindows DLL.
    if (get_first)
        PrepareClasses(get_first());
}

wxLibrary::~wxLibrary()
{
    if ( m_handle )
    {
        wxDllClose(m_handle);
    }
}

wxObject *wxLibrary::CreateObject(const wxString& name)
{
    wxClassInfo *info = (wxClassInfo *)classTable.Get(name);

    if (!info)
        return NULL;

    return info->CreateObject();
}

void wxLibrary::PrepareClasses(wxClassInfo *first)
{
    // Index all class infos by their class name
    wxClassInfo *info = first;
    while (info)
    {
        if (info->m_className)
            classTable.Put(info->m_className, (wxObject *)info);
        info = info->m_next;
    }

    // Set base pointers for each wxClassInfo
    info = first;
    while (info)
    {
        if (info->GetBaseClassName1())
            info->m_baseInfo1 = (wxClassInfo *)classTable.Get(info->GetBaseClassName1());
        if (info->GetBaseClassName2())
            info->m_baseInfo2 = (wxClassInfo *)classTable.Get(info->GetBaseClassName2());
        info = info->m_next;
    }
}

void *wxLibrary::GetSymbol(const wxString& symbname)
{
   return wxDllLoader::GetSymbol(m_handle, symbname);
}

// ---------------------------------------------------------------------------
// wxDllLoader
// ---------------------------------------------------------------------------


#if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
const wxString wxDllLoader::ms_dllext( _T(".dll") );
#elif defined(__UNIX__)
#if defined(__HPUX__)
const wxString wxDllLoader::ms_dllext( _T(".sl") );
#else
const wxString wxDllLoader::ms_dllext( _T(".so") );
#endif
#endif

/* static */
wxDllType wxDllLoader::GetProgramHandle()
{
#if defined( HAVE_DLOPEN ) && !defined(__EMX__)
   // optain handle for main program
   return dlopen(NULL, RTLD_NOW/*RTLD_LAZY*/);
#elif defined (HAVE_SHL_LOAD)
   // shl_findsymbol with NULL handle looks up in main program
   return 0;
#else
   wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2"));
   return 0;
#endif
}

/* static */
wxDllType wxDllLoader::LoadLibrary(const wxString & libname, bool *success)
{
    wxDllType   handle;
    bool        failed = FALSE;

#if defined(__WXMAC__) && !defined(__UNIX__)
    FSSpec      myFSSpec;
    Ptr         myMainAddr;
    Str255      myErrName;

    wxMacFilename2FSSpec( libname , &myFSSpec );

    if( GetDiskFragment( &myFSSpec,
                         0,
                         kCFragGoesToEOF,
                         "\p",
                         kPrivateCFragCopy,
                         &((CFragConnectionID)handle),
                         &myMainAddr,
                         myErrName ) != noErr )
    {
        p2cstr( myErrName );
        wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
                       libname.c_str(),
                       (char*)myErrName );
        handle = 0;
        failed = TRUE;
    }

#elif defined(__WXPM__) || defined(__EMX__)
    char        zError[256] = "";
    wxDllOpen(zError, libname, handle);

#else
    handle = wxDllOpen(libname);

#endif

    if ( !handle )
    {
        wxString msg(_("Failed to load shared library '%s'"));

#ifdef HAVE_DLERROR
        const wxChar *err = dlerror();
        if( err )
        {
            failed = TRUE;
            wxLogError( msg, err );
        }
#else
        failed = TRUE;
        wxLogSysError( msg, libname.c_str() );
#endif
    }

    if ( success )
        *success = !failed;

    return handle;
}


/* static */
void wxDllLoader::UnloadLibrary(wxDllType handle)
{
   wxDllClose(handle);
}

/* static */
void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
{
    bool    failed = FALSE;
    void    *symbol = 0;

#if defined(__WXMAC__) && !defined(__UNIX__)
    Ptr                 symAddress;
    CFragSymbolClass    symClass;
    Str255              symName;

#if TARGET_CARBON
    c2pstrcpy( (StringPtr) symName, name );
#else
    strcpy( (char *) symName, name );
    c2pstr( (char *) symName );
#endif
    if( FindSymbol( ((CFragConnectionID)dllHandle), symName, &symAddress, &symClass ) == noErr )
        symbol = (void *)symAddress;

#elif defined(__WXPM__) || defined(__EMX__)
    wxDllGetSymbol(dllHandle, symbol);

#else
    // mb_str() is necessary in Unicode build
    symbol = wxDllGetSymbol(dllHandle, name.mb_str());

#endif

    if ( !symbol )
    {
        wxString msg(_("wxDllLoader failed to GetSymbol '%s'"));

#ifdef HAVE_DLERROR
        const wxChar *err = dlerror();
        if( err )
        {
            failed = TRUE;
            wxLogError( msg, err );
        }
#else
        failed = TRUE;
        wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"),
                      name.c_str());
#endif
    }

    if( success )
        *success = !failed;

    return symbol;
}

// ---------------------------------------------------------------------------
// wxLibraries (only one instance should normally exist)
// ---------------------------------------------------------------------------

wxLibraries::wxLibraries():m_loaded(wxKEY_STRING)
{
}

wxLibraries::~wxLibraries()
{
    wxNode *node = m_loaded.First();

    while (node) {
        wxLibrary *lib = (wxLibrary *)node->Data();
        delete lib;

        node = node->Next();
    }
}

wxLibrary *wxLibraries::LoadLibrary(const wxString& name)
{
    wxLibrary   *lib;
    wxClassInfo *old_sm_first;
    wxNode      *node = m_loaded.Find(name.GetData());

    if (node != NULL)
        return ((wxLibrary *)node->Data());

    // If DLL shares data, this is necessary.
    old_sm_first = wxClassInfo::sm_first;
    wxClassInfo::sm_first = NULL;

    wxString libname = ConstructLibraryName(name);

    bool success = FALSE;
    wxDllType handle = wxDllLoader::LoadLibrary(libname, &success);
    if(success)
    {
       lib = new wxLibrary(handle);
       wxClassInfo::sm_first = old_sm_first;

       m_loaded.Append(name.GetData(), lib);
    }
    else
       lib = NULL;
    return lib;
}

wxObject *wxLibraries::CreateObject(const wxString& path)
{
    wxNode *node = m_loaded.First();
    wxObject *obj;

    while (node) {
        obj = ((wxLibrary *)node->Data())->CreateObject(path);
        if (obj)
            return obj;

        node = node->Next();
    }
    return NULL;
}

#ifdef __DARWIN__
// ---------------------------------------------------------------------------
// For Darwin/Mac OS X
//   supply the sun style dlopen functions in terms of Darwin NS*
// ---------------------------------------------------------------------------

extern "C" {
#import <mach-o/dyld.h>
};

enum dyldErrorSource
{
    OFImage,
};

static char dl_last_error[1024];

static
void TranslateError(const char *path, enum dyldErrorSource type, int number)
{
    unsigned int index;
    static char *OFIErrorStrings[] =
    {
	"%s(%d): Object Image Load Failure\n",
	"%s(%d): Object Image Load Success\n",
	"%s(%d): Not an recognisable object file\n",
	"%s(%d): No valid architecture\n",
	"%s(%d): Object image has an invalid format\n",
	"%s(%d): Invalid access (permissions?)\n",
	"%s(%d): Unknown error code from NSCreateObjectFileImageFromFile\n",
    };
#define NUM_OFI_ERRORS (sizeof(OFIErrorStrings) / sizeof(OFIErrorStrings[0]))

    switch (type)
    {
     case OFImage:
	 index = number;
	 if (index > NUM_OFI_ERRORS - 1) {
	     index = NUM_OFI_ERRORS - 1;
	 }
	 sprintf(dl_last_error, OFIErrorStrings[index], path, number);
	 break;

     default:
	 sprintf(dl_last_error, "%s(%d): Totally unknown error type %d\n",
		 path, number, type);
	 break;
    }
}

const char *dlerror()
{
    return dl_last_error;
}

void *dlopen(const char *path, int mode /* mode is ignored */)
{
    int dyld_result;
    NSObjectFileImage ofile;
    NSModule handle = NULL;

    dyld_result = NSCreateObjectFileImageFromFile(path, &ofile);
    if (dyld_result != NSObjectFileImageSuccess)
    {
	TranslateError(path, OFImage, dyld_result);
    }
    else
    {
	// NSLinkModule will cause the run to abort on any link error's
	// not very friendly but the error recovery functionality is limited.
	handle = NSLinkModule(ofile, path, TRUE);
    }

    return handle;
}

int dlclose(void *handle) /* stub only */
{
    return 0;
}

void *dlsym(void *handle, const char *symbol)
{
    void *addr;

    if (NSIsSymbolNameDefined(symbol)) {
	addr = NSAddressOfSymbol(NSLookupAndBindSymbol(symbol));
    }
    else {
	addr = NULL;
    }
    return addr;
}

#endif // __DARWIN__

#endif // wxUSE_DYNLIB_CLASS
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: dynlib.cpp
	3	// Purpose: Dynamic library management
	4	// Author: Guilhem Lavaux
	5	// Modified by:
	6	// Created: 20/07/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Guilhem Lavaux
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	# pragma implementation "dynlib.h"
	22	#endif
	23
	24	#include "wx/wxprec.h"
	25
	26	#ifdef __BORLANDC__
	27	#pragma hdrstop
	28	#endif
	29
	30	#if wxUSE_DYNLIB_CLASS && !wxUSE_DYNAMIC_LOADER
	31
	32	#if defined(__WINDOWS__)
	33	#include "wx/msw/private.h"
	34	#endif
	35
	36	#include "wx/dynlib.h"
	37	#include "wx/filefn.h"
	38	#include "wx/intl.h"
	39	#include "wx/log.h"
	40
	41	#if defined(__WXMAC__)
	42	#include "wx/mac/private.h"
	43	#endif
	44
	45	// ----------------------------------------------------------------------------
	46	// conditional compilation
	47	// ----------------------------------------------------------------------------
	48
	49	#if defined(__WXPM__) \|\| defined(__EMX__)
	50	# define INCL_DOS
	51	# include <os2.h>
	52	# define wxDllOpen(error, lib, handle) DosLoadModule(error, sizeof(error), lib, &handle)
	53	# define wxDllGetSymbol(handle, modaddr) DosQueryProcAddr(handle, 1L, NULL, (PFN*)modaddr)
	54	# define wxDllClose(handle) DosFreeModule(handle)
	55	#elif defined(HAVE_DLOPEN)
	56	// note about dlopen() flags: we use RTLD_NOW to have more Windows-like
	57	// behaviour (Win won't let you load a library with missing symbols) and
	58	// RTLD_GLOBAL because it is needed sometimes and probably doesn't hurt
	59	// otherwise. On True64-Unix RTLD_GLOBAL is not allowed and on VMS the
	60	// second argument on dlopen is ignored.
	61	#ifdef __VMS
	62	# define wxDllOpen(lib) dlopen(lib.fn_str(), 0 )
	63	#elif defined( __osf__ )
	64	# define wxDllOpen(lib) dlopen(lib.fn_str(), RTLD_LAZY )
	65	#else
	66	# define wxDllOpen(lib) dlopen(lib.fn_str(), RTLD_LAZY \| RTLD_GLOBAL)
	67	#endif
	68	#define wxDllGetSymbol(handle, name) dlsym(handle, name)
	69	# define wxDllClose dlclose
	70	#elif defined(HAVE_SHL_LOAD)
	71	# define wxDllOpen(lib) shl_load(lib.fn_str(), BIND_DEFERRED, 0)
	72	# define wxDllClose shl_unload
	73
	74	static inline void *wxDllGetSymbol(shl_t handle, const wxString& name)
	75	{
	76	void *sym;
	77	if ( shl_findsym(&handle, name.mb_str(), TYPE_UNDEFINED, &sym) == 0 )
	78	return sym;
	79	else
	80	return 0;
	81	}
	82
	83	#elif defined(__DARWIN__)
	84	/* Porting notes:
	85	* The dlopen port is a port from dl_next.xs by Anno Siegel.
	86	* dl_next.xs is itself a port from dl_dlopen.xs by Paul Marquess.
	87	* The method used here is just to supply the sun style dlopen etc.
	88	* functions in terms of Darwin NS*.
	89	*/
	90	void dlopen(const char path, int mode /* mode is ignored */);
	91	void dlsym(void handle, const char *symbol);
	92	int dlclose(void *handle);
	93	const char *dlerror(void);
	94
	95	# define wxDllOpen(lib) dlopen(lib.fn_str(), 0)
	96	# define wxDllGetSymbol(handle, name) dlsym(handle, name)
	97	# define wxDllClose dlclose
	98	#elif defined(__WINDOWS__)
	99	// using LoadLibraryEx under Win32 to avoid name clash with LoadLibrary
	100	# ifdef __WIN32__
	101	#ifdef _UNICODE
	102	# define wxDllOpen(lib) ::LoadLibraryExW(lib, 0, 0)
	103	#else
	104	# define wxDllOpen(lib) ::LoadLibraryExA(lib, 0, 0)
	105	#endif
	106	# else // Win16
	107	# define wxDllOpen(lib) ::LoadLibrary(lib)
	108	# endif // Win32/16
	109	# define wxDllGetSymbol(handle, name) ::GetProcAddress(handle, name)
	110	# define wxDllClose ::FreeLibrary
	111	#elif defined(__WXMAC__)
	112	# define wxDllClose(handle) CloseConnection(&((CFragConnectionID)handle))
	113	#else
	114	# error "Don't know how to load shared libraries on this platform."
	115	#endif // OS
	116
	117	// ---------------------------------------------------------------------------
	118	// Global variables
	119	// ---------------------------------------------------------------------------
	120
	121	wxLibraries wxTheLibraries;
	122
	123	// ============================================================================
	124	// implementation
	125	// ============================================================================
	126
	127	// construct the full name from the base shared object name: adds a .dll
	128	// suffix under Windows or .so under Unix
	129	static wxString ConstructLibraryName(const wxString& basename)
	130	{
	131	wxString fullname;
	132	fullname << basename << wxDllLoader::GetDllExt();
	133
	134	return fullname;
	135	}
	136
	137	// ---------------------------------------------------------------------------
	138	// wxLibrary (one instance per dynamic library)
	139	// ---------------------------------------------------------------------------
	140
	141	wxLibrary::wxLibrary(wxDllType handle)
	142	{
	143	typedef wxClassInfo (t_get_first)(void);
	144	t_get_first get_first;
	145
	146	m_handle = handle;
	147
	148	// Some system may use a local heap for library.
	149	get_first = (t_get_first)GetSymbol("wxGetClassFirst");
	150	// It is a wxWindows DLL.
	151	if (get_first)
	152	PrepareClasses(get_first());
	153	}
	154
	155	wxLibrary::~wxLibrary()
	156	{
	157	if ( m_handle )
	158	{
	159	wxDllClose(m_handle);
	160	}
	161	}
	162
	163	wxObject *wxLibrary::CreateObject(const wxString& name)
	164	{
	165	wxClassInfo info = (wxClassInfo )classTable.Get(name);
	166
	167	if (!info)
	168	return NULL;
	169
	170	return info->CreateObject();
	171	}
	172
	173	void wxLibrary::PrepareClasses(wxClassInfo *first)
	174	{
	175	// Index all class infos by their class name
	176	wxClassInfo *info = first;
	177	while (info)
	178	{
	179	if (info->m_className)
	180	classTable.Put(info->m_className, (wxObject *)info);
	181	info = info->m_next;
	182	}
	183
	184	// Set base pointers for each wxClassInfo
	185	info = first;
	186	while (info)
	187	{
	188	if (info->GetBaseClassName1())
	189	info->m_baseInfo1 = (wxClassInfo *)classTable.Get(info->GetBaseClassName1());
	190	if (info->GetBaseClassName2())
	191	info->m_baseInfo2 = (wxClassInfo *)classTable.Get(info->GetBaseClassName2());
	192	info = info->m_next;
	193	}
	194	}
	195
	196	void *wxLibrary::GetSymbol(const wxString& symbname)
	197	{
	198	return wxDllLoader::GetSymbol(m_handle, symbname);
	199	}
	200
	201	// ---------------------------------------------------------------------------
	202	// wxDllLoader
	203	// ---------------------------------------------------------------------------
	204
	205
	206	#if defined(__WINDOWS__) \|\| defined(__WXPM__) \|\| defined(__EMX__)
	207	const wxString wxDllLoader::ms_dllext( _T(".dll") );
	208	#elif defined(__UNIX__)
	209	#if defined(__HPUX__)
	210	const wxString wxDllLoader::ms_dllext( _T(".sl") );
	211	#else
	212	const wxString wxDllLoader::ms_dllext( _T(".so") );
	213	#endif
	214	#endif
	215
	216	/* static */
	217	wxDllType wxDllLoader::GetProgramHandle()
	218	{
	219	#if defined( HAVE_DLOPEN ) && !defined(__EMX__)
	220	// optain handle for main program
	221	return dlopen(NULL, RTLD_NOW/RTLD_LAZY/);
	222	#elif defined (HAVE_SHL_LOAD)
	223	// shl_findsymbol with NULL handle looks up in main program
	224	return 0;
	225	#else
	226	wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2"));
	227	return 0;
	228	#endif
	229	}
	230
	231	/* static */
	232	wxDllType wxDllLoader::LoadLibrary(const wxString & libname, bool *success)
	233	{
	234	wxDllType handle;
	235	bool failed = FALSE;
	236
	237	#if defined(__WXMAC__) && !defined(__UNIX__)
	238	FSSpec myFSSpec;
	239	Ptr myMainAddr;
	240	Str255 myErrName;
	241
	242	wxMacFilename2FSSpec( libname , &myFSSpec );
	243
	244	if( GetDiskFragment( &myFSSpec,
	245	0,
	246	kCFragGoesToEOF,
	247	"\p",
	248	kPrivateCFragCopy,
	249	&((CFragConnectionID)handle),
	250	&myMainAddr,
	251	myErrName ) != noErr )
	252	{
	253	p2cstr( myErrName );
	254	wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
	255	libname.c_str(),
	256	(char*)myErrName );
	257	handle = 0;
	258	failed = TRUE;
	259	}
	260
	261	#elif defined(__WXPM__) \|\| defined(__EMX__)
	262	char zError[256] = "";
	263	wxDllOpen(zError, libname, handle);
	264
	265	#else
	266	handle = wxDllOpen(libname);
	267
	268	#endif
	269
	270	if ( !handle )
	271	{
	272	wxString msg(_("Failed to load shared library '%s'"));
	273
	274	#ifdef HAVE_DLERROR
	275	const wxChar *err = dlerror();
	276	if( err )
	277	{
	278	failed = TRUE;
	279	wxLogError( msg, err );
	280	}
	281	#else
	282	failed = TRUE;
	283	wxLogSysError( msg, libname.c_str() );
	284	#endif
	285	}
	286
	287	if ( success )
	288	*success = !failed;
	289
	290	return handle;
	291	}
	292
	293
	294	/* static */
	295	void wxDllLoader::UnloadLibrary(wxDllType handle)
	296	{
	297	wxDllClose(handle);
	298	}
	299
	300	/* static */
	301	void wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool success)
	302	{
	303	bool failed = FALSE;
	304	void *symbol = 0;
	305
	306	#if defined(__WXMAC__) && !defined(__UNIX__)
	307	Ptr symAddress;
	308	CFragSymbolClass symClass;
	309	Str255 symName;
	310
	311	#if TARGET_CARBON
	312	c2pstrcpy( (StringPtr) symName, name );
	313	#else
	314	strcpy( (char *) symName, name );
	315	c2pstr( (char *) symName );
	316	#endif
	317	if( FindSymbol( ((CFragConnectionID)dllHandle), symName, &symAddress, &symClass ) == noErr )
	318	symbol = (void *)symAddress;
	319
	320	#elif defined(__WXPM__) \|\| defined(__EMX__)
	321	wxDllGetSymbol(dllHandle, symbol);
	322
	323	#else
	324	// mb_str() is necessary in Unicode build
	325	symbol = wxDllGetSymbol(dllHandle, name.mb_str());
	326
	327	#endif
	328
	329	if ( !symbol )
	330	{
	331	wxString msg(_("wxDllLoader failed to GetSymbol '%s'"));
	332
	333	#ifdef HAVE_DLERROR
	334	const wxChar *err = dlerror();
	335	if( err )
	336	{
	337	failed = TRUE;
	338	wxLogError( msg, err );
	339	}
	340	#else
	341	failed = TRUE;
	342	wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"),
	343	name.c_str());
	344	#endif
	345	}
	346
	347	if( success )
	348	*success = !failed;
	349
	350	return symbol;
	351	}
	352
	353	// ---------------------------------------------------------------------------
	354	// wxLibraries (only one instance should normally exist)
	355	// ---------------------------------------------------------------------------
	356
	357	wxLibraries::wxLibraries():m_loaded(wxKEY_STRING)
	358	{
	359	}
	360
	361	wxLibraries::~wxLibraries()
	362	{
	363	wxNode *node = m_loaded.First();
	364
	365	while (node) {
	366	wxLibrary lib = (wxLibrary )node->Data();
	367	delete lib;
	368
	369	node = node->Next();
	370	}
	371	}
	372
	373	wxLibrary *wxLibraries::LoadLibrary(const wxString& name)
	374	{
	375	wxLibrary *lib;
	376	wxClassInfo *old_sm_first;
	377	wxNode *node = m_loaded.Find(name.GetData());
	378
	379	if (node != NULL)
	380	return ((wxLibrary *)node->Data());
	381
	382	// If DLL shares data, this is necessary.
	383	old_sm_first = wxClassInfo::sm_first;
	384	wxClassInfo::sm_first = NULL;
	385
	386	wxString libname = ConstructLibraryName(name);
	387
	388	bool success = FALSE;
	389	wxDllType handle = wxDllLoader::LoadLibrary(libname, &success);
	390	if(success)
	391	{
	392	lib = new wxLibrary(handle);
	393	wxClassInfo::sm_first = old_sm_first;
	394
	395	m_loaded.Append(name.GetData(), lib);
	396	}
	397	else
	398	lib = NULL;
	399	return lib;
	400	}
	401
	402	wxObject *wxLibraries::CreateObject(const wxString& path)
	403	{
	404	wxNode *node = m_loaded.First();
	405	wxObject *obj;
	406
	407	while (node) {
	408	obj = ((wxLibrary *)node->Data())->CreateObject(path);
	409	if (obj)
	410	return obj;
	411
	412	node = node->Next();
	413	}
	414	return NULL;
	415	}
	416
	417	#ifdef __DARWIN__
	418	// ---------------------------------------------------------------------------
	419	// For Darwin/Mac OS X
	420	// supply the sun style dlopen functions in terms of Darwin NS*
	421	// ---------------------------------------------------------------------------
	422
	423	extern "C" {
	424	#import <mach-o/dyld.h>
	425	};
	426
	427	enum dyldErrorSource
	428	{
	429	OFImage,
	430	};
	431
	432	static char dl_last_error[1024];
	433
	434	static
	435	void TranslateError(const char *path, enum dyldErrorSource type, int number)
	436	{
	437	unsigned int index;
	438	static char *OFIErrorStrings[] =
	439	{
	440	"%s(%d): Object Image Load Failure\n",
	441	"%s(%d): Object Image Load Success\n",
	442	"%s(%d): Not an recognisable object file\n",
	443	"%s(%d): No valid architecture\n",
	444	"%s(%d): Object image has an invalid format\n",
	445	"%s(%d): Invalid access (permissions?)\n",
	446	"%s(%d): Unknown error code from NSCreateObjectFileImageFromFile\n",
	447	};
	448	#define NUM_OFI_ERRORS (sizeof(OFIErrorStrings) / sizeof(OFIErrorStrings[0]))
	449
	450	switch (type)
	451	{
	452	case OFImage:
	453	index = number;
	454	if (index > NUM_OFI_ERRORS - 1) {
	455	index = NUM_OFI_ERRORS - 1;
	456	}
	457	sprintf(dl_last_error, OFIErrorStrings[index], path, number);
	458	break;
	459
	460	default:
	461	sprintf(dl_last_error, "%s(%d): Totally unknown error type %d\n",
	462	path, number, type);
	463	break;
	464	}
	465	}
	466
	467	const char *dlerror()
	468	{
	469	return dl_last_error;
	470	}
	471
	472	void dlopen(const char path, int mode /* mode is ignored */)
	473	{
	474	int dyld_result;
	475	NSObjectFileImage ofile;
	476	NSModule handle = NULL;
	477
	478	dyld_result = NSCreateObjectFileImageFromFile(path, &ofile);
	479	if (dyld_result != NSObjectFileImageSuccess)
	480	{
	481	TranslateError(path, OFImage, dyld_result);
	482	}
	483	else
	484	{
	485	// NSLinkModule will cause the run to abort on any link error's
	486	// not very friendly but the error recovery functionality is limited.
	487	handle = NSLinkModule(ofile, path, TRUE);
	488	}
	489
	490	return handle;
	491	}
	492
	493	int dlclose(void handle) / stub only */
	494	{
	495	return 0;
	496	}
	497
	498	void dlsym(void handle, const char *symbol)
	499	{
	500	void *addr;
	501
	502	if (NSIsSymbolNameDefined(symbol)) {
	503	addr = NSAddressOfSymbol(NSLookupAndBindSymbol(symbol));
	504	}
	505	else {
	506	addr = NULL;
	507	}
	508	return addr;
	509	}
	510
	511	#endif // __DARWIN__
	512
	513	#endif // wxUSE_DYNLIB_CLASS