command_line_interface.h

Go to the documentation of this file.

// Author(s): Jeroen van der Wulp
// Copyright: see the accompanying file COPYING or copy at
// https://github.com/mCRL2org/mCRL2/blob/master/COPYING
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MCRL2_UTILITIES_COMMAND_LINE_INTERFACE_H
#define MCRL2_UTILITIES_COMMAND_LINE_INTERFACE_H
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <map>
#include <memory>
 
#include "mcrl2/utilities/exception.h"
#include "mcrl2/utilities/text_utility.h"
#include "mcrl2/utilities/toolset_version.h"
 
namespace mcrl2
{
namespace utilities
{
 
class interface_description;
class command_line_parser;
 
inline std::string copyright_period()
{
  // We assume that the version number always starts with a four digit year
  // in which the version was released.
  if (get_toolset_version().size() >= 4)
    return get_toolset_version().substr(0, 4);
  return "Today";
}
 
class interface_description
{
    friend class command_line_parser;
 
  public:
 
 
    class basic_argument
    {
 
      protected:
 
        std::string m_name;
 
        std::string m_type;
 
      protected:
 
        void set_name(std::string const& n)
        {
          m_name = n;
        }
 
        void set_type(std::string const& t)
        {
          m_type = t;
        }
 
      public:
 
        class argument_description
        {
        protected:
          std::string m_long;
          std::string m_short;
          std::string m_description;
 
        public:
          argument_description(const std::string& long_, const std::string& short_, const std::string& description)
            : m_long(long_), m_short(short_), m_description(description)
          {}
 
          argument_description(const std::string& long_, const std::string& description)
            : m_long(long_), m_description(description)
          {}
 
          const std::string& get_long() const
          {
            return m_long;
          }
 
          const std::string& get_short() const
          {
            return m_short;
          }
 
          const std::string& get_description() const
          {
            return m_description;
          }
        };
 
        virtual basic_argument* clone() const = 0;
 
        std::string get_name() const
        {
          return m_name;
        }
 
        std::string get_type() const
        {
          return m_type;
        }
 
        virtual bool has_description() const = 0;
 
        virtual std::vector< argument_description > const& get_description() const = 0;
 
        virtual std::string const& get_default() const = 0;
 
        virtual bool validate(std::string const&) const = 0;
 
        virtual bool is_optional() const = 0;
 
        virtual bool has_default() const = 0;
 
        virtual ~basic_argument()
        {
        }
    };
 
    template < typename T >
    class typed_argument;
 
    template < typename T = std::string >
    class optional_argument;
 
    template < typename T = std::string >
    class mandatory_argument;
 
    template < typename T = std::string >
    class enum_argument;
 
    class file_argument;
 
  private:
 
    class option_descriptor
    {
        friend class command_line_parser;
        friend class interface_description;
 
      private:
 
        std::string                         m_long;
 
        std::string                         m_description;
 
        std::shared_ptr< basic_argument > m_argument;
 
        char                                m_short;
 
        bool                                m_show;
 
      protected:
 
        std::string textual_description(const std::size_t left_width, const std::size_t right_width) const;
 
        std::string man_page_description() const;
 
        std::ostream& xml_page_description(std::ostream& s, const bool is_standard = false, unsigned int indentation = 0) const;
 
      public:
 
        option_descriptor(std::string const& l, std::string const& d, const char s) :
          m_long(l), m_description(d), m_short(s), m_show(true)
        {
 
          assert(!l.empty());
          assert(l.find_first_not_of("_-0123456789abcdefghijklmnopqrstuvwxyz") == std::string::npos);
        }
 
        option_descriptor(option_descriptor const& o) : m_long(o.m_long),
          m_description(o.m_description), m_argument(o.m_argument), m_short(o.m_short), m_show(true)
        {
        }
 
        option_descriptor operator=(option_descriptor const& o)
        {
          return option_descriptor(o);
        }
 
