src/common/dynload.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:         src/common/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     #include "wx/module.h"
  35 #endif
  36
  37 #include "wx/strconv.h"
  38
  39 #include "wx/dynload.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         wxDELETE(wxPluginLibrary::ms_classes);
  65         wxPluginManager::ClearManifest();
  66     }
  67
  68 private:
  69     DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
  70 };
  71
  72 IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
  73
  74
  75 wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
  76         : m_linkcount(1)
  77         , m_objcount(0)
  78 {
  79     const wxClassInfo* const oldFirst = wxClassInfo::GetFirst();
  80     Load( libname, flags );
  81
  82     // It is simple to know what is the last object we registered, it's just
  83     // the new head of the wxClassInfo list:
  84     m_ourLast = wxClassInfo::GetFirst();
  85
  86     // But to find the first wxClassInfo created by this library we need to
  87     // iterate until we get to the previous head as we don't have the links in
  88     // the backwards direction:
  89     if ( m_ourLast != oldFirst )
  90     {
  91         for ( const wxClassInfo* info = m_ourLast; ; info = info->GetNext() )
  92         {
  93             if ( info->GetNext() == oldFirst )
  94             {
  95                 m_ourFirst = info;
  96                 break;
  97             }
  98         }
  99     }
 100     else // We didn't register any classes at all.
 101     {
 102         m_ourFirst =
 103         m_ourLast = NULL;
 104     }
 105
 106     if( m_handle != 0 )
 107     {
 108         UpdateClasses();
 109         RegisterModules();
 110     }
 111     else
 112     {
 113         // Flag us for deletion
 114         --m_linkcount;
 115     }
 116 }
 117
 118 wxPluginLibrary::~wxPluginLibrary()
 119 {
 120     if( m_handle != 0 )
 121     {
 122         UnregisterModules();
 123         RestoreClasses();
 124     }
 125 }
 126
 127 wxPluginLibrary *wxPluginLibrary::RefLib()
 128 {
 129     wxCHECK_MSG( m_linkcount > 0, NULL,
 130                  wxT("Library had been already deleted!") );
 131
 132     ++m_linkcount;
 133     return this;
 134 }
 135
 136 bool wxPluginLibrary::UnrefLib()
 137 {
 138     wxASSERT_MSG( m_objcount == 0,
 139                   wxT("Library unloaded before all objects were destroyed") );
 140
 141     if ( m_linkcount == 0 || --m_linkcount == 0 )
 142     {
 143         delete this;
 144         return true;
 145     }
 146
 147     return false;
 148 }
 149
 150 // ------------------------
 151 // Private methods
 152 // ------------------------
 153
 154 void wxPluginLibrary::UpdateClasses()
 155 {
 156     if ( !m_ourFirst )
 157         return;
 158
 159     for ( const wxClassInfo *info = m_ourFirst; ; info = info->GetNext() )
 160     {
 161         if( info->GetClassName() )
 162         {
 163             // Hash all the class names into a local table too so
 164             // we can quickly find the entry they correspond to.
 165             (*ms_classes)[info->GetClassName()] = this;
 166         }
 167
 168         if ( info == m_ourLast )
 169             break;
 170     }
 171 }
 172
 173 void wxPluginLibrary::RestoreClasses()
 174 {
 175     // Check if there is a need to restore classes.
 176     if (!ms_classes)
 177         return;
 178
 179     if ( !m_ourFirst )
 180         return;
 181
 182     for ( const wxClassInfo *info = m_ourFirst; ; info = info->GetNext() )
 183     {
 184         ms_classes->erase(ms_classes->find(info->GetClassName()));
 185
 186         if ( info == m_ourLast )
 187             break;
 188     }
 189 }
 190
 191 void wxPluginLibrary::RegisterModules()
 192 {
 193     // Plugin libraries might have wxModules, Register and initialise them if
 194     // they do.
 195     //
 196     // Note that these classes are NOT included in the reference counting since
 197     // it's implicit that they will be unloaded if and when the last handle to
 198     // the library is.  We do have to keep a copy of the module's pointer
 199     // though, as there is currently no way to Unregister it without it.
 200
 201     wxASSERT_MSG( m_linkcount == 1,
 202                   wxT("RegisterModules should only be called for the first load") );
 203
 204     if ( m_ourFirst )
 205     {
 206         for ( const wxClassInfo *info = m_ourFirst; ; info = info->GetNext() )
 207         {
 208             if( info->IsKindOf(wxCLASSINFO(wxModule)) )
 209             {
 210                 wxModule *m = wxDynamicCast(info->CreateObject(), wxModule);
 211
 212                 wxASSERT_MSG( m, wxT("wxDynamicCast of wxModule failed") );
 213
 214                 m_wxmodules.push_back(m);
 215                 wxModule::RegisterModule(m);
 216             }
 217
 218             if ( info == m_ourLast )
 219                 break;
 220         }
 221     }
 222
 223     // FIXME: Likewise this is (well was) very similar to InitializeModules()
 224
 225     for ( wxModuleList::iterator it = m_wxmodules.begin();
 226           it != m_wxmodules.end();
 227           ++it)
 228     {
 229         if( !(*it)->Init() )
 230         {
 231             wxLogDebug(wxT("wxModule::Init() failed for wxPluginLibrary"));
 232
 233             // XXX: Watch this, a different hash implementation might break it,
 234             //      a good hash implementation would let us fix it though.
 235
 236             // The name of the game is to remove any uninitialised modules and
 237             // let the dtor Exit the rest on shutdown, (which we'll initiate
 238             // shortly).
 239
 240             wxModuleList::iterator oldNode = m_wxmodules.end();
 241             do {
 242                 ++it;
 243                 if( oldNode != m_wxmodules.end() )
 244                     m_wxmodules.erase(oldNode);
 245                 wxModule::UnregisterModule( *it );
 246                 oldNode = it;
 247             } while( it != m_wxmodules.end() );
 248
 249             --m_linkcount;     // Flag us for deletion
 250             break;
 251         }
 252     }
 253 }
 254
 255 void wxPluginLibrary::UnregisterModules()
 256 {
 257     wxModuleList::iterator it;
 258
 259     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 260         (*it)->Exit();
 261
 262     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 263         wxModule::UnregisterModule( *it );
 264
 265     // NB: content of the list was deleted by UnregisterModule calls above:
 266     m_wxmodules.clear();
 267 }
 268
 269
 270 // ---------------------------------------------------------------------------
 271 // wxPluginManager
 272 // ---------------------------------------------------------------------------
 273
 274 wxDLManifest*   wxPluginManager::ms_manifest = NULL;
 275
 276 // ------------------------
 277 // Static accessors
 278 // ------------------------
 279
 280 wxPluginLibrary *
 281 wxPluginManager::LoadLibrary(const wxString &libname, int flags)
 282 {
 283     wxString realname(libname);
 284
 285     if( !(flags & wxDL_VERBATIM) )
 286         realname += wxDynamicLibrary::GetDllExt();
 287
 288     wxPluginLibrary *entry;
 289
 290     if ( flags & wxDL_NOSHARE )
 291     {
 292         entry = NULL;
 293     }
 294     else
 295     {
 296         entry = FindByName(realname);
 297     }
 298
 299     if ( entry )
 300     {
 301         wxLogTrace(wxT("dll"),
 302                    wxT("LoadLibrary(%s): already loaded."), realname.c_str());
 303
 304         entry->RefLib();
 305     }
 306     else
 307     {
 308         entry = new wxPluginLibrary( libname, flags );
 309
 310         if ( entry->IsLoaded() )
 311         {
 312             (*ms_manifest)[realname] = entry;
 313
 314             wxLogTrace(wxT("dll"),
 315                        wxT("LoadLibrary(%s): loaded ok."), realname.c_str());
 316
 317         }
 318         else
 319         {
 320             wxLogTrace(wxT("dll"),
 321                        wxT("LoadLibrary(%s): failed to load."), realname.c_str());
 322
 323             // we have created entry just above
 324             if ( !entry->UnrefLib() )
 325             {
 326                 // ... so UnrefLib() is supposed to delete it
 327                 wxFAIL_MSG( wxT("Currently linked library is not loaded?") );
 328             }
 329
 330             entry = NULL;
 331         }
 332     }
 333
 334     return entry;
 335 }
 336
 337 bool wxPluginManager::UnloadLibrary(const wxString& libname)
 338 {
 339     wxString realname = libname;
 340
 341     wxPluginLibrary *entry = FindByName(realname);
 342
 343     if ( !entry )
 344     {
 345         realname += wxDynamicLibrary::GetDllExt();
 346
 347         entry = FindByName(realname);
 348     }
 349
 350     if ( !entry )
 351     {
 352         wxLogDebug(wxT("Attempt to unload library '%s' which is not loaded."),
 353                    libname.c_str());
 354
 355         return false;
 356     }
 357
 358     wxLogTrace(wxT("dll"), wxT("UnloadLibrary(%s)"), realname.c_str());
 359
 360     if ( !entry->UnrefLib() )
 361     {
 362         // not really unloaded yet
 363         return false;
 364     }
 365
 366     ms_manifest->erase(ms_manifest->find(realname));
 367
 368     return true;
 369 }
 370
 371 // ------------------------
 372 // Class implementation
 373 // ------------------------
 374
 375 bool wxPluginManager::Load(const wxString &libname, int flags)
 376 {
 377     m_entry = wxPluginManager::LoadLibrary(libname, flags);
 378
 379     return IsLoaded();
 380 }
 381
 382 void wxPluginManager::Unload()
 383 {
 384     wxCHECK_RET( m_entry, wxT("unloading an invalid wxPluginManager?") );
 385
 386     for ( wxDLManifest::iterator i = ms_manifest->begin();
 387           i != ms_manifest->end();
 388           ++i )
 389     {
 390         if ( i->second == m_entry )
 391         {
 392             ms_manifest->erase(i);
 393             break;
 394         }
 395     }
 396
 397     m_entry->UnrefLib();
 398
 399     m_entry = NULL;
 400 }
 401
 402 #endif  // wxUSE_DYNAMIC_LOADER