// Created: 03/12/01
// RCS-ID: $Id$
// Copyright: (c) 2001 Ron Lee <ron@debian.org>
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "dynload.h"
#endif
#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"
+ #include "wx/hash.h"
+ #include "wx/utils.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__)
-
- // 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
+#include "wx/strconv.h"
+#include "wx/dynload.h"
+#include "wx/module.h"
-// ============================================================================
-// implementation
-// ============================================================================
// ---------------------------------------------------------------------------
-// wxDllLoader (all these methods are static)
+// wxPluginLibrary
// ---------------------------------------------------------------------------
-#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
+wxDLImports* wxPluginLibrary::ms_classes = NULL;
-wxDllType wxDllLoader::GetProgramHandle()
+class wxPluginLibraryModule : public wxModule
{
-#if defined( HAVE_DLOPEN ) && !defined(__EMX__)
- // obtain 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
-}
+public:
+ wxPluginLibraryModule() { }
-wxDllType wxDllLoader::LoadLibrary(const wxString &name)
-{
- wxString libname( name + wxDllLoader::GetDllExt() );
- 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 )
+ // TODO: create ms_classes on demand, why always preallocate it?
+ virtual bool OnInit()
{
- p2cstr( myErrName );
- wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
- libname.c_str(),
- (char*)myErrName );
- handle = 0;
+ wxPluginLibrary::ms_classes = new wxDLImports;
+ wxPluginManager::CreateManifest();
+ return TRUE;
}
-#elif defined(__WXPM__) || defined(__EMX__)
- char zError[256] = "";
- wxDllOpen(zError, libname, handle);
-#else
- handle = wxDllOpen(libname);
-#endif
- if ( !handle )
+ virtual void OnExit()
{
- wxString msg(_("Failed to load shared library '%s'"));
-#ifdef HAVE_DLERROR
- const wxChar *err = dlerror();
- if( err )
- wxLogError( msg, err );
-#else
- wxLogSysError( msg, libname.c_str() );
-#endif
+ delete wxPluginLibrary::ms_classes;
+ wxPluginLibrary::ms_classes = NULL;
+ wxPluginManager::ClearManifest();
}
- return handle;
-}
-void wxDllLoader::UnloadLibrary(wxDllType handle)
-{
- wxDllClose(handle);
-}
+private:
+ DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
+};
-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( dllHandle, symName, &symAddress, &symClass ) == noErr )
- symbol = (void *)symAddress;
+IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
-#elif defined(__WXPM__) || defined(__EMX__)
- wxDllGetSymbol(dllHandle, symbol);
-#else
- // mb_str() is necessary in Unicode build
- symbol = wxDllGetSymbol(dllHandle, name.mb_str());
-#endif
+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 ( !symbol )
+ if( m_handle != 0 )
{
- 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
+ UpdateClasses();
+ RegisterModules();
+ }
+ else
+ {
+ // Flag us for deletion
+ --m_linkcount;
}
- if( success )
- *success = !failed;
-
- return symbol;
}
-
-// ---------------------------------------------------------------------------
-// wxDLManifestEntry
-// ---------------------------------------------------------------------------
-
-
-wxDLImports wxDLManifestEntry::ms_classes(wxKEY_STRING);
-
-wxDLManifestEntry::wxDLManifestEntry( const wxString &libname )
- : m_before(wxClassInfo::sm_first)
- , m_handle(wxDllLoader::LoadLibrary( libname ))
- , m_after(wxClassInfo::sm_first)
- , m_linkcount(1)
- , m_objcount(0)
+wxPluginLibrary::~wxPluginLibrary()
{
if( m_handle != 0 )
{
- UpdateClassInfo();
- RegisterModules();
+ UnregisterModules();
+ RestoreClasses();
}
- else
- --m_linkcount; // Flag us for deletion
}
-wxDLManifestEntry::~wxDLManifestEntry()
+wxPluginLibrary *wxPluginLibrary::RefLib()
{
- UnregisterModules();
- RestoreClassInfo();
+ wxCHECK_MSG( m_linkcount > 0, NULL,
+ _T("Library had been already deleted!") );
- wxDllLoader::UnloadLibrary(m_handle);
+ ++m_linkcount;
+ return this;
}
-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 )
+ wxASSERT_MSG( m_objcount == 0,
+ _T("Library unloaded before all objects were destroyed") );
+
+ if ( --m_linkcount == 0 )
{
delete this;
return TRUE;
}
+
return FALSE;
}
// Private methods
// ------------------------
-void wxDLManifestEntry::UpdateClassInfo()
+void wxPluginLibrary::UpdateClasses()
{
- wxClassInfo *info;
- wxHashTable *t = wxClassInfo::sm_classTable;
-
- // FIXME: Below is simply a cut and paste specialisation of
- // wxClassInfo::InitializeClasses. Once this stabilises,
- // the two should probably be merged.
- //
- // Actually it's becoming questionable whether we should merge
- // this info with the main ClassInfo tables since we can nearly
- // handle this completely internally now and it does expose
- // certain (minimal % user_stupidy) risks.
-
- for(info = m_after; info != m_before; info = info->m_next)
+ for (wxClassInfo *info = m_after; info != m_before; info = info->m_next)
{
if( info->m_className )
{
- if( t->Get(info->m_className) == 0 )
- t->Put(info->m_className, (wxObject *)info);
-
// 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);
+ (*ms_classes)[info->m_className] = this;
}
}
-
- for(info = m_after; info != m_before; info = info->m_next)
- {
- if( info->m_baseClassName1 )
- info->m_baseInfo1 = (wxClassInfo *)t->Get(info->m_baseClassName1);
- if( info->m_baseClassName2 )
- info->m_baseInfo2 = (wxClassInfo *)t->Get(info->m_baseClassName2);
- }
}
-void wxDLManifestEntry::RestoreClassInfo()
+void wxPluginLibrary::RestoreClasses()
{
- 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);
- }
-
- if( wxClassInfo::sm_first == m_after )
- wxClassInfo::sm_first = m_before;
- else
+ for(wxClassInfo *info = m_after; info != m_before; info = info->m_next)
{
- 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"))
-
- info->m_next = m_before;
+ ms_classes->erase(ms_classes->find(info->m_className));
}
}
-void wxDLManifestEntry::RegisterModules()
+void wxPluginLibrary::RegisterModules()
{
// Plugin libraries might have wxModules, Register and initialise them if
// they do.
wxASSERT_MSG( m_linkcount == 1,
_T("RegisterModules should only be called for the first load") );
- for(wxClassInfo *info = m_after; info != m_before; info = info->m_next)
+ for ( wxClassInfo *info = m_after; info != m_before; info = info->m_next)
{
if( info->IsKindOf(CLASSINFO(wxModule)) )
{
wxASSERT_MSG( m, _T("wxDynamicCast of wxModule failed") );
- m_wxmodules.Append(m);
+ m_wxmodules.push_back(m);
wxModule::RegisterModule(m);
}
}
// FIXME: Likewise this is (well was) very similar to InitializeModules()
- for(wxModuleList::Node *node = m_wxmodules.GetFirst(); node; node->GetNext())
+ for ( wxModuleList::iterator it = m_wxmodules.begin();
+ it != m_wxmodules.end();
+ ++it)
{
- if( !node->GetData()->Init() )
+ if( !(*it)->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.
// let the dtor Exit the rest on shutdown, (which we'll initiate
// shortly).
- wxModuleList::Node *oldNode = 0;
+ wxModuleList::iterator oldNode = m_wxmodules.end();
do {
- node = node->GetNext();
- delete oldNode;
- wxModule::UnregisterModule( node->GetData() );
- oldNode = node;
- } while( node );
+ ++it;
+ if( oldNode != m_wxmodules.end() )
+ m_wxmodules.erase(oldNode);
+ wxModule::UnregisterModule( *it );
+ oldNode = it;
+ } while( it != m_wxmodules.end() );
--m_linkcount; // Flag us for deletion
break;
}
}
-void wxDLManifestEntry::UnregisterModules()
+void wxPluginLibrary::UnregisterModules()
{
- wxModuleList::Node *node;
+ wxModuleList::iterator it;
- for(node = m_wxmodules.GetFirst(); node; node->GetNext())
- node->GetData()->Exit();
+ for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
+ (*it)->Exit();
- for(node = m_wxmodules.GetFirst(); node; node->GetNext())
- wxModule::UnregisterModule( node->GetData() );
+ for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
+ wxModule::UnregisterModule( *it );
- m_wxmodules.DeleteContents(TRUE);
+ WX_CLEAR_LIST(wxModuleList, m_wxmodules);
}
// ---------------------------------------------------------------------------
-// wxDynamicLibrary
+// wxPluginManager
// ---------------------------------------------------------------------------
-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( !(flags & wxDL_VERBATIM) )
+ realname += wxDynamicLibrary::GetDllExt();
+
+ wxPluginLibrary *entry;
+
+ if ( flags & wxDL_NOSHARE )
+ {
+ entry = NULL;
+ }
+ else
+ {
+ entry = FindByName(realname);
+ }
- if( entry )
+ if ( entry )
{
+ wxLogTrace(_T("dll"),
+ _T("LoadLibrary(%s): already loaded."), realname.c_str());
+
entry->RefLib();
}
else
{
- entry = new wxDLManifestEntry( libname );
+ entry = new wxPluginLibrary( libname, flags );
- if( entry->IsLoaded() )
+ if ( entry->IsLoaded() )
{
- ms_manifest.Put(libname, (wxObject*) entry);
+ (*ms_manifest)[realname] = entry;
+
+ wxLogTrace(_T("dll"),
+ _T("LoadLibrary(%s): loaded ok."), realname.c_str());
+
}
else
{
- wxCHECK_MSG( !entry->UnrefLib(), 0,
- _T("Currently linked library is, ..not loaded??") );
- entry = 0;
+ wxLogTrace(_T("dll"),
+ _T("LoadLibrary(%s): failed to load."), realname.c_str());
+
+ // we have created entry just above
+ if ( !entry->UnrefLib() )
+ {
+ // ... so UnrefLib() is supposed to delete it
+ wxFAIL_MSG( _T("Currently linked library is not loaded?") );
+ }
+
+ entry = NULL;
}
}
+
return entry;
}
-bool wxDynamicLibrary::Unlink(const wxString &libname)
+bool wxPluginManager::UnloadLibrary(const wxString& libname)
{
- wxDLManifestEntry *entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
+ wxString realname = libname;
+
+ wxPluginLibrary *entry = FindByName(realname);
+
+ if ( !entry )
+ {
+ realname += wxDynamicLibrary::GetDllExt();
+
+ entry = FindByName(realname);
+ }
+
+ if ( !entry )
+ {
+ wxLogDebug(_T("Attempt to unload library '%s' which is not loaded."),
+ libname.c_str());
+
+ return FALSE;
+ }
- if( entry )
- return entry->UnrefLib();
+ wxLogTrace(_T("dll"), _T("UnloadLibrary(%s)"), realname.c_str());
- wxLogDebug(_T("Attempt to Unlink library '%s' (which is not linked)."), libname.c_str());
- return 0;
+ if ( !entry->UnrefLib() )
+ {
+ // not really unloaded yet
+ return FALSE;
+ }
+
+ ms_manifest->erase(ms_manifest->find(realname));
+
+ return TRUE;
}
// ------------------------
// Class implementation
// ------------------------
-wxDynamicLibrary::wxDynamicLibrary(const wxString &libname)
+bool wxPluginManager::Load(const wxString &libname, int flags)
{
- m_entry = (wxDLManifestEntry*) ms_manifest.Get(libname);
+ m_entry = wxPluginManager::LoadLibrary(libname, flags);
+
+ return IsLoaded();
+}
- if( m_entry != 0 )
+void wxPluginManager::Unload()
+{
+ wxCHECK_RET( m_entry, _T("unloading an invalid wxPluginManager?") );
+
+ for ( wxDLManifest::iterator i = ms_manifest->begin();
+ i != ms_manifest->end();
+ ++i )
{
- m_entry->RefLib();
+ if ( i->second == m_entry )
+ {
+ ms_manifest->erase(i);
+ break;
+ }
}
- else
+
+ m_entry->UnrefLib();
+
+ m_entry = NULL;
+}
+
+
+
+#if WXWIN_COMPATIBILITY_2_2
+
+wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
+{
+ for ( wxDLManifest::iterator i = ms_manifest->begin();
+ i != ms_manifest->end();
+ ++i )
{
- m_entry = new wxDLManifestEntry( libname );
- ms_manifest.Put(libname, (wxObject*) m_entry);
+ wxPluginLibrary * const lib = i->second;
- wxASSERT_MSG( m_entry != 0, _T("Failed to create manifest entry") );
+ if ( lib->GetLibHandle() == handle )
+ return lib;
}
+
+ return NULL;
}
-wxDynamicLibrary::~wxDynamicLibrary()
+// ---------------------------------------------------------------------------
+// wxDllLoader (all these methods are static)
+// ---------------------------------------------------------------------------
+
+
+wxDllType wxDllLoader::LoadLibrary(const wxString &name, bool *success)
{
- wxNode *node;
- ms_manifest.BeginFind();
+ wxPluginLibrary *p = wxPluginManager::LoadLibrary
+ (
+ name,
+ wxDL_DEFAULT | wxDL_VERBATIM | wxDL_NOSHARE
+ );
- // It's either this or store the name of the lib just to do this.
+ if ( success )
+ *success = p != NULL;
- for(node = ms_manifest.Next(); node; node = ms_manifest.Next())
- if( (wxDLManifestEntry*)node->GetData() == m_entry )
- break;
+ return p ? p->GetLibHandle() : 0;
+}
+
+void wxDllLoader::UnloadLibrary(wxDllType handle)
+{
+ wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
- if( m_entry && m_entry->UnrefLib() )
- delete node;
+ wxCHECK_RET( p, _T("Unloading a library not loaded with wxDllLoader?") );
+
+ p->UnrefLib();
+}
+
+void *
+wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
+{
+ wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
+
+ if ( !p )
+ {
+ wxFAIL_MSG( _T("Using a library not loaded with wxDllLoader?") );
+
+ if ( success )
+ *success = FALSE;
+
+ return NULL;
+ }
+
+ return p->GetSymbol(name, success);
}
-#ifdef __DARWIN__
// ---------------------------------------------------------------------------
-// For Darwin/Mac OS X
-// supply the sun style dlopen functions in terms of Darwin NS*
+// Global variables
// ---------------------------------------------------------------------------
-extern "C" {
-#import <mach-o/dyld.h>
-};
+wxLibraries wxTheLibraries;
-enum dyldErrorSource
+// ============================================================================
+// 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)
{
- OFImage,
-};
+ wxString fullname;
+ fullname << basename << wxDllLoader::GetDllExt();
-static char dl_last_error[1024];
+ return fullname;
+}
-static
-void TranslateError(const char *path, enum dyldErrorSource type, int number)
+// ---------------------------------------------------------------------------
+// wxLibrary (one instance per dynamic library)
+// ---------------------------------------------------------------------------
+
+wxLibrary::wxLibrary(wxDllType handle)
{
- 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)
+ 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(_T("wxGetClassFirst"));
+ // It is a wxWindows DLL.
+ if (get_first)
+ PrepareClasses(get_first());
+}
+
+wxLibrary::~wxLibrary()
+{
+ if ( m_handle )
{
- 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;
+ wxDllLoader::UnloadLibrary(m_handle);
}
}
-const char *dlerror()
+wxObject *wxLibrary::CreateObject(const wxString& name)
{
- return dl_last_error;
+ wxClassInfo *info = (wxClassInfo *)classTable.Get(name);
+
+ if (!info)
+ return NULL;
+
+ return info->CreateObject();
}
-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)
+void wxLibrary::PrepareClasses(wxClassInfo *first)
+{
+ // Index all class infos by their class name
+ wxClassInfo *info = first;
+ while (info)
{
- TranslateError(path, OFImage, dyld_result);
+ if (info->m_className)
+ classTable.Put(info->m_className, (wxObject *)info);
+ info = info->m_next;
}
- else
+
+#if !wxUSE_EXTENDED_RTTI
+ // Set base pointers for each wxClassInfo
+ info = first;
+ while (info)
{
- // 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);
+ 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;
}
+#endif
+}
- return handle;
+void *wxLibrary::GetSymbol(const wxString& symbname)
+{
+ return wxDllLoader::GetSymbol(m_handle, symbname);
}
-int dlclose(void *handle) /* stub only */
+
+// ---------------------------------------------------------------------------
+// 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)
{
- return 0;
+ 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;
}
-void *dlsym(void *handle, const char *symbol)
+wxObject *wxLibraries::CreateObject(const wxString& path)
{
- return NSIsSymbolNameDefined(symbol)
- ? NSAddressOfSymbol( NSLookupAndBindSymbol(symbol) )
- : 0 ;
+ wxNode *node = m_loaded.First();
+ wxObject *obj;
+
+ while (node) {
+ obj = ((wxLibrary *)node->Data())->CreateObject(path);
+ if (obj)
+ return obj;
+
+ node = node->Next();
+ }
+ return NULL;
}
-#endif // __DARWIN__
+#endif // WXWIN_COMPATIBILITY_2_2
+
+
#endif // wxUSE_DYNAMIC_LOADER
-// vi:sts=4:sw=4:et
projects / wxWidgets.git / blobdiff