code_generator.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
 *                            KU Leuven. All rights reserved.
 *    Copyright (C) 2011-2014 Greg Horn
 *
 *    CasADi is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    CasADi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef CASADI_CODE_GENERATOR_HPP
#define CASADI_CODE_GENERATOR_HPP
 
#include "function.hpp"
 
#include <map>
#include <set>
#include <sstream>
#include <type_traits>
 
namespace casadi {
 
  class CASADI_EXPORT CodeGenerator {
  public:
    CodeGenerator(const std::string& name, const Dict& opts = Dict());
 
    void add(const Function& f, bool with_jac_sparsity=false);
 
#ifndef SWIG
    void dump(std::ostream& s);
#endif // SWIG
 
    std::string dump();
 
    std::string generate(const std::string& prefix="");
 
    void add_include(const std::string& new_include, bool relative_path=false,
                    const std::string& use_ifdef=std::string());
 
#ifndef SWIG
    std::string add_dependency(const Function& f);
 
    void add_external(const std::string& new_external, const std::string& name="");
 
    std::string shorthand(const std::string& name) const;
 
    std::string shorthand(const std::string& name, bool allow_adding=true);
 
    /* Add a sparsity pattern
    *
    * \param canonical If true, request canonical form,
    * as opposed to potential dense abbreviation
    */
    std::string sparsity(const Sparsity& sp, bool canonical=true);
 
    /* Add a sparsity pattern, get index
    *
    * \param canonical If true, request canonical form,
    * as opposed to potential dense abbreviation
    */
    casadi_int add_sparsity(const Sparsity& sp, bool canonical=true);
 
    casadi_int get_sparsity(const Sparsity& sp) const;
 
    casadi_int get_constant(const std::vector<double>& v, bool allow_adding=false);
 
    casadi_int get_constant(const std::vector<casadi_int>& v, bool allow_adding=false);
 
    casadi_int get_constant(const std::vector<char>& v, bool allow_adding=false);
 
    casadi_int get_constant(const std::vector<std::string>& v, bool allow_adding=false);
 
    std::string constant(const std::vector<casadi_int>& v);
 
    std::string constant(const std::vector<int>& v) {
        return constant(vector_static_cast<casadi_int>(v));
    }
 
    void constant_copy(
        const std::string& var_name,
        const std::vector<casadi_int>& v,
        const std::string& type="casadi_int");
 
    std::string constant(const std::vector<double>& v);
 
    std::string constant(const std::vector<char>& v);
 
    std::string constant(const std::vector<std::string>& v);
 
    void define_rom_double(const void* id, casadi_int size);
 
    std::string rom_double(const void* id) const;
 
    void define_rom_integer(const void* id, casadi_int size);
 
    std::string rom_integer(const void* id) const;
 
    void define_pool_double(const std::string& name, const std::vector<double>& def);
 
    std::string pool_double(const std::string& name) const;
 
    void define_local_mutex(const Function& f, const std::string& name);
 
    std::string local_mutex(const Function& f, const std::string& name) const;
 
    const std::set<std::string>& local_mutexes(const Function& f) const;
 
    void setup_callback(const std::string& s, const Function& f);
 
    std::string operator()(const Function& f, const std::string& arg,
                           const std::string& res, const std::string& iw,
                           const std::string& w, const std::string& failure_ret="1");
 
    CodeGenerator& operator<<(const std::string& s);
 
    void print_formatted(const std::string& s);
 
    template<typename T>
    CodeGenerator& operator<<(T s) {
      std::stringstream ss;
      ss << s;
      return (*this) << ss.str();
    }
 
    void flush(std::ostream &s);
 
    void local(const std::string& name, const std::string& type, const std::string& ref="");
 
    void scope_enter();
 
    void scope_exit();
 
    void scope_return(const std::string& value);
 
    void scope_return();
 
    void scope_add_cleanup(const std::string& code);
 
    std::string sx_work(casadi_int i);
 
    void init_local(const std::string& name, const std::string& def);
 
    void indent() {current_indent_++;}
 
    void unindent() {current_indent_--;}
 
    bool avoid_stack() const { return avoid_stack_;}
 
    bool thread_safe() const { return thread_safe_; }
 
    std::string constant(double v);
    std::string constant(casadi_int v);
    std::string constant(const std::string& v);
    std::string constant(char v);
 
    std::string format_padded(casadi_int i) const;
 
    std::string zeros(casadi_int sz);
    std::string ones(casadi_int sz);
 
