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

#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"
#include "wx/tokenzr.h"

// ----------------------------------------------------------------------------
// 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 (void *)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(&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 = (wxClassInfo *)info->GetNext();
    }

    // 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
// ---------------------------------------------------------------------------

/* static */
wxString wxDllLoader::GetDllExt()
{
    wxString ext;

#if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
    ext = _T(".dll");
#elif defined(__UNIX__)
#   if defined(__HPUX__)
        ext = _T(".sl");
#   else //__HPUX__
        ext = _T(".so");
#   endif //__HPUX__
#endif

    return ext;
}

/* static */
wxDllType
wxDllLoader::GetProgramHandle(void)
{
#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;

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

    wxMacFilename2FSSpec( libname , &myFSSpec ) ;
    if (GetDiskFragment( &myFSSpec , 0 , kCFragGoesToEOF , "\p" , kPrivateCFragCopy , &handle , &myMainAddr ,
                myErrName ) != noErr )
    {
        p2cstr( myErrName ) ;
        wxLogSysError( _("Failed to load shared library '%s' Error '%s'") , libname.c_str() , (char*)myErrName ) ;
        handle = NULL ;
    }
#elif defined(__WXPM__) || defined(__EMX__)
    char zError[256] = "";
    wxDllOpen(zError, libname, handle);
#else // !Mac
    handle = wxDllOpen(libname);
#endif // OS

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

#ifdef HAVE_DLERROR
        const char *errmsg = dlerror();
        if ( errmsg )
        {
            // the error string format is "libname: ...", but we already have
            // libname, so cut it off
            const char *p = strchr(errmsg, ':');
            if ( p )
            {
                if ( *++p == ' ' )
                    p++;
            }
            else
            {
                p = errmsg;
            }

            msg += _T(" (%s)");
            wxLogError(msg, libname.c_str(), p);
        }
        else
#endif // HAVE_DLERROR
        {
            wxLogSysError(msg, libname.c_str());
        }
    }

    if ( success )
    {
        *success = handle != 0;
    }

    return handle;
}


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

/* static */
void *
wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name)
{
    void *symbol = NULL;    // return value

#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( 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 )
    {
        wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"),
                      name.c_str());
    }
    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)
{
    wxNode *node;
    wxLibrary *lib;
    wxClassInfo *old_sm_first;

#if defined(__VISAGECPP__)
    node = m_loaded.Find(name.GetData());
    if (node != NULL)
        return ((wxLibrary *)node->Data());
#else // !OS/2
    if ( (node = m_loaded.Find(name.GetData())) != NULL)
        return ((wxLibrary *)node->Data());
#endif
    // If DLL shares data, this is necessary.
    old_sm_first = wxClassInfo::sm_first;
    wxClassInfo::sm_first = NULL;

    wxString libname = ConstructLibraryName(name);

/*
  Unix automatically builds that library name, at least for dlopen()
*/
#if 0
#if defined(__UNIX__)
    // found the first file in LD_LIBRARY_PATH with this name
    wxString libPath("/lib:/usr/lib"); // system path first
    const char *envLibPath = getenv("LD_LIBRARY_PATH");
    if ( envLibPath )
        libPath << wxT(':') << envLibPath;
    wxStringTokenizer tokenizer(libPath, wxT(':'));
    while ( tokenizer.HasMoreToken() )
    {
        wxString fullname(tokenizer.NextToken());

        fullname << wxT('/') << libname;
        if ( wxFileExists(fullname) )
        {
            libname = fullname;

            // found the library
            break;
        }
    }
    //else: not found in the path, leave the name as is (secutiry risk?)

#endif // __UNIX__
#endif

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