#include "wx/wxprec.h"
#ifdef __BORLANDC__
-#pragma hdrstop
+ #pragma hdrstop
#endif
#if wxUSE_DYNAMIC_LOADER
#ifdef __WINDOWS__
-#include "wx/msw/private.h"
+ #include "wx/msw/private.h"
#endif
#ifndef WX_PRECOMP
-#include "wx/log.h"
-#include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/intl.h"
#endif
-#include "wx/dynload.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 // __VMS
-
-#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;
- return ( shl_findsym(&handle, name.mb_str(), TYPE_UNDEFINED, &sym) == 0 )
- ? sym : 0;
-}
-
-#elif defined(__DARWIN__)
+#include "wx/filename.h" // for SplitPath()
- // 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."
+#include "wx/dynload.h"
+#include "wx/module.h"
+
+#if 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);
#endif
-
// ============================================================================
// implementation
// ============================================================================
// ---------------------------------------------------------------------------
-// wxDllLoader (all these methods are static)
+// wxDynamicLibrary
// ---------------------------------------------------------------------------
+//FIXME: This class isn't really common at all, it should be moved into
+// platform dependent files.
#if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
-const wxString wxDllLoader::ms_dllext( _T(".dll") );
+const wxString wxDynamicLibrary::ms_dllext( _T(".dll") );
#elif defined(__UNIX__)
#if defined(__HPUX__)
-const wxString wxDllLoader::ms_dllext( _T(".sl") );
+const wxString wxDynamicLibrary::ms_dllext( _T(".sl") );
#else
-const wxString wxDllLoader::ms_dllext( _T(".so") );
+const wxString wxDynamicLibrary::ms_dllext( _T(".so") );
#endif
#endif
-wxDllType wxDllLoader::GetProgramHandle()
+wxDllType wxDynamicLibrary::GetProgramHandle()
{
#if defined( HAVE_DLOPEN ) && !defined(__EMX__)
- // obtain handle for main program
- return dlopen(NULL, RTLD_NOW/*RTLD_LAZY*/);
+ return dlopen(0, RTLD_LAZY);
#elif defined (HAVE_SHL_LOAD)
- // shl_findsymbol with NULL handle looks up in main program
- return 0;
+ return PROG_HANDLE;
#else
wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2"));
return 0;
#endif
}
-wxDllType wxDllLoader::LoadLibrary(const wxString &name)
+bool wxDynamicLibrary::Load(wxString libname, int flags)
{
- wxString libname( name + wxDllLoader::GetDllExt() );
- wxDllType handle;
+ wxASSERT_MSG(m_handle == 0, _T("Library already loaded."));
-#if defined(__WXMAC__) && !defined(__UNIX__)
+ // add the proper extension for the DLL ourselves unless told not to
+ if ( !(flags & wxDL_VERBATIM) )
+ {
+ // and also check that the libname doesn't already have it
+ wxString ext;
+ wxFileName::SplitPath(libname, NULL, NULL, &ext);
+ if ( ext.empty() )
+ {
+ libname += GetDllExt();
+ }
+ }
+
+#if defined(__WXMAC__) && !defined(__DARWIN__)
FSSpec myFSSpec;
Ptr myMainAddr;
Str255 myErrName;
kCFragGoesToEOF,
"\p",
kPrivateCFragCopy,
- &handle,
+ &m_handle,
&myMainAddr,
myErrName ) != noErr )
{
wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
libname.c_str(),
(char*)myErrName );
- handle = 0;
+ m_handle = 0;
}
#elif defined(__WXPM__) || defined(__EMX__)
- char zError[256] = "";
- wxDllOpen(zError, libname, handle);
+ char err[256] = "";
+ DosLoadModule(err, sizeof(err), libname.c_str(), &m_handle);
+
+#elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
+
+#if defined(__VMS) || defined(__DARWIN__)
+ m_handle = dlopen(libname.c_str(), 0); // The second parameter is ignored
#else
- handle = wxDllOpen(libname);
+ int rtldFlags = 0;
+
+ if( flags & wxDL_LAZY )
+ {
+ wxASSERT_MSG( (flags & wxDL_NOW) == 0,
+ _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
+ rtldFlags |= RTLD_LAZY;
+ }
+ else if( flags & wxDL_NOW )
+ {
+ rtldFlags |= RTLD_NOW;
+ }
+ if( flags & wxDL_GLOBAL )
+ {
+#ifdef __osf__
+ wxLogDebug(_T("WARNING: RTLD_GLOBAL is not a supported on this platform."));
#endif
- if ( !handle )
+ rtldFlags |= RTLD_GLOBAL;
+ }
+
+ m_handle = dlopen(libname.c_str(), rtldFlags);
+#endif // __VMS || __DARWIN__
+
+#elif defined(HAVE_SHL_LOAD)
+ int shlFlags = 0;
+
+ if( flags & wxDL_LAZY )
+ {
+ wxASSERT_MSG( (flags & wxDL_NOW) == 0,
+ _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
+ shlFlags |= BIND_DEFERRED;
+ }
+ else if( flags & wxDL_NOW )
+ {
+ shlFlags |= BIND_IMMEDIATE;
+ }
+ m_handle = shl_load(libname.c_str(), BIND_DEFERRED, 0);
+
+#elif defined(__WINDOWS__)
+ m_handle = ::LoadLibrary(libname.c_str());
+
+#else
+#error "runtime shared lib support not implemented"
+#endif
+
+ if ( m_handle == 0 )
{
wxString msg(_("Failed to load shared library '%s'"));
-#ifdef HAVE_DLERROR
+#if defined(HAVE_DLERROR) && !defined(__EMX__)
const wxChar *err = dlerror();
if( err )
wxLogError( msg, err );
wxLogSysError( msg, libname.c_str() );
#endif
}
- return handle;
+
+ return IsLoaded();
}
-void wxDllLoader::UnloadLibrary(wxDllType handle)
+void wxDynamicLibrary::Unload()
{
- wxDllClose(handle);
+ if( IsLoaded() )
+ {
+#if defined(__WXPM__) || defined(__EMX__)
+ DosFreeModule( m_handle );
+#elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
+ dlclose( m_handle );
+#elif defined(HAVE_SHL_LOAD)
+ shl_unload( m_handle );
+#elif defined(__WINDOWS__)
+ ::FreeLibrary( m_handle );
+#elif defined(__WXMAC__) && !defined(__DARWIN__)
+ CloseConnection( (CFragConnectionID*) &m_handle );
+#else
+#error "runtime shared lib support not implemented"
+#endif
+ m_handle = 0;
+ }
}
-void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
+void *wxDynamicLibrary::GetSymbol(const wxString &name, bool *success) const
{
+ wxCHECK_MSG( IsLoaded(), NULL,
+ _T("Can't load symbol from unloaded library") );
+
bool failed = FALSE;
void *symbol = 0;
-#if defined(__WXMAC__) && !defined(__UNIX__)
+#if defined(__WXMAC__) && !defined(__DARWIN__)
Ptr symAddress;
CFragSymbolClass symClass;
Str255 symName;
#if TARGET_CARBON
c2pstrcpy( (StringPtr) symName, name );
#else
- strcpy( (char *) symName, name );
- c2pstr( (char *) symName );
+ 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
+ DosQueryProcAddr( m_handle, 1L, name.c_str(), (PFN*)symbol );
+
+#elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
+ symbol = dlsym( m_handle, name.c_str() );
+
+#elif defined(HAVE_SHL_LOAD)
+ if( shl_findsym( &m_handle, name.c_str(), TYPE_UNDEFINED, &symbol ) != 0 )
+ symbol = 0;
- // mb_str() is necessary in Unicode build
- symbol = wxDllGetSymbol(dllHandle, name.mb_str());
+#elif defined(__WINDOWS__)
+ symbol = (void*) ::GetProcAddress( m_handle, name.mb_str() );
+
+#else
+#error "runtime shared lib support not implemented"
#endif
if ( !symbol )
{
- wxString msg(_("wxDllLoader failed to GetSymbol '%s'"));
-#ifdef HAVE_DLERROR
+ wxString msg(_("wxDynamicLibrary failed to GetSymbol '%s'"));
+#if defined(HAVE_DLERROR) && !defined(__EMX__)
const wxChar *err = dlerror();
if( err )
{
// ---------------------------------------------------------------------------
-// wxDLManifestEntry
+// wxPluginLibrary
// ---------------------------------------------------------------------------
-wxDLImports wxDLManifestEntry::ms_classes(wxKEY_STRING);
+wxDLImports* wxPluginLibrary::ms_classes = NULL;
-wxDLManifestEntry::wxDLManifestEntry( const wxString &libname )
- : m_before(wxClassInfo::sm_first)
- , m_handle(wxDllLoader::LoadLibrary( libname ))
- , m_after(wxClassInfo::sm_first)
- , m_linkcount(1)
+class wxPluginLibraryModule : public wxModule
+{
+public:
+ wxPluginLibraryModule() {}
+ bool OnInit() { wxPluginLibrary::ms_classes = new wxDLImports(wxKEY_STRING); wxPluginManager::CreateManifest(); return TRUE; }
+ void OnExit() { delete wxPluginLibrary::ms_classes; wxPluginLibrary::ms_classes = NULL;
+ wxPluginManager::ClearManifest(); }
+
+private:
+ DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
+
+
+wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
+ : m_linkcount(1)
, m_objcount(0)
{
+ m_before = wxClassInfo::sm_first;
+ Load( libname, flags );
+ m_after = wxClassInfo::sm_first;
+
if( m_handle != 0 )
{
UpdateClassInfo();
--m_linkcount; // Flag us for deletion
}
-wxDLManifestEntry::~wxDLManifestEntry()
+wxPluginLibrary::~wxPluginLibrary()
{
- UnregisterModules();
- RestoreClassInfo();
-
- wxDllLoader::UnloadLibrary(m_handle);
+ if( m_handle != 0 )
+ {
+ UnregisterModules();
+ RestoreClassInfo();
+ }
}
-bool wxDLManifestEntry::UnrefLib()
+bool wxPluginLibrary::UnrefLib()
{
wxASSERT_MSG( m_objcount == 0, _T("Library unloaded before all objects were destroyed") );
if( m_linkcount == 0 || --m_linkcount == 0 )
// Private methods
// ------------------------
-void wxDLManifestEntry::UpdateClassInfo()
+void wxPluginLibrary::UpdateClassInfo()
{
wxClassInfo *info;
wxHashTable *t = wxClassInfo::sm_classTable;
// Hash all the class names into a local table too so
// we can quickly find the entry they correspond to.
- if( ms_classes.Get(info->m_className) == 0 )
- ms_classes.Put(info->m_className, (wxObject *) this);
+ if( ms_classes->Get(info->m_className) == 0 )
+ ms_classes->Put(info->m_className, (wxObject *) this);
}
}
}
}
-void wxDLManifestEntry::RestoreClassInfo()
+void wxPluginLibrary::RestoreClassInfo()
{
wxClassInfo *info;
for(info = m_after; info != m_before; info = info->m_next)
{
wxClassInfo::sm_classTable->Delete(info->m_className);
- ms_classes.Delete(info->m_className);
+ ms_classes->Delete(info->m_className);
}
if( wxClassInfo::sm_first == m_after )
info = wxClassInfo::sm_first;
while( info->m_next && info->m_next != m_after ) info = info->m_next;
- wxASSERT_MSG( info, _T("ClassInfo from wxDynamicLibrary not found on purge"))
+ wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge"))
info->m_next = m_before;
}
}
-void wxDLManifestEntry::RegisterModules()
+void wxPluginLibrary::RegisterModules()
{
// Plugin libraries might have wxModules, Register and initialise them if
// they do.
{
if( !node->GetData()->Init() )
{
- wxLogDebug(_T("wxModule::Init() failed for wxDynamicLibrary"));
+ wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary"));
// XXX: Watch this, a different hash implementation might break it,
// a good hash implementation would let us fix it though.
}
}
-void wxDLManifestEntry::UnregisterModules()
+void wxPluginLibrary::UnregisterModules()
{
wxModuleList::Node *node;
// ---------------------------------------------------------------------------
-// wxDynamicLibrary
+// wxPluginLibrary
// ---------------------------------------------------------------------------
-wxDLManifest wxDynamicLibrary::ms_manifest(wxKEY_STRING);
+wxDLManifest* wxPluginManager::ms_manifest = NULL;
// ------------------------
// Static accessors
// ------------------------
-wxDLManifestEntry *wxDynamicLibrary::Link(const wxString &libname)
+wxPluginLibrary *wxPluginManager::LoadLibrary(const wxString &libname, int flags)
{
- wxDLManifestEntry *entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
+ wxString realname(libname);
- if( entry )
+ if( !(flags & wxDL_VERBATIM) )
+ realname += wxDynamicLibrary::GetDllExt();
+
+ wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest->Get(realname);
+
+ if( entry != 0 )
{
entry->RefLib();
}
else
{
- entry = new wxDLManifestEntry( libname );
+ entry = new wxPluginLibrary( libname, flags );
if( entry->IsLoaded() )
{
- ms_manifest.Put(libname, (wxObject*) entry);
+ ms_manifest->Put(realname, (wxObject*) entry);
}
else
{
- wxCHECK_MSG( !entry->UnrefLib(), 0,
+ wxCHECK_MSG( entry->UnrefLib(), 0,
_T("Currently linked library is, ..not loaded??") );
entry = 0;
}
return entry;
}
-bool wxDynamicLibrary::Unlink(const wxString &libname)
+bool wxPluginManager::UnloadLibrary(const wxString &libname)
{
- wxDLManifestEntry *entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
+ wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest->Get(libname);
+
+ if( !entry )
+ entry = (wxPluginLibrary*) ms_manifest->Get(libname + wxDynamicLibrary::GetDllExt());
if( entry )
return entry->UnrefLib();
wxLogDebug(_T("Attempt to Unlink library '%s' (which is not linked)."), libname.c_str());
+ return FALSE;
+}
+
+#if WXWIN_COMPATIBILITY_2_2
+wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
+{
+ wxNode *node;
+ ms_manifest->BeginFind();
+
+ for(node = ms_manifest->Next(); node; node = ms_manifest->Next())
+ if( ((wxPluginLibrary*)node->GetData())->GetLibHandle() == handle )
+ return (wxPluginLibrary*)node->GetData();
+
return 0;
}
+#endif
// ------------------------
// Class implementation
// ------------------------
-wxDynamicLibrary::wxDynamicLibrary(const wxString &libname)
+bool wxPluginManager::Load(const wxString &libname, int flags)
{
- m_entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
-
- if( m_entry != 0 )
- {
- m_entry->RefLib();
- }
- else
- {
- m_entry = new wxDLManifestEntry( libname );
- ms_manifest.Put(libname, (wxObject*) m_entry);
-
- wxASSERT_MSG( m_entry != 0, _T("Failed to create manifest entry") );
- }
+ m_entry = wxPluginManager::LoadLibrary(libname, flags);
+ return IsLoaded();
}
-wxDynamicLibrary::~wxDynamicLibrary()
+void wxPluginManager::Unload()
{
wxNode *node;
- ms_manifest.BeginFind();
+ ms_manifest->BeginFind();
// It's either this or store the name of the lib just to do this.
- for(node = ms_manifest.Next(); node; node = ms_manifest.Next())
- if( (wxDLManifestEntry*)node->GetData() == m_entry )
+ for(node = ms_manifest->Next(); node; node = ms_manifest->Next())
+ if( (wxPluginLibrary*)node->GetData() == m_entry )
break;
if( m_entry && m_entry->UnrefLib() )
+ {
delete node;
+ m_entry = 0;
+ }
}
-
-#ifdef __DARWIN__
// ---------------------------------------------------------------------------
-// For Darwin/Mac OS X
-// supply the sun style dlopen functions in terms of Darwin NS*
+// wxDllLoader (all these methods are static)
// ---------------------------------------------------------------------------
-extern "C" {
-#import <mach-o/dyld.h>
-};
-
-enum dyldErrorSource
-{
- OFImage,
-};
+#if WXWIN_COMPATIBILITY_2_2
-static char dl_last_error[1024];
-
-static
-void TranslateError(const char *path, enum dyldErrorSource type, int number)
+wxDllType wxDllLoader::LoadLibrary(const wxString &name)
{
- 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;
- }
+ wxPluginLibrary *p = wxPluginManager::LoadLibrary(name, wxDL_DEFAULT | wxDL_VERBATIM);
+ return p->GetLibHandle();
}
-const char *dlerror()
+void wxDllLoader::UnloadLibrary(wxDllType handle)
{
- return dl_last_error;
+ wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
+ p->UnrefLib();
}
-void *dlopen(const char *path, int mode /* mode is ignored */)
-{
- int dyld_result;
- NSObjectFileImage ofile;
- NSModule handle = 0;
- 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 */
+void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
{
- return 0;
+ wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
+ return p->GetSymbol(name, success);
}
-void *dlsym(void *handle, const char *symbol)
-{
- return NSIsSymbolNameDefined(symbol)
- ? NSAddressOfSymbol( NSLookupAndBindSymbol(symbol) )
- : 0 ;
-}
+#endif // WXWIN_COMPATIBILITY_2_2
-#endif // __DARWIN__
#endif // wxUSE_DYNAMIC_LOADER
// vi:sts=4:sw=4:et
projects / wxWidgets.git / blobdiff