    template <typename T>
    std::string initializer(const std::vector<T>& v) {
        std::stringstream s;
        if (v.size() > max_initializer_elements_per_line) {
            s << "\n  ";
        }
 
        s << "{";
        // Shortcut only for arithmetic T; for std::string, `T(0)` would
        // invoke std::string(const char*) with a null pointer.
        bool all_zeros = std::is_arithmetic<T>::value && v.size() > 0;
        if (all_zeros) {
            for (const auto& el : v) {
                if (el != T()) {
                    all_zeros = false;
                    break;
                }
            }
        }
        if (all_zeros) {
            s << constant(T()); // empty_initialization shorthand
        } else {
            for (casadi_int i = 0; i < v.size(); ++i) {
                if (i != 0) {
                    if (max_initializer_elements_per_line > 1 &&
                        i % max_initializer_elements_per_line == 0) {
                        s << ",\n  ";
                    } else {
                        s << ", ";
                    }
                }
                s << constant(v[i]);
            }
        }
        s << "}";
        return s.str();
    }
 
    std::string sanitize_source(const std::string& src,
                                const std::vector<std::string>& inst,
                                bool add_shorthand=true);
 
    void add_runtime(const std::string& key, const std::string& src,
                     const std::vector<std::string>& inst);
 
    std::string dot(casadi_int n, const std::string& x, const std::string& y);
 
    std::string mv(const std::string& x, const Sparsity& sp_x,
                   const std::string& y, const std::string& z, bool tr);
 
    std::string mv(const std::string& x, casadi_int nrow_x, casadi_int ncol_x,
                   const std::string& y, const std::string& z, bool tr);
 
    std::string axpy(casadi_int n, const std::string& a,
                     const std::string& x, const std::string& y);
 
    std::string clip_min(const std::string& x, casadi_int n,
                                  const std::string& min, const std::string& mask);
 
    std::string clip_max(const std::string& x, casadi_int n,
                                    const std::string& min, const std::string& mask);
 
    std::string vector_fmax(casadi_int n, const std::string& x,
                                    const std::string& y, const std::string& z);
 
    std::string vector_fmin(casadi_int n, const std::string& x,
                                    const std::string& y, const std::string& z);
 
    std::string masked_norm_inf(casadi_int n, const std::string& x,
                                    const std::string& mask);
 
 
    std::string scal(casadi_int n, const std::string& alpha, const std::string& x);
 
    std::string mtimes(const std::string& x, const Sparsity& sp_x,
                       const std::string& y, const Sparsity& sp_y,
                       const std::string& z, const Sparsity& sp_z,
                       const std::string& w, bool tr);
 
    std::string mtimes(const std::string& x, casadi_int nrow_x, casadi_int ncol_x,
                       const std::string& y, casadi_int ncol_y,
                       const std::string& z, bool tr);
 
    std::string mtimes_dense_sparse(const std::string& x, casadi_int nrow_x,
                                    const std::string& y, const Sparsity& sp_y,
                                    const std::string& z);
 
    std::string trilsolve(const Sparsity& sp_x, const std::string& x, const std::string& y,
                          bool tr, bool unity, casadi_int nrhs);
 
    std::string triusolve(const Sparsity& sp_x, const std::string& x, const std::string& y,
                          bool tr, bool unity, casadi_int nrhs);
 
    std::string bilin(const std::string& A, const Sparsity& sp_A,
                      const std::string& x, const std::string& y);
 
    std::string rank1(const std::string& A, const Sparsity& sp_A, const std::string& alpha,
                      const std::string& x, const std::string& y);
 
    std::string logsumexp(const std::string& A, casadi_int n);
 
    std::string interpn(const std::string& res, casadi_int ndim, const std::string& grid,
                        const std::string& offset,
                        const std::string& values, const std::string& x,
                        const std::string& lookup_mode, casadi_int m,
                        const std::string& iw, const std::string& w);
 
    std::string interpn_grad(const std::string& grad,
      casadi_int ndim, const std::string& grid,
      const std::string& offset,
      const std::string& values, const std::string& x,
      const std::string& lookup_mode, casadi_int m,
      const std::string& iw, const std::string& w);
 
    std::string trans(const std::string& x, const Sparsity& sp_x,
      const std::string& y, const Sparsity& sp_y, const std::string& iw);
 
    std::string qr(const std::string& sp, const std::string& A,
                   const std::string& w, const std::string& sp_v,
                   const std::string& v, const std::string& sp_r,
                   const std::string& r, const std::string& beta,
                   const std::string& prinv, const std::string& pc);
 
