| // Copyright Vladimir Prus 2002-2004. |
| // 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) |
| |
| #define BOOST_PROGRAM_OPTIONS_SOURCE |
| #include <boost/program_options/config.hpp> |
| |
| #include <boost/config.hpp> |
| |
| #include <boost/program_options/detail/cmdline.hpp> |
| #include <boost/program_options/errors.hpp> |
| #include <boost/program_options/value_semantic.hpp> |
| #include <boost/program_options/options_description.hpp> |
| #include <boost/program_options/positional_options.hpp> |
| #include <boost/throw_exception.hpp> |
| |
| #include <boost/bind.hpp> |
| |
| #include <string> |
| #include <utility> |
| #include <vector> |
| #include <cassert> |
| #include <cstring> |
| #include <cctype> |
| #include <climits> |
| |
| #include <cstdio> |
| |
| #include <iostream> |
| |
| namespace boost { namespace program_options { |
| |
| using namespace std; |
| using namespace boost::program_options::command_line_style; |
| |
| invalid_syntax:: |
| invalid_syntax(const string& tokens, kind_t kind) |
| : error(error_message(kind).append(" in '").append(tokens).append("'")) |
| , m_tokens(tokens) |
| , m_kind(kind) |
| {} |
| |
| string |
| invalid_syntax::error_message(kind_t kind) |
| { |
| // Initially, store the message in 'const char*' variable, |
| // to avoid conversion to string in all cases. |
| const char* msg; |
| switch(kind) |
| { |
| case long_not_allowed: |
| msg = "long options are not allowed"; |
| break; |
| case long_adjacent_not_allowed: |
| msg = "parameters adjacent to long options not allowed"; |
| break; |
| case short_adjacent_not_allowed: |
| msg = "parameters adjust to short options are not allowed"; |
| break; |
| case empty_adjacent_parameter: |
| msg = "adjacent parameter is empty"; |
| break; |
| case missing_parameter: |
| msg = "required parameter is missing"; |
| break; |
| case extra_parameter: |
| msg = "extra parameter"; |
| break; |
| case unrecognized_line: |
| msg = "unrecognized line"; |
| break; |
| default: |
| msg = "unknown error"; |
| } |
| return msg; |
| } |
| |
| invalid_syntax::kind_t |
| invalid_syntax::kind() const |
| { |
| return m_kind; |
| } |
| |
| const string& |
| invalid_syntax::tokens() const |
| { |
| return m_tokens; |
| } |
| |
| invalid_command_line_syntax:: |
| invalid_command_line_syntax(const string& tokens, kind_t kind) |
| : invalid_syntax(tokens, kind) |
| {} |
| |
| }} |
| |
| |
| namespace boost { namespace program_options { namespace detail { |
| |
| // vc6 needs this, but borland chokes when this is added. |
| #if BOOST_WORKAROUND(_MSC_VER, < 1300) |
| using namespace std; |
| using namespace program_options; |
| #endif |
| |
| |
| cmdline::cmdline(const vector<string>& args) |
| { |
| init(args); |
| } |
| |
| cmdline::cmdline(int argc, const char*const * argv) |
| { |
| #if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) |
| vector<string> args; |
| copy(argv+1, argv+argc+!argc, inserter(args, args.end())); |
| init(args); |
| #else |
| init(vector<string>(argv+1, argv+argc+!argc)); |
| #endif |
| } |
| |
| void |
| cmdline::init(const vector<string>& args) |
| { |
| this->args = args; |
| m_style = command_line_style::default_style; |
| m_desc = 0; |
| m_positional = 0; |
| m_allow_unregistered = false; |
| } |
| |
| void |
| cmdline::style(int style) |
| { |
| if (style == 0) |
| style = default_style; |
| |
| check_style(style); |
| this->m_style = style_t(style); |
| } |
| |
| void |
| cmdline::allow_unregistered() |
| { |
| this->m_allow_unregistered = true; |
| } |
| |
| void |
| cmdline::check_style(int style) const |
| { |
| bool allow_some_long = |
| (style & allow_long) || (style & allow_long_disguise); |
| |
| const char* error = 0; |
| if (allow_some_long && |
| !(style & long_allow_adjacent) && !(style & long_allow_next)) |
| error = "style disallows parameters for long options"; |
| |
| if (!error && (style & allow_short) && |
| !(style & short_allow_adjacent) && !(style & short_allow_next)) |
| error = "style disallows parameters for short options"; |
| |
| if (!error && (style & allow_short) && |
| !(style & allow_dash_for_short) && !(style & allow_slash_for_short)) |
| error = "style disallows all characters for short options"; |
| |
| if (error) |
| boost::throw_exception(invalid_command_line_style(error)); |
| |
| // Need to check that if guessing and long disguise are enabled |
| // -f will mean the same as -foo |
| } |
| |
| bool |
| cmdline::is_style_active(style_t style) const |
| { |
| return ((m_style & style) ? true : false); |
| } |
| |
| void |
| cmdline::set_options_description(const options_description& desc) |
| { |
| m_desc = &desc; |
| } |
| |
| void |
| cmdline::set_positional_options( |
| const positional_options_description& positional) |
| { |
| m_positional = &positional; |
| } |
| |
| |
| vector<option> |
| cmdline::run() |
| { |
| // The parsing is done by having a set of 'style parsers' |
| // and trying then in order. Each parser is passed a vector |
| // of unparsed tokens and can consume some of them (by |
| // removing elements on front) and return a vector of options. |
| // |
| // We try each style parser in turn, untill some input |
| // is consumed. The returned vector of option may contain the |
| // result of just syntactic parsing of token, say --foo will |
| // be parsed as option with name 'foo', and the style parser |
| // is not required to care if that option is defined, and how |
| // many tokens the value may take. |
| // So, after vector is returned, we validate them. |
| assert(m_desc); |
| |
| vector<style_parser> style_parsers; |
| |
| if (m_style_parser) |
| style_parsers.push_back(m_style_parser); |
| |
| if (m_additional_parser) |
| style_parsers.push_back( |
| boost::bind(&cmdline::handle_additional_parser, this, _1)); |
| |
| if (m_style & allow_long) |
| style_parsers.push_back( |
| boost::bind(&cmdline::parse_long_option, this, _1)); |
| |
| if ((m_style & allow_long_disguise)) |
| style_parsers.push_back( |
| boost::bind(&cmdline::parse_disguised_long_option, this, _1)); |
| |
| if ((m_style & allow_short) && (m_style & allow_dash_for_short)) |
| style_parsers.push_back( |
| boost::bind(&cmdline::parse_short_option, this, _1)); |
| |
| if ((m_style & allow_short) && (m_style & allow_slash_for_short)) |
| style_parsers.push_back(boost::bind(&cmdline::parse_dos_option, this, _1)); |
| |
| style_parsers.push_back(boost::bind(&cmdline::parse_terminator, this, _1)); |
| |
| vector<option> result; |
| while(!args.empty()) |
| { |
| bool ok = false; |
| for(unsigned i = 0; i < style_parsers.size(); ++i) |
| { |
| unsigned current_size = args.size(); |
| vector<option> next = style_parsers[i](args); |
| |
| // Check that option names |
| // are valid, and that all values are in place. |
| if (!next.empty()) |
| { |
| vector<string> e; |
| for(unsigned k = 0; k < next.size()-1; ++k) { |
| finish_option(next[k], e, style_parsers); |
| } |
| // For the last option, pass the unparsed tokens |
| // so that they can be added to next.back()'s values |
| // if appropriate. |
| finish_option(next.back(), args, style_parsers); |
| for (unsigned j = 0; j < next.size(); ++j) |
| result.push_back(next[j]); |
| } |
| |
| if (args.size() != current_size) { |
| ok = true; |
| break; |
| } |
| } |
| |
| if (!ok) { |
| option opt; |
| opt.value.push_back(args[0]); |
| opt.original_tokens.push_back(args[0]); |
| result.push_back(opt); |
| args.erase(args.begin()); |
| } |
| } |
| |
| /* If an key option is followed by a positional option, |
| can can consume more tokens (e.g. it's multitoke option), |
| give those tokens to it. */ |
| vector<option> result2; |
| for (unsigned i = 0; i < result.size(); ++i) |
| { |
| result2.push_back(result[i]); |
| option& opt = result2.back(); |
| |
| if (opt.string_key.empty()) |
| continue; |
| |
| const option_description* xd = |
| m_desc->find_nothrow(opt.string_key, |
| is_style_active(allow_guessing), |
| is_style_active(long_case_insensitive), |
| is_style_active(short_case_insensitive)); |
| if (!xd) |
| continue; |
| |
| unsigned min_tokens = xd->semantic()->min_tokens(); |
| unsigned max_tokens = xd->semantic()->max_tokens(); |
| if (min_tokens < max_tokens && opt.value.size() < max_tokens) |
| { |
| // This option may grab some more tokens. |
| // We only allow to grab tokens that are not already |
| // recognized as key options. |
| |
| int can_take_more = max_tokens - opt.value.size(); |
| unsigned j = i+1; |
| for (; can_take_more && j < result.size(); --can_take_more, ++j) |
| { |
| option& opt2 = result[j]; |
| if (!opt2.string_key.empty()) |
| break; |
| |
| if (opt2.position_key == INT_MAX) |
| { |
| // We use INT_MAX to mark positional options that |
| // were found after the '--' terminator and therefore |
| // should stay positional forever. |
| break; |
| } |
| |
| assert(opt2.value.size() == 1); |
| |
| opt.value.push_back(opt2.value[0]); |
| |
| assert(opt2.original_tokens.size() == 1); |
| |
| opt.original_tokens.push_back(opt2.original_tokens[0]); |
| } |
| i = j-1; |
| } |
| } |
| result.swap(result2); |
| |
| |
| // Assign position keys to positional options. |
| int position_key = 0; |
| for(unsigned i = 0; i < result.size(); ++i) { |
| if (result[i].string_key.empty()) |
| result[i].position_key = position_key++; |
| } |
| |
| if (m_positional) |
| { |
| unsigned position = 0; |
| for (unsigned i = 0; i < result.size(); ++i) { |
| option& opt = result[i]; |
| if (opt.position_key != -1) { |
| if (position >= m_positional->max_total_count()) |
| { |
| boost::throw_exception(too_many_positional_options_error()); |
| } |
| opt.string_key = m_positional->name_for_position(position); |
| ++position; |
| } |
| } |
| } |
| |
| // set case sensitive flag |
| for (unsigned i = 0; i < result.size(); ++i) { |
| if (result[i].string_key.size() > 2 || |
| (result[i].string_key.size() > 1 && result[i].string_key[0] != '-')) |
| { |
| // it is a long option |
| result[i].case_insensitive = is_style_active(long_case_insensitive); |
| } |
| else |
| { |
| // it is a short option |
| result[i].case_insensitive = is_style_active(short_case_insensitive); |
| } |
| } |
| |
| return result; |
| } |
| |
| void |
| cmdline::finish_option(option& opt, |
| vector<string>& other_tokens, |
| const vector<style_parser>& style_parsers) |
| { |
| if (opt.string_key.empty()) |
| return; |
| |
| // First check that the option is valid, and get its description. |
| const option_description* xd = m_desc->find_nothrow(opt.string_key, |
| is_style_active(allow_guessing), |
| is_style_active(long_case_insensitive), |
| is_style_active(short_case_insensitive)); |
| |
| if (!xd) |
| { |
| if (m_allow_unregistered) { |
| opt.unregistered = true; |
| return; |
| } else { |
| boost::throw_exception(unknown_option(opt.string_key)); |
| } |
| } |
| const option_description& d = *xd; |
| |
| // Canonize the name |
| opt.string_key = d.key(opt.string_key); |
| |
| // We check that the min/max number of tokens for the option |
| // agrees with the number of tokens we have. The 'adjacent_value' |
| // (the value in --foo=1) counts as a separate token, and if present |
| // must be consumed. The following tokens on the command line may be |
| // left unconsumed. |
| |
| // We don't check if those tokens look like option, or not! |
| |
| unsigned min_tokens = d.semantic()->min_tokens(); |
| unsigned max_tokens = d.semantic()->max_tokens(); |
| |
| unsigned present_tokens = opt.value.size() + other_tokens.size(); |
| |
| if (present_tokens >= min_tokens) |
| { |
| if (!opt.value.empty() && max_tokens == 0) |
| { |
| boost::throw_exception(invalid_command_line_syntax(opt.string_key, |
| invalid_command_line_syntax::extra_parameter)); |
| } |
| |
| // If an option wants, at minimum, N tokens, we grab them there, |
| // when adding these tokens as values to current option we check |
| // if they look like options |
| if (opt.value.size() <= min_tokens) |
| { |
| min_tokens -= opt.value.size(); |
| } |
| else |
| { |
| min_tokens = 0; |
| } |
| |
| // Everything's OK, move the values to the result. |
| for(;!other_tokens.empty() && min_tokens--; ) |
| { |
| // check if extra parameter looks like a known option |
| // we use style parsers to check if it is syntactically an option, |
| // additionally we check if an option_description exists |
| vector<option> followed_option; |
| vector<string> next_token(1, other_tokens[0]); |
| for (unsigned i = 0; followed_option.empty() && i < style_parsers.size(); ++i) |
| { |
| followed_option = style_parsers[i](next_token); |
| } |
| if (!followed_option.empty()) |
| { |
| const option_description* od = m_desc->find_nothrow(other_tokens[0], |
| is_style_active(allow_guessing), |
| is_style_active(long_case_insensitive), |
| is_style_active(short_case_insensitive)); |
| if (od) |
| boost::throw_exception(invalid_command_line_syntax(opt.string_key, |
| invalid_command_line_syntax::missing_parameter)); |
| } |
| opt.value.push_back(other_tokens[0]); |
| opt.original_tokens.push_back(other_tokens[0]); |
| other_tokens.erase(other_tokens.begin()); |
| } |
| } |
| else |
| { |
| boost::throw_exception(invalid_command_line_syntax(opt.string_key, |
| invalid_command_line_syntax::missing_parameter)); |
| |
| } |
| } |
| |
| vector<option> |
| cmdline::parse_long_option(vector<string>& args) |
| { |
| vector<option> result; |
| const string& tok = args[0]; |
| if (tok.size() >= 3 && tok[0] == '-' && tok[1] == '-') |
| { |
| string name, adjacent; |
| |
| string::size_type p = tok.find('='); |
| if (p != tok.npos) |
| { |
| name = tok.substr(2, p-2); |
| adjacent = tok.substr(p+1); |
| if (adjacent.empty()) |
| boost::throw_exception( invalid_command_line_syntax(name, |
| invalid_command_line_syntax::empty_adjacent_parameter) ); |
| } |
| else |
| { |
| name = tok.substr(2); |
| } |
| option opt; |
| opt.string_key = name; |
| if (!adjacent.empty()) |
| opt.value.push_back(adjacent); |
| opt.original_tokens.push_back(tok); |
| result.push_back(opt); |
| args.erase(args.begin()); |
| } |
| return result; |
| } |
| |
| |
| vector<option> |
| cmdline::parse_short_option(vector<string>& args) |
| { |
| const string& tok = args[0]; |
| if (tok.size() >= 2 && tok[0] == '-' && tok[1] != '-') |
| { |
| vector<option> result; |
| |
| string name = tok.substr(0,2); |
| string adjacent = tok.substr(2); |
| |
| // Short options can be 'grouped', so that |
| // "-d -a" becomes "-da". Loop, processing one |
| // option at a time. We exit the loop when either |
| // we've processed all the token, or when the remainder |
| // of token is considered to be value, not further grouped |
| // option. |
| for(;;) { |
| const option_description* d |
| = m_desc->find_nothrow(name, false, false, |
| is_style_active(short_case_insensitive)); |
| |
| // FIXME: check for 'allow_sticky'. |
| if (d && (m_style & allow_sticky) && |
| d->semantic()->max_tokens() == 0 && !adjacent.empty()) { |
| // 'adjacent' is in fact further option. |
| option opt; |
| opt.string_key = name; |
| result.push_back(opt); |
| |
| if (adjacent.empty()) |
| { |
| args.erase(args.begin()); |
| break; |
| } |
| |
| name = string("-") + adjacent[0]; |
| adjacent.erase(adjacent.begin()); |
| } else { |
| |
| option opt; |
| opt.string_key = name; |
| opt.original_tokens.push_back(tok); |
| if (!adjacent.empty()) |
| opt.value.push_back(adjacent); |
| result.push_back(opt); |
| args.erase(args.begin()); |
| break; |
| } |
| } |
| return result; |
| } |
| return vector<option>(); |
| } |
| |
| vector<option> |
| cmdline::parse_dos_option(vector<string>& args) |
| { |
| vector<option> result; |
| const string& tok = args[0]; |
| if (tok.size() >= 2 && tok[0] == '/') |
| { |
| string name = "-" + tok.substr(1,1); |
| string adjacent = tok.substr(2); |
| |
| option opt; |
| opt.string_key = name; |
| if (!adjacent.empty()) |
| opt.value.push_back(adjacent); |
| opt.original_tokens.push_back(tok); |
| result.push_back(opt); |
| args.erase(args.begin()); |
| } |
| return result; |
| } |
| |
| vector<option> |
| cmdline::parse_disguised_long_option(vector<string>& args) |
| { |
| const string& tok = args[0]; |
| if (tok.size() >= 2 && |
| ((tok[0] == '-' && tok[1] != '-') || |
| ((m_style & allow_slash_for_short) && tok[0] == '/'))) |
| { |
| if (m_desc->find_nothrow(tok.substr(1, tok.find('=')-1), |
| is_style_active(allow_guessing), |
| is_style_active(long_case_insensitive), |
| is_style_active(short_case_insensitive))) |
| { |
| args[0].insert(0, "-"); |
| if (args[0][1] == '/') |
| args[0][1] = '-'; |
| return parse_long_option(args); |
| } |
| } |
| return vector<option>(); |
| } |
| |
| vector<option> |
| cmdline::parse_terminator(vector<string>& args) |
| { |
| vector<option> result; |
| const string& tok = args[0]; |
| if (tok == "--") |
| { |
| for(unsigned i = 1; i < args.size(); ++i) |
| { |
| option opt; |
| opt.value.push_back(args[i]); |
| opt.original_tokens.push_back(args[i]); |
| opt.position_key = INT_MAX; |
| result.push_back(opt); |
| } |
| args.clear(); |
| } |
| return result; |
| } |
| |
| vector<option> |
| cmdline::handle_additional_parser(vector<string>& args) |
| { |
| vector<option> result; |
| pair<string, string> r = m_additional_parser(args[0]); |
| if (!r.first.empty()) { |
| option next; |
| next.string_key = r.first; |
| if (!r.second.empty()) |
| next.value.push_back(r.second); |
| result.push_back(next); |
| args.erase(args.begin()); |
| } |
| return result; |
| } |
| |
| void |
| cmdline::set_additional_parser(additional_parser p) |
| { |
| m_additional_parser = p; |
| } |
| |
| void |
| cmdline::extra_style_parser(style_parser s) |
| { |
| m_style_parser = s; |
| } |
| |
| |
| |
| }}} |
