src/common/dynlib.cpp

   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
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21 #   pragma implementation "dynlib.h"
  22 #endif
  23
  24 #include  "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27   #pragma hdrstop
  28 #endif
  29 #if wxUSE_DYNLIB_CLASS
  30
  31 #include "wx/dynlib.h"
  32 #include "wx/filefn.h"
  33 #include "wx/intl.h"
  34 #include "wx/log.h"
  35 #include "wx/tokenzr.h"
  36
  37 // ----------------------------------------------------------------------------
  38 // conditional compilation
  39 // ----------------------------------------------------------------------------
  40
  41 #if defined(HAVE_DLOPEN)
  42 #   define wxDllOpen(lib)                dlopen(lib.fn_str(), RTLD_NOW/*RTLD_LAZY*/)
  43 #   define wxDllGetSymbol(handle, name)  dlsym(handle, name.mb_str())
  44 #   define wxDllClose                    dlclose
  45 #elif defined(HAVE_SHL_LOAD)
  46 #   define wxDllOpen(lib)                shl_load(lib.fn_str(), BIND_DEFERRED, 0)
  47 #   define wxDllClose      shl_unload
  48
  49     static inline void *wxDllGetSymbol(shl_t handle, const wxString& name)
  50     {
  51         void *sym;
  52         if ( shl_findsym(&handle, name.mb_str(), TYPE_UNDEFINED, &sym) == 0 )
  53             return sym;
  54         else
  55             return (void *)0;
  56     }
  57 #elif defined(__WINDOWS__)
  58 #   include <windows.h>
  59
  60     // using LoadLibraryEx under Win32 to avoid name clash with LoadLibrary
  61 #   ifdef __WIN32__
  62 #      define wxDllOpen(lib)                  ::LoadLibraryEx(lib, 0, 0)
  63 #   else   // Win16
  64 #      define wxDllOpen(lib)                  ::LoadLibrary(lib)
  65 #   endif  // Win32/16
  66 #   define wxDllGetSymbol(handle, name)    ::GetProcAddress(handle, name)
  67 #   define wxDllClose                      ::FreeLibrary
  68
  69 #elif defined(__OS2__)
  70
  71 #  define INCL_DOS
  72 #  include <os2.h>
  73 #  define wxDllOpen(error, lib, handle)     DosLoadModule(error, sizeof(error), lib, &handle)
  74 #  define wxDllGetSymbol(handle, modaddr)   DosQueryProcAddr(handle, 1L, NULL, (PFN*)modaddr)
  75 #  define wxDllClose(handle)                DosFreeModule(handle)
  76 #else
  77 #   error "Don't know how to load shared libraries on this platform."
  78 #endif // OS
  79
  80 // ---------------------------------------------------------------------------
  81 // Global variables
  82 // ---------------------------------------------------------------------------
  83
  84 wxLibraries wxTheLibraries;
  85
  86 // ----------------------------------------------------------------------------
  87 // private functions
  88 // ----------------------------------------------------------------------------
  89
  90 // construct the full name from the base shared object name: adds a .dll
  91 // suffix under Windows or .so under Unix
  92 static wxString ConstructLibraryName(const wxString& basename)
  93 {
  94     wxString fullname(basename);
  95
  96 #if defined(__UNIX__)
  97 #   if defined(__HPUX__)
  98         fullname << ".sl";
  99 #   else        //__HPUX__
 100         fullname << ".so";
 101 #   endif       //__HPUX__
 102 #elif defined(__WINDOWS__) || defined(__OS2__)
 103     fullname << ".dll";
 104 #endif
 105
 106     return fullname;
 107 }
 108
 109 // ============================================================================
 110 // implementation
 111 // ============================================================================
 112
 113
 114 // ---------------------------------------------------------------------------
 115 // wxLibrary (one instance per dynamic library)
 116 // ---------------------------------------------------------------------------
 117
 118 wxLibrary::wxLibrary(wxDllType handle)
 119 {
 120     typedef wxClassInfo *(*t_get_first)(void);
 121     t_get_first get_first;
 122
 123     m_handle = handle;
 124
 125     // Some system may use a local heap for library.
 126     get_first = (t_get_first)GetSymbol("wxGetClassFirst");
 127     // It is a wxWindows DLL.
 128     if (get_first)
 129         PrepareClasses(get_first());
 130 }
 131
 132 wxLibrary::~wxLibrary()
 133 {
 134     if ( m_handle )
 135     {
 136         wxDllClose(m_handle);
 137     }
 138 }
 139
 140 wxObject *wxLibrary::CreateObject(const wxString& name)
 141 {
 142     wxClassInfo *info = (wxClassInfo *)classTable.Get(name);
 143
 144     if (!info)
 145         return NULL;
 146
 147     return info->CreateObject();
 148 }
 149
 150 void wxLibrary::PrepareClasses(wxClassInfo *first)
 151 {
 152     // Index all class infos by their class name
 153     wxClassInfo *info = first;
 154     while (info)
 155     {
 156         if (info->m_className)
 157             classTable.Put(info->m_className, (wxObject *)info);
 158         info = info->GetNext();
 159     }
 160
 161     // Set base pointers for each wxClassInfo
 162     info = first;
 163     while (info)
 164     {
 165         if (info->GetBaseClassName1())
 166             info->m_baseInfo1 = (wxClassInfo *)classTable.Get(info->GetBaseClassName1());
 167         if (info->GetBaseClassName2())
 168             info->m_baseInfo2 = (wxClassInfo *)classTable.Get(info->GetBaseClassName2());
 169         info = info->m_next;
 170     }
 171 }
 172
 173 void *wxLibrary::GetSymbol(const wxString& symbname)
 174 {
 175    return wxDllLoader::GetSymbol(m_handle, symbname);
 176 }
 177
 178 // ---------------------------------------------------------------------------
 179 // wxDllLoader
 180 // ---------------------------------------------------------------------------
 181
 182 /* static */
 183 wxDllType
 184 wxDllLoader::GetProgramHandle(void)
 185 {
 186 #if defined( HAVE_DLOPEN )
 187    // optain handle for main program
 188    return dlopen(NULL, RTLD_NOW/*RTLD_LAZY*/);
 189 #elif defined (HAVE_SHL_LOAD)
 190    // shl_findsymbol with NULL handle looks up in main program
 191    return 0;
 192 #else
 193    wxFAIL_MSG(_("This method is not implemented under Windows or OS/2"));
 194    return 0;
 195 #endif
 196 }
 197
 198 /* static */
 199 wxDllType
 200 wxDllLoader::LoadLibrary(const wxString & libname, bool *success)
 201 {
 202     wxDllType handle;
 203
 204 #if defined(__WXMAC__)
 205     FSSpec myFSSpec ;
 206     Ptr myMainAddr ;
 207     Str255      myErrName ;
 208
 209     wxMacPathToFSSpec( libname , &myFSSpec ) ;
 210     if (GetDiskFragment( &myFSSpec , 0 , kCFragGoesToEOF , "\p" , kPrivateCFragCopy , &handle , &myMainAddr ,
 211                 myErrName ) != noErr )
 212     {
 213         p2cstr( myErrName ) ;
 214         wxASSERT_MSG( 1 , (char*)myErrName ) ;
 215         return NULL ;
 216     }
 217 #elif defined(__OS2__)
 218     char                            zError[256] = "";
 219     wxDllOpen(zError, libname, handle);
 220 #else // !Mac
 221     handle = wxDllOpen(libname);
 222 #endif // OS
 223
 224     if ( !handle )
 225     {
 226         wxLogSysError(_("Failed to load shared library '%s'"), libname.c_str());
 227     }
 228
 229     if ( success )
 230     {
 231         *success = handle != 0;
 232     }
 233
 234     return handle;
 235 }
 236
 237
 238 /* static */
 239 void
 240 wxDllLoader::UnloadLibrary(wxDllType handle)
 241 {
 242    wxDllClose(handle);
 243 }
 244
 245 /* static */
 246 void *
 247 wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name)
 248 {
 249     void *symbol = NULL;    // return value
 250
 251 #if defined( __WXMAC__ )
 252     Ptr symAddress ;
 253     CFragSymbolClass symClass ;
 254     Str255      symName ;
 255
 256     strcpy( (char*) symName , name ) ;
 257     c2pstr( (char*) symName ) ;
 258
 259     if ( FindSymbol( dllHandle , symName , &symAddress , &symClass ) == noErr )
 260         symbol = (void *)symAddress ;
 261 #elif defined( __OS2__ )
 262     wxDllGetSymbol(dllHandle, symbol);
 263 #else
 264     symbol = wxDllGetSymbol(dllHandle, name);
 265 #endif
 266
 267     if ( !symbol )
 268     {
 269         wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"),
 270                       name.c_str());
 271     }
 272     return symbol;
 273 }
 274
 275 // ---------------------------------------------------------------------------
 276 // wxLibraries (only one instance should normally exist)
 277 // ---------------------------------------------------------------------------
 278
 279 wxLibraries::wxLibraries():m_loaded(wxKEY_STRING)
 280 {
 281 }
 282
 283 wxLibraries::~wxLibraries()
 284 {
 285     wxNode *node = m_loaded.First();
 286
 287     while (node) {
 288         wxLibrary *lib = (wxLibrary *)node->Data();
 289         delete lib;
 290
 291         node = node->Next();
 292     }
 293 }
 294
 295 wxLibrary *wxLibraries::LoadLibrary(const wxString& name)
 296 {
 297     wxNode *node;
 298     wxLibrary *lib;
 299     wxClassInfo *old_sm_first;
 300
 301 #if defined(__VISAGECPP__)
 302     node = m_loaded.Find(name.GetData());
 303     if (node != NULL)
 304         return ((wxLibrary *)node->Data());
 305 #else // !OS/2
 306     if ( (node = m_loaded.Find(name.GetData())) )
 307         return ((wxLibrary *)node->Data());
 308 #endif
 309     // If DLL shares data, this is necessary.
 310     old_sm_first = wxClassInfo::sm_first;
 311     wxClassInfo::sm_first = NULL;
 312
 313     wxString libname = ConstructLibraryName(name);
 314
 315 /*
 316   Unix automatically builds that library name, at least for dlopen()
 317 */
 318 #if 0
 319 #if defined(__UNIX__)
 320     // found the first file in LD_LIBRARY_PATH with this name
 321     wxString libPath("/lib:/usr/lib"); // system path first
 322     const char *envLibPath = getenv("LD_LIBRARY_PATH");
 323     if ( envLibPath )
 324         libPath << ':' << envLibPath;
 325     wxStringTokenizer tokenizer(libPath, wxT(':'));
 326     while ( tokenizer.HasMoreToken() )
 327     {
 328         wxString fullname(tokenizer.NextToken());
 329
 330         fullname << '/' << libname;
 331         if ( wxFileExists(fullname) )
 332         {
 333             libname = fullname;
 334
 335             // found the library
 336             break;
 337         }
 338     }
 339     //else: not found in the path, leave the name as is (secutiry risk?)
 340
 341 #endif // __UNIX__
 342 #endif
 343
 344     bool success = FALSE;
 345     wxDllType handle = wxDllLoader::LoadLibrary(libname, &success);
 346     if(success)
 347     {
 348        lib = new wxLibrary(handle);
 349        wxClassInfo::sm_first = old_sm_first;
 350        m_loaded.Append(name.GetData(), lib);
 351     }
 352     else
 353        lib = NULL;
 354     return lib;
 355 }
 356
 357 wxObject *wxLibraries::CreateObject(const wxString& path)
 358 {
 359     wxNode *node = m_loaded.First();
 360     wxObject *obj;
 361
 362     while (node) {
 363         obj = ((wxLibrary *)node->Data())->CreateObject(path);
 364         if (obj)
 365             return obj;
 366
 367         node = node->Next();
 368     }
 369     return NULL;
 370 }
 371
 372 #endif // wxUSE_DYNLIB_CLASS