    std::string det(const std::string& sp_v, const std::string& v,
                    const std::string& sp_r, const std::string& r, const std::string& beta);
 
    std::string qr_solve(const std::string& x, casadi_int nrhs, bool tr,
                         const std::string& sp_v, const std::string& v,
                         const std::string& sp_r, const std::string& r,
                         const std::string& beta, const std::string& prinv,
                         const std::string& pc, const std::string& w);
 
    std::string lsqr_solve(const std::string& A, const std::string&x,
                          casadi_int nrhs, bool tr, const std::string& sp, const std::string& w);
 
    std::string ldl(const std::string& sp_a, const std::string& a,
                   const std::string& sp_lt, const std::string& lt,
                   const std::string& d, const std::string& p,
                   const std::string& w);
 
    std::string ldl_solve(const std::string& x, casadi_int nrhs,
                         const std::string& sp_lt, const std::string& lt,
                         const std::string& d, const std::string& p,
                         const std::string& w);
 
    std::string fmax(const std::string& x, const std::string& y);
 
    std::string fmin(const std::string& x, const std::string& y);
 
    std::string mmax(const std::string& x, casadi_int n, bool is_dense);
 
    std::string mmin(const std::string& x, casadi_int n, bool is_dense);
 
    std::string vfmax(const std::string& x, casadi_int n, const std::string& y);
 
    std::string vfmin(const std::string& x, casadi_int n, const std::string& y);
 
    std::string vfmax(const std::string& x, const std::string& n, const std::string& y);
 
    std::string vfmin(const std::string& x, const std::string& n, const std::string& y);
 
    std::string max(const std::string& x, const std::string& y);
 
    std::string min(const std::string& x, const std::string& y);
 
    std::string norm_inf(casadi_int n, const std::string& x);
 
    std::string norm_1(casadi_int n, const std::string& x);
 
    std::string norm_2(casadi_int n, const std::string& x);
 
    std::string max_viol(casadi_int n, const std::string& x,
      const std::string& lb, const std::string& ub);
 
    std::string sum_viol(casadi_int n, const std::string& x,
      const std::string& lb, const std::string& ub);
 
    std::string bound_consistency(casadi_int n, const std::string& x,
      const std::string& lam, const std::string& lbx, const std::string& ubx);
 
    std::string lb_eig(const Sparsity& sp_h, const std::string& h);
 
    std::string regularize(const Sparsity& sp_h, const std::string& h, const std::string& reg);
 
    std::string convexify_eval(const ConvexifyData& d,
      const std::string& Hin, const std::string& Hout, const std::string& iw, const std::string& w);
 
    std::string low(const std::string& x, const std::string& grid,
      casadi_int ng, casadi_int lookup_mode);
 
    std::string declare(std::string s);
 
    void comment(const std::string& s);
 
