#include <shell_compiler.hpp>

Detailed Description

Author: Joel Andersson

Date: 2015

Interface to the JIT compiler SHELL

Extra doc: https://github.com/casadi/casadi/wiki/L_22w

List of available options
Id	Type	Description
cleanup	OT_BOOL	Cleanup temporary files when unloading. Default: true
compiler	OT_STRING	Compiler command
compiler_flags	OT_STRINGVECTOR	Alias for 'compiler_flags'
compiler_output_flag	OT_STRING	Compiler flag to denote object output. Default: '-o '
compiler_setup	OT_STRING	Compiler setup command. Intended to be fixed. The 'flag' option is the prefered way to set custom flags.
directory	OT_STRING	Directory to put temporary objects in. Must end with a file separator.
extra_suffixes	OT_STRINGVECTOR	List of suffixes for extra files that the compiler may generate. Default: None
flags	OT_STRINGVECTOR	Compile flags for the JIT compiler. Default: None
linker	OT_STRING	Linker command
linker_flags	OT_STRINGVECTOR	Linker flags for the JIT compiler. Default: None
linker_output_flag	OT_STRING	Linker flag to denote shared library output. Default: '-o '
linker_setup	OT_STRING	Linker setup command. Intended to be fixed. The 'flag' option is the prefered way to set custom flags.
name	OT_STRING	The file name used to write out compiled objects/libraries. The actual file names used depend on 'temp_suffix' and include extensions. Default: 'tmp_casadi_compiler_shell'
temp_suffix	OT_BOOL	Use a temporary (seemingly random) filename suffix for file names. This is desired for thread-safety. This behaviour may defeat caching compiler wrappers. Default: true

List of available options
Id	Type	Description	Used in
cleanup	OT_BOOL	Cleanup temporary files when unloading. Default: true	casadi::ShellCompiler
compiler	OT_STRING	Compiler command	casadi::ShellCompiler
compiler_flags	OT_STRINGVECTOR	Alias for 'compiler_flags'	casadi::ShellCompiler
compiler_output_flag	OT_STRING	Compiler flag to denote object output. Default: '-o '	casadi::ShellCompiler
compiler_setup	OT_STRING	Compiler setup command. Intended to be fixed. The 'flag' option is the prefered way to set custom flags.	casadi::ShellCompiler
directory	OT_STRING	Directory to put temporary objects in. Must end with a file separator.	casadi::ShellCompiler
extra_suffixes	OT_STRINGVECTOR	List of suffixes for extra files that the compiler may generate. Default: None	casadi::ShellCompiler
flags	OT_STRINGVECTOR	Compile flags for the JIT compiler. Default: None	casadi::ShellCompiler
linker	OT_STRING	Linker command	casadi::ShellCompiler
linker_flags	OT_STRINGVECTOR	Linker flags for the JIT compiler. Default: None	casadi::ShellCompiler
linker_output_flag	OT_STRING	Linker flag to denote shared library output. Default: '-o '	casadi::ShellCompiler
linker_setup	OT_STRING	Linker setup command. Intended to be fixed. The 'flag' option is the prefered way to set custom flags.	casadi::ShellCompiler
name	OT_STRING	The file name used to write out compiled objects/libraries. The actual file names used depend on 'temp_suffix' and include extensions. Default: 'tmp_casadi_compiler_shell'	casadi::ShellCompiler
temp_suffix	OT_BOOL	Use a temporary (seemingly random) filename suffix for file names. This is desired for thread-safety. This behaviour may defeat caching compiler wrappers. Default: true	casadi::ShellCompiler
verbose	OT_BOOL	Verbose evaluation – for debugging	casadi::ImporterInternal

Definition at line 53 of file shell_compiler.hpp.

Inheritance diagram for casadi::ShellCompiler:

[legend]

Collaboration diagram for casadi::ShellCompiler:

[legend]

Public Types
typedef ImporterInternal (	Creator) (const std::string &name)

using	weak_ref_type = WeakRefInternal

typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	ShellCompiler (const std::string &name)
	Constructor. More...

	~ShellCompiler () override
	Destructor. More...

void	init (const Dict &opts) override
	Initialize. More...

const char *	plugin_name () const override
	Get name of plugin. More...

std::string	class_name () const override
	Get type name. More...

signal_t	get_function (const std::string &symname) override
	Get a function pointer for numerical evaluation. More...

std::string	library () const override
	Get library name. More...

void	disp (std::ostream &stream, bool more) const override
	Print. More...

void	construct (const Dict &opts)
	Construct. More...

virtual void	finalize ()

bool	has_function (const std::string &symname) const
	Get a function pointer for numerical evaluation. More...