        basic_argument const& argument() const
        {
          return *m_argument;
        }
 
        template < typename T >
        void set_argument(T* a)
        {
          m_argument.reset(a);
        }
 
        inline const std::string& get_long() const
        {
          return m_long;
        }
 
        inline std::string const& get_default() const
        {
          return m_argument->get_default();
        }
 
        inline std::string get_description() const
        {
          return m_description;
        }
 
        inline bool needs_argument() const
        {
          return !(m_argument.get() == nullptr || m_argument->is_optional());
        }
 
        inline bool accepts_argument() const
        {
          return m_argument.get() != nullptr;
        }
    };
 
    struct option_identifier_less
    {
      bool operator()(char const& c1, char const& c2) const
      {
        char c1u = toupper(c1);
        char c2u = toupper(c2);
 
        return c1u < c2u || (c1u == c2u && c2 < c1);
      }
 
      template < typename S >
      bool operator()(S const& s1, S const& s2) const
      {
        std::string s1u = s1;
        std::string s2u = s2;
        std::transform(s1u.begin(), s1u.end(), s1u.begin(), ::toupper);
        std::transform(s2u.begin(), s2u.end(), s2u.begin(), ::toupper);
 
        return s1u < s2u || (s1u == s2u && s2 < s1);
      }
    };
 
    typedef std::map< std::string, option_descriptor > option_map;
 
    typedef std::map< const char,  std::string, option_identifier_less > short_to_long_map;
 
    option_map        m_options;
 
  private:
 
    std::string       m_path;
 
    std::string       m_name;
 
    std::string       m_authors;
 
    std::string       m_what_is;
 
    std::string       m_usage;
 
    std::string       m_description;
 
    std::string       m_known_issues;
 
 
 
    short_to_long_map m_short_to_long;
 
  private:
 
    char long_to_short(std::string const& n) const
    {
      char result = '\0';
 
      for (short_to_long_map::const_iterator i = m_short_to_long.begin(); result == '\0' && i != m_short_to_long.end(); ++i)
      {
        if (i->second == n)
        {
          result = i->first;
        }
      }
 
      return result;
    }
 
    option_descriptor const& find_option(std::string const& long_identifier) const;
 
    static interface_description& get_standard_description();
 
    template < typename T >
    inline static void register_initialiser()
    {
      T::add_options(get_standard_description());
    }
 
    inline interface_description()
    {
    }
 
  public:
 
    interface_description(std::string const& path, std::string const& name, std::string const& authors,
                          std::string const& what_is, std::string const& synopsis, std::string const& description,
                          std::string const& known_issues = "");
 
    static std::string copyright_message();
 
    std::string version_information() const;
 
    template < typename T >
    interface_description& add_option(std::string const& long_identifier,
                                      typed_argument< T > const& argument_specification,
                                      std::string const& description,
                                      char const short_identifier = '\0')
    {
 
      add_option(long_identifier, description, short_identifier);
 
      m_options.find(long_identifier)->second.set_argument(argument_specification.clone());
 
      return *this;
    }
 
    interface_description& add_option(std::string const& long_identifier,
                                      std::string const& description,
                                      char const short_identifier = '\0')
    {
 
      if (m_options.find(long_identifier) != m_options.end())
      {
        throw std::logic_error("Duplicate long option (--" + long_identifier + "); this is a serious program error!");
      }
 
      if (short_identifier != '\0')
      {
        if (m_short_to_long.find(short_identifier) != m_short_to_long.end())
        {
          throw std::logic_error("Duplicate short option (-" + std::string(1, short_identifier) + "); this is a serious program error!");
        }
 
        m_short_to_long[short_identifier] = long_identifier;
      }
 
      m_options.insert(std::make_pair(long_identifier, option_descriptor(long_identifier, description, short_identifier)));
 
      return *this;
    }
 
