src/common/dynload.cpp

   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 licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ----------------------------------------------------------------------------
  14 // headers
  15 // ----------------------------------------------------------------------------
  16
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20     #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_DYNAMIC_LOADER
  24
  25 #ifdef __WINDOWS__
  26     #include "wx/msw/private.h"
  27 #endif
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/log.h"
  31     #include "wx/intl.h"
  32     #include "wx/hash.h"
  33     #include "wx/utils.h"
  34 #endif
  35
  36 #include "wx/strconv.h"
  37
  38 #include "wx/dynload.h"
  39 #include "wx/module.h"
  40
  41
  42 // ---------------------------------------------------------------------------
  43 // wxPluginLibrary
  44 // ---------------------------------------------------------------------------
  45
  46
  47 wxDLImports*  wxPluginLibrary::ms_classes = NULL;
  48
  49 class wxPluginLibraryModule : public wxModule
  50 {
  51 public:
  52     wxPluginLibraryModule() { }
  53
  54     // TODO: create ms_classes on demand, why always preallocate it?
  55     virtual bool OnInit()
  56     {
  57         wxPluginLibrary::ms_classes = new wxDLImports;
  58         wxPluginManager::CreateManifest();
  59         return true;
  60     }
  61
  62     virtual void OnExit()
  63     {
  64         delete wxPluginLibrary::ms_classes;
  65         wxPluginLibrary::ms_classes = NULL;
  66         wxPluginManager::ClearManifest();
  67     }
  68
  69 private:
  70     DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
  71 };
  72
  73 IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
  74
  75
  76 wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
  77         : m_linkcount(1)
  78         , m_objcount(0)
  79 {
  80     m_before = wxClassInfo::sm_first;
  81     Load( libname, flags );
  82     m_after = wxClassInfo::sm_first;
  83
  84     if( m_handle != 0 )
  85     {
  86         UpdateClasses();
  87         RegisterModules();
  88     }
  89     else
  90     {
  91         // Flag us for deletion
  92         --m_linkcount;
  93     }
  94 }
  95
  96 wxPluginLibrary::~wxPluginLibrary()
  97 {
  98     if( m_handle != 0 )
  99     {
 100         UnregisterModules();
 101         RestoreClasses();
 102     }
 103 }
 104
 105 wxPluginLibrary *wxPluginLibrary::RefLib()
 106 {
 107     wxCHECK_MSG( m_linkcount > 0, NULL,
 108                  _T("Library had been already deleted!") );
 109
 110     ++m_linkcount;
 111     return this;
 112 }
 113
 114 bool wxPluginLibrary::UnrefLib()
 115 {
 116     wxASSERT_MSG( m_objcount == 0,
 117                   _T("Library unloaded before all objects were destroyed") );
 118
 119     if ( m_linkcount == 0 || --m_linkcount == 0 )
 120     {
 121         delete this;
 122         return true;
 123     }
 124
 125     return false;
 126 }
 127
 128 // ------------------------
 129 // Private methods
 130 // ------------------------
 131
 132 void wxPluginLibrary::UpdateClasses()
 133 {
 134     for (wxClassInfo *info = m_after; info != m_before; info = info->m_next)
 135     {
 136         if( info->GetClassName() )
 137         {
 138             // Hash all the class names into a local table too so
 139             // we can quickly find the entry they correspond to.
 140             (*ms_classes)[info->GetClassName()] = this;
 141         }
 142     }
 143 }
 144
 145 void wxPluginLibrary::RestoreClasses()
 146 {
 147     // Check if there is a need to restore classes.
 148     if (!ms_classes)
 149         return;
 150
 151     for(wxClassInfo *info = m_after; info != m_before; info = info->m_next)
 152     {
 153         ms_classes->erase(ms_classes->find(info->GetClassName()));
 154     }
 155 }
 156
 157 void wxPluginLibrary::RegisterModules()
 158 {
 159     // Plugin libraries might have wxModules, Register and initialise them if
 160     // they do.
 161     //
 162     // Note that these classes are NOT included in the reference counting since
 163     // it's implicit that they will be unloaded if and when the last handle to
 164     // the library is.  We do have to keep a copy of the module's pointer
 165     // though, as there is currently no way to Unregister it without it.
 166
 167     wxASSERT_MSG( m_linkcount == 1,
 168                   _T("RegisterModules should only be called for the first load") );
 169
 170     for ( wxClassInfo *info = m_after; info != m_before; info = info->m_next)
 171     {
 172         if( info->IsKindOf(CLASSINFO(wxModule)) )
 173         {
 174             wxModule *m = wxDynamicCast(info->CreateObject(), wxModule);
 175
 176             wxASSERT_MSG( m, _T("wxDynamicCast of wxModule failed") );
 177
 178             m_wxmodules.push_back(m);
 179             wxModule::RegisterModule(m);
 180         }
 181     }
 182
 183     // FIXME: Likewise this is (well was) very similar to InitializeModules()
 184
 185     for ( wxModuleList::iterator it = m_wxmodules.begin();
 186           it != m_wxmodules.end();
 187           ++it)
 188     {
 189         if( !(*it)->Init() )
 190         {
 191             wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary"));
 192
 193             // XXX: Watch this, a different hash implementation might break it,
 194             //      a good hash implementation would let us fix it though.
 195
 196             // The name of the game is to remove any uninitialised modules and
 197             // let the dtor Exit the rest on shutdown, (which we'll initiate
 198             // shortly).
 199
 200             wxModuleList::iterator oldNode = m_wxmodules.end();
 201             do {
 202                 ++it;
 203                 if( oldNode != m_wxmodules.end() )
 204                     m_wxmodules.erase(oldNode);
 205                 wxModule::UnregisterModule( *it );
 206                 oldNode = it;
 207             } while( it != m_wxmodules.end() );
 208
 209             --m_linkcount;     // Flag us for deletion
 210             break;
 211         }
 212     }
 213 }
 214
 215 void wxPluginLibrary::UnregisterModules()
 216 {
 217     wxModuleList::iterator it;
 218
 219     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 220         (*it)->Exit();
 221
 222     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 223         wxModule::UnregisterModule( *it );
 224
 225     // NB: content of the list was deleted by UnregisterModule calls above:
 226     m_wxmodules.clear();
 227 }
 228
 229
 230 // ---------------------------------------------------------------------------
 231 // wxPluginManager
 232 // ---------------------------------------------------------------------------
 233
 234 wxDLManifest*   wxPluginManager::ms_manifest = NULL;
 235
 236 // ------------------------
 237 // Static accessors
 238 // ------------------------
 239
 240 wxPluginLibrary *
 241 wxPluginManager::LoadLibrary(const wxString &libname, int flags)
 242 {
 243     wxString realname(libname);
 244
 245     if( !(flags & wxDL_VERBATIM) )
 246         realname += wxDynamicLibrary::GetDllExt();
 247
 248     wxPluginLibrary *entry;
 249
 250     if ( flags & wxDL_NOSHARE )
 251     {
 252         entry = NULL;
 253     }
 254     else
 255     {
 256         entry = FindByName(realname);
 257     }
 258
 259     if ( entry )
 260     {
 261         wxLogTrace(_T("dll"),
 262                    _T("LoadLibrary(%s): already loaded."), realname.c_str());
 263
 264         entry->RefLib();
 265     }
 266     else
 267     {
 268         entry = new wxPluginLibrary( libname, flags );
 269
 270         if ( entry->IsLoaded() )
 271         {
 272             (*ms_manifest)[realname] = entry;
 273
 274             wxLogTrace(_T("dll"),
 275                        _T("LoadLibrary(%s): loaded ok."), realname.c_str());
 276
 277         }
 278         else
 279         {
 280             wxLogTrace(_T("dll"),
 281                        _T("LoadLibrary(%s): failed to load."), realname.c_str());
 282
 283             // we have created entry just above
 284             if ( !entry->UnrefLib() )
 285             {
 286                 // ... so UnrefLib() is supposed to delete it
 287                 wxFAIL_MSG( _T("Currently linked library is not loaded?") );
 288             }
 289
 290             entry = NULL;
 291         }
 292     }
 293
 294     return entry;
 295 }
 296
 297 bool wxPluginManager::UnloadLibrary(const wxString& libname)
 298 {
 299     wxString realname = libname;
 300
 301     wxPluginLibrary *entry = FindByName(realname);
 302
 303     if ( !entry )
 304     {
 305         realname += wxDynamicLibrary::GetDllExt();
 306
 307         entry = FindByName(realname);
 308     }
 309
 310     if ( !entry )
 311     {
 312         wxLogDebug(_T("Attempt to unload library '%s' which is not loaded."),
 313                    libname.c_str());
 314
 315         return false;
 316     }
 317
 318     wxLogTrace(_T("dll"), _T("UnloadLibrary(%s)"), realname.c_str());
 319
 320     if ( !entry->UnrefLib() )
 321     {
 322         // not really unloaded yet
 323         return false;
 324     }
 325
 326     ms_manifest->erase(ms_manifest->find(realname));
 327
 328     return true;
 329 }
 330
 331 // ------------------------
 332 // Class implementation
 333 // ------------------------
 334
 335 bool wxPluginManager::Load(const wxString &libname, int flags)
 336 {
 337     m_entry = wxPluginManager::LoadLibrary(libname, flags);
 338
 339     return IsLoaded();
 340 }
 341
 342 void wxPluginManager::Unload()
 343 {
 344     wxCHECK_RET( m_entry, _T("unloading an invalid wxPluginManager?") );
 345
 346     for ( wxDLManifest::iterator i = ms_manifest->begin();
 347           i != ms_manifest->end();
 348           ++i )
 349     {
 350         if ( i->second == m_entry )
 351         {
 352             ms_manifest->erase(i);
 353             break;
 354         }
 355     }
 356
 357     m_entry->UnrefLib();
 358
 359     m_entry = NULL;
 360 }
 361
 362
 363
 364 #if WXWIN_COMPATIBILITY_2_2
 365
 366 wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
 367 {
 368     for ( wxDLManifest::iterator i = ms_manifest->begin();
 369           i != ms_manifest->end();
 370           ++i )
 371     {
 372         wxPluginLibrary * const lib = i->second;
 373
 374         if ( lib->GetLibHandle() == handle )
 375             return lib;
 376     }
 377
 378     return NULL;
 379 }
 380
 381 // ---------------------------------------------------------------------------
 382 // wxDllLoader   (all these methods are static)
 383 // ---------------------------------------------------------------------------
 384
 385
 386 wxDllType wxDllLoader::LoadLibrary(const wxString &name, bool *success)
 387 {
 388     wxPluginLibrary *p = wxPluginManager::LoadLibrary
 389                          (
 390                             name,
 391                             wxDL_DEFAULT | wxDL_VERBATIM | wxDL_NOSHARE
 392                          );
 393
 394     if ( success )
 395         *success = p != NULL;
 396
 397     return p ? p->GetLibHandle() : 0;
 398 }
 399
 400 void wxDllLoader::UnloadLibrary(wxDllType handle)
 401 {
 402     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
 403
 404     wxCHECK_RET( p, _T("Unloading a library not loaded with wxDllLoader?") );
 405
 406     p->UnrefLib();
 407 }
 408
 409 void *
 410 wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
 411 {
 412     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
 413
 414     if ( !p )
 415     {
 416         wxFAIL_MSG( _T("Using a library not loaded with wxDllLoader?") );
 417
 418         if ( success )
 419             *success = false;
 420
 421         return NULL;
 422     }
 423
 424     return p->GetSymbol(name, success);
 425 }
 426
 427
 428 // ---------------------------------------------------------------------------
 429 // Global variables
 430 // ---------------------------------------------------------------------------
 431
 432 wxLibraries wxTheLibraries;
 433
 434 // ============================================================================
 435 // implementation
 436 // ============================================================================
 437
 438 // construct the full name from the base shared object name: adds a .dll
 439 // suffix under Windows or .so under Unix
 440 static wxString ConstructLibraryName(const wxString& basename)
 441 {
 442     wxString fullname;
 443     fullname << basename << wxDllLoader::GetDllExt();
 444
 445     return fullname;
 446 }
 447
 448 // ---------------------------------------------------------------------------
 449 // wxLibrary (one instance per dynamic library)
 450 // ---------------------------------------------------------------------------
 451
 452 wxLibrary::wxLibrary(wxDllType handle)
 453 {
 454     typedef wxClassInfo *(*t_get_first)(void);
 455     t_get_first get_first;
 456
 457     m_handle = handle;
 458
 459     // Some system may use a local heap for library.
 460     get_first = (t_get_first)GetSymbol(_T("wxGetClassFirst"));
 461     // It is a wxWidgets DLL.
 462     if (get_first)
 463         PrepareClasses(get_first());
 464 }
 465
 466 wxLibrary::~wxLibrary()
 467 {
 468     if ( m_handle )
 469     {
 470         wxDllLoader::UnloadLibrary(m_handle);
 471     }
 472 }
 473
 474 wxObject *wxLibrary::CreateObject(const wxString& name)
 475 {
 476     wxClassInfo *info = (wxClassInfo *)classTable.Get(name);
 477
 478     if (!info)
 479         return NULL;
 480
 481     return info->CreateObject();
 482 }
 483
 484 void wxLibrary::PrepareClasses(wxClassInfo *first)
 485 {
 486     // Index all class infos by their class name
 487     wxClassInfo *info = first;
 488     while (info)
 489     {
 490         if (info->m_className)
 491             classTable.Put(info->m_className, (wxObject *)info);
 492         info = info->m_next;
 493     }
 494
 495 #if !wxUSE_EXTENDED_RTTI
 496     // Set base pointers for each wxClassInfo
 497     info = first;
 498     while (info)
 499     {
 500         if (info->GetBaseClassName1())
 501             info->m_baseInfo1 = (wxClassInfo *)classTable.Get(info->GetBaseClassName1());
 502         if (info->GetBaseClassName2())
 503             info->m_baseInfo2 = (wxClassInfo *)classTable.Get(info->GetBaseClassName2());
 504         info = info->m_next;
 505     }
 506 #endif
 507 }
 508
 509 void *wxLibrary::GetSymbol(const wxString& symbname)
 510 {
 511    return wxDllLoader::GetSymbol(m_handle, symbname);
 512 }
 513
 514
 515 // ---------------------------------------------------------------------------
 516 // wxLibraries (only one instance should normally exist)
 517 // ---------------------------------------------------------------------------
 518
 519 wxLibraries::wxLibraries():m_loaded(wxKEY_STRING)
 520 {
 521 }
 522
 523 wxLibraries::~wxLibraries()
 524 {
 525     wxNode *node = m_loaded.GetFirst();
 526
 527     while (node) {
 528         wxLibrary *lib = (wxLibrary *)node->GetData();
 529         delete lib;
 530
 531         node = node->GetNext();
 532     }
 533 }
 534
 535 wxLibrary *wxLibraries::LoadLibrary(const wxString& name)
 536 {
 537     wxLibrary   *lib;
 538     wxClassInfo *old_sm_first;
 539     wxNode      *node = m_loaded.Find(name.GetData());
 540
 541     if (node != NULL)
 542         return ((wxLibrary *)node->GetData());
 543
 544     // If DLL shares data, this is necessary.
 545     old_sm_first = wxClassInfo::sm_first;
 546     wxClassInfo::sm_first = NULL;
 547
 548     wxString libname = ConstructLibraryName(name);
 549
 550     bool success = false;
 551     wxDllType handle = wxDllLoader::LoadLibrary(libname, &success);
 552     if(success)
 553     {
 554        lib = new wxLibrary(handle);
 555        wxClassInfo::sm_first = old_sm_first;
 556
 557        m_loaded.Append(name.GetData(), lib);
 558     }
 559     else
 560        lib = NULL;
 561     return lib;
 562 }
 563
 564 wxObject *wxLibraries::CreateObject(const wxString& path)
 565 {
 566     wxNode *node = m_loaded.GetFirst();
 567     wxObject *obj;
 568
 569     while (node) {
 570         obj = ((wxLibrary *)node->GetData())->CreateObject(path);
 571         if (obj)
 572             return obj;
 573
 574         node = node->GetNext();
 575     }
 576     return NULL;
 577 }
 578
 579 #endif  // WXWIN_COMPATIBILITY_2_2
 580
 581
 582 #endif  // wxUSE_DYNAMIC_LOADER
 583