bool	has_meta (const std::string &cmd, casadi_int ind=-1) const
	Does an entry exist? More...

std::string	get_meta (const std::string &cmd, casadi_int ind=-1) const
	Get entry as a text. More...

void	read_meta (std::istream &file, casadi_int &offset)
	Get meta information. More...

void	read_external (const std::string &sym, bool inlined, std::istream &file, casadi_int &offset)
	Get an external function declaration. More...

bool	inlined (const std::string &symname) const

std::string	body (const std::string &symname) const
	Get the function body, if inlined. More...

virtual bool	can_have_meta () const
	Can meta information be read? More...

std::string	to_text (const std::string &cmd, casadi_int ind=-1) const
	Get entry as a text. More...

void	serialize (SerializingStream &s) const

virtual void	serialize_type (SerializingStream &s) const

virtual void	serialize_body (SerializingStream &s) const

casadi_int	getCount () const
	Get the reference count. More...

std::string	debug_repr (const SharedObjectInternal *) const

GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...

Static Public Member Functions
static ImporterInternal *	creator (const std::string &name)
	Create a new JIT function. More...

static std::string	shortname ()
	Short name. More...

static std::string	indexed (const std::string &cmd, casadi_int ind)

static ImporterInternal *	deserialize (DeserializingStream &s)

static bool	has_plugin (const std::string &pname, bool verbose=false)
	Check if a plugin is available or can be loaded. More...

static const Options &	plugin_options (const std::string &pname)
	Get the plugin options. More...

static Deserialize	plugin_deserialize (const std::string &pname)
	Get the plugin deserialize_map. More...

static Plugin	pluginFromRegFcn (RegFcn regfcn)
	Instantiate a Plugin struct from a factory function. More...

static Plugin	load_plugin (const std::string &pname, bool register_plugin=true, bool needs_lock=true)
	Load a plugin dynamically. More...

static handle_t	load_library (const std::string &libname, std::string &resultpath, bool global)
	Load a library dynamically. More...

static void	registerPlugin (const Plugin &plugin, bool needs_lock=true)
	Register an integrator in the factory. More...

static void	registerPlugin (RegFcn regfcn, bool needs_lock=true)
	Register an integrator in the factory. More...

static Plugin &	getPlugin (const std::string &pname)
	Load and get the creator function. More...

static ImporterInternal *	instantiate (const std::string &fname, const std::string &pname, Problem problem)

Public Attributes
std::string	name_
	C filename. More...

std::map< std::string, std::pair< casadi_int, std::string > >	meta_
	Meta data. More...

std::map< std::string, std::pair< bool, std::string > >	external_
	External functions. More...

bool	verbose_
	Verbose – for debugging purposes. More...

Static Public Attributes
static const std::string	meta_doc
	A documentation string. More...

static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...

static const std::string	infix_ = "importer"
	Infix. More...

Protected Member Functions
void	initSingleton ()

void	destroySingleton ()

B	shared_from_this ()
	Get a shared object from the current internal object. More...

const B	shared_from_this () const
	Get a shared object from the current internal object. More...

Protected Attributes
std::string	base_name_

std::string	bin_name_
	Temporary file. More...

std::string	obj_name_
	Temporary file. More...

std::vector< std::string >	extra_suffixes_
	Extra files. More...

bool	cleanup_
	Cleanup temporary files when unloading. More...

handle_t	handle_

static const Options	options_
	Options. More...

const Options &	get_options () const override
	Options. More...

Member Typedef Documentation

◆ Creator

typedef ImporterInternal*(* casadi::ImporterInternal::Creator) (const std::string &name)

inherited

Definition at line 66 of file importer_internal.hpp.

◆ RegFcn

typedef int(* casadi::PluginInterface< ImporterInternal >::RegFcn) (Plugin *plugin)

inherited

Definition at line 73 of file plugin_interface.hpp.

◆ weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

◆ ShellCompiler()

casadi::ShellCompiler::ShellCompiler ( const std::string & name )

explicit

Definition at line 57 of file shell_compiler.cpp.

                                                     :
     ImporterInternal(name) {
       handle_ = nullptr;
   }

References handle_.

◆ ~ShellCompiler()

casadi::ShellCompiler::~ShellCompiler ( )

override

Definition at line 62 of file shell_compiler.cpp.

                                 {
     if (handle_) close_shared_library(handle_);
  
     if (cleanup_) {
       if (remove(bin_name_.c_str())) casadi_warning("Failed to remove " + bin_name_);
       if (remove(obj_name_.c_str())) casadi_warning("Failed to remove " + obj_name_);
       for (const std::string& s : extra_suffixes_) {
         std::string name = base_name_+s;
         remove(name.c_str());
       }
     }
   }

