Make list consistent with tree in terms of Vetoed changes closing the inline edit...

[wxWidgets.git] / include / wx / dynlib.h

diff --git a/include/wx/dynlib.h b/include/wx/dynlib.h
index 49b54d71dbbad3155cd2077c30924bc0c7b82fcd..70287c0b19ddb113d1dc280ec749079b9739f087 100644 (file)
--- a/include/wx/dynlib.h
+++ b/include/wx/dynlib.h
@@ -12,7 +12,7 @@
 #ifndef _WX_DYNLIB_H__
 #define _WX_DYNLIB_H__
 
 #ifndef _WX_DYNLIB_H__
 #define _WX_DYNLIB_H__
 

-#if defined(__GNUG__) && !defined(__APPLE__)
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

 #   pragma interface "dynlib.h"
 #endif
 
 #   pragma interface "dynlib.h"
 #endif
 


@@ -21,6 +21,7 @@
 #if wxUSE_DYNLIB_CLASS
 
 #include "wx/string.h"
 #if wxUSE_DYNLIB_CLASS
 
 #include "wx/string.h"

+#include "wx/dynarray.h"

 
 // FIXME: can this go in private.h or something too??
 #if defined(__WXPM__) || defined(__EMX__)
 
 // FIXME: can this go in private.h or something too??
 #if defined(__WXPM__) || defined(__EMX__)


@@ -32,39 +33,38 @@
 #include "wx/msw/private.h"
 #endif
 
 #include "wx/msw/private.h"
 #endif
 

+#if defined(HAVE_DLERROR) && !defined(__EMX__)
+    #define wxHAVE_DYNLIB_ERROR
+#endif
+
+class WXDLLIMPEXP_BASE wxDynamicLibraryDetailsCreator;
+

 // ----------------------------------------------------------------------------
 // conditional compilation
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // conditional compilation
 // ----------------------------------------------------------------------------
 

-    // Note: WXPM/EMX has to be tested first, since we want to use
-    // native version, even if configure detected presence of DLOPEN.
-
+// Note: WXPM/EMX has to be tested first, since we want to use
+// native version, even if configure detected presence of DLOPEN.

 #if defined(__WXPM__) || defined(__EMX__) || defined(__WINDOWS__)
 #if defined(__WXPM__) || defined(__EMX__) || defined(__WINDOWS__)

-typedef HMODULE             wxDllType;
+    typedef HMODULE             wxDllType;

 #elif defined(HAVE_DLOPEN)
 #elif defined(HAVE_DLOPEN)

-#include <dlfcn.h>
-typedef void               *wxDllType;
+    #include <dlfcn.h>
+    typedef void               *wxDllType;

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

-#include <dl.h>
-typedef shl_t               wxDllType;
+    #include <dl.h>
+    typedef shl_t               wxDllType;

 #elif defined(__DARWIN__)
 #elif defined(__DARWIN__)

-typedef void               *wxDllType;
+    typedef void               *wxDllType;

 #elif defined(__WXMAC__)
 #elif defined(__WXMAC__)

-typedef CFragConnectionID   wxDllType;
+    #include <CodeFragments.h>
+    typedef CFragConnectionID   wxDllType;

 #else
 #else

-#error "Dynamic Loading classes can't be compiled on this platform, sorry."
+    #error "Dynamic Loading classes can't be compiled on this platform, sorry."

 #endif
 
 #endif
 

