/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/sys/plugin

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_sys_plugin
#define inlib_sys_plugin

#include "../smanip"

#include <ostream>
#include <cstdlib>
#include <cstring> //memcpy

#ifdef WIN32
#include <windows.h>
#else
#include <dlfcn.h>
#endif

namespace inlib {

class plugin {
public:
  plugin(const std::string& a_name,std::ostream& a_out,bool a_verbose = false,bool a_quiet = false)
  :m_module(0)
  ,m_out(a_out)
  ,m_name(a_name)
  ,m_verbose(a_verbose)
  {
    // a_name is the full name (path + libname).
    if(!open()) {
      if(!a_quiet) {
        m_out << "inlib::plugin :" 
              << " can't load " << sout(m_name) << " library." << std::endl;
        m_out << "inlib::plugin :" 
              << " error  : " << m_error 
              << std::endl;
      }
    }
  }

  virtual ~plugin(){close();}

protected:
  plugin(const plugin& a_from):m_out(a_from.m_out){}
  plugin& operator=(const plugin&){return *this;}

public:
  bool open() {
    m_error = "";
    std::string splg = m_name;  
    if(m_verbose) {
      m_out << "inlib::plugin :" 
            << " open " 
            << sout(splg) << "..." << std::endl;
    }
#ifdef WIN32
    m_module = ::LoadLibrary(splg.c_str());
#else
   {std::string path,name,sfx;
    path_name_suffix(m_name,path,name,sfx);
    if(path.empty()) { //Relative path
      std::string sfx = suffix(splg);
      if(sfx.empty()) {
        // Only the name "Xxx" had been given, we have to
#if defined(__CYGWIN__) && defined(__GNUC__)
        // build the name "Xxx.dll" :      
        splg = m_name + ".dll";
#elif defined(__APPLE__)
        splg = m_name + ".bundle";
#else
        // build the name "libXxx.so" :      
        splg = "lib" + m_name + ".so";
#endif
      }
    }}
    int flags = RTLD_NOW | RTLD_GLOBAL;
    m_module = ::dlopen(splg.c_str(),flags);
#if defined(__APPLE__)
    if(!m_module) {
      std::vector<std::string> ps = paths(); 
      unsigned int pathn = ps.size();
      for(unsigned int index=0;index<pathn;index++) {
        splg = ps[index]+"/" + m_name + ".bundle";
        if(m_verbose) {
          m_out << "inlib::plugin::open :" 
                << " open " 
                << sout(splg) << "..." 
                << std::endl;
        }
        m_module = ::dlopen(splg.c_str(),flags);
        if(m_module) break;
      }
    }
#endif
    const char* cerror;
    if ((cerror=dlerror())!=NULL) m_error = cerror;
#endif
    if(!m_module) return false;
    if(m_verbose) {
      m_out << "inlib::plugin :" 
            << " " << sout(splg) << " opened." << std::endl;
    }
    m_plugin = splg;  
    return true;
  }

  void close(){
    if(!m_module) return; //done
    if(m_verbose) {
      m_out << "inlib::close :" 
            << " close " << sout(m_name) << "..." << std::endl;
    }
#ifdef WIN32
    ::FreeLibrary((HMODULE)m_module);
#else
    if(::dlclose(m_module)) {
      m_out << "inlib::~plugin :" 
            << " error  : " << ::dlerror() << std::endl;
    }
#endif
    if(m_verbose) {
      m_out << "inlib::~plugin :" 
            << " close " << sout(m_name) << " done." << std::endl;
    }
    m_module = 0;
  }

  bool is_opened() const {return m_module?true:false;}

  const std::string& file_name() const{return m_name;}

  typedef void (*procedure)();

  procedure find(const std::string& a_name,bool a_quiet = false) const {
    if(!m_module) return 0;
    std::string name = a_name;
    procedure p = 0;
    if(m_verbose) {
      m_out << "inlib::find :" 
            << " search symbol " 
            << sout(name) << "..." << std::endl;
    }
#ifdef WIN32
    p = (procedure)::GetProcAddress((HMODULE)m_module,name.c_str());
    if (!p) {
      name = "_" + a_name;
      p = (procedure)::GetProcAddress((HMODULE)m_module,name.c_str());
      if (!p) {
        if(!a_quiet) {
          m_out << "Lib : Can't find symbol " << sout(a_name) << "." 
                << std::endl;
        }
      }
    }
#else
    void* a = ::dlsym(m_module,(char*)name.c_str());
    //trick to avoid the warning :
    //ISO C++ forbids casting between pointer-to-function and pointer-to-object
    ::memcpy(&p,&a,sizeof(void*)); //beurk

    const char* cerror;
    if ((cerror=dlerror())!=NULL) {
      std::string serror = cerror;
      name = "_" + a_name;
      void* a = ::dlsym(m_module,(char*)name.c_str());
      ::memcpy(&p,&a,sizeof(void*)); //rebeurk

      if ((cerror=dlerror())!=NULL) {
        if(!a_quiet) {
          m_out << "inlib::find :" 
                << " problem when searching " << sout(a_name)
                << " in " << sout(m_plugin) << "."
                << " dlerror  : " << serror << std::endl;
        } 
      } 
    }
#endif
    if(p && m_verbose) {
      m_out << "inlib::find :" 
            << " symbol " << sout(name) << " found." << std::endl;
    }
    return p;
  }

public:
  static bool is_valid(const std::string& a_name,std::ostream& a_out) {
    plugin plg(a_name,a_out,0,true);
    bool status = plg.is_opened();
    plg.close();
    return status;
  }

protected:
  static std::vector<std::string> paths() { //APPLE only.
    const char* env = ::getenv("DYLD_LIBRARY_PATH");
    if(!env) env = ::getenv("GDB_DYLD_LIBRARY_PATH");
    std::string senv = (env==NULL ? std::string("") : std::string(env));
    return words(senv,":");
  }

protected:
  void* m_module;
  std::ostream& m_out;
  std::string m_name;
  std::string m_plugin;
  bool m_verbose;
  std::string m_error;
};

}

#include <map>

namespace inlib {

class plugin_cache {
public:
  virtual bool open(const std::string& a_name,plugin*& a_plugin){
    std::map<std::string,plugin*>::iterator it = m_cache.find(a_name);
    if(it!=m_cache.end()) { //a_name in the cache.
      a_plugin = (*it).second;
      return true;
    }
    a_plugin = new plugin(a_name,m_out);
    if(!a_plugin->is_opened()) {
      m_out << "inlib::can't open plugin " << a_name << std::endl;
      delete a_plugin;
      a_plugin = 0;
      return false;
    }
    m_cache[a_name] = a_plugin;
    return true;
  }
public:
  plugin_cache(std::ostream& a_out)
  :m_out(a_out)
  {}
  virtual ~plugin_cache(){clear();}
protected:
  plugin_cache(const plugin_cache& a_from)
  :m_out(a_from.m_out)
  {}
  plugin_cache& operator=(const plugin_cache&){return *this;}
public:
  void clear() {
    std::map<std::string,plugin*>::iterator it;
    for(it = m_cache.begin();it!=m_cache.end();++it) {
      delete (*it).second;
    }
    m_cache.clear();
  }
protected:
  std::ostream& m_out;
  std::map<std::string,plugin*> m_cache; 
};


}

#endif