References base_name_, bin_name_, cleanup_, extra_suffixes_, handle_, obj_name_, and casadi::remove().

Member Function Documentation

◆ body()

std::string casadi::ImporterInternal::body ( const std::string & symname ) const

inherited

Definition at line 299 of file importer_internal.cpp.

                                                                  {
     auto it = external_.find(symname);
     casadi_assert_dev(it!=external_.end() && it->second.first);
     return it->second.second;
   }

References casadi::ImporterInternal::external_.

◆ can_have_meta()

virtual bool casadi::ImporterInternal::can_have_meta ( ) const

inlinevirtualinherited

Reimplemented in casadi::DllLibrary.

Definition at line 142 of file importer_internal.hpp.

142 { return true;}

Referenced by casadi::ImporterInternal::init().

◆ class_name()

std::string casadi::ShellCompiler::class_name ( ) const

inlineoverridevirtual

Extra doc: https://github.com/casadi/casadi/wiki/L_219

Reimplemented from casadi::ImporterInternal.

Definition at line 83 of file shell_compiler.hpp.

83 { return "ShellCompiler";}

◆ construct()

void casadi::ImporterInternal::construct ( const Dict & opts )

inherited

Prepares the function for evaluation

Extra doc: https://github.com/casadi/casadi/wiki/L_21b

Definition at line 57 of file importer_internal.cpp.

                                                    {
     // Sanitize dictionary is needed
     if (!Options::is_sane(opts)) {
       // Call recursively
       return construct(Options::sanitize(opts));
     }
  
     // Make sure all options exist
     get_options().check(opts);
  
     // Initialize object
     init(opts);
  
     // Revisit class hierarchy in reverse order
     finalize();
   }

References casadi::Options::check(), casadi::ImporterInternal::finalize(), casadi::ImporterInternal::get_options(), casadi::ImporterInternal::init(), casadi::Options::is_sane(), and casadi::Options::sanitize().

Referenced by casadi::Importer::create().

◆ creator()

static ImporterInternal* casadi::ShellCompiler::creator ( const std::string & name )

inlinestatic

Definition at line 60 of file shell_compiler.hpp.

                                                             {
       return new ShellCompiler(name);
     }

Referenced by casadi::casadi_register_importer_shell().

◆ debug_repr()

std::string casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::debug_repr ( const Internal * i ) const

inherited

Definition at line 62 of file generic_shared_internal.hpp.

                                                                                        {
     // Note: i != this because of something something multiple inheritance
     return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
   }

◆ deserialize()

ImporterInternal * casadi::ImporterInternal::deserialize ( DeserializingStream & s )

staticinherited

Definition at line 332 of file importer_internal.cpp.

                                                                         {
     std::string class_name;
     s.unpack("ImporterInternal::type", class_name);
     if (class_name=="DllLibrary") {
       return DllLibrary::deserialize(s);
     } else {
        casadi_error("Cannot deserialize type '" + class_name + "'");
     }
   }

References casadi::ImporterInternal::class_name(), casadi::DllLibrary::deserialize(), and casadi::DeserializingStream::unpack().

Referenced by casadi::Importer::deserialize().

◆ destroySingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::destroySingleton ( )

inlineprotectedinherited

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

                             {
       static_cast<Internal*>(this)->count--;
     }

◆ disp()

void casadi::ImporterInternal::disp	(	std::ostream &	stream,
		bool	more
	)		const

overridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21a

Implements casadi::SharedObjectInternal.

Definition at line 38 of file importer_internal.cpp.

38 {

39 }

◆ finalize()

virtual void casadi::ImporterInternal::finalize ( )

inlinevirtualinherited

Reimplemented in casadi::DllLibrary.

Definition at line 88 of file importer_internal.hpp.

88 {}

Referenced by casadi::ImporterInternal::construct().

◆ get_function()

signal_t casadi::ShellCompiler::get_function ( const std::string & symname )

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 262 of file shell_compiler.cpp.

                                                                {
 #ifdef _WIN32
     return (signal_t)GetProcAddress(handle_, TEXT(symname.c_str()));
 #else // _WIN32
     signal_t fcnPtr = reinterpret_cast<signal_t>(dlsym(handle_, symname.c_str()));
     if (dlerror()) {
       fcnPtr=nullptr;
       dlerror(); // Reset error flags
     }
     return fcnPtr;
 #endif // _WIN32
   }

References handle_.

◆ get_meta()

std::string casadi::ImporterInternal::get_meta	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21f

Definition at line 283 of file importer_internal.cpp.

                                                                                  {
     if (ind>=0) return get_meta(indexed(cmd, ind));
     casadi_assert(has_meta(cmd), "No such command: " + cmd);
     return meta_.at(cmd).second;
   }

