| // Copyright 2018 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include <lib/cmdline/args_parser.h> | |
| #include <algorithm> | |
| namespace cmdline { | |
| namespace { | |
| // Returns true if the argument is the special string that indicates the end | |
| // of options. | |
| bool IsOptionEndFlag(const char* arg) { return strcmp(arg, "--") == 0; } | |
| // Checks if the given argument is a short option and if it is, returns the | |
| // letter. If not, returns 0. | |
| char GetShortOption(const char* arg, const char** value_begin) { | |
| if (arg[0] == '-' && arg[1] != 0 && arg[1] != '-') { | |
| *value_begin = &arg[2]; // Arg (if any) follows immediately. | |
| return arg[1]; | |
| } | |
| *value_begin = nullptr; | |
| return 0; | |
| } | |
| // Checks if the given argument is a long option and returns it, not including | |
| // the preceding "--". If it's not an option, returns the empty string. To | |
| // differentiate args consisting of only "--" and non-options, callers should | |
| // call IsOptionEndFlag() before this. | |
| std::string GetLongOption(const char* arg, const char** value_begin) { | |
| *value_begin = nullptr; | |
| if (arg[0] != '-' || arg[1] != '-') | |
| return std::string(); | |
| // See if there's and "=<arg>" in this flag. | |
| const char* equals = strchr(arg, '='); | |
| if (!equals) | |
| return &arg[2]; // No "=<arg>". | |
| // value_begin gets everything after the equals. | |
| *value_begin = &equals[1]; | |
| // Return everything between the '--' (2 bytes) and the equals. | |
| return std::string(&arg[2], equals - arg - 2); | |
| } | |
| } // namespace | |
| GeneralArgsParser::GeneralArgsParser() = default; | |
| GeneralArgsParser::~GeneralArgsParser() = default; | |
| void GeneralArgsParser::AddGeneralSwitch(const char* long_name, const char short_name, | |
| const char* help, OnOffSwitchCallback on_switch, | |
| OnOffSwitchCallback off_switch) { | |
| Record& record = records_.emplace_back(); | |
| record.long_name = long_name; | |
| record.short_name = short_name; | |
| record.help_text = help; | |
| record.on_switch_callback = std::move(on_switch); | |
| if (off_switch != nullptr) { | |
| record.off_switch_callback = std::move(off_switch); | |
| } | |
| } | |
| void GeneralArgsParser::AddGeneralSwitch(const char* long_name, const char short_name, | |
| const char* help, StringCallback cb) { | |
| Record& record = records_.emplace_back(); | |
| record.long_name = long_name; | |
| record.short_name = short_name; | |
| record.help_text = help; | |
| record.string_callback = std::move(cb); | |
| } | |
| std::string GeneralArgsParser::GetHelp() const { | |
| std::vector<std::string> switches; | |
| for (const auto& record : records_) | |
| switches.push_back(record.help_text); | |
| std::sort(switches.begin(), switches.end()); | |
| std::string result; | |
| for (const std::string& str : switches) { | |
| result.append(str); | |
| result.append("\n\n"); | |
| } | |
| return result; | |
| } | |
| Status GeneralArgsParser::ParseGeneral(int argc, const char* const argv[], | |
| std::vector<std::string>* params) const { | |
| // Expect argv[0] to be the program itself. | |
| if (argc <= 1) | |
| return Status::Ok(); | |
| int last_option_index = argc - 1; | |
| for (int i = 1; i < argc; i++) { | |
| // Non-null when we find the argument. | |
| const char* arg_begin = nullptr; | |
| bool off_switch = false; | |
| const Record* record = nullptr; | |
| if (IsOptionEndFlag(argv[i])) { | |
| // End of option indicator. | |
| last_option_index = i; | |
| break; | |
| } else if (char c = GetShortOption(argv[i], &arg_begin)) { | |
| // Single-letter option. | |
| for (const Record& cur_record : records_) { | |
| if (cur_record.short_name == c) { | |
| record = &cur_record; | |
| break; | |
| } | |
| } | |
| } else if (auto long_opt = GetLongOption(argv[i], &arg_begin); !long_opt.empty()) { | |
| // Long option. | |
| for (const Record& cur_record : records_) { | |
| if (cur_record.long_name == long_opt) { | |
| record = &cur_record; | |
| break; | |
| } else if (std::string("no") + cur_record.long_name == long_opt) { | |
| off_switch = true; | |
| record = &cur_record; | |
| break; | |
| } | |
| } | |
| } else { | |
| // Non-option. | |
| last_option_index = i - 1; | |
| break; | |
| } | |
| // If we get here we should have found a record for the option. | |
| if (!record) | |
| return Status::Error(std::string(argv[i]) + " is not a valid option. " + | |
| invalid_option_suggestion_); | |
| if (NeedsArg(record)) { | |
| // Arguments can be already found ("-cfoo" or "--foo=bar") or they could | |
| // be the following parameter. | |
| if (!arg_begin || !*arg_begin) { | |
| // Argument is in the next token of the command line. | |
| if (i == argc - 1) | |
| return Status::Error(std::string(argv[i]) + | |
| " expects an argument but none was given.\n\n" + record->help_text); | |
| i++; | |
| arg_begin = argv[i]; | |
| } | |
| } else { | |
| // Don't expect an arg for this switch. | |
| if (arg_begin && *arg_begin) { | |
| // Arg points somewhere other than the end of the string when we | |
| // weren't expecting an arg. | |
| return Status::Error( | |
| std::string("Unexpected value for argument that doesn't take one:\n ") + argv[i] + | |
| "\n\n" + record->help_text); | |
| } | |
| } | |
| // Execute the right callback. | |
| Status status = Status::Ok(); | |
| if (off_switch) { | |
| if (record->off_switch_callback) { | |
| record->off_switch_callback(); | |
| } else { | |
| status = Status::Error(std::string("--") + record->long_name + | |
| " can only be turned on, not off.\n\n" + record->help_text); | |
| } | |
| } else if (record->on_switch_callback) { | |
| record->on_switch_callback(); | |
| } else if (record->string_callback) { | |
| status = record->string_callback(arg_begin); | |
| } | |
| if (status.has_error()) | |
| return status; | |
| } | |
| // Everything else following the parameters are the positional arguments. | |
| for (int i = last_option_index + 1; i < argc; i++) | |
| params->push_back(argv[i]); | |
| return Status::Ok(); | |
| } | |
| // static | |
| bool GeneralArgsParser::NeedsArg(const Record* record) { return !!record->string_callback; } | |
| namespace internal { | |
| std::vector<std::string> SplitString(const std::string& input, char delimiter) { | |
| std::vector<std::string> output; | |
| if (input.empty()) { | |
| return output; | |
| } | |
| if (delimiter == '\0') { | |
| output.push_back(input); | |
| return output; | |
| } | |
| size_t start = 0; | |
| while (start != std::string::npos) { | |
| // Extract a substring. | |
| size_t end = input.find_first_of(delimiter, start); | |
| std::string str; | |
| if (end == std::string::npos) { | |
| str = input.substr(start); | |
| start = std::string::npos; | |
| } else { | |
| str = input.substr(start, end - start); | |
| start = end + 1; | |
| } | |
| // Ignore empty substring. | |
| if (str.empty()) { | |
| continue; | |
| } | |
| output.push_back(str); | |
| } | |
| return output; | |
| } | |
| } // namespace internal | |
| } // namespace cmdline |