]>
Commit | Line | Data |
---|---|---|
0b9ab0bd RL |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: dynload.cpp | |
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) | |
6 | // Modified by: | |
7 | // Created: 03/12/01 | |
8 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) 2001 Ron Lee <ron@debian.org> | |
10 | // Licence: wxWindows license | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | #ifdef __GNUG__ | |
14 | #pragma implementation "dynload.h" | |
15 | #endif | |
16 | ||
17 | // ---------------------------------------------------------------------------- | |
18 | // headers | |
19 | // ---------------------------------------------------------------------------- | |
20 | ||
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
409bd320 | 24 | #pragma hdrstop |
0b9ab0bd RL |
25 | #endif |
26 | ||
27 | #if wxUSE_DYNAMIC_LOADER | |
28 | ||
29 | #ifdef __WINDOWS__ | |
409bd320 | 30 | #include "wx/msw/private.h" |
0b9ab0bd RL |
31 | #endif |
32 | ||
33 | #ifndef WX_PRECOMP | |
409bd320 VZ |
34 | #include "wx/log.h" |
35 | #include "wx/intl.h" | |
2b5f62a0 | 36 | #include "wx/hash.h" |
0b9ab0bd RL |
37 | #endif |
38 | ||
409bd320 | 39 | #include "wx/filename.h" // for SplitPath() |
401eb3de | 40 | #include "wx/strconv.h" |
0b9ab0bd | 41 | |
409bd320 | 42 | #include "wx/dynload.h" |
dabd1377 | 43 | #include "wx/module.h" |
0b9ab0bd | 44 | |
f9ee64b1 GD |
45 | #if defined(__DARWIN__) |
46 | /* Porting notes: | |
47 | * The dlopen port is a port from dl_next.xs by Anno Siegel. | |
48 | * dl_next.xs is itself a port from dl_dlopen.xs by Paul Marquess. | |
49 | * The method used here is just to supply the sun style dlopen etc. | |
50 | * functions in terms of Darwin NS*. | |
51 | */ | |
52 | void *dlopen(const char *path, int mode /* mode is ignored */); | |
53 | void *dlsym(void *handle, const char *symbol); | |
54 | int dlclose(void *handle); | |
55 | const char *dlerror(void); | |
56 | #endif | |
57 | ||
0b9ab0bd RL |
58 | // ============================================================================ |
59 | // implementation | |
60 | // ============================================================================ | |
61 | ||
62 | // --------------------------------------------------------------------------- | |
4f89dbc4 | 63 | // wxDynamicLibrary |
0b9ab0bd RL |
64 | // --------------------------------------------------------------------------- |
65 | ||
4f89dbc4 RL |
66 | //FIXME: This class isn't really common at all, it should be moved into |
67 | // platform dependent files. | |
0b9ab0bd RL |
68 | |
69 | #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__) | |
478e0341 | 70 | const wxChar *wxDynamicLibrary::ms_dllext = _T(".dll"); |
0b9ab0bd | 71 | #elif defined(__UNIX__) |
d0fcccc4 | 72 | #if defined(__HPUX__) |
478e0341 | 73 | const wxChar *wxDynamicLibrary::ms_dllext = _T(".sl"); |
d0fcccc4 | 74 | #else |
478e0341 | 75 | const wxChar *wxDynamicLibrary::ms_dllext = _T(".so"); |
d0fcccc4 | 76 | #endif |
0b9ab0bd RL |
77 | #endif |
78 | ||
4f89dbc4 | 79 | wxDllType wxDynamicLibrary::GetProgramHandle() |
0b9ab0bd RL |
80 | { |
81 | #if defined( HAVE_DLOPEN ) && !defined(__EMX__) | |
4f89dbc4 | 82 | return dlopen(0, RTLD_LAZY); |
0b9ab0bd | 83 | #elif defined (HAVE_SHL_LOAD) |
4f89dbc4 | 84 | return PROG_HANDLE; |
0b9ab0bd RL |
85 | #else |
86 | wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2")); | |
87 | return 0; | |
88 | #endif | |
89 | } | |
90 | ||
23213f18 | 91 | bool wxDynamicLibrary::Load(wxString libname, int flags) |
0b9ab0bd | 92 | { |
4f89dbc4 RL |
93 | wxASSERT_MSG(m_handle == 0, _T("Library already loaded.")); |
94 | ||
409bd320 VZ |
95 | // add the proper extension for the DLL ourselves unless told not to |
96 | if ( !(flags & wxDL_VERBATIM) ) | |
97 | { | |
98 | // and also check that the libname doesn't already have it | |
99 | wxString ext; | |
100 | wxFileName::SplitPath(libname, NULL, NULL, &ext); | |
101 | if ( ext.empty() ) | |
102 | { | |
103 | libname += GetDllExt(); | |
104 | } | |
105 | } | |
0b9ab0bd | 106 | |
ee1107cf VZ |
107 | // different ways to load a shared library |
108 | // | |
109 | // FIXME: should go to the platform-specific files! | |
f9ee64b1 | 110 | #if defined(__WXMAC__) && !defined(__DARWIN__) |
0b9ab0bd RL |
111 | FSSpec myFSSpec; |
112 | Ptr myMainAddr; | |
113 | Str255 myErrName; | |
114 | ||
115 | wxMacFilename2FSSpec( libname , &myFSSpec ); | |
116 | ||
117 | if( GetDiskFragment( &myFSSpec, | |
118 | 0, | |
119 | kCFragGoesToEOF, | |
120 | "\p", | |
121 | kPrivateCFragCopy, | |
4f89dbc4 | 122 | &m_handle, |
0b9ab0bd RL |
123 | &myMainAddr, |
124 | myErrName ) != noErr ) | |
125 | { | |
126 | p2cstr( myErrName ); | |
127 | wxLogSysError( _("Failed to load shared library '%s' Error '%s'"), | |
128 | libname.c_str(), | |
129 | (char*)myErrName ); | |
4f89dbc4 | 130 | m_handle = 0; |
0b9ab0bd RL |
131 | } |
132 | ||
133 | #elif defined(__WXPM__) || defined(__EMX__) | |
4f89dbc4 | 134 | char err[256] = ""; |
c822ad5a | 135 | DosLoadModule(err, sizeof(err), libname.c_str(), &m_handle); |
4f89dbc4 | 136 | |
f9ee64b1 | 137 | #elif defined(HAVE_DLOPEN) || defined(__DARWIN__) |
4f89dbc4 | 138 | |
f9ee64b1 | 139 | #if defined(__VMS) || defined(__DARWIN__) |
4f89dbc4 | 140 | m_handle = dlopen(libname.c_str(), 0); // The second parameter is ignored |
ee1107cf | 141 | #else // !__VMS && !__DARWIN__ |
4f89dbc4 RL |
142 | int rtldFlags = 0; |
143 | ||
ee1107cf | 144 | if ( flags & wxDL_LAZY ) |
4f89dbc4 RL |
145 | { |
146 | wxASSERT_MSG( (flags & wxDL_NOW) == 0, | |
147 | _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") ); | |
ee1107cf | 148 | #ifdef RTLD_LAZY |
4f89dbc4 | 149 | rtldFlags |= RTLD_LAZY; |
ee1107cf VZ |
150 | #else |
151 | wxLogDebug(_T("wxDL_LAZY is not supported on this platform")); | |
152 | #endif | |
4f89dbc4 | 153 | } |
ee1107cf | 154 | else if ( flags & wxDL_NOW ) |
4f89dbc4 | 155 | { |
ee1107cf | 156 | #ifdef RTLD_NOW |
4f89dbc4 | 157 | rtldFlags |= RTLD_NOW; |
ee1107cf VZ |
158 | #else |
159 | wxLogDebug(_T("wxDL_NOW is not supported on this platform")); | |
160 | #endif | |
4f89dbc4 | 161 | } |
ee1107cf VZ |
162 | |
163 | if ( flags & wxDL_GLOBAL ) | |
4f89dbc4 | 164 | { |
ee1107cf | 165 | #ifdef RTLD_GLOBAL |
4f89dbc4 | 166 | rtldFlags |= RTLD_GLOBAL; |
ee1107cf VZ |
167 | #else |
168 | wxLogDebug(_T("RTLD_GLOBAL is not supported on this platform.")); | |
169 | #endif | |
4f89dbc4 RL |
170 | } |
171 | ||
401eb3de | 172 | m_handle = dlopen(libname.fn_str(), rtldFlags); |
ee1107cf | 173 | #endif // __VMS || __DARWIN__ ? |
4f89dbc4 RL |
174 | |
175 | #elif defined(HAVE_SHL_LOAD) | |
176 | int shlFlags = 0; | |
177 | ||
178 | if( flags & wxDL_LAZY ) | |
179 | { | |
180 | wxASSERT_MSG( (flags & wxDL_NOW) == 0, | |
181 | _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") ); | |
182 | shlFlags |= BIND_DEFERRED; | |
183 | } | |
184 | else if( flags & wxDL_NOW ) | |
185 | { | |
186 | shlFlags |= BIND_IMMEDIATE; | |
187 | } | |
401eb3de | 188 | m_handle = shl_load(libname.fn_str(), BIND_DEFERRED, 0); |
4f89dbc4 | 189 | |
4f89dbc4 RL |
190 | #elif defined(__WINDOWS__) |
191 | m_handle = ::LoadLibrary(libname.c_str()); | |
0b9ab0bd | 192 | #else |
ee1107cf | 193 | #error "runtime shared lib support not implemented on this platform" |
0b9ab0bd | 194 | #endif |
4f89dbc4 RL |
195 | |
196 | if ( m_handle == 0 ) | |
0b9ab0bd RL |
197 | { |
198 | wxString msg(_("Failed to load shared library '%s'")); | |
c822ad5a | 199 | #if defined(HAVE_DLERROR) && !defined(__EMX__) |
401eb3de | 200 | |
8e11fbb0 | 201 | #if wxUSE_UNICODE |
401eb3de RR |
202 | wxWCharBuffer buffer = wxConvLocal.cMB2WC( dlerror() ); |
203 | const wxChar *err = buffer; | |
204 | #else | |
205 | const wxChar *err = dlerror(); | |
206 | #endif | |
207 | ||
0b9ab0bd RL |
208 | if( err ) |
209 | wxLogError( msg, err ); | |
210 | #else | |
211 | wxLogSysError( msg, libname.c_str() ); | |
212 | #endif | |
213 | } | |
4f89dbc4 RL |
214 | |
215 | return IsLoaded(); | |
0b9ab0bd RL |
216 | } |
217 | ||
4f89dbc4 | 218 | void wxDynamicLibrary::Unload() |
0b9ab0bd | 219 | { |
4f89dbc4 RL |
220 | if( IsLoaded() ) |
221 | { | |
222 | #if defined(__WXPM__) || defined(__EMX__) | |
223 | DosFreeModule( m_handle ); | |
f9ee64b1 | 224 | #elif defined(HAVE_DLOPEN) || defined(__DARWIN__) |
4f89dbc4 RL |
225 | dlclose( m_handle ); |
226 | #elif defined(HAVE_SHL_LOAD) | |
227 | shl_unload( m_handle ); | |
228 | #elif defined(__WINDOWS__) | |
229 | ::FreeLibrary( m_handle ); | |
f9ee64b1 GD |
230 | #elif defined(__WXMAC__) && !defined(__DARWIN__) |
231 | CloseConnection( (CFragConnectionID*) &m_handle ); | |
4f89dbc4 RL |
232 | #else |
233 | #error "runtime shared lib support not implemented" | |
234 | #endif | |
235 | m_handle = 0; | |
236 | } | |
0b9ab0bd RL |
237 | } |
238 | ||
4f89dbc4 | 239 | void *wxDynamicLibrary::GetSymbol(const wxString &name, bool *success) const |
0b9ab0bd | 240 | { |
4f89dbc4 RL |
241 | wxCHECK_MSG( IsLoaded(), NULL, |
242 | _T("Can't load symbol from unloaded library") ); | |
243 | ||
0b9ab0bd RL |
244 | bool failed = FALSE; |
245 | void *symbol = 0; | |
246 | ||
f9ee64b1 | 247 | #if defined(__WXMAC__) && !defined(__DARWIN__) |
0b9ab0bd RL |
248 | Ptr symAddress; |
249 | CFragSymbolClass symClass; | |
250 | Str255 symName; | |
251 | #if TARGET_CARBON | |
252 | c2pstrcpy( (StringPtr) symName, name ); | |
253 | #else | |
4f89dbc4 RL |
254 | strcpy( (char *)symName, name ); |
255 | c2pstr( (char *)symName ); | |
0b9ab0bd RL |
256 | #endif |
257 | if( FindSymbol( dllHandle, symName, &symAddress, &symClass ) == noErr ) | |
258 | symbol = (void *)symAddress; | |
259 | ||
260 | #elif defined(__WXPM__) || defined(__EMX__) | |
4f89dbc4 RL |
261 | DosQueryProcAddr( m_handle, 1L, name.c_str(), (PFN*)symbol ); |
262 | ||
f9ee64b1 | 263 | #elif defined(HAVE_DLOPEN) || defined(__DARWIN__) |
401eb3de | 264 | symbol = dlsym( m_handle, name.fn_str() ); |
0b9ab0bd | 265 | |
4f89dbc4 | 266 | #elif defined(HAVE_SHL_LOAD) |
2b5f62a0 VZ |
267 | // use local variable since shl_findsym modifies the handle argument |
268 | // to indicate where the symbol was found (GD) | |
269 | wxDllType the_handle = m_handle; | |
270 | if( shl_findsym( &the_handle, name.fn_str(), TYPE_UNDEFINED, &symbol ) != 0 ) | |
4f89dbc4 RL |
271 | symbol = 0; |
272 | ||
4f89dbc4 | 273 | #elif defined(__WINDOWS__) |
7fc0bd1c | 274 | symbol = (void*) ::GetProcAddress( m_handle, name.mb_str() ); |
4f89dbc4 RL |
275 | |
276 | #else | |
277 | #error "runtime shared lib support not implemented" | |
0b9ab0bd RL |
278 | #endif |
279 | ||
280 | if ( !symbol ) | |
281 | { | |
4f89dbc4 | 282 | wxString msg(_("wxDynamicLibrary failed to GetSymbol '%s'")); |
c822ad5a | 283 | #if defined(HAVE_DLERROR) && !defined(__EMX__) |
401eb3de | 284 | |
8e11fbb0 | 285 | #if wxUSE_UNICODE |
401eb3de RR |
286 | wxWCharBuffer buffer = wxConvLocal.cMB2WC( dlerror() ); |
287 | const wxChar *err = buffer; | |
288 | #else | |
a1706592 | 289 | const wxChar *err = dlerror(); |
401eb3de RR |
290 | #endif |
291 | ||
0b9ab0bd RL |
292 | if( err ) |
293 | { | |
294 | failed = TRUE; | |
295 | wxLogError( msg, err ); | |
296 | } | |
297 | #else | |
298 | failed = TRUE; | |
299 | wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"), | |
300 | name.c_str()); | |
301 | #endif | |
302 | } | |
303 | if( success ) | |
304 | *success = !failed; | |
305 | ||
306 | return symbol; | |
307 | } | |
308 | ||
309 | ||
310 | // --------------------------------------------------------------------------- | |
4f89dbc4 | 311 | // wxPluginLibrary |
0b9ab0bd RL |
312 | // --------------------------------------------------------------------------- |
313 | ||
314 | ||
dabd1377 JS |
315 | wxDLImports* wxPluginLibrary::ms_classes = NULL; |
316 | ||
317 | class wxPluginLibraryModule : public wxModule | |
318 | { | |
319 | public: | |
d0fcccc4 VZ |
320 | wxPluginLibraryModule() { } |
321 | ||
322 | // TODO: create ms_classes on demand, why always preallocate it? | |
323 | virtual bool OnInit() | |
324 | { | |
325 | wxPluginLibrary::ms_classes = new wxDLImports(wxKEY_STRING); | |
326 | wxPluginManager::CreateManifest(); | |
327 | return TRUE; | |
328 | } | |
329 | ||
330 | virtual void OnExit() | |
331 | { | |
332 | delete wxPluginLibrary::ms_classes; | |
333 | wxPluginLibrary::ms_classes = NULL; | |
334 | wxPluginManager::ClearManifest(); | |
335 | } | |
dabd1377 JS |
336 | |
337 | private: | |
338 | DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule ) | |
339 | }; | |
340 | ||
341 | IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule) | |
342 | ||
0b9ab0bd | 343 | |
23213f18 | 344 | wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags) |
4f89dbc4 | 345 | : m_linkcount(1) |
7c1e2b44 | 346 | , m_objcount(0) |
0b9ab0bd | 347 | { |
4f89dbc4 RL |
348 | m_before = wxClassInfo::sm_first; |
349 | Load( libname, flags ); | |
350 | m_after = wxClassInfo::sm_first; | |
351 | ||
0b9ab0bd RL |
352 | if( m_handle != 0 ) |
353 | { | |
354 | UpdateClassInfo(); | |
355 | RegisterModules(); | |
356 | } | |
357 | else | |
d0fcccc4 VZ |
358 | { |
359 | // Flag us for deletion | |
360 | --m_linkcount; | |
361 | } | |
0b9ab0bd RL |
362 | } |
363 | ||
4f89dbc4 | 364 | wxPluginLibrary::~wxPluginLibrary() |
0b9ab0bd | 365 | { |
01610529 RL |
366 | if( m_handle != 0 ) |
367 | { | |
368 | UnregisterModules(); | |
369 | RestoreClassInfo(); | |
01610529 | 370 | } |
0b9ab0bd RL |
371 | } |
372 | ||
d0fcccc4 VZ |
373 | wxPluginLibrary *wxPluginLibrary::RefLib() |
374 | { | |
375 | wxCHECK_MSG( m_linkcount > 0, NULL, | |
376 | _T("Library had been already deleted!") ); | |
377 | ||
378 | ++m_linkcount; | |
379 | return this; | |
380 | } | |
381 | ||
4f89dbc4 | 382 | bool wxPluginLibrary::UnrefLib() |
7c1e2b44 | 383 | { |
d0fcccc4 VZ |
384 | wxASSERT_MSG( m_objcount == 0, |
385 | _T("Library unloaded before all objects were destroyed") ); | |
386 | ||
387 | if ( --m_linkcount == 0 ) | |
7c1e2b44 RL |
388 | { |
389 | delete this; | |
390 | return TRUE; | |
391 | } | |
d0fcccc4 | 392 | |
7c1e2b44 RL |
393 | return FALSE; |
394 | } | |
0b9ab0bd RL |
395 | |
396 | // ------------------------ | |
397 | // Private methods | |
398 | // ------------------------ | |
399 | ||
4f89dbc4 | 400 | void wxPluginLibrary::UpdateClassInfo() |
0b9ab0bd RL |
401 | { |
402 | wxClassInfo *info; | |
403 | wxHashTable *t = wxClassInfo::sm_classTable; | |
404 | ||
405 | // FIXME: Below is simply a cut and paste specialisation of | |
406 | // wxClassInfo::InitializeClasses. Once this stabilises, | |
407 | // the two should probably be merged. | |
408 | // | |
409 | // Actually it's becoming questionable whether we should merge | |
410 | // this info with the main ClassInfo tables since we can nearly | |
411 | // handle this completely internally now and it does expose | |
412 | // certain (minimal % user_stupidy) risks. | |
413 | ||
414 | for(info = m_after; info != m_before; info = info->m_next) | |
415 | { | |
416 | if( info->m_className ) | |
417 | { | |
418 | if( t->Get(info->m_className) == 0 ) | |
419 | t->Put(info->m_className, (wxObject *)info); | |
420 | ||
421 | // Hash all the class names into a local table too so | |
422 | // we can quickly find the entry they correspond to. | |
2b5f62a0 | 423 | (*ms_classes)[info->m_className] = this; |
0b9ab0bd RL |
424 | } |
425 | } | |
426 | ||
427 | for(info = m_after; info != m_before; info = info->m_next) | |
428 | { | |
429 | if( info->m_baseClassName1 ) | |
430 | info->m_baseInfo1 = (wxClassInfo *)t->Get(info->m_baseClassName1); | |
431 | if( info->m_baseClassName2 ) | |
432 | info->m_baseInfo2 = (wxClassInfo *)t->Get(info->m_baseClassName2); | |
433 | } | |
434 | } | |
435 | ||
4f89dbc4 | 436 | void wxPluginLibrary::RestoreClassInfo() |
0b9ab0bd RL |
437 | { |
438 | wxClassInfo *info; | |
439 | ||
440 | for(info = m_after; info != m_before; info = info->m_next) | |
441 | { | |
442 | wxClassInfo::sm_classTable->Delete(info->m_className); | |
2b5f62a0 | 443 | ms_classes->erase(ms_classes->find(info->m_className)); |
0b9ab0bd RL |
444 | } |
445 | ||
446 | if( wxClassInfo::sm_first == m_after ) | |
447 | wxClassInfo::sm_first = m_before; | |
448 | else | |
449 | { | |
450 | info = wxClassInfo::sm_first; | |
451 | while( info->m_next && info->m_next != m_after ) info = info->m_next; | |
452 | ||
63fd5f0b | 453 | wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge")); |
0b9ab0bd RL |
454 | |
455 | info->m_next = m_before; | |
456 | } | |
457 | } | |
458 | ||
4f89dbc4 | 459 | void wxPluginLibrary::RegisterModules() |
0b9ab0bd RL |
460 | { |
461 | // Plugin libraries might have wxModules, Register and initialise them if | |
462 | // they do. | |
463 | // | |
464 | // Note that these classes are NOT included in the reference counting since | |
465 | // it's implicit that they will be unloaded if and when the last handle to | |
466 | // the library is. We do have to keep a copy of the module's pointer | |
467 | // though, as there is currently no way to Unregister it without it. | |
468 | ||
7c1e2b44 | 469 | wxASSERT_MSG( m_linkcount == 1, |
0b9ab0bd RL |
470 | _T("RegisterModules should only be called for the first load") ); |
471 | ||
6eccc0c4 | 472 | for ( wxClassInfo *info = m_after; info != m_before; info = info->m_next) |
0b9ab0bd RL |
473 | { |
474 | if( info->IsKindOf(CLASSINFO(wxModule)) ) | |
475 | { | |
476 | wxModule *m = wxDynamicCast(info->CreateObject(), wxModule); | |
477 | ||
478 | wxASSERT_MSG( m, _T("wxDynamicCast of wxModule failed") ); | |
479 | ||
480 | m_wxmodules.Append(m); | |
481 | wxModule::RegisterModule(m); | |
482 | } | |
483 | } | |
484 | ||
485 | // FIXME: Likewise this is (well was) very similar to InitializeModules() | |
486 | ||
6eccc0c4 VZ |
487 | for ( wxModuleList::Node *node = m_wxmodules.GetFirst(); |
488 | node; | |
489 | node = node->GetNext()) | |
0b9ab0bd RL |
490 | { |
491 | if( !node->GetData()->Init() ) | |
492 | { | |
4f89dbc4 | 493 | wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary")); |
0b9ab0bd RL |
494 | |
495 | // XXX: Watch this, a different hash implementation might break it, | |
496 | // a good hash implementation would let us fix it though. | |
497 | ||
498 | // The name of the game is to remove any uninitialised modules and | |
499 | // let the dtor Exit the rest on shutdown, (which we'll initiate | |
500 | // shortly). | |
501 | ||
502 | wxModuleList::Node *oldNode = 0; | |
503 | do { | |
504 | node = node->GetNext(); | |
505 | delete oldNode; | |
506 | wxModule::UnregisterModule( node->GetData() ); | |
507 | oldNode = node; | |
508 | } while( node ); | |
509 | ||
7c1e2b44 | 510 | --m_linkcount; // Flag us for deletion |
0b9ab0bd RL |
511 | break; |
512 | } | |
513 | } | |
514 | } | |
515 | ||
4f89dbc4 | 516 | void wxPluginLibrary::UnregisterModules() |
0b9ab0bd RL |
517 | { |
518 | wxModuleList::Node *node; | |
519 | ||
6eccc0c4 | 520 | for ( node = m_wxmodules.GetFirst(); node; node = node->GetNext() ) |
0b9ab0bd RL |
521 | node->GetData()->Exit(); |
522 | ||
6eccc0c4 | 523 | for ( node = m_wxmodules.GetFirst(); node; node = node->GetNext() ) |
0b9ab0bd RL |
524 | wxModule::UnregisterModule( node->GetData() ); |
525 | ||
526 | m_wxmodules.DeleteContents(TRUE); | |
527 | } | |
528 | ||
529 | ||
530 | // --------------------------------------------------------------------------- | |
d0fcccc4 | 531 | // wxPluginManager |
0b9ab0bd RL |
532 | // --------------------------------------------------------------------------- |
533 | ||
dabd1377 | 534 | wxDLManifest* wxPluginManager::ms_manifest = NULL; |
0b9ab0bd RL |
535 | |
536 | // ------------------------ | |
537 | // Static accessors | |
538 | // ------------------------ | |
539 | ||
d0fcccc4 VZ |
540 | wxPluginLibrary * |
541 | wxPluginManager::LoadLibrary(const wxString &libname, int flags) | |
0b9ab0bd | 542 | { |
4f89dbc4 | 543 | wxString realname(libname); |
0b9ab0bd | 544 | |
4f89dbc4 RL |
545 | if( !(flags & wxDL_VERBATIM) ) |
546 | realname += wxDynamicLibrary::GetDllExt(); | |
547 | ||
d0fcccc4 VZ |
548 | wxPluginLibrary *entry; |
549 | ||
550 | if ( flags & wxDL_NOSHARE ) | |
551 | { | |
552 | entry = NULL; | |
553 | } | |
554 | else | |
555 | { | |
2b5f62a0 | 556 | entry = FindByName(realname); |
d0fcccc4 | 557 | } |
4f89dbc4 | 558 | |
d0fcccc4 | 559 | if ( entry ) |
0b9ab0bd | 560 | { |
d0fcccc4 VZ |
561 | wxLogTrace(_T("dll"), |
562 | _T("LoadLibrary(%s): already loaded."), realname.c_str()); | |
563 | ||
7c1e2b44 | 564 | entry->RefLib(); |
0b9ab0bd RL |
565 | } |
566 | else | |
567 | { | |
4f89dbc4 | 568 | entry = new wxPluginLibrary( libname, flags ); |
0b9ab0bd | 569 | |
d0fcccc4 | 570 | if ( entry->IsLoaded() ) |
0b9ab0bd | 571 | { |
2b5f62a0 | 572 | (*ms_manifest)[realname] = entry; |
d0fcccc4 VZ |
573 | |
574 | wxLogTrace(_T("dll"), | |
575 | _T("LoadLibrary(%s): loaded ok."), realname.c_str()); | |
576 | ||
0b9ab0bd RL |
577 | } |
578 | else | |
579 | { | |
d0fcccc4 VZ |
580 | wxLogTrace(_T("dll"), |
581 | _T("LoadLibrary(%s): failed to load."), realname.c_str()); | |
582 | ||
583 | // we have created entry just above | |
584 | if ( !entry->UnrefLib() ) | |
585 | { | |
586 | // ... so UnrefLib() is supposed to delete it | |
587 | wxFAIL_MSG( _T("Currently linked library is not loaded?") ); | |
588 | } | |
589 | ||
590 | entry = NULL; | |
0b9ab0bd RL |
591 | } |
592 | } | |
d0fcccc4 | 593 | |
0b9ab0bd RL |
594 | return entry; |
595 | } | |
596 | ||
d0fcccc4 | 597 | bool wxPluginManager::UnloadLibrary(const wxString& libname) |
0b9ab0bd | 598 | { |
d0fcccc4 | 599 | wxString realname = libname; |
4f89dbc4 | 600 | |
2b5f62a0 | 601 | wxPluginLibrary *entry = FindByName(realname); |
0b9ab0bd | 602 | |
d0fcccc4 VZ |
603 | if ( !entry ) |
604 | { | |
605 | realname += wxDynamicLibrary::GetDllExt(); | |
0b9ab0bd | 606 | |
2b5f62a0 | 607 | entry = FindByName(realname); |
d0fcccc4 VZ |
608 | } |
609 | ||
610 | if ( !entry ) | |
611 | { | |
612 | wxLogDebug(_T("Attempt to unload library '%s' which is not loaded."), | |
613 | libname.c_str()); | |
614 | ||
615 | return FALSE; | |
616 | } | |
617 | ||
618 | wxLogTrace(_T("dll"), _T("UnloadLibrary(%s)"), realname.c_str()); | |
619 | ||
620 | if ( !entry->UnrefLib() ) | |
621 | { | |
622 | // not really unloaded yet | |
623 | return FALSE; | |
624 | } | |
625 | ||
2b5f62a0 | 626 | ms_manifest->erase(ms_manifest->find(realname)); |
d0fcccc4 VZ |
627 | |
628 | return TRUE; | |
4f89dbc4 RL |
629 | } |
630 | ||
631 | #if WXWIN_COMPATIBILITY_2_2 | |
632 | wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle) | |
633 | { | |
2b5f62a0 VZ |
634 | for ( wxDLManifest::iterator i = ms_manifest->begin(); |
635 | i != ms_manifest->end(); | |
636 | ++i ) | |
637 | { | |
638 | wxPluginLibrary * const lib = i->second; | |
4f89dbc4 | 639 | |
2b5f62a0 VZ |
640 | if ( lib->GetLibHandle() == handle ) |
641 | return lib; | |
642 | } | |
4f89dbc4 | 643 | |
d0fcccc4 | 644 | return NULL; |
0b9ab0bd | 645 | } |
d0fcccc4 | 646 | #endif // WXWIN_COMPATIBILITY_2_2 |
0b9ab0bd RL |
647 | |
648 | // ------------------------ | |
649 | // Class implementation | |
650 | // ------------------------ | |
651 | ||
23213f18 | 652 | bool wxPluginManager::Load(const wxString &libname, int flags) |
0b9ab0bd | 653 | { |
4f89dbc4 | 654 | m_entry = wxPluginManager::LoadLibrary(libname, flags); |
2b5f62a0 | 655 | |
4f89dbc4 | 656 | return IsLoaded(); |
0b9ab0bd RL |
657 | } |
658 | ||
4f89dbc4 | 659 | void wxPluginManager::Unload() |
0b9ab0bd | 660 | { |
2b5f62a0 | 661 | wxCHECK_RET( m_entry, _T("unloading an invalid wxPluginManager?") ); |
0b9ab0bd | 662 | |
2b5f62a0 VZ |
663 | for ( wxDLManifest::iterator i = ms_manifest->begin(); |
664 | i != ms_manifest->end(); | |
665 | ++i ) | |
4f89dbc4 | 666 | { |
2b5f62a0 VZ |
667 | if ( i->second == m_entry ) |
668 | { | |
669 | ms_manifest->erase(i); | |
670 | return; | |
671 | } | |
4f89dbc4 | 672 | } |
2b5f62a0 VZ |
673 | |
674 | m_entry->UnrefLib(); | |
675 | ||
676 | m_entry = NULL; | |
0b9ab0bd RL |
677 | } |
678 | ||
4f89dbc4 RL |
679 | // --------------------------------------------------------------------------- |
680 | // wxDllLoader (all these methods are static) | |
681 | // --------------------------------------------------------------------------- | |
682 | ||
683 | #if WXWIN_COMPATIBILITY_2_2 | |
684 | ||
3d7fa4e6 | 685 | wxDllType wxDllLoader::LoadLibrary(const wxString &name, bool *success) |
4f89dbc4 | 686 | { |
d0fcccc4 VZ |
687 | wxPluginLibrary *p = wxPluginManager::LoadLibrary |
688 | ( | |
689 | name, | |
690 | wxDL_DEFAULT | wxDL_VERBATIM | wxDL_NOSHARE | |
691 | ); | |
692 | ||
3d7fa4e6 VZ |
693 | if ( success ) |
694 | *success = p != NULL; | |
695 | ||
d0fcccc4 | 696 | return p ? p->GetLibHandle() : 0; |
0b9ab0bd RL |
697 | } |
698 | ||
4f89dbc4 | 699 | void wxDllLoader::UnloadLibrary(wxDllType handle) |
0b9ab0bd | 700 | { |
4f89dbc4 | 701 | wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle); |
d0fcccc4 VZ |
702 | |
703 | wxCHECK_RET( p, _T("Unloading a library not loaded with wxDllLoader?") ); | |
704 | ||
4f89dbc4 | 705 | p->UnrefLib(); |
0b9ab0bd RL |
706 | } |
707 | ||
d0fcccc4 VZ |
708 | void * |
709 | wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success) | |
0b9ab0bd | 710 | { |
4f89dbc4 | 711 | wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle); |
d0fcccc4 VZ |
712 | |
713 | if ( !p ) | |
714 | { | |
715 | wxFAIL_MSG( _T("Using a library not loaded with wxDllLoader?") ); | |
716 | ||
717 | if ( success ) | |
718 | *success = FALSE; | |
719 | ||
720 | return NULL; | |
721 | } | |
722 | ||
4f89dbc4 | 723 | return p->GetSymbol(name, success); |
0b9ab0bd RL |
724 | } |
725 | ||
4f89dbc4 RL |
726 | #endif // WXWIN_COMPATIBILITY_2_2 |
727 | ||
0b9ab0bd RL |
728 | #endif // wxUSE_DYNAMIC_LOADER |
729 |