References casadi::ImporterInternal::has_meta(), casadi::ImporterInternal::indexed(), and casadi::ImporterInternal::meta_.

◆ get_options()

const Options& casadi::ShellCompiler::get_options ( ) const

inlineoverridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 70 of file shell_compiler.hpp.

70 { return options_;}

casadi::ShellCompiler::options_

static const Options options_

Options.

Definition: shell_compiler.hpp:69

◆ getCount()

casadi_int casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 60 of file generic_shared_internal.hpp.

                                                                      {
     return static_cast<const Internal*>(this)->count;
   }

◆ getPlugin()

PluginInterface< ImporterInternal >::Plugin & casadi::PluginInterface< ImporterInternal >::getPlugin ( const std::string & pname )

staticinherited

Definition at line 102 of file plugin_interface.hpp.

                                                             {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Check if the solver has been loaded
     auto it=Derived::solvers_.find(pname);
  
     // Load the solver if needed
     if (it==Derived::solvers_.end()) {
       load_plugin(pname, true, false);
       it=Derived::solvers_.find(pname);
     }
     casadi_assert_dev(it!=Derived::solvers_.end());
     return it->second;
   }

◆ has_function()

bool casadi::ImporterInternal::has_function ( const std::string & symname ) const

inherited

Definition at line 214 of file importer_internal.cpp.

                                                                     {
     // Check if in meta information
     if (external_.find(symname)!=external_.end()) return true;
  
     // Convert to a dummy function pointer
     return const_cast<ImporterInternal*>(this)->get_function(symname)!=nullptr;
   }

References casadi::ImporterInternal::external_, and casadi::ImporterInternal::get_function().

◆ has_meta()

bool casadi::ImporterInternal::has_meta	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21e

Definition at line 289 of file importer_internal.cpp.

                                                                             {
     if (ind>=0) return has_meta(indexed(cmd, ind));
     return meta_.find(cmd) != meta_.end();
   }

References casadi::ImporterInternal::indexed(), and casadi::ImporterInternal::meta_.

Referenced by casadi::ImporterInternal::get_meta().

◆ has_plugin()

bool casadi::PluginInterface< ImporterInternal >::has_plugin	(	const std::string &	pname,
		bool	verbose = `false`
	)

staticinherited

Definition at line 76 of file plugin_interface.hpp.

                                                                                 {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Quick return if available
     if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
       return true;
     }
  
     // Try loading the plugin
     try {
       (void)load_plugin(pname, false, false);
       return true;
     } catch (CasadiException& ex) {
       if (verbose) {
         casadi_warning(ex.what());
       }
       return false;
     }
   }

◆ indexed()

static std::string casadi::ImporterInternal::indexed	(	const std::string &	cmd,
		casadi_int	ind
	)

inlinestaticinherited

Convert indexed command

Definition at line 150 of file importer_internal.hpp.

                                                                           {
       std::stringstream ss;
       ss << cmd << "[" << ind << "]";
       return ss.str();
     }

Referenced by casadi::ImporterInternal::get_meta(), and casadi::ImporterInternal::has_meta().

◆ init()