-
-// ---------------------------------------------------------------------------
-// wxDynamicLibrary
-// ---------------------------------------------------------------------------
-
-//FIXME:  This class isn't really common at all, it should be moved
-//        into platform dependent files.
-
-// NOTE: this class is (deliberately) not virtual, do not attempt
-//       to use it polymorphically.
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------

 
 enum wxDLFlags
 {
 
 enum wxDLFlags
 {


@@ -89,103 +89,210 @@ enum wxDLFlags
 enum wxDynamicLibraryCategory
 {
     wxDL_LIBRARY,       // standard library
 enum wxDynamicLibraryCategory
 {
     wxDL_LIBRARY,       // standard library

-    wxDL_MODULE,        // loadable module/plugin
+    wxDL_MODULE         // loadable module/plugin

 };
 
 enum wxPluginCategory
 {
     wxDL_PLUGIN_GUI,    // plugin that uses GUI classes
 };
 
 enum wxPluginCategory
 {
     wxDL_PLUGIN_GUI,    // plugin that uses GUI classes

-    wxDL_PLUGIN_BASE,   // wxBase-only plugin
+    wxDL_PLUGIN_BASE    // wxBase-only plugin

 };
 
 };
 

+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------

 
 

-class WXDLLIMPEXP_BASE wxDynamicLibrary
+// when loading a function from a DLL you always have to cast the returned
+// "void *" pointer to the correct type and, even more annoyingly, you have to
+// repeat this type twice if you want to declare and define a function pointer
+// all in one line
+//
+// this macro makes this slightly less painful by allowing you to specify the
+// type only once, as the first parameter, and creating a variable of this type
+// called "pfn<name>" initialized with the "name" from the "dynlib"
+#define wxDYNLIB_FUNCTION(type, name, dynlib) \
+    type pfn ## name = (type)(dynlib).GetSymbol(_T(#name))
+
+// ----------------------------------------------------------------------------
+// wxDynamicLibraryDetails: contains details about a loaded wxDynamicLibrary
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_BASE wxDynamicLibraryDetails

 {
 public:
 {
 public:

-        // return a valid handle for the main program itself or NULL if
-        // back linking is not supported by the current platform (e.g. Win32)
+    // ctor, normally never used as these objects are only created by
+    // wxDynamicLibrary::ListLoaded()
+    wxDynamicLibraryDetails() { m_address = NULL; m_length = 0; }

 
 

-    static wxDllType         GetProgramHandle();
+    // get the (base) name
+    wxString GetName() const { return m_name; }
+
+    // get the full path of this object
+    wxString GetPath() const { return m_path; }
+
+    // get the load address and the extent, return true if this information is
+    // available
+    bool GetAddress(void **addr, size_t *len) const
+    {
+        if ( !m_address )
+            return false;
+
+        if ( addr )
+            *addr = m_address;
+        if ( len )
+            *len = m_length;
+
+        return true;
+    }
+
+    // return the version of the DLL (may be empty if no version info)
+    wxString GetVersion() const
+    {
+        return m_version;
+    }
+
+private:
+    wxString m_name,
+             m_path,
+             m_version;
+
+    void *m_address;
+    size_t m_length;
+
+    friend class wxDynamicLibraryDetailsCreator;
+};
+
+WX_DECLARE_USER_EXPORTED_OBJARRAY(wxDynamicLibraryDetails,
+                                  wxDynamicLibraryDetailsArray,
+                                  WXDLLIMPEXP_BASE);

 
 

-        // return the platform standard DLL extension (with leading dot)
+// ----------------------------------------------------------------------------
+// wxDynamicLibrary: represents a handle to a DLL/shared object
+// ----------------------------------------------------------------------------

 
 

+class WXDLLIMPEXP_BASE wxDynamicLibrary
+{
+public:
+    // return a valid handle for the main program itself or NULL if back
+    // linking is not supported by the current platform (e.g. Win32)
+    static wxDllType         GetProgramHandle();
+
+    // return the platform standard DLL extension (with leading dot)

     static const wxChar *GetDllExt() { return ms_dllext; }
 
     static const wxChar *GetDllExt() { return ms_dllext; }
 

-    wxDynamicLibrary() : m_handle(0) {}
+    wxDynamicLibrary() : m_handle(0) { }

     wxDynamicLibrary(const wxString& libname, int flags = wxDL_DEFAULT)
         : m_handle(0)
     {
         Load(libname, flags);
     }
     wxDynamicLibrary(const wxString& libname, int flags = wxDL_DEFAULT)
         : m_handle(0)
     {
         Load(libname, flags);
     }

-    ~wxDynamicLibrary() { Unload(); }

 
 

-        // return TRUE if the library was loaded successfully
+    // NOTE: this class is (deliberately) not virtual, do not attempt
+    //       to use it polymorphically.
+    ~wxDynamicLibrary() { Unload(); }

 
 

+    // return true if the library was loaded successfully

     bool IsLoaded() const { return m_handle != 0; }
 
     bool IsLoaded() const { return m_handle != 0; }
 

-        // load the library with the given name
-        // (full or not), return TRUE on success
+    // load the library with the given name (full or not), return true if ok
+    bool Load(const wxString& libname, int flags = wxDL_DEFAULT);

 
 

-    bool Load(wxString libname, int flags = wxDL_DEFAULT);
+    // raw function for loading dynamic libs: always behaves as if
+    // wxDL_VERBATIM were specified and doesn't log error message if the
+    // library couldn't be loaded but simply returns NULL
+    static wxDllType RawLoad(const wxString& libname, int flags = wxDL_DEFAULT);

 
 

-        // detach the library object from its handle, i.e. prevent the object
-        // from unloading the library in its dtor -- the caller is now
-        // responsible for doing this
+    // detach the library object from its handle, i.e. prevent the object from
+    // unloading the library in its dtor -- the caller is now responsible for
+    // doing this

     wxDllType Detach() { wxDllType h = m_handle; m_handle = 0; return h; }
 
     wxDllType Detach() { wxDllType h = m_handle; m_handle = 0; return h; }
 

-        // unload the library, also done automatically in dtor
-
-    void Unload();
+    // unload the given library handle (presumably returned by Detach() before)
+    static void Unload(wxDllType handle);

 
 

-        // Return the raw handle from dlopen and friends.
+    // unload the library, also done automatically in dtor
+    void Unload() { if ( IsLoaded() ) { Unload(m_handle); m_handle = 0; } }

 
 

+    // Return the raw handle from dlopen and friends.

     wxDllType GetLibHandle() const { return m_handle; }
 
     wxDllType GetLibHandle() const { return m_handle; }
 

-        // resolve a symbol in a loaded DLL, such as a variable or function
-        // name.  'name' is the (possibly mangled) name of the symbol.
-        // (use extern "C" to export unmangled names)
-        //
-        // Since it is perfectly valid for the returned symbol to actually be
-        // NULL, that is not always indication of an error.  Pass and test the
-        // parameter 'success' for a true indication of success or failure to
-        // load the symbol.
-        //
-        // Returns a pointer to the symbol on success, or NULL if an error
-        // occurred or the symbol wasn't found.
-
-    void *GetSymbol(const wxString& name, bool *success = 0) const;
+    // check if the given symbol is present in the library, useful to verify if
+    // a loadable module is our plugin, for example, without provoking error
+    // messages from GetSymbol()
+    bool HasSymbol(const wxString& name) const
+    {
+        bool ok;
+        DoGetSymbol(name, &ok);
+        return ok;
+    }

 
 

-#if WXWIN_COMPATIBILITY_2_2
-    operator bool() const { return IsLoaded(); }
+    // resolve a symbol in a loaded DLL, such as a variable or function name.
+    // 'name' is the (possibly mangled) name of the symbol. (use extern "C" to
+    // export unmangled names)
+    //
+    // Since it is perfectly valid for the returned symbol to actually be NULL,
+    // that is not always indication of an error.  Pass and test the parameter
+    // 'success' for a true indication of success or failure to load the
+    // symbol.
+    //
+    // Returns a pointer to the symbol on success, or NULL if an error occurred
+    // or the symbol wasn't found.
+    void *GetSymbol(const wxString& name, bool *success = NULL) const;
+
+    // low-level version of GetSymbol()
+    static void *RawGetSymbol(wxDllType handle, const wxString& name);
+    void *RawGetSymbol(const wxString& name) const
+    {
+#if defined (__WXPM__) || defined(__EMX__)
+        return GetSymbol(name);
+#else
+        return RawGetSymbol(m_handle, name);

 #endif
 #endif

+    }
+
+    // return all modules/shared libraries in the address space of this process
+    //
+    // returns an empty array if not implemented or an error occured
+    static wxDynamicLibraryDetailsArray ListLoaded();

 
     // return platform-specific name of dynamic library with proper extension
     // and prefix (e.g. "foo.dll" on Windows or "libfoo.so" on Linux)
     static wxString CanonicalizeName(const wxString& name,
                                      wxDynamicLibraryCategory cat = wxDL_LIBRARY);
 
 
     // return platform-specific name of dynamic library with proper extension
     // and prefix (e.g. "foo.dll" on Windows or "libfoo.so" on Linux)
     static wxString CanonicalizeName(const wxString& name,
                                      wxDynamicLibraryCategory cat = wxDL_LIBRARY);
 

-    // return name of wxWindows plugin (adds compiler and version info
+    // return name of wxWidgets plugin (adds compiler and version info

     // to the filename):
     // to the filename):

-    static wxString CanonicalizePluginName(const wxString& name,
-                                           wxPluginCategory cat);
+    static wxString
+    CanonicalizePluginName(const wxString& name,
+                           wxPluginCategory cat = wxDL_PLUGIN_GUI);

 
     // return plugin directory on platforms where it makes sense and empty
     // string on others:
     static wxString GetPluginsDirectory();
 
 
     // return plugin directory on platforms where it makes sense and empty
     // string on others:
     static wxString GetPluginsDirectory();
 

+
+#if WXWIN_COMPATIBILITY_2_2
+    operator bool() const { return IsLoaded(); }
+#endif
+

 protected:
 protected:

+    // common part of GetSymbol() and HasSymbol()
+    void *DoGetSymbol(const wxString& name, bool *success = 0) const;

 
 

-        // Platform specific shared lib suffix.
+#ifdef wxHAVE_DYNLIB_ERROR
+    // log the error after a dlxxx() function failure
+    static void Error();
+#endif // wxHAVE_DYNLIB_ERROR

 
 

-    static const wxChar *ms_dllext;

 
 

-        // the handle to DLL or NULL
+    // platform specific shared lib suffix.
+    static const wxChar *ms_dllext;

 
 

+    // the handle to DLL or NULL

     wxDllType m_handle;
 
     wxDllType m_handle;
 

-        // no copy ctor/assignment operators
-        // or we'd try to unload the library twice
-
+    // no copy ctor/assignment operators (or we'd try to unload the library
+    // twice)

     DECLARE_NO_COPY_CLASS(wxDynamicLibrary)
 };
 
     DECLARE_NO_COPY_CLASS(wxDynamicLibrary)
 };
 


@@ -212,11 +319,11 @@ public:
       which case the library is searched for in all standard locations
       (use GetDllExt() to construct the filename)
 
       which case the library is searched for in all standard locations
       (use GetDllExt() to construct the filename)
 

-      if success pointer is not NULL, it will be filled with TRUE if everything
-      went ok and FALSE otherwise
+      if success pointer is not NULL, it will be filled with true if everything
+      went ok and false otherwise

      */
     static wxDllType LoadLibrary(const wxString& name, bool *success = NULL);
      */
     static wxDllType LoadLibrary(const wxString& name, bool *success = NULL);

-    
+

     /*
       This function unloads the shared library previously loaded with
       LoadLibrary
     /*
       This function unloads the shared library previously loaded with
       LoadLibrary