    template < typename T >
    void add_hidden_option(
      std::string const& long_identifier,
      typed_argument< T > const& argument_specification,
      std::string const& description,
      char const short_identifier = '\0')
    {
 
      add_option(long_identifier, argument_specification, description, short_identifier);
 
      m_options.find(long_identifier)->second.m_show = false;
    }
 
    void add_hidden_option(std::string const& long_identifier,
                           std::string const& description,
                           char const short_identifier = '\0')
    {
 
      add_option(long_identifier, description, short_identifier);
 
      m_options.find(long_identifier)->second.m_show = false;
    }
 
    std::string textual_description(bool show_hidden) const;
 
    std::string man_page() const;
 
    std::ostream& xml_page(std::ostream&) const;
 
    std::map<std::string, std::string>  get_long_argument_with_description();
 
    std::string get_toolname()
    {
      return m_name;
    }
};
 
class command_line_parser
{
  public:
 
    typedef std::multimap< std::string, std::string >  option_map;
 
    typedef std::vector< std::string >                 argument_list;
 
  private:
 
    option_map              m_options;
 
    argument_list           m_arguments;
 
    interface_description&  m_interface;
 
    bool                    m_continue;
 
  public:
 
    option_map const&       options;
 
    argument_list const&    arguments;
 
    bool has_option(const std::string& option) const
    {
      return options.find(option) != options.end();
    }
 
  private:
 
    static std::vector< std::string > parse_command_line(char const* const arguments);
 
    static std::vector< std::string > convert(const int count, char const* const* const arguments);
 
    static std::vector< std::string > convert(const int count, wchar_t const* const* const arguments);
 
    void collect(interface_description& d, std::vector< std::string > const& arguments);
 
    void process_default_options(interface_description& d);
 
    static std::vector< bool (*)(command_line_parser&) >& get_registered_actions()
    {
      static std::vector< bool (*)(command_line_parser&) > actions;
 
      return actions;
    }
 
    static void register_action(bool (*action)(command_line_parser&))
    {
      get_registered_actions().push_back(action);
    }
 
    inline void
    option_argument_as_impl(std::string const& long_identifier, std::string& res) const
    {
      res = option_argument(long_identifier);
    }
 
    template < typename T >
    inline void
    option_argument_as_impl(std::string const& long_identifier, T& result) const
    {
      std::istringstream in(option_argument(long_identifier));
 
      result = T();
 
      in >> result;
 
      if (in.fail())
      {
        const char short_option(m_interface.long_to_short(long_identifier));
 
        error("argument `" + option_argument(long_identifier) + "' to option --" + long_identifier +
              ((short_option == '\0') ? " " : " or -" + std::string(1, short_option)) + " is invalid");
      }
    }
 
  public:
 
    inline command_line_parser(interface_description& interface_specification, char const* const command_line) :
      m_interface(interface_specification), m_continue(true), options(m_options), arguments(m_arguments)
    {
      collect(interface_specification, parse_command_line(command_line));
 
      process_default_options(interface_specification);
    }
 
    template < typename CharacterType >
    command_line_parser(interface_description& interface_specification,
                        const int argument_count, CharacterType const* const* const arguments);
 
    void error(std::string const& message) const
    {
      throw mcrl2::command_line_error(m_interface.m_name, message);
    }
 
    void check_no_duplicate_arguments() const
    {
      for (option_map::const_iterator i = m_options.begin(); i != m_options.end(); ++i)
      {
        if (1 < m_options.count(i->first))
        {
          error("option -" + (m_interface.long_to_short(i->first) != '\0' ?
                              std::string(1, m_interface.long_to_short(i->first)).append(", --") : "-") + i->first + " specified more than once");
        }
      }
    }
 
    std::string const& option_argument(std::string const& long_identifier) const;
 
    inline bool continue_execution() const
    {
      return m_continue;
    }
 
