CommandLine.cc

Go to the documentation of this file.

#include <mutils/CommandLine.h>

namespace mutils {

bool CommandLine::parseLong(const char *name, const char *next)
{
  const char *fn = "CommandLine::parseLong";
  const std::vector<Option> &opts = *validOpts_;
  MU_EXCEPTION_IF(*name == '=', fn, "Invalid option '%s'", name);

  bool used = false;
  std::string opt, arg = nullStr;  // C string cannot produce this value.
  const char *attach = strchr(name, '=');
  if (attach == nullptr) {
    opt.assign(name);
  } else {
    // Attached value.
    opt.assign(name, attach-name);
  }

  // Check if option is valid.
  auto o = std::find_if(opts.begin(), opts.end(),
               [&opt](const Option &x) { return !opt.compare(x.longName); });
  MU_EXCEPTION_IF(o == opts.end(), fn, "Unknown option '%s'", opt);

  if (! o->valueName.empty()) {
    if (attach == nullptr) {
      MU_EXCEPTION_IF(!next, fn, "Option '%s' requires a value", opt);

      // Trailing value.
      arg.assign(next);
      used = true;
    } else {
      // Attached value.
      arg.assign(attach+1);
    }
  } else {
    MU_EXCEPTION_IF(attach, fn, "Option '%s' does not take a value", opt);
  }

  // Insert option.
  auto p = longOpts_.upper_bound(opt);
  longOpts_.insert(p, LongMap::value_type(opt, arg));

  return used;
}


bool CommandLine::parseShort(const char *name, const char *next)
{
  const char *fn = "CommandLine::parseShort";
  const std::vector<Option> &opts = *validOpts_;

  // Allowing attached values precludes -= as an option.
  MU_EXCEPTION_IF(*name == '=', fn, "Invalid option '%s'", name);

  // Add new option(s).
  bool used = false;
  for (; *name != 0; name++) {
    char opt = *name;
    std::string arg = nullStr;  // C string cannot produce this value.

    // Check if option is valid.
    auto o = std::find_if(opts.begin(), opts.end(),
                         [opt](const Option &x) { return x.shortName == opt; });
    MU_EXCEPTION_IF(o == opts.end(), fn, "Unknown option '%c'", opt);

    // Last option may have a value.
    if (! o->valueName.empty()) {
      if (name[1] == '=') {
        // Attached value.
        arg.assign(name+2);
      } else {
        // Option must be the last of this group and needs a value.
        MU_EXCEPTION_IF(name[1] != '\0' || next == nullptr,
                        fn, "Option '%c' requires a value", opt);

        // Trailing value.
        arg.assign(next);
        used = true;
      }

      // Insert option and return.
      auto p = shortOpts_.upper_bound(opt);
      shortOpts_.insert(p, ShortMap::value_type(opt, arg));
      break;
    } else {
      MU_EXCEPTION_IF(name[1] == '=',
                      fn, "Option '%c' does not take a value", opt);

      // Insert option and continue.
      auto p = shortOpts_.upper_bound(opt);
      shortOpts_.insert(p, ShortMap::value_type(opt, arg));
    }
  }

  return used;
}

void CommandLine::init(int argc, char *argv[], const std::vector<Option> *opts)
{
  // Clean slate.
  driver_ = (argc > 0 ? argv[0] : "");
  validOpts_ = opts;
  shortOpts_.clear();
  longOpts_.clear();
  args_.clear();

  // Parse input into maps of short and long options, plus trailing arguments.
  int i = 1;
  for (; i < argc; i++) {
    char *arg = argv[i], *next = (i+1 < argc ? argv[i+1] : nullptr);

    // End of options?
    if (!strcmp(arg, "--") || !strcmp(arg, "-") || arg[0] != '-') {
      i += !strcmp(arg, "--");
      break;
    }

    // New option(s).
    i += (arg[1] != '-' ? parseShort(arg+1, next) : parseLong(arg+2, next));
  }

  // Store trailing arguments.
  for (; i < argc; i++) { args_.push_back(argv[i]); }
}

unsigned CommandLine::getOption(const Option &option, Arguments *values,
                                unsigned nMax) const
{
  const char *const fn = "CommandLine::getOption";
  std::string names;
  unsigned n = 0;

  if (values != nullptr) {
    // Fill in the values.
    values->clear();

    if (option.shortName != '\0') {
      auto s = shortOpts_.equal_range(option.shortName);
      for (auto x = s.first; x != s.second; x++, n++) {
        values->push_back(x->second);
      }
      names += '-';
      names += option.shortName;
    }
    if (! option.longName.empty()) {
      auto l = longOpts_.equal_range(option.longName);
      for (auto x = l.first; x != l.second; x++, n++) {
        values->push_back(x->second);
      }
      if (! names.empty()) { names += '/'; }
      names += "--";
      names += option.longName;
    }
  } else {
    n = (option.shortName != '\0' ?  shortOpts_.count(option.shortName) : 0) +
        (!option.longName.empty() ?   longOpts_.count(option.longName)  : 0);
  }
  MU_EXCEPTION_IF(n > nMax, fn,
                  "Option %s can appear at most %lu time%s (%lu present)",
                  names, nMax, nMax ==1 ? "" : "s", n);

  return n;
}

unsigned CommandLine::getOption(char shortName, Arguments *values,
                                unsigned nMax) const
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.shortName == shortName) { return getOption(opt, values, nMax); }
  }
  return 0;
}