    enum Auxiliary {
      AUX_COPY,
      AUX_CVX,
      AUX_CONVEXIFY,
      AUX_SWAP,
      AUX_SCAL,
      AUX_AXPY,
      AUX_DOT,
      AUX_BILIN,
      AUX_KRON,
      AUX_KRON_DENSE,
      AUX_KRON_DENSE_SPARSE,
      AUX_KRON_SPARSE_DENSE,
      AUX_KRON_CONTRACT_INNER,
      AUX_KRON_CONTRACT_INNER_DENSE,
      AUX_KRON_CONTRACT_INNER_DENSE_SPARSE,
      AUX_KRON_CONTRACT_INNER_SPARSE_DENSE,
      AUX_KRON_CONTRACT_OUTER,
      AUX_KRON_CONTRACT_OUTER_DENSE,
      AUX_KRON_CONTRACT_OUTER_DENSE_SPARSE,
      AUX_KRON_CONTRACT_OUTER_SPARSE_DENSE,
      AUX_RANK1,
      AUX_NORM_1,
      AUX_NORM_2,
      AUX_CLIP_MAX,
      AUX_CLIP_MIN,
      AUX_VECTOR_FMAX,
      AUX_VECTOR_FMIN,
      AUX_NORM_INF,
      AUX_MASKED_NORM_INF,
      AUX_IAMAX,
      AUX_CLEAR,
      AUX_FILL,
      AUX_MV,
      AUX_MV_DENSE,
      AUX_MTIMES,
      AUX_MTIMES_DENSE,
      AUX_MTIMES_DENSE_SPARSE,
      AUX_TRILSOLVE,
      AUX_TRIUSOLVE,
      AUX_PROJECT,
      AUX_TRI_PROJECT,
      AUX_DENSIFY,
      AUX_SPARSIFY,
      AUX_TRANS,
      AUX_TO_MEX,
      AUX_FROM_MEX,
      AUX_INTERPN,
      AUX_INTERPN_GRAD,
      AUX_FLIP,
      AUX_INTERPN_WEIGHTS,
      AUX_LOW,
      AUX_INTERPN_INTERPOLATE,
      AUX_DE_BOOR,
      AUX_TENSOR_TTV,
      AUX_ND_BOOR_EVAL,
      AUX_FINITE_DIFF,
      AUX_QR,
      AUX_DET,
      AUX_QP,
      AUX_QRQP,
      AUX_SOCP,
      AUX_NLP,
      AUX_SQPMETHOD,
      AUX_FEASIBLESQPMETHOD,
      AUX_LDL,
      AUX_NEWTON,
      AUX_IVP,
      AUX_IVP_ADAPT,
      AUX_IVP_EVENT,
      AUX_ROSENBROCK,
      AUX_ERK,
      AUX_TO_DOUBLE,
      AUX_TO_INT,
      AUX_CAST,
      AUX_SQ,
      AUX_SIGN,
      AUX_IF_ELSE,
      AUX_PRINTF,
      AUX_FMIN,
      AUX_FMAX,
      AUX_FABS,
      AUX_MIN,
      AUX_MAX,
      AUX_VFMIN,
      AUX_VFMAX,
      AUX_MAX_VIOL,
      AUX_SUM_VIOL,
      AUX_SUM,
      AUX_REGULARIZE,
      AUX_INF,
      AUX_NAN,
      AUX_REAL_MIN,
      AUX_ISINF,
      AUX_ISFINITE,
      AUX_BOUNDS_CONSISTENCY,
      AUX_LSQR,
      AUX_FILE_SLURP,
      AUX_CACHE,
      AUX_LOG1P,
      AUX_EXPM1,
      AUX_HYPOT,
      AUX_MMIN,
      AUX_MMAX,
      AUX_LOGSUMEXP,
      AUX_SPARSITY,
      AUX_BFGS,
      AUX_ORACLE_CALLBACK,
      AUX_OCP_BLOCK,
      AUX_ORACLE,
      AUX_SCALED_COPY,
      AUX_BLAZING_COMMON,
      AUX_BLAZING_1D_BOOR_EVAL,
      AUX_BLAZING_2D_BOOR_EVAL,
      AUX_BLAZING_3D_BOOR_EVAL,
      AUX_BLAZING_4D_BOOR_EVAL,
      AUX_BLAZING_5D_BOOR_EVAL,
      AUX_PRINTME,
      AUX_PRINT_SCALAR,
      AUX_PRINT_VECTOR,
      AUX_PRINT_CANONICAL,
      AUX_FPRINTF_SCALAR,
      AUX_FPRINTF_VECTOR,
      AUX_TO_FILE,
      AUX_THREADS
    };
 
    void add_auxiliary(Auxiliary f, const std::vector<std::string>& inst = {"casadi_real"});
 
    void add_io_sparsities(const std::string& name,
                           const std::vector<Sparsity>& sp_in,
                           const std::vector<Sparsity>& sp_out);
 
    std::string work(casadi_int n, casadi_int sz, bool is_ref) const;
 
    std::string workel(casadi_int n) const;
 
    void reserve_work(casadi_int n);
 
    void set_codegen_sz_w(const FunctionInternal* f, size_t sz_w);
 
    bool get_codegen_sz_w(const FunctionInternal* f, size_t& sz_w) const;
 
    static std::string array(const std::string& type, const std::string& name, casadi_int len,
                             const std::string& def=std::string());
 
    void print_vector(std::ostream &s, const std::string& name,
                             const std::vector<casadi_int>& v);
 
    void print_vector(std::ostream &s, const std::string& name,
                             const std::vector<char>& v);
 
    void print_vector(std::ostream &s, const std::string& name,
                             const std::vector<double>& v);
 
    void print_vector(std::ostream &s, const std::string& name,
                             const std::vector<std::string>& v);
 
    std::string print_canonical(const Sparsity& sp, const std::string& arg);
 
    std::string print_vector(casadi_int sz, const std::string& arg);
 
    std::string print_scalar(const std::string& arg);
 
    std::string fprintf_scalar(const std::string& f, const std::string& arg);
 