    template < typename T >
    inline T option_argument_as(std::string const& long_identifier) const
    {
      T result;
      option_argument_as_impl(long_identifier, result);
      return result;
    }
 
};
 
template < typename ArgumentType >
interface_description::optional_argument< ArgumentType > make_optional_argument(std::string const& name, std::string const& default_value)
{
  return interface_description::optional_argument< ArgumentType >(name, default_value);
}
 
interface_description::optional_argument< std::string > make_optional_argument(std::string const& name, std::string const& default_value);
 
template < typename ArgumentType >
interface_description::mandatory_argument< ArgumentType > make_mandatory_argument(std::string const& name)
{
  return interface_description::mandatory_argument< ArgumentType >(name);
}
 
interface_description::mandatory_argument< std::string >
make_mandatory_argument(std::string const& name);
 
template < typename ArgumentType >
interface_description::mandatory_argument< ArgumentType >
make_mandatory_argument(std::string const& name, std::string const& standard_value)
{
  return interface_description::mandatory_argument< ArgumentType >(name, standard_value);
}
 
interface_description::mandatory_argument< std::string >
make_mandatory_argument(std::string const& name, std::string const& default_value);
 
template < typename ArgumentType >
interface_description::enum_argument< ArgumentType > make_enum_argument(std::string const& name)
{
  return interface_description::enum_argument< ArgumentType >(name);
}
 
template < typename T >
class interface_description::typed_argument : public basic_argument
{
 
  public:
    typed_argument()
    {
      set_type("typed");
    }
 
    inline bool validate(std::string const& s) const
    {
      std::istringstream test(s);
 
      T result;
 
      test >> result;
 
      return !test.fail();
    }
};
 
template < >
inline bool interface_description::typed_argument< std::string >::validate(std::string const&) const
{
  return true;
}
 
template < typename T >
class interface_description::enum_argument : public typed_argument< T >
{
  protected:
 
    std::vector< basic_argument::argument_description > m_enum;
 
    std::string m_default;
    bool m_has_default;
 
    enum_argument& add_value_with_short(const std::string& long_arg, const std::string& short_arg, const std::string& description, const bool is_default = false)
    {
      m_enum.push_back(basic_argument::argument_description(long_arg, short_arg, description));
 
      if(is_default)
      {
        if(has_default())
        {
          throw std::runtime_error("cannot define duplicate default value to enum argument");
        }
        m_default = long_arg;
        m_has_default = true;
      }
 
      return (*this);
    }
 
  public:
 
    enum_argument(std::string const& name) :
      m_has_default(false)
    {
      basic_argument::set_type("enum");
      basic_argument::set_name(name);
    }
 
    virtual
    enum_argument* clone() const
    {
      return new enum_argument< T >(*this);
    }
 
    virtual
    bool has_default() const
    {
      return m_has_default;
    }
 
    virtual
    const std::string& get_default() const
    {
      return m_default;
    }
 
    virtual
    bool is_optional() const
    {
      return false;
    }
 
    inline bool validate(std::string const& s) const
    {
      for(typename std::vector< basic_argument::argument_description >::const_iterator i = m_enum.begin(); i != m_enum.end(); ++i)
      {
        if(i->get_long() == s || i->get_short() == s)
        {
          std::istringstream test(s);
          T result;
          test >> result;
 
          return !test.fail();
        }
      }
      return false;
    }
 
    enum_argument& add_value(const T& arg, const bool is_default = false)
    {
      return add_value_with_short(to_string(arg), std::string(), description(arg), is_default);
    }
 
    enum_argument& add_value_desc(const T& arg, const std::string& description, const bool is_default = false)
    {
      return add_value_with_short(to_string(arg), std::string(), description, is_default);
    }
 
    enum_argument& add_value_short(const T& arg, const std::string& short_argument, const bool is_default = false)
    {
      return add_value_with_short(to_string(arg), short_argument, description(arg), is_default);
    }
 
 
 
    virtual bool has_description() const
    {
      return true;
    }
 
