Fixed size buffers are not a good thing. Period.

[wxWidgets.git] / src / common / dynload.cpp

diff --git a/src/common/dynload.cpp b/src/common/dynload.cpp
index b127ecf5d2985daa86a860feb902ac9382655a54..aa917ba051d22dd19ea7836ed727f0e9aa4fdc05 100644 (file)
--- a/src/common/dynload.cpp
+++ b/src/common/dynload.cpp
@@ -36,8 +36,10 @@
 #endif
 
 #include "wx/filename.h"        // for SplitPath()
 #endif
 
 #include "wx/filename.h"        // for SplitPath()

+#include "wx/strconv.h"

 
 #include "wx/dynload.h"
 
 #include "wx/dynload.h"

+#include "wx/module.h"

 
 #if defined(__DARWIN__)
 /* Porting notes:
 
 #if defined(__DARWIN__)
 /* Porting notes:


@@ -64,13 +66,13 @@ const char *dlerror(void);
 //        platform dependent files.
 
 #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
 //        platform dependent files.
 
 #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)

-const wxString wxDynamicLibrary::ms_dllext( _T(".dll") );
+    const wxChar *wxDynamicLibrary::ms_dllext = _T(".dll");

 #elif defined(__UNIX__)
 #elif defined(__UNIX__)

-#if defined(__HPUX__)
-const wxString wxDynamicLibrary::ms_dllext( _T(".sl") );
-#else
-const wxString wxDynamicLibrary::ms_dllext( _T(".so") );
-#endif
+    #if defined(__HPUX__)
+        const wxChar *wxDynamicLibrary::ms_dllext = _T(".sl");
+    #else
+        const wxChar *wxDynamicLibrary::ms_dllext = _T(".so");
+    #endif

 #endif
 
 wxDllType wxDynamicLibrary::GetProgramHandle()
 #endif
 
 wxDllType wxDynamicLibrary::GetProgramHandle()


@@ -101,6 +103,9 @@ bool wxDynamicLibrary::Load(wxString libname, int flags)
         }
     }
 
         }
     }
 

+    // different ways to load a shared library
+    //
+    // FIXME: should go to the platform-specific files!

 #if defined(__WXMAC__) && !defined(__DARWIN__)
     FSSpec      myFSSpec;
     Ptr         myMainAddr;
 #if defined(__WXMAC__) && !defined(__DARWIN__)
     FSSpec      myFSSpec;
     Ptr         myMainAddr;


@@ -132,29 +137,39 @@ bool wxDynamicLibrary::Load(wxString libname, int flags)
 
 #if defined(__VMS) || defined(__DARWIN__)
     m_handle = dlopen(libname.c_str(), 0);  // The second parameter is ignored
 
 #if defined(__VMS) || defined(__DARWIN__)
     m_handle = dlopen(libname.c_str(), 0);  // The second parameter is ignored

-#else
+#else // !__VMS  && !__DARWIN__

     int rtldFlags = 0;
 
     int rtldFlags = 0;
 

-    if( flags & wxDL_LAZY )
+    if ( flags & wxDL_LAZY )

     {
         wxASSERT_MSG( (flags & wxDL_NOW) == 0,
                       _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
     {
         wxASSERT_MSG( (flags & wxDL_NOW) == 0,
                       _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );

+#ifdef RTLD_LAZY

         rtldFlags |= RTLD_LAZY;
         rtldFlags |= RTLD_LAZY;

+#else
+        wxLogDebug(_T("wxDL_LAZY is not supported on this platform"));
+#endif

     }
     }

-    else if( flags & wxDL_NOW )
+    else if ( flags & wxDL_NOW )

     {
     {

+#ifdef RTLD_NOW

         rtldFlags |= RTLD_NOW;
         rtldFlags |= RTLD_NOW;

+#else
+        wxLogDebug(_T("wxDL_NOW is not supported on this platform"));
+#endif

     }
     }

-    if( flags & wxDL_GLOBAL )
+
+    if ( flags & wxDL_GLOBAL )

     {
     {

-#ifdef __osf__
-        wxLogDebug(_T("WARNING: RTLD_GLOBAL is not a supported on this platform."));
-#endif
+#ifdef RTLD_GLOBAL

         rtldFlags |= RTLD_GLOBAL;
         rtldFlags |= RTLD_GLOBAL;

+#else
+        wxLogDebug(_T("RTLD_GLOBAL is not supported on this platform."));
+#endif

     }
 
     }
 

-    m_handle = dlopen(libname.c_str(), rtldFlags);
-#endif  // __VMS || __DARWIN__
+    m_handle = dlopen(libname.fn_str(), rtldFlags);
+#endif  // __VMS || __DARWIN__ ?

 
 #elif defined(HAVE_SHL_LOAD)
     int shlFlags = 0;
 
 #elif defined(HAVE_SHL_LOAD)
     int shlFlags = 0;


@@ -169,20 +184,26 @@ bool wxDynamicLibrary::Load(wxString libname, int flags)
     {
         shlFlags |= BIND_IMMEDIATE;
     }
     {
         shlFlags |= BIND_IMMEDIATE;
     }

-    m_handle = shl_load(libname.c_str(), BIND_DEFERRED, 0);
+    m_handle = shl_load(libname.fn_str(), BIND_DEFERRED, 0);

 
 #elif defined(__WINDOWS__)
     m_handle = ::LoadLibrary(libname.c_str());
 
 #elif defined(__WINDOWS__)
     m_handle = ::LoadLibrary(libname.c_str());

-

 #else
 #else

-#error  "runtime shared lib support not implemented"
+    #error  "runtime shared lib support not implemented on this platform"

 #endif
 
     if ( m_handle == 0 )
     {
         wxString msg(_("Failed to load shared library '%s'"));
 #if defined(HAVE_DLERROR) && !defined(__EMX__)
 #endif
 
     if ( m_handle == 0 )
     {
         wxString msg(_("Failed to load shared library '%s'"));
 #if defined(HAVE_DLERROR) && !defined(__EMX__)

-        const wxChar  *err = dlerror();
+
+#if wxUSE_UNICODE
+        wxWCharBuffer buffer = wxConvLocal.cMB2WC( dlerror() );
+        const wxChar *err = buffer;
+#else
+        const wxChar *err = dlerror();
+#endif
+

         if( err )
             wxLogError( msg, err );
 #else
         if( err )
             wxLogError( msg, err );
 #else


@@ -239,10 +260,10 @@ void *wxDynamicLibrary::GetSymbol(const wxString &name, bool *success) const
     DosQueryProcAddr( m_handle, 1L, name.c_str(), (PFN*)symbol );
 
 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
     DosQueryProcAddr( m_handle, 1L, name.c_str(), (PFN*)symbol );
 
 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)

-    symbol = dlsym( m_handle, name.c_str() );
+    symbol = dlsym( m_handle, name.fn_str() );

 
 #elif defined(HAVE_SHL_LOAD)
 
 #elif defined(HAVE_SHL_LOAD)

-    if( shl_findsym( &m_handle, name.c_str(), TYPE_UNDEFINED, &symbol ) != 0 )
+    if( shl_findsym( &m_handle, name.fn_str(), TYPE_UNDEFINED, &symbol ) != 0 )

         symbol = 0;
 
 #elif defined(__WINDOWS__)
         symbol = 0;
 
 #elif defined(__WINDOWS__)


@@ -256,7 +277,14 @@ void *wxDynamicLibrary::GetSymbol(const wxString &name, bool *success) const
     {
         wxString msg(_("wxDynamicLibrary failed to GetSymbol '%s'"));
 #if defined(HAVE_DLERROR) && !defined(__EMX__)
     {
         wxString msg(_("wxDynamicLibrary failed to GetSymbol '%s'"));
 #if defined(HAVE_DLERROR) && !defined(__EMX__)

+
+#if wxUSE_UNICODE
+        wxWCharBuffer buffer = wxConvLocal.cMB2WC( dlerror() );
+        const wxChar *err = buffer;
+#else

         const wxChar *err = dlerror();
         const wxChar *err = dlerror();

+#endif
+

         if( err )
         {
             failed = TRUE;
         if( err )
         {
             failed = TRUE;


@@ -280,7 +308,34 @@ void *wxDynamicLibrary::GetSymbol(const wxString &name, bool *success) const
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 
 

-wxDLImports  wxPluginLibrary::ms_classes(wxKEY_STRING);
+wxDLImports*  wxPluginLibrary::ms_classes = NULL;
+
+class wxPluginLibraryModule : public wxModule
+{
+public:
+    wxPluginLibraryModule() { }
+
+    // TODO: create ms_classes on demand, why always preallocate it?
+    virtual bool OnInit()
+    {
+        wxPluginLibrary::ms_classes = new wxDLImports(wxKEY_STRING);
+        wxPluginManager::CreateManifest();
+        return TRUE;
+    }
+
+    virtual void OnExit()
+    {
+        delete wxPluginLibrary::ms_classes;
+        wxPluginLibrary::ms_classes = NULL;
+        wxPluginManager::ClearManifest();
+    }
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
+

 
 wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
         : m_linkcount(1)
 
 wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
         : m_linkcount(1)


@@ -296,7 +351,10 @@ wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
         RegisterModules();
     }
     else
         RegisterModules();
     }
     else

-        --m_linkcount;      // Flag us for deletion
+    {
+        // Flag us for deletion
+        --m_linkcount;
+    }

 }
 
 wxPluginLibrary::~wxPluginLibrary()
 }
 
 wxPluginLibrary::~wxPluginLibrary()


@@ -308,14 +366,26 @@ wxPluginLibrary::~wxPluginLibrary()
     }
 }
 
     }
 }
 

+wxPluginLibrary *wxPluginLibrary::RefLib()
+{
+    wxCHECK_MSG( m_linkcount > 0, NULL,
+                 _T("Library had been already deleted!") );
+
+    ++m_linkcount;
+    return this;
+}
+

 bool wxPluginLibrary::UnrefLib()
 {
 bool wxPluginLibrary::UnrefLib()
 {

-    wxASSERT_MSG( m_objcount == 0, _T("Library unloaded before all objects were destroyed") );
-    if( m_linkcount == 0 || --m_linkcount == 0 )
+    wxASSERT_MSG( m_objcount == 0,
+                  _T("Library unloaded before all objects were destroyed") );
+
+    if ( --m_linkcount == 0 )

     {
         delete this;
         return TRUE;
     }
     {
         delete this;
         return TRUE;
     }

+

     return FALSE;
 }
 
     return FALSE;
 }
 


@@ -347,8 +417,8 @@ void wxPluginLibrary::UpdateClassInfo()
             // Hash all the class names into a local table too so
             // we can quickly find the entry they correspond to.
 
             // Hash all the class names into a local table too so
             // we can quickly find the entry they correspond to.
 

-            if( ms_classes.Get(info->m_className) == 0 )
-                ms_classes.Put(info->m_className, (wxObject *) this);
+            if( ms_classes->Get(info->m_className) == 0 )
+                ms_classes->Put(info->m_className, (wxObject *) this);

         }
     }
 
         }
     }
 


@@ -368,7 +438,7 @@ void wxPluginLibrary::RestoreClassInfo()
     for(info = m_after; info != m_before; info = info->m_next)
     {
         wxClassInfo::sm_classTable->Delete(info->m_className);
     for(info = m_after; info != m_before; info = info->m_next)
     {
         wxClassInfo::sm_classTable->Delete(info->m_className);

-        ms_classes.Delete(info->m_className);
+        ms_classes->Delete(info->m_className);

     }
 
     if( wxClassInfo::sm_first == m_after )
     }
 
     if( wxClassInfo::sm_first == m_after )


@@ -378,7 +448,7 @@ void wxPluginLibrary::RestoreClassInfo()
         info = wxClassInfo::sm_first;
         while( info->m_next && info->m_next != m_after ) info = info->m_next;
 
         info = wxClassInfo::sm_first;
         while( info->m_next && info->m_next != m_after ) info = info->m_next;
 

-        wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge"))
+        wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge"));

 
         info->m_next = m_before;
     }
 
         info->m_next = m_before;
     }


@@ -454,73 +524,119 @@ void wxPluginLibrary::UnregisterModules()
 
 
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------

-// wxPluginLibrary
+// wxPluginManager

 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 

-wxDLManifest   wxPluginManager::ms_manifest(wxKEY_STRING);
+wxDLManifest*   wxPluginManager::ms_manifest = NULL;

 
 // ------------------------
 // Static accessors
 // ------------------------
 
 
 // ------------------------
 // Static accessors
 // ------------------------
 

-wxPluginLibrary *wxPluginManager::LoadLibrary(const wxString &libname, int flags)
+wxPluginLibrary *
+wxPluginManager::LoadLibrary(const wxString &libname, int flags)

 {
     wxString realname(libname);
 
     if( !(flags & wxDL_VERBATIM) )
         realname += wxDynamicLibrary::GetDllExt();
 
 {
     wxString realname(libname);
 
     if( !(flags & wxDL_VERBATIM) )
         realname += wxDynamicLibrary::GetDllExt();
 

-    wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest.Get(realname);
+    wxPluginLibrary *entry;

 
 

-    if( entry != 0 )
+    if ( flags & wxDL_NOSHARE )

     {
     {

+        entry = NULL;
+    }
+    else
+    {
+        entry = (wxPluginLibrary*) ms_manifest->Get(realname);
+    }
+
+    if ( entry )
+    {
+        wxLogTrace(_T("dll"),
+                   _T("LoadLibrary(%s): already loaded."), realname.c_str());
+

         entry->RefLib();
     }
     else
     {
         entry = new wxPluginLibrary( libname, flags );
 
         entry->RefLib();
     }
     else
     {
         entry = new wxPluginLibrary( libname, flags );
 

-        if( entry->IsLoaded() )
+        if ( entry->IsLoaded() )

         {
         {

-            ms_manifest.Put(realname, (wxObject*) entry);
+            ms_manifest->Put(realname, (wxObject*) entry);
+
+            wxLogTrace(_T("dll"),
+                       _T("LoadLibrary(%s): loaded ok."), realname.c_str());
+

         }
         else
         {
         }
         else
         {

-            wxCHECK_MSG( entry->UnrefLib(), 0,
-                         _T("Currently linked library is, ..not loaded??") );
-            entry = 0;
+            wxLogTrace(_T("dll"),
+                       _T("LoadLibrary(%s): failed to load."), realname.c_str());
+
+            // we have created entry just above
+            if ( !entry->UnrefLib() )
+            {
+                // ... so UnrefLib() is supposed to delete it
+                wxFAIL_MSG( _T("Currently linked library is not loaded?") );
+            }
+
+            entry = NULL;

         }
     }
         }
     }

+

     return entry;
 }
 
     return entry;
 }
 

-bool wxPluginManager::UnloadLibrary(const wxString &libname)
+bool wxPluginManager::UnloadLibrary(const wxString& libname)

 {
 {

-    wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest.Get(libname);
+    wxString realname = libname;

 
 

-    if( !entry )
-        entry = (wxPluginLibrary*) ms_manifest.Get(libname + wxDynamicLibrary::GetDllExt());
+    wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest->Get(realname);

 
 

-    if( entry )
-        return entry->UnrefLib();
+    if ( !entry )
+    {
+        realname += wxDynamicLibrary::GetDllExt();

 
 

-    wxLogDebug(_T("Attempt to Unlink library '%s' (which is not linked)."), libname.c_str());
-    return FALSE;
+        entry = (wxPluginLibrary*) ms_manifest->Get(realname);
+    }
+
+    if ( !entry )
+    {
+        wxLogDebug(_T("Attempt to unload library '%s' which is not loaded."),
+                   libname.c_str());
+
+        return FALSE;
+    }
+
+    wxLogTrace(_T("dll"), _T("UnloadLibrary(%s)"), realname.c_str());
+
+    if ( !entry->UnrefLib() )
+    {
+        // not really unloaded yet
+        return FALSE;
+    }
+
+    ms_manifest->Delete(realname);
+
+    return TRUE;

 }
 
 #if WXWIN_COMPATIBILITY_2_2
 wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
 {
     wxNode  *node;
 }
 
 #if WXWIN_COMPATIBILITY_2_2
 wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
 {
     wxNode  *node;

-    ms_manifest.BeginFind();
+    ms_manifest->BeginFind();

 
 

-    for(node = ms_manifest.Next(); node; node = ms_manifest.Next())
+    for(node = ms_manifest->Next(); node; node = ms_manifest->Next())

         if( ((wxPluginLibrary*)node->GetData())->GetLibHandle() == handle )
             return (wxPluginLibrary*)node->GetData();
 
         if( ((wxPluginLibrary*)node->GetData())->GetLibHandle() == handle )
             return (wxPluginLibrary*)node->GetData();
 

-    return 0;
+    return NULL;

 }
 }

-#endif
+#endif // WXWIN_COMPATIBILITY_2_2

 
 // ------------------------
 // Class implementation
 
 // ------------------------
 // Class implementation


@@ -535,11 +651,11 @@ bool wxPluginManager::Load(const wxString &libname, int flags)
 void wxPluginManager::Unload()
 {
     wxNode  *node;
 void wxPluginManager::Unload()
 {
     wxNode  *node;

-    ms_manifest.BeginFind();
+    ms_manifest->BeginFind();

 
     // It's either this or store the name of the lib just to do this.
 
 
     // It's either this or store the name of the lib just to do this.
 

-    for(node = ms_manifest.Next(); node; node = ms_manifest.Next())
+    for(node = ms_manifest->Next(); node; node = ms_manifest->Next())

         if( (wxPluginLibrary*)node->GetData() == m_entry )
             break;
 
         if( (wxPluginLibrary*)node->GetData() == m_entry )
             break;
 


@@ -556,21 +672,44 @@ void wxPluginManager::Unload()
 
 #if WXWIN_COMPATIBILITY_2_2
 
 
 #if WXWIN_COMPATIBILITY_2_2
 

-wxDllType wxDllLoader::LoadLibrary(const wxString &name)
+wxDllType wxDllLoader::LoadLibrary(const wxString &name, bool *success)

 {
 {

-    wxPluginLibrary *p = wxPluginManager::LoadLibrary(name, wxDL_DEFAULT | wxDL_VERBATIM);
-    return p->GetLibHandle();
+    wxPluginLibrary *p = wxPluginManager::LoadLibrary
+                         (
+                            name,
+                            wxDL_DEFAULT | wxDL_VERBATIM | wxDL_NOSHARE
+                         );
+
+    if ( success )
+        *success = p != NULL;
+
+    return p ? p->GetLibHandle() : 0;

 }
 
 void wxDllLoader::UnloadLibrary(wxDllType handle)
 {
     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
 }
 
 void wxDllLoader::UnloadLibrary(wxDllType handle)
 {
     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);

+
+    wxCHECK_RET( p, _T("Unloading a library not loaded with wxDllLoader?") );
+

     p->UnrefLib();
 }
 
     p->UnrefLib();
 }
 

-void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
+void *
+wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)

 {
     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
 {
     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);

+
+    if ( !p )
+    {
+        wxFAIL_MSG( _T("Using a library not loaded with wxDllLoader?") );
+
+        if ( success )
+            *success = FALSE;
+
+        return NULL;
+    }
+

     return p->GetSymbol(name, success);
 }
 
     return p->GetSymbol(name, success);
 }
 


@@ -578,4 +717,3 @@ void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *su
 
 #endif  // wxUSE_DYNAMIC_LOADER
 
 
 #endif  // wxUSE_DYNAMIC_LOADER
 

-// vi:sts=4:sw=4:et