---

more/lang/compilation.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: compilation.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $

//  !! Experimental.  Interface may change !!

#ifndef MORE_LANG_COMPILATION_H
#define MORE_LANG_COMPILATION_H

#include <string>
#include <list>
#include <map>
#include <more/io/fwd.h>

namespace more {
namespace lang {

  /** An enum type to identify a programming language. */
  enum lang_t
  {
      // NB. Sync with lang_info in compilation.cc.

      lang_undefined,

      // These are supported by compilation.
      lang_c,           // C
      lang_cxx,         // C++

      // The following are not used here (at least yet).
      lang_scheme,      // Scheme
      lang_java,        // Java
      lang_shell,       // Bourne shell or bash
      lang_perl,        // Perl
      lang_f77,         // FORTRAN 77
      lang_f90,         // FORTRAN 90
      // ... extend if needed

      lang_end
  };

  std::string language_name(lang_t lang);

  std::string header_file_name(std::string const& bname, lang_t lang,
                               std::string const& dir = ".");
  std::string source_file_name(std::string const& bname, lang_t lang,
                               std::string const& dir = ".");
  std::string c_header_file_name(std::string const& bname,
                                 std::string const& dir = ".");
  std::string cxx_header_file_name(std::string const& bname,
                                   std::string const& dir = ".");
  std::string c_source_file_name(std::string const& bname,
                                 std::string const& dir = ".");
  std::string cxx_source_file_name(std::string const& bname,
                                   std::string const& dir = ".");
  std::string ltobject_file_name(std::string const& bname,
                                 std::string const& dir = ".");
  std::string program_file_name(std::string const& bname,
                                std::string const& dir = ".");
  std::string library_file_name(std::string const& bname,
                                std::string const& dir = ".");
  std::string dlopen_file_name(std::string const& bname,
                               std::string const& dir = ".");

  /** The state of a C/C++ compilation and linkage. */
  struct compilation
  {
      enum target_type
      {
          target_none, target_program,
          target_library, target_library_dlopen
      };
      typedef unsigned long version_type;

    private:
      struct source_entry
      {
          source_entry() {}
          source_entry(lang_t lang, double t, bool rebuild_p)
              : m_lang(lang), m_version(t), m_rebuild_p(rebuild_p) {}
          void sync(io::syncstream&);

          lang_t m_lang;
          double m_version;
          bool m_rebuild_p;
      };
      typedef std::map<std::string, source_entry> source_entry_container;
      typedef source_entry_container::iterator source_entry_iterator;
      typedef source_entry_container::const_iterator source_entry_const_iterator;

    public:
      compilation(std::string const& srcdir,
                  std::string const& builddir);

      compilation(std::string const& srcdir,
                  std::string const& builddir,
                  std::string const& includedir,
                  std::string const& libdir);

      // Directories
      std::string const& src_dir() const { return m_srcdir; }
      std::string const& build_dir() const { return m_builddir; }
      std::string const& include_dir() const { return m_includedir; }
      std::string const& lib_dir() const { return m_libdir; }

      // Insert Sources
//       std::string insert_cxx_header(std::string const& bname);
//       std::string insert_c_header(std::string const& bname);

      std::string insert_header(std::string const& bname, lang_t lang);

//       std::string insert_cxx_source(std::string const& bname);
//       std::string insert_c_source(std::string const& bname);

      /** Insert a C or C++ source file.  \a version is the time or
          version of the file.  The file will be compiled if the there
          is no file with this name already, and recompiled if the
          version is newer than that of the existing file.  Use \c
          version==0 to never rebuild.  Returns the full path to the
          file, or an empty string if the file shall not be
          (re)compiled. */
      std::string insert_source(std::string const& bname, lang_t lang,
                                version_type version);
      /** Insert a C or C++ source file.  Same as the overloaded
          function, except this will always assume the inserted file
          is new and rebuild. */
      std::string insert_source(std::string const& bname, lang_t lang);

      std::string insert_libadd(std::string const& bname);

      // Insert Flags
      void append_cppflags(std::string const& cppflags);
      void append_cflags(std::string const& cxxflags);
      void append_cxxflags(std::string const& cflags);
      void append_ldflags(std::string const& ldflags);

      // Set Target
      void set_target_program(std::string const& bname);
      void set_target_library(std::string const& bname, bool module_p);

      // Get Target Names
      std::string program_file_name() const { return m_target; }
      std::string library_file_name() const { return m_target; }

      // Take Action
      bool make_all();
      bool make_install();

      // Versioning
      void set_interface_added() { m_interface_added = 1; }
      void set_interface_changed() { m_interface_changed = 1; }

    private:
      bool check_cache();

      bool libtool(std::string const& cmd, char const* mode);
      bool libtool_compile(std::string const& cmd)
      {
          return libtool(cmd, "compile");
      }
      bool libtool_link(std::string const& cmd)
      {
          return libtool(cmd, "link");
      }

      void sync_state(io::syncstream&);

      typedef std::list<std::string> string_list;

      std::string m_srcdir;
      std::string m_builddir;
      std::string m_includedir;
      std::string m_libdir;

      // bnames of sources
//       string_list m_c_headers;
//       string_list m_cxx_headers;
      string_list m_headers;
      source_entry_container m_sources;
//       string_list m_c_sources;
//       string_list m_cxx_sources;

      std::string m_cppflags;
      std::string m_cflags;
      std::string m_cxxflags;
      std::string m_ldflags;

      target_type m_target_type;
      std::string m_target; // full names sans directory
      std::string m_target_bname;

      int m_so_version_scheme;
      static int const s_so_version_scheme_none = 0;    // don't use versions
      static int const s_so_version_scheme_libtool = 1; // libtool logic
      static int const s_so_version_scheme_max = 1;
      int m_so_version_current; // MSB
      int m_so_version_revision;
      int m_so_version_age;
      unsigned int m_interface_added : 1;
      unsigned int m_interface_changed : 1;
  };

}}

#endif

---