    std::string fprintf_vector(const std::string& f, casadi_int sz,
      const std::string& arg, const std::string& sep);
 
    std::string copy(const std::string& arg, std::size_t n, const std::string& res);
    void copy_check(const std::string& arg, std::size_t n, const std::string& res,
      bool check_lhs=true, bool check_rhs=true);
    void copy_default(const std::string& arg, std::size_t n, const std::string& res,
      const std::string& def,  bool check_rhs=true);
 
    // Should we elide a copy?
    bool elide_copy(casadi_int sz);
 
    std::string fill(const std::string& res, std::size_t n, const std::string& v);
 
    std::string clear(const std::string& res, std::size_t n);
 
    std::string arg(casadi_int i) const;
 
    std::string res(casadi_int i) const;
 
    std::string mem(const Function& f);
 
    std::string project(const std::string& arg, const Sparsity& sp_arg,
                        const std::string& res, const Sparsity& sp_res,
                        const std::string& w);
 
    std::string tri_project(const std::string& arg, const Sparsity& sp_arg,
                        const std::string& res, bool lower);
 
    std::string densify(const std::string& arg, const Sparsity& sp_arg,
                        const std::string& res, bool tr=false);
 
    std::string sparsify(const std::string& arg, const std::string& res,
                         const Sparsity& sp_res, bool tr=false);
 
    std::string to_mex(const Sparsity& sp, const std::string& arg);
 
    std::string from_mex(std::string& arg,
                         const std::string& res, std::size_t res_off, const Sparsity& sp_res,
                         const std::string& w);
 
    static std::string fmu_helpers(const std::string& modelname);
 
    std::string printf(const std::string& str,
                       const std::vector<std::string>& arg=std::vector<std::string>());
    std::string printf(const std::string& str, const std::string& arg1);
    std::string printf(const std::string& str, const std::string& arg1, const std::string& arg2);
    std::string printf(const std::string& str, const std::string& arg1, const std::string& arg2,
                       const std::string& arg3);
 
    std::string print_op(casadi_int op, const std::string& a0);
    std::string print_op(casadi_int op, const std::string& a0, const std::string& a1);
 
    std::string file_slurp(const std::string& fname, casadi_int n, const std::string& a);
 
    std::string to_file(const std::string& f, const Sparsity& sp, const std::string& x);
 
    void generate_dump(const Function& f, const std::string& arr, bool is_input);
 
    void generate_print(const Function& f, const std::string& arr, bool is_input);
 
    std::string cache_check(const std::string& key, const std::string& cache,
        const std::string& loc, casadi_int stride, casadi_int sz, casadi_int key_sz,
        const std::string& val);
 
    static std::string casadi_version();
 
    static void stream_open(std::ostream& f, bool cpp);
 
    static void stream_close(std::ostream& f, bool cpp);
 
    void sz_work(size_t& sz_arg, size_t& sz_res, size_t& sz_iw, size_t& sz_w) const;
 
  private:
 
    // Generate casadi_real definition
    void generate_casadi_real(std::ostream &s) const;
 
    // Generate casadi_int definition
    void generate_casadi_int(std::ostream &s) const;
 
    // Generate mex entry point
    void generate_mex(std::ostream &s) const;
 
    // Generate function specific code for Simulink s-Function
    std::string codegen_sfunction(const Function& f) const;
 
    // Export s-Function to file
    void generate_sfunction(const std::string& name, const std::string& sfunction) const;
 
    // Generate main entry point
    void generate_main(std::ostream &s) const;
 
    // Generate export symbol macros
    void generate_export_symbol(std::ostream &s) const;
 
    // Generate import symbol macros
    void generate_import_symbol(std::ostream &s) const;
 
    //  private:
  public:
 
    // Name of generated file
    std::string name, suffix;
 
    // Real-type used for the codegen
    std::string casadi_real_type;
 
    // Int-type used for the codegen
    std::string casadi_int_type;
 
    // Should we create a memory entry point?
    bool with_mem;
 
    // Generate header file?
    bool with_header;
 
    // Are we creating a MEX file?
    bool mex;
 
    // Are we creating a s-function?
    bool with_sfunction;
    std::vector<std::string> added_sfunctions;
 
    // Unroll arguments?
    bool unroll_args;
 
    // Emit runtime auxiliary functions with 'static' storage class?
    bool static_aux;
 
    // Emit runtime auxiliary functions with 'inline' hint?
    bool inline_aux;
 
    // Verbose codegen?
    bool verbose;
 
    // Verbose runtime?
    bool verbose_runtime;
 
