1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Dynamic loading framework
4 // Author: Ron Lee, David Falkinder, Vadim Zeitlin and a cast of 1000's
5 // (derived in part from dynlib.cpp (c) 1998 Guilhem Lavaux)
9 // Copyright: (c) 2001 Ron Lee <ron@debian.org>
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
14 #pragma implementation "dynload.h"
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
21 #include "wx/wxprec.h"
27 #if wxUSE_DYNAMIC_LOADER
30 #include "wx/msw/private.h"
38 #include "wx/filename.h" // for SplitPath()
40 #include "wx/dynload.h"
41 #include "wx/module.h"
43 #if defined(__DARWIN__)
45 * The dlopen port is a port from dl_next.xs by Anno Siegel.
46 * dl_next.xs is itself a port from dl_dlopen.xs by Paul Marquess.
47 * The method used here is just to supply the sun style dlopen etc.
48 * functions in terms of Darwin NS*.
50 void *dlopen(const char *path
, int mode
/* mode is ignored */);
51 void *dlsym(void *handle
, const char *symbol
);
52 int dlclose(void *handle
);
53 const char *dlerror(void);
56 // ============================================================================
58 // ============================================================================
60 // ---------------------------------------------------------------------------
62 // ---------------------------------------------------------------------------
64 //FIXME: This class isn't really common at all, it should be moved into
65 // platform dependent files.
67 #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
68 const wxChar
*wxDynamicLibrary::ms_dllext( _T(".dll") );
69 #elif defined(__UNIX__)
71 const wxChar
*wxDynamicLibrary::ms_dllext( _T(".sl") );
73 const wxChar
*wxDynamicLibrary::ms_dllext( _T(".so") );
77 wxDllType
wxDynamicLibrary::GetProgramHandle()
79 #if defined( HAVE_DLOPEN ) && !defined(__EMX__)
80 return dlopen(0, RTLD_LAZY
);
81 #elif defined (HAVE_SHL_LOAD)
84 wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2"));
89 bool wxDynamicLibrary::Load(wxString libname
, int flags
)
91 wxASSERT_MSG(m_handle
== 0, _T("Library already loaded."));
93 // add the proper extension for the DLL ourselves unless told not to
94 if ( !(flags
& wxDL_VERBATIM
) )
96 // and also check that the libname doesn't already have it
98 wxFileName::SplitPath(libname
, NULL
, NULL
, &ext
);
101 libname
+= GetDllExt();
105 #if defined(__WXMAC__) && !defined(__DARWIN__)
110 wxMacFilename2FSSpec( libname
, &myFSSpec
);
112 if( GetDiskFragment( &myFSSpec
,
119 myErrName
) != noErr
)
122 wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
128 #elif defined(__WXPM__) || defined(__EMX__)
130 DosLoadModule(err
, sizeof(err
), libname
.c_str(), &m_handle
);
132 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
134 #if defined(__VMS) || defined(__DARWIN__)
135 m_handle
= dlopen(libname
.c_str(), 0); // The second parameter is ignored
139 if( flags
& wxDL_LAZY
)
141 wxASSERT_MSG( (flags
& wxDL_NOW
) == 0,
142 _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
143 rtldFlags
|= RTLD_LAZY
;
145 else if( flags
& wxDL_NOW
)
147 rtldFlags
|= RTLD_NOW
;
149 if( flags
& wxDL_GLOBAL
)
152 wxLogDebug(_T("WARNING: RTLD_GLOBAL is not a supported on this platform."));
154 rtldFlags
|= RTLD_GLOBAL
;
157 m_handle
= dlopen(libname
.c_str(), rtldFlags
);
158 #endif // __VMS || __DARWIN__
160 #elif defined(HAVE_SHL_LOAD)
163 if( flags
& wxDL_LAZY
)
165 wxASSERT_MSG( (flags
& wxDL_NOW
) == 0,
166 _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
167 shlFlags
|= BIND_DEFERRED
;
169 else if( flags
& wxDL_NOW
)
171 shlFlags
|= BIND_IMMEDIATE
;
173 m_handle
= shl_load(libname
.c_str(), BIND_DEFERRED
, 0);
175 #elif defined(__WINDOWS__)
176 m_handle
= ::LoadLibrary(libname
.c_str());
179 #error "runtime shared lib support not implemented"
184 wxString
msg(_("Failed to load shared library '%s'"));
185 #if defined(HAVE_DLERROR) && !defined(__EMX__)
186 const wxChar
*err
= dlerror();
188 wxLogError( msg
, err
);
190 wxLogSysError( msg
, libname
.c_str() );
197 void wxDynamicLibrary::Unload()
201 #if defined(__WXPM__) || defined(__EMX__)
202 DosFreeModule( m_handle
);
203 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
205 #elif defined(HAVE_SHL_LOAD)
206 shl_unload( m_handle
);
207 #elif defined(__WINDOWS__)
208 ::FreeLibrary( m_handle
);
209 #elif defined(__WXMAC__) && !defined(__DARWIN__)
210 CloseConnection( (CFragConnectionID
*) &m_handle
);
212 #error "runtime shared lib support not implemented"
218 void *wxDynamicLibrary::GetSymbol(const wxString
&name
, bool *success
) const
220 wxCHECK_MSG( IsLoaded(), NULL
,
221 _T("Can't load symbol from unloaded library") );
226 #if defined(__WXMAC__) && !defined(__DARWIN__)
228 CFragSymbolClass symClass
;
231 c2pstrcpy( (StringPtr
) symName
, name
);
233 strcpy( (char *)symName
, name
);
234 c2pstr( (char *)symName
);
236 if( FindSymbol( dllHandle
, symName
, &symAddress
, &symClass
) == noErr
)
237 symbol
= (void *)symAddress
;
239 #elif defined(__WXPM__) || defined(__EMX__)
240 DosQueryProcAddr( m_handle
, 1L, name
.c_str(), (PFN
*)symbol
);
242 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
243 symbol
= dlsym( m_handle
, name
.c_str() );
245 #elif defined(HAVE_SHL_LOAD)
246 if( shl_findsym( &m_handle
, name
.c_str(), TYPE_UNDEFINED
, &symbol
) != 0 )
249 #elif defined(__WINDOWS__)
250 symbol
= (void*) ::GetProcAddress( m_handle
, name
.mb_str() );
253 #error "runtime shared lib support not implemented"
258 wxString
msg(_("wxDynamicLibrary failed to GetSymbol '%s'"));
259 #if defined(HAVE_DLERROR) && !defined(__EMX__)
260 const wxChar
*err
= dlerror();
264 wxLogError( msg
, err
);
268 wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"),
279 // ---------------------------------------------------------------------------
281 // ---------------------------------------------------------------------------
284 wxDLImports
* wxPluginLibrary::ms_classes
= NULL
;
286 class wxPluginLibraryModule
: public wxModule
289 wxPluginLibraryModule() { }
291 // TODO: create ms_classes on demand, why always preallocate it?
292 virtual bool OnInit()
294 wxPluginLibrary::ms_classes
= new wxDLImports(wxKEY_STRING
);
295 wxPluginManager::CreateManifest();
299 virtual void OnExit()
301 delete wxPluginLibrary::ms_classes
;
302 wxPluginLibrary::ms_classes
= NULL
;
303 wxPluginManager::ClearManifest();
307 DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule
)
310 IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule
, wxModule
)
313 wxPluginLibrary::wxPluginLibrary(const wxString
&libname
, int flags
)
317 m_before
= wxClassInfo::sm_first
;
318 Load( libname
, flags
);
319 m_after
= wxClassInfo::sm_first
;
328 // Flag us for deletion
333 wxPluginLibrary::~wxPluginLibrary()
342 wxPluginLibrary
*wxPluginLibrary::RefLib()
344 wxCHECK_MSG( m_linkcount
> 0, NULL
,
345 _T("Library had been already deleted!") );
351 bool wxPluginLibrary::UnrefLib()
353 wxASSERT_MSG( m_objcount
== 0,
354 _T("Library unloaded before all objects were destroyed") );
356 if ( --m_linkcount
== 0 )
365 // ------------------------
367 // ------------------------
369 void wxPluginLibrary::UpdateClassInfo()
372 wxHashTable
*t
= wxClassInfo::sm_classTable
;
374 // FIXME: Below is simply a cut and paste specialisation of
375 // wxClassInfo::InitializeClasses. Once this stabilises,
376 // the two should probably be merged.
378 // Actually it's becoming questionable whether we should merge
379 // this info with the main ClassInfo tables since we can nearly
380 // handle this completely internally now and it does expose
381 // certain (minimal % user_stupidy) risks.
383 for(info
= m_after
; info
!= m_before
; info
= info
->m_next
)
385 if( info
->m_className
)
387 if( t
->Get(info
->m_className
) == 0 )
388 t
->Put(info
->m_className
, (wxObject
*)info
);
390 // Hash all the class names into a local table too so
391 // we can quickly find the entry they correspond to.
393 if( ms_classes
->Get(info
->m_className
) == 0 )
394 ms_classes
->Put(info
->m_className
, (wxObject
*) this);
398 for(info
= m_after
; info
!= m_before
; info
= info
->m_next
)
400 if( info
->m_baseClassName1
)
401 info
->m_baseInfo1
= (wxClassInfo
*)t
->Get(info
->m_baseClassName1
);
402 if( info
->m_baseClassName2
)
403 info
->m_baseInfo2
= (wxClassInfo
*)t
->Get(info
->m_baseClassName2
);
407 void wxPluginLibrary::RestoreClassInfo()
411 for(info
= m_after
; info
!= m_before
; info
= info
->m_next
)
413 wxClassInfo::sm_classTable
->Delete(info
->m_className
);
414 ms_classes
->Delete(info
->m_className
);
417 if( wxClassInfo::sm_first
== m_after
)
418 wxClassInfo::sm_first
= m_before
;
421 info
= wxClassInfo::sm_first
;
422 while( info
->m_next
&& info
->m_next
!= m_after
) info
= info
->m_next
;
424 wxASSERT_MSG( info
, _T("ClassInfo from wxPluginLibrary not found on purge"))
426 info
->m_next
= m_before
;
430 void wxPluginLibrary::RegisterModules()
432 // Plugin libraries might have wxModules, Register and initialise them if
435 // Note that these classes are NOT included in the reference counting since
436 // it's implicit that they will be unloaded if and when the last handle to
437 // the library is. We do have to keep a copy of the module's pointer
438 // though, as there is currently no way to Unregister it without it.
440 wxASSERT_MSG( m_linkcount
== 1,
441 _T("RegisterModules should only be called for the first load") );
443 for(wxClassInfo
*info
= m_after
; info
!= m_before
; info
= info
->m_next
)
445 if( info
->IsKindOf(CLASSINFO(wxModule
)) )
447 wxModule
*m
= wxDynamicCast(info
->CreateObject(), wxModule
);
449 wxASSERT_MSG( m
, _T("wxDynamicCast of wxModule failed") );
451 m_wxmodules
.Append(m
);
452 wxModule::RegisterModule(m
);
456 // FIXME: Likewise this is (well was) very similar to InitializeModules()
458 for(wxModuleList::Node
*node
= m_wxmodules
.GetFirst(); node
; node
->GetNext())
460 if( !node
->GetData()->Init() )
462 wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary"));
464 // XXX: Watch this, a different hash implementation might break it,
465 // a good hash implementation would let us fix it though.
467 // The name of the game is to remove any uninitialised modules and
468 // let the dtor Exit the rest on shutdown, (which we'll initiate
471 wxModuleList::Node
*oldNode
= 0;
473 node
= node
->GetNext();
475 wxModule::UnregisterModule( node
->GetData() );
479 --m_linkcount
; // Flag us for deletion
485 void wxPluginLibrary::UnregisterModules()
487 wxModuleList::Node
*node
;
489 for(node
= m_wxmodules
.GetFirst(); node
; node
->GetNext())
490 node
->GetData()->Exit();
492 for(node
= m_wxmodules
.GetFirst(); node
; node
->GetNext())
493 wxModule::UnregisterModule( node
->GetData() );
495 m_wxmodules
.DeleteContents(TRUE
);
499 // ---------------------------------------------------------------------------
501 // ---------------------------------------------------------------------------
503 wxDLManifest
* wxPluginManager::ms_manifest
= NULL
;
505 // ------------------------
507 // ------------------------
510 wxPluginManager::LoadLibrary(const wxString
&libname
, int flags
)
512 wxString
realname(libname
);
514 if( !(flags
& wxDL_VERBATIM
) )
515 realname
+= wxDynamicLibrary::GetDllExt();
517 wxPluginLibrary
*entry
;
519 if ( flags
& wxDL_NOSHARE
)
525 entry
= (wxPluginLibrary
*) ms_manifest
->Get(realname
);
530 wxLogTrace(_T("dll"),
531 _T("LoadLibrary(%s): already loaded."), realname
.c_str());
537 entry
= new wxPluginLibrary( libname
, flags
);
539 if ( entry
->IsLoaded() )
541 ms_manifest
->Put(realname
, (wxObject
*) entry
);
543 wxLogTrace(_T("dll"),
544 _T("LoadLibrary(%s): loaded ok."), realname
.c_str());
549 wxLogTrace(_T("dll"),
550 _T("LoadLibrary(%s): failed to load."), realname
.c_str());
552 // we have created entry just above
553 if ( !entry
->UnrefLib() )
555 // ... so UnrefLib() is supposed to delete it
556 wxFAIL_MSG( _T("Currently linked library is not loaded?") );
566 bool wxPluginManager::UnloadLibrary(const wxString
& libname
)
568 wxString realname
= libname
;
570 wxPluginLibrary
*entry
= (wxPluginLibrary
*) ms_manifest
->Get(realname
);
574 realname
+= wxDynamicLibrary::GetDllExt();
576 entry
= (wxPluginLibrary
*) ms_manifest
->Get(realname
);
581 wxLogDebug(_T("Attempt to unload library '%s' which is not loaded."),
587 wxLogTrace(_T("dll"), _T("UnloadLibrary(%s)"), realname
.c_str());
589 if ( !entry
->UnrefLib() )
591 // not really unloaded yet
595 ms_manifest
->Delete(realname
);
600 #if WXWIN_COMPATIBILITY_2_2
601 wxPluginLibrary
*wxPluginManager::GetObjectFromHandle(wxDllType handle
)
604 ms_manifest
->BeginFind();
606 for(node
= ms_manifest
->Next(); node
; node
= ms_manifest
->Next())
607 if( ((wxPluginLibrary
*)node
->GetData())->GetLibHandle() == handle
)
608 return (wxPluginLibrary
*)node
->GetData();
612 #endif // WXWIN_COMPATIBILITY_2_2
614 // ------------------------
615 // Class implementation
616 // ------------------------
618 bool wxPluginManager::Load(const wxString
&libname
, int flags
)
620 m_entry
= wxPluginManager::LoadLibrary(libname
, flags
);
624 void wxPluginManager::Unload()
627 ms_manifest
->BeginFind();
629 // It's either this or store the name of the lib just to do this.
631 for(node
= ms_manifest
->Next(); node
; node
= ms_manifest
->Next())
632 if( (wxPluginLibrary
*)node
->GetData() == m_entry
)
635 if( m_entry
&& m_entry
->UnrefLib() )
642 // ---------------------------------------------------------------------------
643 // wxDllLoader (all these methods are static)
644 // ---------------------------------------------------------------------------
646 #if WXWIN_COMPATIBILITY_2_2
648 wxDllType
wxDllLoader::LoadLibrary(const wxString
&name
)
650 wxPluginLibrary
*p
= wxPluginManager::LoadLibrary
653 wxDL_DEFAULT
| wxDL_VERBATIM
| wxDL_NOSHARE
656 return p
? p
->GetLibHandle() : 0;
659 void wxDllLoader::UnloadLibrary(wxDllType handle
)
661 wxPluginLibrary
*p
= wxPluginManager::GetObjectFromHandle(handle
);
663 wxCHECK_RET( p
, _T("Unloading a library not loaded with wxDllLoader?") );
669 wxDllLoader::GetSymbol(wxDllType dllHandle
, const wxString
&name
, bool *success
)
671 wxPluginLibrary
*p
= wxPluginManager::GetObjectFromHandle(dllHandle
);
675 wxFAIL_MSG( _T("Using a library not loaded with wxDllLoader?") );
683 return p
->GetSymbol(name
, success
);
686 #endif // WXWIN_COMPATIBILITY_2_2
688 #endif // wxUSE_DYNAMIC_LOADER