]>
Commit | Line | Data |
---|---|---|
7a4b9130 GL |
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 | |
55d99c7a | 9 | // Licence: wxWindows licence |
7a4b9130 GL |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
7b0bfbb2 VZ |
12 | // ============================================================================ |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
7a4b9130 | 20 | #ifdef __GNUG__ |
a585ca5c | 21 | # pragma implementation "dynlib.h" |
7a4b9130 GL |
22 | #endif |
23 | ||
0c32066b JS |
24 | #include "wx/wxprec.h" |
25 | ||
2df7be7f RR |
26 | #ifdef __BORLANDC__ |
27 | #pragma hdrstop | |
28 | #endif | |
f6bcfd97 | 29 | |
481fcc78 | 30 | #if wxUSE_DYNLIB_CLASS && !wxUSE_DYNAMIC_LOADER |
8a0d4cf6 | 31 | |
f6bcfd97 BP |
32 | #if defined(__WINDOWS__) |
33 | #include "wx/msw/private.h" | |
34 | #endif | |
35 | ||
7b0bfbb2 VZ |
36 | #include "wx/dynlib.h" |
37 | #include "wx/filefn.h" | |
38 | #include "wx/intl.h" | |
39 | #include "wx/log.h" | |
40 | ||
76a5e5d2 SC |
41 | #if defined(__WXMAC__) |
42 | #include "wx/mac/private.h" | |
43 | #endif | |
44 | ||
7b0bfbb2 VZ |
45 | // ---------------------------------------------------------------------------- |
46 | // conditional compilation | |
47 | // ---------------------------------------------------------------------------- | |
48 | ||
1a787c5d SN |
49 | #if defined(__WXPM__) || defined(__EMX__) |
50 | # define INCL_DOS | |
51 | # include <os2.h> | |
52 | # define wxDllOpen(error, lib, handle) DosLoadModule(error, sizeof(error), lib, &handle) | |
53 | # define wxDllGetSymbol(handle, modaddr) DosQueryProcAddr(handle, 1L, NULL, (PFN*)modaddr) | |
54 | # define wxDllClose(handle) DosFreeModule(handle) | |
55 | #elif defined(HAVE_DLOPEN) | |
237c5c02 VZ |
56 | // note about dlopen() flags: we use RTLD_NOW to have more Windows-like |
57 | // behaviour (Win won't let you load a library with missing symbols) and | |
58 | // RTLD_GLOBAL because it is needed sometimes and probably doesn't hurt | |
343a06a5 JJ |
59 | // otherwise. On True64-Unix RTLD_GLOBAL is not allowed and on VMS the |
60 | // second argument on dlopen is ignored. | |
99d96a2b JJ |
61 | #ifdef __VMS |
62 | # define wxDllOpen(lib) dlopen(lib.fn_str(), 0 ) | |
343a06a5 JJ |
63 | #elif defined( __osf__ ) |
64 | # define wxDllOpen(lib) dlopen(lib.fn_str(), RTLD_LAZY ) | |
99d96a2b JJ |
65 | #else |
66 | # define wxDllOpen(lib) dlopen(lib.fn_str(), RTLD_LAZY | RTLD_GLOBAL) | |
67 | #endif | |
68 | #define wxDllGetSymbol(handle, name) dlsym(handle, name) | |
a585ca5c | 69 | # define wxDllClose dlclose |
8a0d4cf6 | 70 | #elif defined(HAVE_SHL_LOAD) |
a585ca5c | 71 | # define wxDllOpen(lib) shl_load(lib.fn_str(), BIND_DEFERRED, 0) |
237c5c02 | 72 | # define wxDllClose shl_unload |
846e1424 | 73 | |
0b9ab0bd RL |
74 | static inline void *wxDllGetSymbol(shl_t handle, const wxString& name) |
75 | { | |
76 | void *sym; | |
77 | if ( shl_findsym(&handle, name.mb_str(), TYPE_UNDEFINED, &sym) == 0 ) | |
78 | return sym; | |
79 | else | |
80 | return 0; | |
81 | } | |
82 | ||
f11bdd03 GD |
83 | #elif defined(__DARWIN__) |
84 | /* Porting notes: | |
85 | * The dlopen port is a port from dl_next.xs by Anno Siegel. | |
86 | * dl_next.xs is itself a port from dl_dlopen.xs by Paul Marquess. | |
87 | * The method used here is just to supply the sun style dlopen etc. | |
88 | * functions in terms of Darwin NS*. | |
89 | */ | |
4c27c3c6 GD |
90 | void *dlopen(const char *path, int mode /* mode is ignored */); |
91 | void *dlsym(void *handle, const char *symbol); | |
03e11df5 | 92 | int dlclose(void *handle); |
4c27c3c6 | 93 | const char *dlerror(void); |
03e11df5 GD |
94 | |
95 | # define wxDllOpen(lib) dlopen(lib.fn_str(), 0) | |
96 | # define wxDllGetSymbol(handle, name) dlsym(handle, name) | |
97 | # define wxDllClose dlclose | |
7b0bfbb2 | 98 | #elif defined(__WINDOWS__) |
90022ddc | 99 | // using LoadLibraryEx under Win32 to avoid name clash with LoadLibrary |
a585ca5c | 100 | # ifdef __WIN32__ |
f6bcfd97 BP |
101 | #ifdef _UNICODE |
102 | # define wxDllOpen(lib) ::LoadLibraryExW(lib, 0, 0) | |
103 | #else | |
104 | # define wxDllOpen(lib) ::LoadLibraryExA(lib, 0, 0) | |
105 | #endif | |
a585ca5c KB |
106 | # else // Win16 |
107 | # define wxDllOpen(lib) ::LoadLibrary(lib) | |
108 | # endif // Win32/16 | |
109 | # define wxDllGetSymbol(handle, name) ::GetProcAddress(handle, name) | |
110 | # define wxDllClose ::FreeLibrary | |
763ca781 | 111 | #elif defined(__WXMAC__) |
76a5e5d2 | 112 | # define wxDllClose(handle) CloseConnection(&((CFragConnectionID)handle)) |
7b0bfbb2 | 113 | #else |
a585ca5c | 114 | # error "Don't know how to load shared libraries on this platform." |
7b0bfbb2 | 115 | #endif // OS |
7a4b9130 GL |
116 | |
117 | // --------------------------------------------------------------------------- | |
7b0bfbb2 | 118 | // Global variables |
7a4b9130 GL |
119 | // --------------------------------------------------------------------------- |
120 | ||
7b0bfbb2 | 121 | wxLibraries wxTheLibraries; |
7a4b9130 | 122 | |
f6bcfd97 BP |
123 | // ============================================================================ |
124 | // implementation | |
125 | // ============================================================================ | |
123a7fdd | 126 | |
7b0bfbb2 VZ |
127 | // construct the full name from the base shared object name: adds a .dll |
128 | // suffix under Windows or .so under Unix | |
129 | static wxString ConstructLibraryName(const wxString& basename) | |
130 | { | |
f6bcfd97 BP |
131 | wxString fullname; |
132 | fullname << basename << wxDllLoader::GetDllExt(); | |
27529614 | 133 | |
7b0bfbb2 VZ |
134 | return fullname; |
135 | } | |
7a4b9130 | 136 | |
7a4b9130 | 137 | // --------------------------------------------------------------------------- |
7b0bfbb2 | 138 | // wxLibrary (one instance per dynamic library) |
7a4b9130 GL |
139 | // --------------------------------------------------------------------------- |
140 | ||
7b0bfbb2 | 141 | wxLibrary::wxLibrary(wxDllType handle) |
7a4b9130 | 142 | { |
7b0bfbb2 VZ |
143 | typedef wxClassInfo *(*t_get_first)(void); |
144 | t_get_first get_first; | |
7a4b9130 | 145 | |
7b0bfbb2 | 146 | m_handle = handle; |
7a4b9130 | 147 | |
7b0bfbb2 | 148 | // Some system may use a local heap for library. |
55b7aaea | 149 | get_first = (t_get_first)GetSymbol(_T("wxGetClassFirst")); |
7b0bfbb2 VZ |
150 | // It is a wxWindows DLL. |
151 | if (get_first) | |
152 | PrepareClasses(get_first()); | |
7a4b9130 GL |
153 | } |
154 | ||
155 | wxLibrary::~wxLibrary() | |
156 | { | |
7b0bfbb2 VZ |
157 | if ( m_handle ) |
158 | { | |
159 | wxDllClose(m_handle); | |
160 | } | |
7a4b9130 GL |
161 | } |
162 | ||
163 | wxObject *wxLibrary::CreateObject(const wxString& name) | |
164 | { | |
7b0bfbb2 | 165 | wxClassInfo *info = (wxClassInfo *)classTable.Get(name); |
f4a8c29f | 166 | |
7b0bfbb2 VZ |
167 | if (!info) |
168 | return NULL; | |
f4a8c29f | 169 | |
7b0bfbb2 | 170 | return info->CreateObject(); |
f4a8c29f GL |
171 | } |
172 | ||
856d2e52 | 173 | void wxLibrary::PrepareClasses(wxClassInfo *first) |
f4a8c29f | 174 | { |
7b0bfbb2 VZ |
175 | // Index all class infos by their class name |
176 | wxClassInfo *info = first; | |
177 | while (info) | |
178 | { | |
179 | if (info->m_className) | |
180 | classTable.Put(info->m_className, (wxObject *)info); | |
0b9ab0bd | 181 | info = info->m_next; |
7b0bfbb2 VZ |
182 | } |
183 | ||
184 | // Set base pointers for each wxClassInfo | |
185 | info = first; | |
186 | while (info) | |
187 | { | |
188 | if (info->GetBaseClassName1()) | |
189 | info->m_baseInfo1 = (wxClassInfo *)classTable.Get(info->GetBaseClassName1()); | |
190 | if (info->GetBaseClassName2()) | |
191 | info->m_baseInfo2 = (wxClassInfo *)classTable.Get(info->GetBaseClassName2()); | |
192 | info = info->m_next; | |
193 | } | |
7a4b9130 GL |
194 | } |
195 | ||
196 | void *wxLibrary::GetSymbol(const wxString& symbname) | |
197 | { | |
a585ca5c KB |
198 | return wxDllLoader::GetSymbol(m_handle, symbname); |
199 | } | |
7b0bfbb2 | 200 | |
a585ca5c KB |
201 | // --------------------------------------------------------------------------- |
202 | // wxDllLoader | |
203 | // --------------------------------------------------------------------------- | |
7b0bfbb2 | 204 | |
f6bcfd97 BP |
205 | |
206 | #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__) | |
0b9ab0bd | 207 | const wxString wxDllLoader::ms_dllext( _T(".dll") ); |
f6bcfd97 | 208 | #elif defined(__UNIX__) |
0b9ab0bd RL |
209 | #if defined(__HPUX__) |
210 | const wxString wxDllLoader::ms_dllext( _T(".sl") ); | |
211 | #else | |
212 | const wxString wxDllLoader::ms_dllext( _T(".so") ); | |
213 | #endif | |
337b2454 SC |
214 | #elif defined(__WXMAC__) |
215 | const wxString wxDllLoader::ms_dllext( _T("") ); | |
f6bcfd97 | 216 | #endif |
f6bcfd97 | 217 | |
0868079c | 218 | /* static */ |
0b9ab0bd | 219 | wxDllType wxDllLoader::GetProgramHandle() |
0868079c | 220 | { |
1a787c5d | 221 | #if defined( HAVE_DLOPEN ) && !defined(__EMX__) |
7742efff | 222 | // optain handle for main program |
d236a959 | 223 | return dlopen(NULL, RTLD_NOW/*RTLD_LAZY*/); |
7742efff KB |
224 | #elif defined (HAVE_SHL_LOAD) |
225 | // shl_findsymbol with NULL handle looks up in main program | |
d236a959 | 226 | return 0; |
0868079c | 227 | #else |
58c837a4 | 228 | wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2")); |
7742efff | 229 | return 0; |
7cc98b3e | 230 | #endif |
0868079c KB |
231 | } |
232 | ||
a585ca5c | 233 | /* static */ |
0b9ab0bd | 234 | wxDllType wxDllLoader::LoadLibrary(const wxString & libname, bool *success) |
a585ca5c | 235 | { |
0b9ab0bd RL |
236 | wxDllType handle; |
237 | bool failed = FALSE; | |
7b0bfbb2 | 238 | |
03e11df5 | 239 | #if defined(__WXMAC__) && !defined(__UNIX__) |
0b9ab0bd RL |
240 | FSSpec myFSSpec; |
241 | Ptr myMainAddr; | |
242 | Str255 myErrName; | |
243 | ||
244 | wxMacFilename2FSSpec( libname , &myFSSpec ); | |
245 | ||
246 | if( GetDiskFragment( &myFSSpec, | |
247 | 0, | |
248 | kCFragGoesToEOF, | |
249 | "\p", | |
250 | kPrivateCFragCopy, | |
76a5e5d2 | 251 | &((CFragConnectionID)handle), |
0b9ab0bd RL |
252 | &myMainAddr, |
253 | myErrName ) != noErr ) | |
7cc98b3e | 254 | { |
0b9ab0bd RL |
255 | p2cstr( myErrName ); |
256 | wxLogSysError( _("Failed to load shared library '%s' Error '%s'"), | |
257 | libname.c_str(), | |
258 | (char*)myErrName ); | |
259 | handle = 0; | |
260 | failed = TRUE; | |
7cc98b3e | 261 | } |
0b9ab0bd | 262 | |
1a787c5d | 263 | #elif defined(__WXPM__) || defined(__EMX__) |
0b9ab0bd | 264 | char zError[256] = ""; |
c2ff79b1 | 265 | wxDllOpen(zError, libname, handle); |
0b9ab0bd RL |
266 | |
267 | #else | |
93d2bf44 | 268 | handle = wxDllOpen(libname); |
0b9ab0bd RL |
269 | |
270 | #endif | |
a585ca5c | 271 | |
7cc98b3e VZ |
272 | if ( !handle ) |
273 | { | |
f6bcfd97 BP |
274 | wxString msg(_("Failed to load shared library '%s'")); |
275 | ||
276 | #ifdef HAVE_DLERROR | |
d0166913 | 277 | const wxChar *err = dlerror(); |
0b9ab0bd | 278 | if( err ) |
f6bcfd97 | 279 | { |
0b9ab0bd RL |
280 | failed = TRUE; |
281 | wxLogError( msg, err ); | |
f6bcfd97 | 282 | } |
0b9ab0bd RL |
283 | #else |
284 | failed = TRUE; | |
285 | wxLogSysError( msg, libname.c_str() ); | |
286 | #endif | |
7cc98b3e VZ |
287 | } |
288 | ||
289 | if ( success ) | |
0b9ab0bd | 290 | *success = !failed; |
7cc98b3e VZ |
291 | |
292 | return handle; | |
a585ca5c KB |
293 | } |
294 | ||
752c7d6b KB |
295 | |
296 | /* static */ | |
0b9ab0bd | 297 | void wxDllLoader::UnloadLibrary(wxDllType handle) |
752c7d6b KB |
298 | { |
299 | wxDllClose(handle); | |
300 | } | |
301 | ||
a585ca5c | 302 | /* static */ |
0b9ab0bd | 303 | void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success) |
a585ca5c | 304 | { |
0b9ab0bd RL |
305 | bool failed = FALSE; |
306 | void *symbol = 0; | |
a585ca5c | 307 | |
03e11df5 | 308 | #if defined(__WXMAC__) && !defined(__UNIX__) |
0b9ab0bd RL |
309 | Ptr symAddress; |
310 | CFragSymbolClass symClass; | |
311 | Str255 symName; | |
7cc98b3e | 312 | |
c4e41ce3 SC |
313 | wxMacStringToPascal( name.c_str() , symName ) ; |
314 | ||
76a5e5d2 | 315 | if( FindSymbol( ((CFragConnectionID)dllHandle), symName, &symAddress, &symClass ) == noErr ) |
0b9ab0bd | 316 | symbol = (void *)symAddress; |
7cc98b3e | 317 | |
0b9ab0bd | 318 | #elif defined(__WXPM__) || defined(__EMX__) |
c2ff79b1 | 319 | wxDllGetSymbol(dllHandle, symbol); |
0b9ab0bd | 320 | |
b7b35e50 VZ |
321 | #else // Windows or Unix |
322 | ||
f6bcfd97 | 323 | // mb_str() is necessary in Unicode build |
b7b35e50 VZ |
324 | // |
325 | // "void *" cast is needed by gcc 3.1 + w32api 1.4, don't ask me why | |
326 | symbol = (void *)wxDllGetSymbol(dllHandle, name.mb_str()); | |
0b9ab0bd | 327 | |
b7b35e50 | 328 | #endif // OS |
7b0bfbb2 VZ |
329 | |
330 | if ( !symbol ) | |
331 | { | |
0b9ab0bd | 332 | #ifdef HAVE_DLERROR |
d0166913 | 333 | const wxChar *err = dlerror(); |
0b9ab0bd RL |
334 | if( err ) |
335 | { | |
ee682a94 | 336 | wxLogError(wxT("%s"), err); |
0b9ab0bd RL |
337 | } |
338 | #else | |
339 | failed = TRUE; | |
7cc98b3e VZ |
340 | wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"), |
341 | name.c_str()); | |
0b9ab0bd | 342 | #endif |
7b0bfbb2 | 343 | } |
0b9ab0bd RL |
344 | |
345 | if( success ) | |
346 | *success = !failed; | |
347 | ||
7b0bfbb2 | 348 | return symbol; |
7a4b9130 GL |
349 | } |
350 | ||
351 | // --------------------------------------------------------------------------- | |
352 | // wxLibraries (only one instance should normally exist) | |
353 | // --------------------------------------------------------------------------- | |
354 | ||
65fd5cb0 | 355 | wxLibraries::wxLibraries():m_loaded(wxKEY_STRING) |
7a4b9130 GL |
356 | { |
357 | } | |
358 | ||
359 | wxLibraries::~wxLibraries() | |
360 | { | |
7b0bfbb2 | 361 | wxNode *node = m_loaded.First(); |
7a4b9130 | 362 | |
7b0bfbb2 VZ |
363 | while (node) { |
364 | wxLibrary *lib = (wxLibrary *)node->Data(); | |
365 | delete lib; | |
7a4b9130 | 366 | |
7b0bfbb2 VZ |
367 | node = node->Next(); |
368 | } | |
7a4b9130 GL |
369 | } |
370 | ||
371 | wxLibrary *wxLibraries::LoadLibrary(const wxString& name) | |
372 | { | |
0b9ab0bd | 373 | wxLibrary *lib; |
7b0bfbb2 | 374 | wxClassInfo *old_sm_first; |
0b9ab0bd | 375 | wxNode *node = m_loaded.Find(name.GetData()); |
7a4b9130 | 376 | |
c2ff79b1 DW |
377 | if (node != NULL) |
378 | return ((wxLibrary *)node->Data()); | |
0b9ab0bd | 379 | |
7b0bfbb2 VZ |
380 | // If DLL shares data, this is necessary. |
381 | old_sm_first = wxClassInfo::sm_first; | |
382 | wxClassInfo::sm_first = NULL; | |
383 | ||
7cc98b3e | 384 | wxString libname = ConstructLibraryName(name); |
856d2e52 | 385 | |
4dc2c3bb | 386 | bool success = FALSE; |
7cc98b3e | 387 | wxDllType handle = wxDllLoader::LoadLibrary(libname, &success); |
a585ca5c | 388 | if(success) |
7b0bfbb2 | 389 | { |
a585ca5c KB |
390 | lib = new wxLibrary(handle); |
391 | wxClassInfo::sm_first = old_sm_first; | |
0b9ab0bd | 392 | |
a585ca5c | 393 | m_loaded.Append(name.GetData(), lib); |
7b0bfbb2 | 394 | } |
a585ca5c KB |
395 | else |
396 | lib = NULL; | |
7b0bfbb2 | 397 | return lib; |
7a4b9130 GL |
398 | } |
399 | ||
400 | wxObject *wxLibraries::CreateObject(const wxString& path) | |
401 | { | |
7b0bfbb2 VZ |
402 | wxNode *node = m_loaded.First(); |
403 | wxObject *obj; | |
7a4b9130 | 404 | |
7b0bfbb2 VZ |
405 | while (node) { |
406 | obj = ((wxLibrary *)node->Data())->CreateObject(path); | |
407 | if (obj) | |
408 | return obj; | |
7a4b9130 | 409 | |
7b0bfbb2 VZ |
410 | node = node->Next(); |
411 | } | |
412 | return NULL; | |
7a4b9130 | 413 | } |
8a0d4cf6 | 414 | |
229d3f1c GD |
415 | #endif // wxUSE_DYNLIB_CLASS && !wxUSE_DYNAMIC_LOADER |
416 | ||
417 | #if defined(__DARWIN__) && (wxUSE_DYNLIB_CLASS || wxUSE_DYNAMIC_LOADER) | |
f11bdd03 GD |
418 | // --------------------------------------------------------------------------- |
419 | // For Darwin/Mac OS X | |
420 | // supply the sun style dlopen functions in terms of Darwin NS* | |
421 | // --------------------------------------------------------------------------- | |
422 | ||
229d3f1c GD |
423 | #include <stdio.h> |
424 | #include <mach-o/dyld.h> | |
f11bdd03 GD |
425 | |
426 | static char dl_last_error[1024]; | |
427 | ||
428 | static | |
f9ee64b1 | 429 | void TranslateError(const char *path, int number) |
f11bdd03 GD |
430 | { |
431 | unsigned int index; | |
432 | static char *OFIErrorStrings[] = | |
433 | { | |
434 | "%s(%d): Object Image Load Failure\n", | |
435 | "%s(%d): Object Image Load Success\n", | |
436 | "%s(%d): Not an recognisable object file\n", | |
437 | "%s(%d): No valid architecture\n", | |
438 | "%s(%d): Object image has an invalid format\n", | |
439 | "%s(%d): Invalid access (permissions?)\n", | |
440 | "%s(%d): Unknown error code from NSCreateObjectFileImageFromFile\n", | |
441 | }; | |
442 | #define NUM_OFI_ERRORS (sizeof(OFIErrorStrings) / sizeof(OFIErrorStrings[0])) | |
443 | ||
f9ee64b1 GD |
444 | index = number; |
445 | if (index > NUM_OFI_ERRORS - 1) { | |
446 | index = NUM_OFI_ERRORS - 1; | |
f11bdd03 | 447 | } |
f9ee64b1 | 448 | sprintf(dl_last_error, OFIErrorStrings[index], path, number); |
f11bdd03 GD |
449 | } |
450 | ||
451 | const char *dlerror() | |
452 | { | |
453 | return dl_last_error; | |
454 | } | |
455 | ||
1b0674f7 | 456 | void *dlopen(const char *path, int WXUNUSED(mode) /* mode is ignored */) |
f11bdd03 GD |
457 | { |
458 | int dyld_result; | |
459 | NSObjectFileImage ofile; | |
460 | NSModule handle = NULL; | |
461 | ||
462 | dyld_result = NSCreateObjectFileImageFromFile(path, &ofile); | |
463 | if (dyld_result != NSObjectFileImageSuccess) | |
464 | { | |
f9ee64b1 | 465 | TranslateError(path, dyld_result); |
f11bdd03 GD |
466 | } |
467 | else | |
468 | { | |
469 | // NSLinkModule will cause the run to abort on any link error's | |
470 | // not very friendly but the error recovery functionality is limited. | |
f9ee64b1 | 471 | handle = NSLinkModule(ofile, path, NSLINKMODULE_OPTION_BINDNOW); |
f11bdd03 GD |
472 | } |
473 | ||
474 | return handle; | |
475 | } | |
476 | ||
f9ee64b1 | 477 | int dlclose(void *handle) |
f11bdd03 | 478 | { |
a8522481 | 479 | NSUnLinkModule( handle, NSUNLINKMODULE_OPTION_NONE); |
f11bdd03 GD |
480 | return 0; |
481 | } | |
482 | ||
0154fd2c | 483 | void *dlsym(void *handle, const char *symbol) |
f11bdd03 GD |
484 | { |
485 | void *addr; | |
0154fd2c SC |
486 | |
487 | NSSymbol nsSymbol = NSLookupSymbolInModule( handle , symbol ) ; | |
f11bdd03 | 488 | |
0154fd2c SC |
489 | if ( nsSymbol) |
490 | { | |
491 | addr = NSAddressOfSymbol(nsSymbol); | |
f11bdd03 | 492 | } |
0154fd2c SC |
493 | else |
494 | { | |
495 | addr = NULL; | |
f11bdd03 GD |
496 | } |
497 | return addr; | |
498 | } | |
499 | ||
229d3f1c | 500 | #endif // defined(__DARWIN__) && (wxUSE_DYNLIB_CLASS || wxUSE_DYNAMIC_LOADER) |