void casadi::ShellCompiler::init ( const Dict & opts )

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 131 of file shell_compiler.cpp.

                                            {
     // Base class
     ImporterInternal::init(opts);
  
     // Default options
  
     cleanup_ = true;
     bool temp_suffix = true;
     std::string bare_name = "tmp_casadi_compiler_shell";
     std::string directory = "";
  
     std::vector<std::string> compiler_flags;
     std::vector<std::string> linker_flags;
     std::string suffix = OBJECT_FILE_SUFFIX;
  
 #ifdef _WIN32
     std::string compiler = "cl.exe";
     std::string linker = "link.exe";
     std::string compiler_setup = "/c";
     std::string linker_setup = "/DLL";
     std::string compiler_output_flag = "/Fo";
     std::string linker_output_flag = "/out:";
     extra_suffixes_ = {".exp", ".lib"};
 #else
     std::string compiler = "gcc";
     std::string linker = "gcc";
     std::string compiler_setup = "-fPIC -c";
     std::string linker_setup = "-shared";
     std::string compiler_output_flag = "-o ";
     std::string linker_output_flag = "-o ";
 #endif
  
     // Read options
     for (auto&& op : opts) {
       if (op.first=="compiler") {
         compiler = op.second.to_string();
       } else if (op.first=="linker") {
         linker = op.second.to_string();
       } else if (op.first=="directory") {
         directory = op.second.to_string();
       } else if (op.first=="compiler_setup") {
         compiler_setup = op.second.to_string();
       } else if (op.first=="cleanup") {
         cleanup_ = op.second;
       } else if (op.first=="linker_setup") {
         linker_setup = op.second.to_string();
       } else if (op.first=="compiler_flags" || op.first=="flags") {
         compiler_flags = op.second;
       } else if (op.first=="linker_flags") {
         linker_flags = op.second;
       } else if (op.first=="compiler_output_flag") {
         compiler_output_flag = op.second.to_string();
       } else if (op.first=="linker_output_flag") {
         linker_output_flag = op.second.to_string();
       } else if (op.first=="extra_suffixes") {
         extra_suffixes_ = op.second.to_string_vector();
       } else if (op.first=="name") {
         bare_name = op.second.to_string();
       } else if (op.first=="temp_suffix") {
         temp_suffix = op.second;
       }
     }
  
     // Name of temporary file
     if (temp_suffix) {
       obj_name_ = temporary_file(directory + bare_name, suffix);
     } else {
       obj_name_ = directory + bare_name + suffix;
     }
     base_name_ = std::string(obj_name_.begin(), obj_name_.begin()+obj_name_.size()-suffix.size());
     bin_name_ = base_name_+SHARED_LIBRARY_SUFFIX;
  
 #ifndef _WIN32
     // Have relative paths start with ./
     if (obj_name_.at(0)!='/') {
       obj_name_ = "./" + obj_name_;
     }
  
     if (bin_name_.at(0)!='/') {
       bin_name_ = "./" + bin_name_;
     }
 #endif // _WIN32
  
     // Construct the compiler command
     std::stringstream cccmd;
     cccmd << compiler;
     for (auto i=compiler_flags.begin(); i!=compiler_flags.end(); ++i) {
       cccmd << " " << *i;
     }
     cccmd << " " << compiler_setup;
  
     // C/C++ source file
     cccmd << " " << name_;
  
     // Temporary object file
     cccmd << " " + compiler_output_flag << obj_name_;
  
     // Compile into an object
     if (verbose_) casadi_message("calling \"" + cccmd.str() + "\"");
     if (system(cccmd.str().c_str())) {
       casadi_error("Compilation failed. Tried \"" + cccmd.str() + "\"");
     }
  
     // Link step
     std::stringstream ldcmd;
     ldcmd << linker;
  
     // Temporary file
     ldcmd << " " << obj_name_ << " " + linker_output_flag + bin_name_;
  
     // Add flags
     for (auto i=linker_flags.begin(); i!=linker_flags.end(); ++i) {
       ldcmd << " " << *i;
     }
     ldcmd << " " << linker_setup;
  
     // Compile into a shared library
     if (verbose_) casadi_message("calling \"" + ldcmd.str() + "\"");
     if (system(ldcmd.str().c_str())) {
       casadi_error("Linking failed. Tried \"" + ldcmd.str() + "\"");
     }
  
     std::vector<std::string> search_paths = get_search_paths();
     handle_ = open_shared_library(bin_name_, search_paths, "ShellCompiler::init");
  
   }

References base_name_, bin_name_, cleanup_, extra_suffixes_, casadi::get_search_paths(), handle_, casadi::ImporterInternal::init(), casadi::ImporterInternal::name_, obj_name_, casadi::temporary_file(), and casadi::ImporterInternal::verbose_.

◆ initSingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::initSingleton ( )

inlineprotectedinherited

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(static_cast<Internal*>(this)->count==0);
       static_cast<Internal*>(this)->count++;
     }

◆ inlined()

bool casadi::ImporterInternal::inlined ( const std::string & symname ) const

inherited

Definition at line 294 of file importer_internal.cpp.

                                                                {
     auto it = external_.find(symname);
     return it!=external_.end() && it->second.first;
   }

References casadi::ImporterInternal::external_.

Referenced by casadi::ImporterInternal::init(), and casadi::ImporterInternal::read_external().

◆ instantiate()

ImporterInternal * casadi::PluginInterface< ImporterInternal >::instantiate	(	const std::string &	fname,
		const std::string &	pname,
		Problem	problem
	)

staticinherited

Definition at line 106 of file plugin_interface.hpp.

                                                        {
  
     // Assert the plugin exists (needed for adaptors)
     if (!has_plugin(pname, true)) {
       casadi_error("Plugin '" + pname + "' is not found.");
     }
     return getPlugin(pname).creator(fname, problem);
   }

◆ library()

std::string casadi::ShellCompiler::library ( ) const

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 258 of file shell_compiler.cpp.

                                          {
     return bin_name_;
   }

References bin_name_.

◆ load_library()

handle_t casadi::PluginInterface< ImporterInternal >::load_library	(	const std::string &	libname,
		std::string &	resultpath,
		bool	global
	)

staticinherited

