comin_setup.cpp

Go to the documentation of this file.

 
#include "comin.h"
 
#include "comin_logging.hpp"
#include "comin_plugin_info.hpp"
#include "comin_state.hpp"
#include "comin_util.hpp"
 
#include <algorithm>
#include <dlfcn.h>
#include <string>

struct t_comin_plugin_description {
  char name[COMIN_MAX_LEN_PLUGIN_NAME + 1];
  char plugin_library[COMIN_MAX_LEN_PLUGIN_LIBRARY + 1];
  char primary_constructor[COMIN_MAX_LEN_PRIMARY_CONSTRUCTOR + 1];
  char options[COMIN_MAX_LEN_OPTIONS + 1];
  char comm[COMIN_MAX_LEN_COMM + 1];
  int log_severity;
};
 
extern "C" {
  // Load plugin modules and call their primary constructors.
  // Takes an array with size of plugin descriptions. Loads each plugin and
  // calls its primary constructor in order. The communicator and options
  // strings are copied so the plugin can request them later.
  //
  // Called by the host model through a Fortran interface
  // (comin_setup::comin_plugin_primaryconstructor).
  void
  comin_plugin_primaryconstructor(const t_comin_plugin_description* plugin_list,
                                  int num_plugins) {
    using comin::into_string;
    using comin::state;
 
    comin_state_set_num_plugins(num_plugins);
 
    for (int i = 0; i < num_plugins; ++i) {
      auto name           = into_string(plugin_list[i].name);
      auto plugin_library = into_string(plugin_list[i].plugin_library);
      auto constructor    = into_string(plugin_list[i].primary_constructor);
 
      void* dlhandle;
      if (plugin_library.empty()) {
        dlhandle = dlopen(nullptr, RTLD_NOW);
      } else {
        dlhandle = dlopen(plugin_library.c_str(), RTLD_NOW);
      }
 
      if (name.empty()) {
        if (plugin_library.empty()) {
          name = "<self>";
        } else if (auto pos = plugin_library.rfind('/');
                   pos != std::string::npos) {
          name = std::string(plugin_library, pos + 1);
        } else {
          name = plugin_library;
        }
        name += "(" + constructor + ")";
      }
 
      if (!dlhandle) {
        comin_plugin_finish_f("comin_plugin_primaryconstructor",
                              "Cannot load plugin <%s>: %s", name.c_str(),
                              dlerror());
        return;
      }
 
      auto primary_constructor =
          reinterpret_cast<void (*)()>(dlsym(dlhandle, constructor.c_str()));
 
      if (!primary_constructor) {
        comin_plugin_finish_f(
            "comin_plugin_primaryconstructor",
            "Cannot load plugin <%s> primary constructor '%s': %s",
            name.c_str(), constructor.c_str(), dlerror());
        return;
      }
 
      if (plugin_list[i].log_severity < COMIN_SEVERITY_DEBUG ||
          plugin_list[i].log_severity > COMIN_SEVERITY_ERROR) {
        comin_plugin_finish_f("comin_plugin_primaryconstructor",
                              "Plugin <%s> log severity %d out of range.",
                              name.c_str(), plugin_list[i].log_severity);
        return;
      }
      auto severity =
          static_cast<t_comin_log_severity>(plugin_list[i].log_severity);
 
      t_comin_plugin_info info;
      info.comm          = into_string(plugin_list[i].comm);
      info.errors_return = false;
      info.id            = i + 1;
      info.log_severity  = severity;
      info.name          = std::move(name);
      info.options       = into_string(plugin_list[i].options);
 
      state.plugin_info.push_back(std::move(info));
 
      comin_current_set_plugin_id(i + 1);
      primary_constructor();
    }
 
    comin::logging::message(0, "     Complete primary constructors");
    comin_state_set_primary_done();
  }
 
  void comin_setup_get_version(unsigned int* major, unsigned int* minor,
                               unsigned int* patch) {
    *major = COMIN_VERSION_MAJOR;
    *minor = COMIN_VERSION_MINOR;
    *patch = COMIN_VERSION_PATCH;
  }
}