unsigned CommandLine::getOption(const std::string &longName,
                                Arguments *values, unsigned nMax) const
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.longName == longName) { return getOption(opt, values, nMax); }
  }
  return 0;
}

size_t CommandLine::popOption(const Option &option)
{
  size_t rtn = 0;
  if (option.shortName != '\0') { rtn += shortOpts_.erase(option.shortName); }
  if (!option.longName.empty()) { rtn +=  longOpts_.erase(option.longName);  }
  return rtn;
}

size_t CommandLine::popOption(char shortName)
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.shortName == shortName) { return popOption(opt); }
  }
  return 0;
}

size_t CommandLine::popOption(const std::string &longName)
{
  // Find option specification.
  for (auto &opt: *validOpts_) {
    if (opt.longName == longName) { return popOption(opt); }
  }
  return 0;
}


long CommandLine::getInteger(char shortName) const
{
  const char *const fn = "CommandLine::getInteger";
  Arguments vals;
  MU_EXCEPTION_IF(getOption(shortName, &vals, 1) == 0, fn,
                  "Option '%c' not found", shortName);
  return strtol(vals[0].c_str(), nullptr, 10);
}

long CommandLine::getInteger(char shortName, long defValue) const
{
  Arguments vals;
  return (getOption(shortName, &vals, 1) ?
            strtol(vals[0].c_str(), nullptr, 10) : defValue);
}


double CommandLine::getDouble(char shortName, double defValue) const
{
  Arguments vals;
  return (getOption(shortName, &vals, 1) ?
            strtod(vals[0].c_str(), nullptr) : defValue);
}

std::string CommandLine::getString(char shortName,
                                   const std::string &defValue) const
{
  Arguments vals;
  return (getOption(shortName, &vals, 1) ? vals[0] : defValue);
}


void CommandLine::usage(FILE *f, const std::vector<Option> &opts,
                        const char *args, bool quiet, bool basename) const
{
  size_t base = (basename ? driver_.find_last_of('/') : npos);
  fprintf(f, "Usage:  %s [OPTIONS] %s\n\nOptions:\n",
          driver_.c_str()+(base != npos ? base+1 : 0U), args);

  // Output formatted option summary.
  for (auto &opt: opts) {
    bool hasShort = ( opt.shortName != '\0'),
         hasLong  = (!opt.longName.empty()),
         hasValue = (!opt.valueName.empty());
    fprintf(f, "%s  %s%c%s%s%s%s%s%s",
            (quiet ? "" : "\n"),
            (hasShort ? "-" : ""), opt.shortName,
            (hasShort && hasLong ? ", " : ""), (hasLong ? "--" : ""),
            (hasLong  ? opt.longName.c_str() : ""),
            (hasValue ? (hasLong ? "=" : " ") : ""),
            (hasValue ? opt.valueName.c_str() : ""),
            (hasLong || hasValue ? "\n" : ""));

    if (!quiet) {
      // Print each line of the help text on an indented line.
      int indent = (hasLong || hasValue ? 8 : 4);
      const char *line = opt.helpText.c_str();
      while (line != nullptr) {
        const char *next = strchr(line, '\n');
        if (next == nullptr) {
          fprintf(f, "%*s%s\n", indent, "", line);
          line = next;
        } else {
          fprintf(f, "%*s%.*s\n", indent, "", (int )(next-line), line);
          line = next+1;
        }
        indent = 8;
      }
      if (Log::level >= Log::DEBUG && opt.keyName != nullStr) {
        fprintf(f, "%*s(File option: *SECTION = %s::%s, keyword %s)\n",
                indent, "", opt.scopeName.c_str(), opt.sectName.c_str(),
                opt.keyword().c_str());
      }
    }
  }
}

}  // namespace mutils