Definition at line 92 of file plugin_interface.hpp.

                                         {
  
 #ifndef WITH_DL
     casadi_error("WITH_DL option needed for dynamic loading");
 #else // WITH_DL
  
     // Get the name of the shared library
     std::string lib = SHARED_LIBRARY_PREFIX + libname + SHARED_LIBRARY_SUFFIX;
  
     // Build up search paths;
     std::vector<std::string> search_paths = get_search_paths();
     return open_shared_library(lib, search_paths, resultpath,
       "PluginInterface::load_plugin", global);
  
 #endif // WITH_DL
   }

◆ load_plugin()

PluginInterface< ImporterInternal >::Plugin casadi::PluginInterface< ImporterInternal >::load_plugin	(	const std::string &	pname,
		bool	register_plugin = `true`,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 88 of file plugin_interface.hpp.

                                                {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Issue warning and quick return if already loaded
     if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
       casadi_warning("PluginInterface: Solver " + pname + " is already in use. Ignored.");
       return Plugin();
     }
  
     // Logger singletons are lazily instantiated on first uout()/uerr() calls
     // This instantation may lead to a data race with potential instatiations in plugin
     // To be safe, trigger instantatin before any plugin loading
     uout();
     uerr();
  
 #ifndef WITH_DL
     casadi_error("WITH_DL option needed for dynamic loading");
 #else // WITH_DL
     // Retrieve the registration function
     RegFcn reg;
  
     // Load the dll
     std::string regName = "casadi_register_" + Derived::infix_ + "_" + pname;
  
     std::string searchpath;
     handle_t handle = load_library("casadi_" + Derived::infix_ + "_" + pname, searchpath,
       false);
  
 #ifdef _WIN32
  
 #if __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
 #endif
     reg = reinterpret_cast<RegFcn>(GetProcAddress(handle, TEXT(regName.c_str())));
 #if __GNUC__
 #pragma GCC diagnostic pop
 #endif
  
 #else // _WIN32
     // Reset error
     dlerror();
  
     // Load creator
     reg = reinterpret_cast<RegFcn>(dlsym(handle, regName.c_str()));
 #endif // _WIN32
     casadi_assert(reg!=nullptr,
       "PluginInterface::load_plugin: no \"" + regName + "\" found in " + searchpath + ".");
  
     // Create a temporary struct
     Plugin plugin = pluginFromRegFcn(reg);
     // Register the plugin
     if (register_plugin) {
       registerPlugin(plugin, false);
     }
  
     return plugin;
  
 #endif // WITH_DL
   }

◆ plugin_deserialize()

Deserialize casadi::PluginInterface< ImporterInternal >::plugin_deserialize ( const std::string & pname )

staticinherited

Definition at line 82 of file plugin_interface.hpp.

                                                                                  {
     Deserialize m = getPlugin(pname).deserialize;
     casadi_assert(m, "Plugin \"" + pname + "\" does not support deserialize");
     return m;
   }

◆ plugin_name()

const char* casadi::ShellCompiler::plugin_name ( ) const

inlineoverridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 80 of file shell_compiler.hpp.

80 { return "shell";}

◆ plugin_options()

const Options & casadi::PluginInterface< ImporterInternal >::plugin_options ( const std::string & pname )

staticinherited

Definition at line 79 of file plugin_interface.hpp.

                                                                                 {
     const Options *op = getPlugin(pname).options;
     casadi_assert(op!=nullptr, "Plugin \"" + pname + "\" does not support options");
     return *op;
   }

◆ pluginFromRegFcn()

PluginInterface< ImporterInternal >::Plugin casadi::PluginInterface< ImporterInternal >::pluginFromRegFcn ( RegFcn regfcn )

staticinherited

Definition at line 85 of file plugin_interface.hpp.

                                                               {
     // Create a temporary struct
     Plugin plugin;
  
     // Set the fields
     int flag = regfcn(&plugin);
     casadi_assert(flag==0, "Registration of plugin failed.");
  
     return plugin;
   }

◆ read_external()

void casadi::ImporterInternal::read_external	(	const std::string &	sym,
		bool	inlined,
		std::istream &	file,
		casadi_int &	offset
	)

inherited

Definition at line 179 of file importer_internal.cpp.

                                                                                           {
     // New entry
     std::stringstream ss;
  
     // Are we still in the function declaration
     bool in_declaration = true;
  
     // Loop over the lines
     std::string line;
     while (getline(file, line)) {
       offset++;
  
       // Skip line if still in declaration
       if (in_declaration) {
         size_t stop = line.find('{');
         if (stop != std::string::npos) in_declaration = false;
         continue;
       }
  
       // End of declaration found?
       if (line.find("/*CASADIEXTERNAL") != std::string::npos) {
         auto new_el = external_.insert(std::make_pair(sym, std::make_pair(inlined, ss.str())));
         casadi_assert(new_el.second, "Duplicate symbol: \"" + sym + "\"");
         return;
       }
  
       // Add to entry
       if (inlined) {
         ss << line << std::endl;
       }
     }
     casadi_error("End-of-file reached while searching for \"/*CASADIEXTERNAL\"");
   }

