cOSModule.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cOSModule_H
#define _INC_cOSModule_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cOSHandle.h"
#include "cFilePath.h"
#include "cMime.h"
 
#ifdef _WIN32
#define MODULE_EXT MIME_EXT_dll
 
#elif defined(__linux__)
#include <dlfcn.h>
#define MODULE_EXT MIME_EXT_so
typedef int (GRAYCALL * FARPROC)();
#else
#error NOOS
#endif
 
namespace Gray
{
#define HMODULE_NULL ((HMODULE)nullptr) // This sometimes means the current process module.
 
        class GRAYCORE_LINK cOSModule
        {
 
        private:
                HMODULE m_hModule;              
                UINT32 m_uFlags;                
#if defined(__linux__)
                cStringF m_sModuleName; 
#endif
 
        protected:
                void FreeModuleLast();
 
        public:
#ifdef _WIN32
 
#ifndef LOAD_LIBRARY_AS_IMAGE_RESOURCE 
#define LOAD_LIBRARY_AS_IMAGE_RESOURCE      0x00000020          // __GNUC__
#endif
                static const UINT k_Load_Normal = 0;                            
                static const UINT k_Load_Preload = DONT_RESOLVE_DLL_REFERENCES;                 
                static const UINT k_Load_Resource = LOAD_LIBRARY_AS_IMAGE_RESOURCE;             
#elif defined(__linux__)
                static const UINT k_Load_Normal = RTLD_NOW;                     
                static const UINT k_Load_Preload = RTLD_LAZY;           
                static const UINT k_Load_Resource = RTLD_LAZY;          
#endif
                static const UINT k_Load_OSMask         = 0x0FFFFFFF;
                static const UINT k_Load_ByName         = 0x40000000;   
                static const UINT k_Load_NoRefCount     = 0x80000000;   
 
                cOSModule(HMODULE hModule = HMODULE_NULL, UINT32 uFlags = k_Load_Normal);
                cOSModule(const FILECHAR_t* pszModuleName, UINT32 uFlags);
                ~cOSModule();
 
                static MIME_TYPE GRAYCALL CheckModuleTypeFile(const FILECHAR_t* pszPathName);
 
#ifndef UNDER_CE
                static HMODULE GRAYCALL GetModuleHandleForAddr(const void* pAddr);
#endif
                FARPROC GetSymbolAddress(const char* pszSymbolName) const;
 
                bool isValidModule() const noexcept
                {
                        return(m_hModule != HMODULE_NULL);
                }
                operator HMODULE() const noexcept
                {
                        return m_hModule;
                }
                HMODULE get_ModuleHandle() const noexcept
                {
                        return m_hModule;
                }
                UINT_PTR get_ModuleInt() const noexcept
                {
                        return (UINT_PTR)m_hModule;
                }
                bool isResourceModule() const noexcept
                {
                        // We cant call this. its not loaded as code.
                        return ( m_uFlags & (k_Load_Preload | k_Load_Resource));
                }
 
                StrLen_t GetModulePath(FILECHAR_t* pszModuleName, StrLen_t nSizeMax) const;
                cStringF get_Name() const;
 
                HRESULT GetLastErrorDef(HRESULT hResDef = E_FAIL) const
                {
#ifdef _WIN32
                        return HResult::GetLastDef(hResDef);
#elif defined(__linux__)
                        // Just a string?
                        const char* pszError = ::dlerror();
                        UNREFERENCED_PARAMETER(pszError);
                        return E_NOTIMPL;
#endif
                }
 
                void AttachModule(HMODULE hModule = HMODULE_NULL, UINT32 uFlags = k_Load_Normal)
                {
                        FreeModuleLast();
                        m_hModule = hModule;
                        m_uFlags = uFlags;
                }
                void ClearModule() noexcept
                {
                        m_hModule = HMODULE_NULL;
                        m_uFlags = k_Load_Normal;
#ifdef __linux__
                        m_sModuleName.Empty();
#endif
                }
                HMODULE DetachModule() noexcept
                {
                        HMODULE hModule = m_hModule;
                        ClearModule();
                        return hModule;
                }
                void FreeThisModule();
 
                bool AttachModuleName(const FILECHAR_t* pszModuleName, UINT32 uFlags = k_Load_NoRefCount);
                HRESULT LoadModule(const FILECHAR_t* pszModuleName, UINT32 uFlags = k_Load_Normal);
                HRESULT LoadModuleWithSymbol(const FILECHAR_t* pszModuleName, const char* pszSymbolName);
 
#ifdef _WIN32
                // Load or enum resources ?? cWinResource, cAppRes
#endif
                UNITTEST_FRIEND(cOSModule);
        };
 
        template<class TYPE = FARPROC>
        class cOSModuleFunc
        {
        public:
                TYPE m_pFunc;           
        public:
                cOSModuleFunc(TYPE pFunc = nullptr)
                        : m_pFunc(pFunc)
                {
                }
                ~cOSModuleFunc()
                {
                }
                void ClearFuncAddress()
                {
                        m_pFunc = nullptr;
                }
                bool put_FuncAddress(TYPE pFunc)
                {
                        m_pFunc = pFunc;
                        if (m_pFunc == nullptr)
                                return false;
                        return true;
                }
                bool put_FuncGeneric(FARPROC pFunc)
                {
                        m_pFunc = (TYPE)pFunc;
                        if (m_pFunc == nullptr)
                                return false;
                        return true;
                }
                bool isValidFunc() const
                {
                        return(m_pFunc != nullptr);
                }
                operator TYPE () const
                {
                        return m_pFunc;
                }
        };
 
        typedef cOSModuleFunc<FARPROC> cOSModuleFuncGeneric;
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYCORE_LINK cOSModuleFunc < FARPROC >;
#endif
}
#endif // _INC_cOSModule_H