    // Are we generating C++?
    bool cpp;
 
    // Should we generate a main (allowing evaluation from command line)
    bool main;
 
    // Should we include mayth library?
    bool include_math;
 
    // Do we want to be lean on stack usage?
    bool avoid_stack_;
 
    std::string infinity, nan, real_min;
 
    bool codegen_scalars;
 
    // Have a flag for exporting/importing symbols
    bool with_export, with_import;
 
    // Maximum number of declarations per line
    casadi_int max_declarations_per_line;
 
    // Maximum number of initializer elements per line
    casadi_int max_initializer_elements_per_line;
 
    // Force the external API to use canonical sparsity
    bool force_canonical;
 
    // Route L1 ops (axpy/dot/scal/norm_1/norm_2) through the active BLAS
    // plugin in generated code; off => built-in reference kernels.
    bool l1_blas;
 
    // Emit thread-safe checkout/release?
    bool thread_safe_;
 
    // Prefix symbols in DLLs?
    std::string dll_export, dll_import;
 
    // Prefix
    std::string prefix;
 
    // Prefix/suffix for dump directory in codegen
    std::string dump_dir_prefix;
    std::string dump_dir_suffix;
 
    // std::stringstreams holding the different parts of the file being generated
    std::stringstream includes;
    std::stringstream auxiliaries;
    std::stringstream body;
    std::stringstream header;
    std::stringstream buffer;
 
    // Are we at a new line?
    bool newline_;
 
    // Indentation
    casadi_int indent_;
    casadi_int current_indent_;
 
    // Number of zeros/ones
    casadi_int sz_zeros_;
    casadi_int sz_ones_;
 
    casadi_int padding_length_;
 
    // Names of exposed functions
    std::vector<std::string> exposed_fname;
 
    // Code generated sparsities
    std::set<std::string> sparsity_meta;
 
    // Set of already included header files
    std::set<std::string> added_includes_;
    std::set<std::string> added_externals_;
    std::set<std::string> external_names_;
    std::set<std::string> added_shorthands_;
    std::set<std::string> added_runtimes_;
    std::multimap<Auxiliary, std::vector<std::string>> added_auxiliaries_;
    std::multimap<size_t, size_t> added_double_constants_;
    std::multimap<size_t, size_t> added_integer_constants_;
    std::multimap<size_t, size_t> added_char_constants_;
    std::multimap<size_t, size_t> added_string_constants_;
    std::map<std::string, std::pair<std::string, std::string> > local_variables_;
    std::vector<std::string> local_cleanup_;
    bool local_void_;
    std::map<std::string, std::string> local_default_;
    std::map<const void *, casadi_int> file_scope_double_;
    std::map<const void *, casadi_int> file_scope_integer_;
    std::vector< std::vector<double> > pool_double_defaults_;
    std::map<std::string, casadi_int> pool_double_;
    std::map<const FunctionInternal*, std::set<std::string> > local_mutexes_;
 
    // Work vector sizes of generated function bodies, cf. set_codegen_sz_w
    std::map<const FunctionInternal*, size_t> codegen_sz_w_;
 
    // Added functions
    struct FunctionMeta {
      // The function object
      Function f;
      // Name in codegen
      std::string codegen_name;
    };
    std::vector<FunctionMeta> added_functions_;
 
    // Counters for creating unique identifiers
    std::map<std::string, std::map<FunctionInternal*, casadi_int> > added_wrappers_;
 
    // Constants
    std::vector<std::vector<double> > double_constants_;
    std::vector<std::vector<casadi_int> > integer_constants_;
    std::vector<std::vector<char> > char_constants_;
    std::vector<std::vector<std::string> > string_constants_;
 
    // Does any function need thread-local memory?
    bool needs_mem_;
 
    // Hash a vector
    static size_t hash(const std::vector<double>& v);
    static size_t hash(const std::vector<casadi_int>& v);
    static size_t hash(const std::vector<char>& v);
    static size_t hash(const std::vector<std::string>& v);
 
    std::string wrapper(const Function& base, const std::string& name);
 
    // Compare two vectors
    template<typename T>
    static bool equal(const std::vector<T>& v1, const std::vector<T>& v2) {
      if (v1.size()!=v2.size()) return false;
      for (casadi_int j=0; j<v1.size(); ++j) {
        if (v1[j]!=v2[j]) return false;
      }
      return true;
    }
#endif // SWIG
  };
 
 
} // namespace casadi
 
#endif // CASADI_CODE_GENERATOR_HPP