References casadi::ImporterInternal::external_, and casadi::ImporterInternal::inlined().

Referenced by casadi::ImporterInternal::init().

◆ read_meta()

void casadi::ImporterInternal::read_meta	(	std::istream &	file,
		casadi_int &	offset
	)

inherited

Definition at line 132 of file importer_internal.cpp.

                                                                        {
     // Loop over the lines
     std::string line;
     while (getline(file, line)) {
       offset++;
  
       // End of meta found?
       if (line.find("*/") != std::string::npos) return;
  
       // If comment or empty line, skip
       if (line.empty() || line.at(0)=='#') continue;
  
       // Get command string
       casadi_assert(line.at(0)==':',
                             "Syntax error: " + line + " is not a command string");
       std::string cmd = line.substr(1, line.find(' ')-1);
  
       // New entry
       std::stringstream ss;
  
       // Collect the meta data
       line = line.substr(cmd.size()+2);
       while (true) {
         // Find the backslash, if any
         size_t stop = line.find('\\');
  
         // Add to entry
         ss << line.substr(0, stop);
  
         // Break if not multiline
         if (stop == std::string::npos) break;
  
         // Read another line
         ss << std::endl;
         if (!getline(file, line)) {
           casadi_error("Failed to read \"" + cmd + "\"");
         }
         offset++;
       }
  
       // Insert new element in map
       auto new_el = meta_.insert(std::make_pair(cmd, std::make_pair(offset, ss.str())));
       casadi_assert(new_el.second, "Duplicate entry: \"" + cmd + "\"");
     }
     casadi_error("End-of-file reached while searching for \"*/\"");
   }

References casadi::ImporterInternal::meta_.

Referenced by casadi::ImporterInternal::init().

◆ registerPlugin() [1/2]