    virtual const std::vector< basic_argument::argument_description >& get_description() const
    {
      return m_enum;
    }
 
};
 
template < typename T >
class interface_description::optional_argument : public typed_argument< T >
{
    friend class interface_description;
    friend class interface_description::option_descriptor;
    friend class command_line_parser;
 
  protected:
 
    std::string m_default;
 
    std::vector< basic_argument::argument_description > m_description;
 
  public:
 
    virtual basic_argument* clone() const
    {
      return new optional_argument< T >(*this);
    }
 
    inline optional_argument(std::string const& name, std::string const& d) : m_default(d)
    {
      basic_argument::set_type("optional");
      basic_argument::set_name(name);
    }
 
    inline bool has_default() const
    {
      return true;
    }
 
    inline std::string const& get_default() const
    {
      return m_default;
    }
 
    inline bool is_optional() const
    {
      return true;
    }
 
    inline bool has_description() const
    {
      return false;
    }
 
    inline const std::vector< basic_argument::argument_description >& get_description() const
    {
      return m_description;
    }
};
 
template < typename T >
class interface_description::mandatory_argument : public typed_argument< T >
{
 
  protected:
 
    std::string m_default;
 
    bool        m_has_default;
 
    std::vector< basic_argument::argument_description > m_description;
 
  public:
 
    virtual basic_argument* clone() const
    {
      return new mandatory_argument< T >(*this);
    }
 
    inline mandatory_argument(std::string const& name) : m_has_default(false)
    {
      basic_argument::set_type("mandatory");
      basic_argument::set_name(name);
    }
 
    inline mandatory_argument(std::string const& name, std::string const& d) : m_default(d), m_has_default(true)
    {
      basic_argument::set_type("mandatory");
      basic_argument::set_name(name);
    }
 
    inline std::string const& get_default() const
    {
      return m_default;
    }
 
    inline bool has_default() const
    {
      return m_has_default;
    }
 
    inline bool is_optional() const
    {
      return false;
    }
 
    inline bool has_description() const
    {
      return false;
    }
 
    inline const std::vector< basic_argument::argument_description >& get_description() const
    {
      return m_description;
    }
};
 
class interface_description::file_argument : public typed_argument<std::string>
{
 
  protected:
 
    std::string m_default;
 
    bool        m_has_default;
 
    std::vector< basic_argument::argument_description > m_description;
 
  public:
 
    virtual basic_argument* clone() const
    {
      return new file_argument(*this);
    }
 
 
    inline bool validate(std::string const& /*s*/) const
    {
      return true;
    }
 
    inline file_argument(std::string const& name) : m_has_default(false)
    {
      basic_argument::set_type("file");
      basic_argument::set_name(name);
    }
 
    inline std::string const& get_default() const
    {
      return m_default;
    }
 
    inline bool has_default() const
    {
      return m_has_default;
    }
 
    inline bool is_optional() const
    {
      return false;
    }
 
    inline bool has_description() const
    {
      return false;
    }
 
    inline const std::vector< basic_argument::argument_description >& get_description() const
    {
      return m_description;
    }
};
 
inline
interface_description::file_argument make_file_argument(std::string const& name)
{
  return interface_description::file_argument(name);
}
 
#if !defined(__COMMAND_LINE_INTERFACE__)
 
template <>
inline command_line_parser::command_line_parser(interface_description& d, const int c, char const* const* const a) :
  m_interface(d), m_continue(true), options(m_options), arguments(m_arguments)
{
 
  collect(d, convert(c, a));
 
  process_default_options(d);
}
# ifndef __CYGWIN__ // std::wstring is not available for Cygwin
template <>
inline command_line_parser::command_line_parser(interface_description& d, const int c, wchar_t const* const* const a) :
  m_interface(d), m_continue(true), options(m_options), arguments(m_arguments)
{
 
  collect(d, convert(c, a));
 
  process_default_options(d);
}
# endif // __CYGWIN__
#endif
} // namespace utilities
} // namespace mcrl2
 
#endif