home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / include / wx / dynlib.h < prev    next >
C/C++ Source or Header  |  2002-08-31  |  8KB  |  247 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        wx/dynlib.h
  3. // Purpose:     Dynamic library loading classes
  4. // Author:      Guilhem Lavaux, Vadim Zeitlin, Vaclav Slavik
  5. // Modified by:
  6. // Created:     20/07/98
  7. // RCS-ID:      $Id: dynlib.h,v 1.34 2002/08/31 11:29:10 GD Exp $
  8. // Copyright:   (c) 1998 Guilhem Lavaux
  9. // Licence:     wxWindows license
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifndef _WX_DYNLIB_H__
  13. #define _WX_DYNLIB_H__
  14.  
  15. #if defined(__GNUG__) && !defined(__APPLE__)
  16. #   pragma interface "dynlib.h"
  17. #endif
  18.  
  19. #include "wx/setup.h"
  20.  
  21. #if wxUSE_DYNAMIC_LOADER
  22.  
  23. #include "wx/dynload.h"  // Use the new (version of) wxDynamicLibrary instead
  24.  
  25. #elif wxUSE_DYNLIB_CLASS
  26.  
  27. #include "wx/string.h"
  28. #include "wx/list.h"
  29. #include "wx/hash.h"
  30.  
  31. // this is normally done by configure, but I leave it here for now...
  32. #if defined(__UNIX__) && !(defined(HAVE_DLOPEN) || defined(HAVE_SHL_LOAD))
  33. #   if defined(__LINUX__) || defined(__SOLARIS__) || defined(__SUNOS__) || defined(__FREEBSD__)
  34. #      define HAVE_DLOPEN
  35. #   elif defined(__HPUX__)
  36. #      define HAVE_SHL_LOAD
  37. #   endif // Unix flavour
  38. #endif // !Unix or already have some HAVE_xxx defined
  39.  
  40. // Note: WXPM/EMX has to be tested first, since we want to use
  41. // native version, even if configure detected presence of DLOPEN.
  42. #if defined(__WXPM__) || defined(__EMX__)
  43. #   define INCL_DOS
  44. #   include <os2.h>
  45.     typedef HMODULE wxDllType;
  46. #elif defined(HAVE_DLOPEN)
  47. #   include <dlfcn.h>
  48.     typedef void *wxDllType;
  49. #elif defined(HAVE_SHL_LOAD)
  50. #   include <dl.h>
  51.     typedef shl_t wxDllType;
  52. #elif defined(__WINDOWS__)
  53. #   include <windows.h>         // needed to get HMODULE
  54.     typedef HMODULE wxDllType;
  55. #elif defined(__DARWIN__)
  56.     typedef void *wxDllType;
  57. #elif defined(__WXMAC__)
  58.     typedef void *wxDllType;
  59. #else
  60. #   error "wxLibrary can't be compiled on this platform, sorry."
  61. #endif // OS
  62.  
  63. // LoadLibrary is defined in windows.h as LoadLibraryA, but wxDllLoader method
  64. // should be called LoadLibrary, not LoadLibraryA or LoadLibraryW!
  65. #if defined(__WIN32__) && defined(LoadLibrary)
  66. #   include "wx/msw/winundef.h"
  67. #endif
  68.  
  69. // ----------------------------------------------------------------------------
  70. // wxDllLoader: low level DLL functions, use wxDynamicLibrary in your code
  71. // ----------------------------------------------------------------------------
  72.  
  73. /*
  74.     wxDllLoader is a class providing an interface similar to unix's dlopen().
  75.     It is used by wxDynamicLibrary wxLibrary and manages the actual loading of
  76.     DLLs and the resolving of symbols in them. There are no instances of this
  77.     class, it simply serves as a namespace for its static member functions.
  78. */
  79. class WXDLLEXPORT wxDllLoader
  80. {
  81. public:
  82.     /*
  83.       This function loads the shared library libname into memory.
  84.  
  85.       libname may be either the full path to the file or just the filename in
  86.       which case the library is searched for in all standard locations
  87.       (use GetDllExt() to construct the filename)
  88.  
  89.       if success pointer is not NULL, it will be filled with TRUE if everything
  90.       went ok and FALSE otherwise
  91.      */
  92.     static wxDllType LoadLibrary(const wxString& libname, bool *success = 0);
  93.  
  94.     /*
  95.       This function unloads the shared library previously loaded with
  96.       LoadLibrary
  97.      */
  98.     static void UnloadLibrary(wxDllType dll);
  99.  
  100.     /*
  101.        This function returns a valid handle for the main program
  102.        itself or NULL if back linking is not supported by the current platform
  103.        (e.g. Win32).
  104.      */
  105.     static wxDllType GetProgramHandle();
  106.  
  107.     /*
  108.        This function resolves a symbol in a loaded DLL, such as a
  109.        variable or function name.
  110.  
  111.        dllHandle Handle of the DLL, as returned by LoadDll().
  112.        name Name of the symbol.
  113.  
  114.        Returns the pointer to the symbol or NULL on error.
  115.      */
  116.     static void *GetSymbol(wxDllType dllHandle,
  117.                            const wxString &name,
  118.                            bool *success = NULL);
  119.  
  120.     // return the standard DLL extension (with leading dot) for this platform
  121.     static const wxString &GetDllExt() { return ms_dllext; }
  122.  
  123. private:
  124.     // forbid construction of objects
  125.     wxDllLoader();
  126.     static const wxString   ms_dllext;
  127. };
  128.  
  129. // ----------------------------------------------------------------------------
  130. // wxDynamicLibrary - friendly interface to wxDllLoader
  131. // ----------------------------------------------------------------------------
  132.  
  133. class WXDLLEXPORT wxDynamicLibrary
  134. {
  135. public:
  136.     // ctors
  137.     wxDynamicLibrary() { m_library = 0; }
  138.     wxDynamicLibrary(const wxString& name) { Load(name); }
  139.  
  140.     // return TRUE if the library was loaded successfully
  141.     bool IsLoaded() const { return m_library != 0; }
  142.     operator bool() const { return IsLoaded(); }
  143.  
  144.     // load the library with the given name (full or not), return TRUE on
  145.     // success
  146.     bool Load(const wxString& name)
  147.     {
  148.         m_library = wxDllLoader::LoadLibrary(name);
  149.  
  150.         return IsLoaded();
  151.     }
  152.  
  153.     // unload the library, also done automatically in dtor
  154.     void Unload()
  155.     {
  156.         if ( IsLoaded() )
  157.             wxDllLoader::UnloadLibrary(m_library);
  158.     }
  159.  
  160.     // load a symbol from the library, return NULL if an error occured or
  161.     // symbol wasn't found
  162.     void *GetSymbol(const wxString& name) const
  163.     {
  164.         wxCHECK_MSG( IsLoaded(), NULL,
  165.                      _T("can't load symbol from unloaded library") );
  166.  
  167.         return wxDllLoader::GetSymbol(m_library, name);
  168.     }
  169.  
  170.     // unload the library
  171.     //
  172.     // NB: dtor is not virtual, don't derive from this class
  173.     ~wxDynamicLibrary() { Unload(); }
  174.  
  175. private:
  176.     // the handle to DLL or NULL
  177.     wxDllType m_library;
  178.  
  179.     // no copy ctor/assignment operators (or we'd try to unload the library
  180.     // twice)
  181.     DECLARE_NO_COPY_CLASS(wxDynamicLibrary)
  182. };
  183.  
  184. // ----------------------------------------------------------------------------
  185. // wxLibrary
  186. // ----------------------------------------------------------------------------
  187.  
  188. class WXDLLEXPORT wxLibrary : public wxObject
  189. {
  190. public:
  191.     wxLibrary(wxDllType handle);
  192.     virtual ~wxLibrary();
  193.  
  194.     // Get a symbol from the dynamic library
  195.     void *GetSymbol(const wxString& symbname);
  196.  
  197.     // Create the object whose classname is "name"
  198.     wxObject *CreateObject(const wxString& name);
  199.  
  200. protected:
  201.     void PrepareClasses(wxClassInfo *first);
  202.  
  203.     wxDllType m_handle;
  204.  
  205. public:
  206.     wxHashTable classTable;
  207. };
  208.  
  209. // ----------------------------------------------------------------------------
  210. // wxLibraries
  211. // ----------------------------------------------------------------------------
  212.  
  213. class WXDLLEXPORT wxLibraries
  214. {
  215. public:
  216.     wxLibraries();
  217.     ~wxLibraries();
  218.  
  219.     // caller is responsible for deleting the returned pointer if !NULL
  220.     wxLibrary *LoadLibrary(const wxString& basename);
  221.  
  222.     wxObject *CreateObject(const wxString& name);
  223.  
  224. protected:
  225.     wxList m_loaded;
  226. };
  227.  
  228. // ----------------------------------------------------------------------------
  229. // Global variables
  230. // ----------------------------------------------------------------------------
  231.  
  232. extern WXDLLEXPORT_DATA(wxLibraries) wxTheLibraries;
  233.  
  234. // ----------------------------------------------------------------------------
  235. // Interesting defines
  236. // ----------------------------------------------------------------------------
  237.  
  238. #define WXDLL_ENTRY_FUNCTION() \
  239. extern "C" WXEXPORT const wxClassInfo *wxGetClassFirst(); \
  240. const wxClassInfo *wxGetClassFirst() { \
  241.   return wxClassInfo::GetFirst(); \
  242. }
  243.  
  244. #endif // wxUSE_DYNLIB_CLASS
  245.  
  246. #endif // _WX_DYNLIB_H__
  247.