void casadi::PluginInterface< ImporterInternal >::registerPlugin	(	const Plugin &	plugin,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 96 of file plugin_interface.hpp.

                                                                                      {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Check if the solver name is in use
     typename std::map<std::string, Plugin>::iterator it=Derived::solvers_.find(plugin.name);
     casadi_assert(it==Derived::solvers_.end(),
       "Solver " + str(plugin.name) + " is already in use");
  
     // Add to list of solvers
     Derived::solvers_[plugin.name] = plugin;
   }

◆ registerPlugin() [2/2]

void casadi::PluginInterface< ImporterInternal >::registerPlugin	(	RegFcn	regfcn,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 99 of file plugin_interface.hpp.

                                                                               {
     registerPlugin(pluginFromRegFcn(regfcn), needs_lock);
   }

◆ serialize()

void casadi::ImporterInternal::serialize ( SerializingStream & s ) const

inherited

Definition at line 309 of file importer_internal.cpp.

                                                              {
     serialize_type(s);
     serialize_body(s);
   }

References casadi::ImporterInternal::serialize_body(), and casadi::ImporterInternal::serialize_type().

◆ serialize_body()

void casadi::ImporterInternal::serialize_body ( SerializingStream & s ) const

virtualinherited

Definition at line 318 of file importer_internal.cpp.

                                                                   {
     s.version("ImporterInternal", 1);
     s.pack("ImporterInternal::name", name_);
     s.pack("ImporterInternal::meta", meta_);
     s.pack("ImporterInternal::external", external_);
   }

References casadi::ImporterInternal::external_, casadi::ImporterInternal::meta_, casadi::ImporterInternal::name_, casadi::SerializingStream::pack(), and casadi::SerializingStream::version().

Referenced by casadi::ImporterInternal::serialize().

◆ serialize_type()

void casadi::ImporterInternal::serialize_type ( SerializingStream & s ) const

virtualinherited

Definition at line 314 of file importer_internal.cpp.

                                                                   {
     s.pack("ImporterInternal::type", class_name());
   }

References casadi::ImporterInternal::class_name(), and casadi::SerializingStream::pack().

Referenced by casadi::ImporterInternal::serialize().

◆ shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
       B ret;
       ret.own(static_cast<Internal*>(this));
       return ret;
     }

◆ shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                      {
       casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
       B ret;
       ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
       return ret;
     }

◆ shortname()

static std::string casadi::ImporterInternal::shortname ( )

inlinestaticinherited

Definition at line 104 of file importer_internal.hpp.

104 { return "importer";}

◆ to_text()

std::string casadi::ImporterInternal::to_text	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21g

◆ weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1ai

Definition at line 67 of file generic_shared_internal.hpp.

                                                                                   {
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
   }

Member Data Documentation

◆ base_name_

std::string casadi::ShellCompiler::base_name_

protected

Definition at line 92 of file shell_compiler.hpp.

Referenced by init(), and ~ShellCompiler().

◆ bin_name_

std::string casadi::ShellCompiler::bin_name_

protected

Definition at line 95 of file shell_compiler.hpp.

Referenced by init(), library(), and ~ShellCompiler().

◆ cleanup_

bool casadi::ShellCompiler::cleanup_

protected

Definition at line 104 of file shell_compiler.hpp.

Referenced by init(), and ~ShellCompiler().

◆ external_

std::map<std::string, std::pair<bool, std::string> > casadi::ImporterInternal::external_

inherited

Definition at line 163 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::body(), casadi::ImporterInternal::has_function(), casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::inlined(), casadi::ImporterInternal::read_external(), and casadi::ImporterInternal::serialize_body().

◆ extra_suffixes_

std::vector<std::string> casadi::ShellCompiler::extra_suffixes_

protected

Definition at line 101 of file shell_compiler.hpp.

Referenced by init(), and ~ShellCompiler().

◆ handle_

handle_t casadi::ShellCompiler::handle_

protected

Definition at line 107 of file shell_compiler.hpp.

Referenced by get_function(), init(), ShellCompiler(), and ~ShellCompiler().

◆ infix_

const std::string casadi::ImporterInternal::infix_ = "importer"

staticinherited

Definition at line 101 of file importer_internal.hpp.

◆ meta_

std::map<std::string, std::pair<casadi_int, std::string> > casadi::ImporterInternal::meta_

inherited

Definition at line 160 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::get_meta(), casadi::ImporterInternal::has_meta(), casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::read_meta(), and casadi::ImporterInternal::serialize_body().

◆ meta_doc

const std::string casadi::ShellCompiler::meta_doc

static

Definition at line 77 of file shell_compiler.hpp.

Referenced by casadi::casadi_register_importer_shell().

◆ name_

std::string casadi::ImporterInternal::name_

inherited

Definition at line 157 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::init(), casadi::ClangCompiler::init(), init(), casadi::DllLibrary::init_handle(), casadi::DllLibrary::library(), and casadi::ImporterInternal::serialize_body().

◆ obj_name_

std::string casadi::ShellCompiler::obj_name_

protected

Definition at line 98 of file shell_compiler.hpp.

Referenced by init(), and ~ShellCompiler().

◆ options_

const Options casadi::ShellCompiler::options_

static

Definition at line 69 of file shell_compiler.hpp.

Referenced by casadi::casadi_register_importer_shell().

◆ solvers_

std::map< std::string, ImporterInternal::Plugin > casadi::ImporterInternal::solvers_

staticinherited

Definition at line 94 of file importer_internal.hpp.

◆ verbose_

bool casadi::ImporterInternal::verbose_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21h

Definition at line 168 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::init(), and init().

The documentation for this class was generated from the following files:

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ Creator

◆ RegFcn

◆ weak_ref_type

Constructor & Destructor Documentation

◆ ShellCompiler()

◆ ~ShellCompiler()

Member Function Documentation

◆ body()

◆ can_have_meta()

◆ class_name()

◆ construct()

◆ creator()

◆ debug_repr()

◆ deserialize()

◆ destroySingleton()

◆ disp()

◆ finalize()

◆ get_function()

◆ get_meta()

◆ get_options()

◆ getCount()

◆ getPlugin()

◆ has_function()

◆ has_meta()

◆ has_plugin()

◆ indexed()

◆ init()

◆ initSingleton()

◆ inlined()

◆ instantiate()

◆ library()

◆ load_library()

◆ load_plugin()

◆ plugin_deserialize()

◆ plugin_name()

◆ plugin_options()

◆ pluginFromRegFcn()

◆ read_external()

◆ read_meta()

◆ registerPlugin() [1/2]

◆ registerPlugin() [2/2]

◆ serialize()

◆ serialize_body()

◆ serialize_type()

◆ shared_from_this() [1/2]

◆ shared_from_this() [2/2]

◆ shortname()

◆ to_text()

◆ weak()

Member Data Documentation

◆ base_name_

◆ bin_name_

◆ cleanup_

◆ external_

◆ extra_suffixes_

◆ handle_

◆ infix_

◆ meta_

◆ meta_doc

◆ name_

◆ obj_name_

◆ options_

◆ solvers_

◆ verbose_