parser.hpp

Go to the documentation of this file.

/* Option++ -- read command-line program options
 * Copyright (C) 2017-2020 Greg Kikola.
 *
 * This file is part of Option++.
 *
 * Option++ is free software: you can redistribute it and/or modify
 * it under the terms of the Boost Software License version 1.0.
 *
 * Option++ 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
 * Boost Software License for more details.
 *
 * You should have received a copy of the Boost Software License
 * along with Option++.  If not, see
 * <https://www.boost.org/LICENSE_1_0.txt>.
 */
/* Written by Greg Kikola <[email protected]>. */
 
#ifndef OPTIONPP_PARSER_HPP
#define OPTIONPP_PARSER_HPP
 
#include <initializer_list>
#include <iosfwd>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#include <optionpp/option_group.hpp>
#include <optionpp/parser_result.hpp>
#include <optionpp/utility.hpp>
 
namespace optionpp {
 
  class parse_error : public error {
  public:
    parse_error(const std::string msg, const std::string fn_name,
                const std::string option = "")
      : error(msg, fn_name), m_option{option} {}
 
    const std::string& option() const noexcept { return m_option; }
 
  private:
    std::string m_option; //< Option that triggered the error.
  };
 
  class parser {
  public:
 
    parser() noexcept {}
    parser(const std::initializer_list<option>& il) {
      m_groups.emplace_back("", il.begin(), il.end());
    }
    template <typename InputIt>
    parser(InputIt first, InputIt last) { m_groups.emplace_back("", first, last); }
 
    option_group& group(const std::string& name);
 
    option& add_option(const option& opt = option{});
 
    option& add_option(const std::string& long_name,
                       char short_name = '\0',
                       const std::string& description = "",
                       const std::string& arg_name = "",
                       bool arg_required = false,
                       const std::string& group_name = "");
 
    template <typename InputIt>
    parser_result parse(InputIt first, InputIt last, bool ignore_first = true) const;
 
    parser_result parse(int argc, char* argv[], bool ignore_first = true) const;
 
    parser_result parse(const std::string& cmd_line, bool ignore_first = false) const;
 
    void set_custom_strings(const std::string& delims,
                            const std::string& short_prefix = "",
                            const std::string& long_prefix = "",
                            const std::string& end_indicator = "",
                            const std::string& equals = "");
 
    void sort_groups();
 
    void sort_options();
 
    option& operator[](const std::string& long_name);
 
    option& operator[](char short_name);
 
    std::ostream& print_help(std::ostream& os,
                             int max_line_length = 78,
                             int group_indent = 0,
                             int option_indent = 2,
                             int desc_first_line_indent = 30,
                             int desc_multiline_indent = 32) const;
 
 
  private:
 
    using group_container = std::vector<option_group>;
    using group_iterator = group_container::iterator;
    using group_const_iterator = group_container::const_iterator;
    using option_iterator = option_group::iterator;
    using option_const_iterator = option_group::const_iterator;
 
    group_iterator find_group(const std::string& name);
    group_const_iterator find_group(const std::string& name) const;
 
    option* find_option(const std::string& long_name);
    const option* find_option(const std::string& long_name) const;
 
    option* find_option(char short_name);
    const option* find_option(char short_name) const;
 
    bool is_end_indicator(const std::string& argument) const noexcept {
      return argument == m_end_of_options;
    }
 
    bool is_long_option(const std::string& argument) const noexcept {
      return argument.size() > m_long_option_prefix.size()
        && utility::is_substr_at_pos(argument, m_long_option_prefix);
    }
 
    bool is_short_option_group(const std::string& argument) const noexcept {
      return argument.size() > m_short_option_prefix.size()
        && utility::is_substr_at_pos(argument, m_short_option_prefix);
    }
 
    bool is_non_option(const std::string& argument) const noexcept {
      return !is_end_indicator(argument)
        && !is_long_option(argument)
        && !is_short_option_group(argument);
    }
 
    void write_option_argument(const parsed_entry& entry) const;
 
    enum class cl_arg_type { non_option, //< If the argument is not an option.
                             end_indicator, //< If the argument is an end-of-options marker.
                             arg_required, //< If the argument ends with an option that needs a mandatory argument.
                             arg_optional, //< If the argument ends with an option that can take an optional argument.
                             no_arg //< If the argument ends with an option that does not take an argument (or an argument was already given).
    };
 
    void parse_argument(const std::string& argument,
                        parser_result& result, cl_arg_type& type) const;
 
    void parse_short_option_group(const std::string& short_names,
                                  const std::string& argument, bool has_arg,
                                  parser_result& result, cl_arg_type& type) const;
 
    group_container m_groups; //< The container of option groups.
 
    std::string m_delims{" \t\n\r"}; //< Delimiters used to separate command-line arguments.
    std::string m_short_option_prefix{"-"}; //< String that indicates a group of short option names.
    std::string m_long_option_prefix{"--"}; //< String that indicates a long option name.
    std::string m_end_of_options{"--"}; //< String that marks the end of the program options.
    std::string m_equals{"="}; //< String used to specify an explicit argument to an option.
  };
 
  std::ostream& operator<<(std::ostream& os, const parser& parser);
 
} // End namespace
 
/* Implementation */
 
// Doxygen seems to think that the parse implementation below is a new
// function, so we'll ask it to skip this part of the header
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
template <typename InputIt>
optionpp::parser_result
optionpp::parser::parse(InputIt first, InputIt last, bool ignore_first) const {
  if (ignore_first && first != last)
    ++first;
 
  InputIt it{first};
 
  parser_result result{};
  cl_arg_type prev_type{cl_arg_type::non_option};
  while (it != last) {
    const std::string& arg{*it};
 
    // If we are expecting a standalone option argument...
    if (prev_type == cl_arg_type::arg_required
        || prev_type == cl_arg_type::arg_optional) {
      // ...then this token should be a non-option; but if the
      // argument is required we'll interpret it that way regardless
      if (is_non_option(arg)
          || prev_type == cl_arg_type::arg_required) {
        auto& arg_info = result.back();
        arg_info.argument = arg;
        arg_info.original_text.push_back(' ');
        arg_info.original_text += arg;
        prev_type = cl_arg_type::non_option;
        if (arg_info.opt_info)
          write_option_argument(arg_info);
      } else { // Found an option, reset type and continue
        prev_type = cl_arg_type::non_option;
        continue; // Continue without incrementing 'it' in order to reevaluate current token
      }
    } else if (prev_type == cl_arg_type::end_indicator) { // Ignore options
      parsed_entry arg_info;
      arg_info.original_text = arg;
      arg_info.is_option = false;
      result.push_back(std::move(arg_info));
    } else { // Regular argument
      parse_argument(arg, result, prev_type);
    }
 
    ++it;
  }
 
  // Make sure we don't still need a mandatory argument
  if (prev_type == cl_arg_type::arg_required) {
    const auto& opt_name = result.back().original_text;
    throw parse_error{"option '" + opt_name + "' requires an argument",
        "optionpp::parser::parse", opt_name};
  }
 
  return result;
}
 
#endif // DOXYGEN_SHOULD_SKIP_THIS
 
#endif