popl.h

/***
     ____   __  ____  __
    (  _ \ /  \‍(  _ \‍(  )
     ) __/(  O )) __// (_/\
    (__)   \__/(__)  \____/
    version 1.2.0
    https://github.com/badaix/popl
 
    This file is part of popl (program options parser lib)
    Copyright (C) 2015-2018 Johannes Pohl
 
    This software may be modified and distributed under the terms
    of the MIT license.  See the 3rdparty/popl/LICENSE file for details.
***/
 
#pragma once
 
#ifndef NOMINMAX
#define NOMINMAX
#endif // NOMINMAX
 
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <vector>
 
 
namespace Piduino {
 
#define POPL_VERSION "1.2.0"
 
 
 
  enum class Argument {
    no = 0,    // option never takes an argument
    required,  // option always requires an argument
    optional   // option may take an argument
  };
 
 
 
  enum class Attribute {
    inactive = 0,
    hidden = 1,
    required = 2,
    optional = 3,
    advanced = 4,
    expert = 5
  };
 
 
 
  enum class OptionName {
    unspecified,
    short_name,
    long_name
  };
 
 
 
  class Option {
      friend class OptionParser;
    public:
      Option (const std::string& short_name, const std::string& long_name, std::string description);
 
      virtual ~Option() = default;
 
      Option (const Option&) = default;
 
      Option (Option &&) = default;
 
      Option& operator= (const Option&) = default;
 
      Option& operator= (Option &&) = default;
 
      char short_name() const;
 
      std::string long_name() const;
 
      std::string name (OptionName what_name, bool with_hypen = false) const;
 
      std::string description() const;
 
      virtual bool get_default (std::ostream& out) const = 0;
 
      void set_attribute (const Attribute& attribute);
 
      Attribute attribute() const;
 
      virtual Argument argument_type() const = 0;
 
      virtual size_t count() const = 0;
 
      virtual bool is_set() const = 0;
 
    protected:
      virtual void parse (OptionName what_name, const char* value) = 0;
 
      virtual void clear() = 0;
 
      std::string short_name_;
      std::string long_name_;
      std::string description_;
      Attribute attribute_;
  };
 
 
 
 
 
  template<class T>
  class Value : public Option {
    public:
      Value (const std::string& short_name, const std::string& long_name, const std::string& description);
 
      Value (const std::string& short_name, const std::string& long_name, const std::string& description, const T& default_val, T* assign_to = nullptr);
 
      size_t count() const override;
      bool is_set() const override;
 
      void assign_to (T* var);
 
      void set_value (const T& value);
 
      T value (size_t idx = 0) const;
 
      void set_default (const T& value);
 
      bool has_default() const;
 
      T get_default() const;
      bool get_default (std::ostream& out) const override;
 
      Argument argument_type() const override;
 
    protected:
      void parse (OptionName what_name, const char* value) override;
      std::unique_ptr<T> default_;
 
      virtual void update_reference();
      virtual void add_value (const T& value);
      void clear() override;
 
      T* assign_to_;
      std::vector<T> values_;
  };
 
 
 
 
 
  template<class T>
  class Implicit : public Value<T> {
    public:
      Implicit (const std::string& short_name, const std::string& long_name, const std::string& description, const T& implicit_val, T* assign_to = nullptr);
 
      Argument argument_type() const override;
 
    protected:
      void parse (OptionName what_name, const char* value) override;
  };
 
 
 
 
 
  class Switch : public Value<bool> {
    public:
      Switch (const std::string& short_name, const std::string& long_name, const std::string& description, bool* assign_to = nullptr);
 
      void set_default (const bool& value) = delete;
      Argument argument_type() const override;
 
    protected:
      void parse (OptionName what_name, const char* value) override;
  };
 
 
 
 
  using Option_ptr = std::shared_ptr<Option>;
 
 
  class OptionParser {
    public:
      explicit OptionParser (std::string description = "");
 
      virtual ~OptionParser() = default;
 
      template<typename T, Attribute attribute, typename... Ts>
      std::shared_ptr<T> add (Ts && ... params);
 
      template<typename T, typename... Ts>
      std::shared_ptr<T> add (Ts && ... params);
 
      void parse (int argc, const char * const argv[]);
 
      std::string help (const Attribute& max_attribute = Attribute::optional) const;
 
      std::string description() const;
 
      const std::vector<Option_ptr>& options() const;
 
      const std::vector<std::string>& non_option_args() const;
 
      const std::vector<std::string>& unknown_options() const;
 
      template<typename T>
      std::shared_ptr<T> get_option (const std::string& long_name) const;
 
      template<typename T>
      std::shared_ptr<T> get_option (char short_name) const;
 
    protected:
      std::vector<Option_ptr> options_;
      std::string description_;
      std::vector<std::string> non_option_args_;
      std::vector<std::string> unknown_options_;
 
      Option_ptr find_option (const std::string& long_name) const;
      Option_ptr find_option (char short_name) const;
  };
 
 
 
  class invalid_option : public std::invalid_argument {
    public:
      enum class Error {
        missing_argument,
        invalid_argument,
        too_many_arguments,
        missing_option
      };
 
      invalid_option (const Option* option, invalid_option::Error error, OptionName what_name, std::string value, const std::string& text) :
        std::invalid_argument (text.c_str()), option_ (option), error_ (error), what_name_ (what_name), value_ (std::move (value)) {
      }
 
      invalid_option (const Option* option, invalid_option::Error error, const std::string& text) :
        invalid_option (option, error, OptionName::unspecified, "", text) {
      }
 
      const Option* option() const {
        return option_;
      }
 
      Error error() const {
        return error_;
      }
 
      OptionName what_name() const {
        return what_name_;
      }
 
      std::string value() const {
        return value_;
      }
 
    private:
      const Option* option_;
      Error error_;
      OptionName what_name_;
      std::string value_;
  };
 
 
 
 
  class OptionPrinter {
    public:
      explicit OptionPrinter (const OptionParser* option_parser) : option_parser_ (option_parser) {
      }
 
      virtual ~OptionPrinter() = default;
 
      virtual std::string print (const Attribute& max_attribute = Attribute::optional) const = 0;
 
    protected:
      const OptionParser* option_parser_;
  };
 
 
 
 
 
  class ConsoleOptionPrinter : public OptionPrinter {
    public:
      explicit ConsoleOptionPrinter (const OptionParser* option_parser);
      ~ConsoleOptionPrinter() override = default;
 
      std::string print (const Attribute& max_attribute = Attribute::optional) const override;
 
    private:
      std::string to_string (Option_ptr option) const;
  };
 
 
 
 
 
  class GroffOptionPrinter : public OptionPrinter {
    public:
      explicit GroffOptionPrinter (const OptionParser* option_parser);
      ~GroffOptionPrinter() override = default;
 
      std::string print (const Attribute& max_attribute = Attribute::optional) const override;
 
    private:
      std::string to_string (Option_ptr option) const;
  };
 
 
 
 
 
  class BashCompletionOptionPrinter : public OptionPrinter {
    public:
      BashCompletionOptionPrinter (const OptionParser* option_parser, std::string program_name);
      ~BashCompletionOptionPrinter() override = default;
 
      std::string print (const Attribute& max_attribute = Attribute::optional) const override;
 
    private:
      std::string program_name_;
  };
 
 
 
 
 
  inline Option::Option (const std::string& short_name, const std::string& long_name, std::string description) :
    short_name_ (short_name),
    long_name_ (long_name),
    description_ (std::move (description)),
    attribute_ (Attribute::optional) {
    if (short_name.size() > 1) {
      throw std::invalid_argument ("length of short name must be <= 1: '" + short_name + "'");
    }
 
    if (short_name.empty() && long_name.empty()) {
      throw std::invalid_argument ("short and long name are empty");
    }
  }
 
 
  inline char Option::short_name() const {
    if (!short_name_.empty()) {
      return short_name_[0];
    }
    return 0;
  }
 
 
  inline std::string Option::long_name() const {
    return long_name_;
  }
 
 
  inline std::string Option::name (OptionName what_name, bool with_hypen) const {
    if (what_name == OptionName::short_name) {
      return short_name_.empty() ? "" : ( (with_hypen ? "-" : "") + short_name_);
    }
    if (what_name == OptionName::long_name) {
      return long_name_.empty() ? "" : ( (with_hypen ? "--" : "") + long_name_);
    }
    return "";
  }
 
 
  inline std::string Option::description() const {
    return description_;
  }
 
 
  inline void Option::set_attribute (const Attribute& attribute) {
    attribute_ = attribute;
  }
 
 
  inline Attribute Option::attribute() const {
    return attribute_;
  }
 
 
 
 
 
  template<class T>
  inline Value<T>::Value (const std::string& short_name, const std::string& long_name, const std::string& description) :
    Option (short_name, long_name, description),
    assign_to_ (nullptr) {
  }
 
 
  template<class T>
  inline Value<T>::Value (const std::string& short_name, const std::string& long_name, const std::string& description, const T& default_val, T* assign_to) :
    Value<T> (short_name, long_name, description) {
    assign_to_ = assign_to;
    set_default (default_val);
  }
 
 
  template<class T>
  inline size_t Value<T>::count() const {
    return values_.size();
  }
 
 
  template<class T>
  inline bool Value<T>::is_set() const {
    return !values_.empty();
  }
 
 
  template<class T>
  inline void Value<T>::assign_to (T* var) {
    assign_to_ = var;
    update_reference();
  }
 
 
  template<class T>
  inline void Value<T>::set_value (const T& value) {
    clear();
    add_value (value);
  }
 
 
  template<class T>
  inline T Value<T>::value (size_t idx) const {
    if (!this->is_set() && default_) {
      return *default_;
    }
 
    if (!is_set() || (idx >= count())) {
      std::stringstream optionStr;
      if (!is_set()) {
        optionStr << "option not set: \"";
      }
      else {
        optionStr << "index out of range (" << idx << ") for \"";
      }
 
      if (short_name() != 0) {
        optionStr << "-" << short_name();
      }
      else {
        optionStr << "--" << long_name();
      }
 
      optionStr << "\"";
      throw std::out_of_range (optionStr.str());
    }
 
    return values_[idx];
  }
 
 
 
  template<class T>
  inline void Value<T>::set_default (const T& value) {
    this->default_.reset (new T);
    *this->default_ = value;
    update_reference();
  }
 
 
  template<class T>
  inline bool Value<T>::has_default() const {
    return (this->default_ != nullptr);
  }
 
 
  template<class T>
  inline T Value<T>::get_default() const {
    if (!has_default()) {
      throw std::runtime_error ("no default value set");
    }
    return *this->default_;
  }
 
 
  template<class T>
  inline bool Value<T>::get_default (std::ostream& out) const {
    if (!has_default()) {
      return false;
    }
    out << *this->default_;
    return true;
  }
 
 
  template<class T>
  inline Argument Value<T>::argument_type() const {
    return Argument::required;
  }
 
 
  template<>
  inline void Value<std::string>::parse (OptionName what_name, const char* value) {
    if (strlen (value) == 0) {
      throw invalid_option (this, invalid_option::Error::missing_argument, what_name, value, "missing argument for " + name (what_name, true));
    }
 
    add_value (value);
  }
 
 
  template<class T>
  inline void Value<T>::parse (OptionName what_name, const char* value) {
    T parsed_value;
    std::string strValue;
    if (value != nullptr) {
      strValue = value;
    }
 
    std::istringstream is (strValue);
    int valuesRead = 0;
    while (is.good()) {
      if (is.peek() != EOF) {
        is >> parsed_value;
      }
      else {
        break;
      }
 
      valuesRead++;
    }
 
    if (is.fail()) {
      throw invalid_option (this, invalid_option::Error::invalid_argument, what_name, value, "invalid argument for " + name (what_name, true) + ": '" + strValue + "'");
    }
 
    if (valuesRead > 1) {
      throw invalid_option (this, invalid_option::Error::too_many_arguments, what_name, value, "too many arguments for " + name (what_name, true) + ": '" + strValue + "'");
    }
 
    if (strValue.empty()) {
      throw invalid_option (this, invalid_option::Error::missing_argument, what_name, "", "missing argument for " + name (what_name, true));
    }
 
    this->add_value (parsed_value);
  }
 
 
  template<class T>
  inline void Value<T>::update_reference() {
    if (this->assign_to_) {
      if (this->is_set() || default_) {
        *this->assign_to_ = value();
      }
    }
  }
 
 
  template<class T>
  inline void Value<T>::add_value (const T& value) {
    values_.push_back (value);
    update_reference();
  }
 
 
  template<class T>
  inline void Value<T>::clear() {
    values_.clear();
    update_reference();
  }
 
 
 
 
  template<class T>
  inline Implicit<T>::Implicit (const std::string& short_name, const std::string& long_name, const std::string& description, const T& implicit_val, T* assign_to) :
    Value<T> (short_name, long_name, description, implicit_val, assign_to) {
  }
 
 
  template<class T>
  inline Argument Implicit<T>::argument_type() const {
    return Argument::optional;
  }
 
 
  template<class T>
  inline void Implicit<T>::parse (OptionName what_name, const char* value) {
    if ( (value != nullptr) && (strlen (value) > 0)) {
      Value<T>::parse (what_name, value);
    }
    else {
      this->add_value (*this->default_);
    }
  }
 
 
 
 
 
  inline Switch::Switch (const std::string& short_name, const std::string& long_name, const std::string& description, bool* assign_to) :
    Value<bool> (short_name, long_name, description, false, assign_to) {
  }
 
 
  inline void Switch::parse (OptionName /*what_name*/, const char* /*value*/) {
    add_value (true);
  }
 
 
  inline Argument Switch::argument_type() const {
    return Argument::no;
  }
 
 
 
 
 
  inline OptionParser::OptionParser (std::string description) : description_ (std::move (description)) {
  }
 
 
  template<typename T, typename... Ts>
  inline std::shared_ptr<T> OptionParser::add (Ts && ... params) {
    return add<T, Attribute::optional> (std::forward<Ts> (params)...);
  }
 
 
  template<typename T, Attribute attribute, typename... Ts>
  inline std::shared_ptr<T> OptionParser::add (Ts && ... params) {
    static_assert (
      std::is_base_of<Option, typename std::decay<T>::type>::value,
      "type T must be Switch, Value or Implicit"
    );
    std::shared_ptr<T> option = std::make_shared<T> (std::forward<Ts> (params)...);
 
    for (const auto & o : options_) {
      if ( (option->short_name() != 0) && (option->short_name() == o->short_name())) {
        throw std::invalid_argument ("duplicate short option name '-" + std::string (1, option->short_name()) + "'");
      }
      if (!option->long_name().empty() && (option->long_name() == (o->long_name()))) {
        throw std::invalid_argument ("duplicate long option name '--" + option->long_name() + "'");
      }
    }
    option->set_attribute (attribute);
    options_.push_back (option);
    return option;
  }
 
 
  inline std::string OptionParser::description() const {
    return description_;
  }
 
 
  inline const std::vector<Option_ptr>& OptionParser::options() const {
    return options_;
  }
 
 
  inline const std::vector<std::string>& OptionParser::non_option_args() const {
    return non_option_args_;
  }
 
 
  inline const std::vector<std::string>& OptionParser::unknown_options() const {
    return unknown_options_;
  }
 
 
  inline Option_ptr OptionParser::find_option (const std::string& long_name) const {
    for (const auto & option : options_)
      if (option->long_name() == long_name) {
        return option;
      }
    return nullptr;
  }
 
 
  inline Option_ptr OptionParser::find_option (char short_name) const {
    for (const auto & option : options_)
      if (option->short_name() == short_name) {
        return option;
      }
    return nullptr;
  }
 
 
  template<typename T>
  inline std::shared_ptr<T> OptionParser::get_option (const std::string& long_name) const {
    Option_ptr option = find_option (long_name);
    if (!option) {
      throw std::invalid_argument ("option not found: " + long_name);
    }
    auto result = std::dynamic_pointer_cast<T> (option);
    if (!result) {
      throw std::invalid_argument ("cannot cast option to T: " + long_name);
    }
    return result;
  }
 
 
  template<typename T>
  inline std::shared_ptr<T> OptionParser::get_option (char short_name) const {
    Option_ptr option = find_option (short_name);
    if (!option) {
      throw std::invalid_argument ("option not found: " + std::string (1, short_name));
    }
    auto result = std::dynamic_pointer_cast<T> (option);
    if (!result) {
      throw std::invalid_argument ("cannot cast option to T: " + std::string (1, short_name));
    }
    return result;
  }
 
 
  inline void OptionParser::parse (int argc, const char * const argv[]) {
    unknown_options_.clear();
    non_option_args_.clear();
    for (auto & opt : options_) {
      opt->clear();
    }
 
    for (int n = 1; n < argc; ++n) {
      const std::string arg (argv[n]);
      if (arg == "--") {
        for (int m = n + 1; m < argc; ++m) {
          non_option_args_.emplace_back (argv[m]);
        }
      }
      else if (arg.find ("--") == 0) {
        std::string opt = arg.substr (2);
        std::string optarg;
        size_t equalIdx = opt.find ('=');
        if (equalIdx != std::string::npos) {
          optarg = opt.substr (equalIdx + 1);
          opt.resize (equalIdx);
        }
 
        Option_ptr option = find_option (opt);
        if (option && (option->attribute() == Attribute::inactive)) {
          option = nullptr;
        }
        if (option) {
          if (option->argument_type() == Argument::no) {
            if (!optarg.empty()) {
              option = nullptr;
            }
          }
          else if (option->argument_type() == Argument::required) {
            if (optarg.empty() && n < argc - 1) {
              optarg = argv[++n];
            }
          }
        }
 
        if (option) {
          option->parse (OptionName::long_name, optarg.c_str());
        }
        else {
          unknown_options_.push_back (arg);
        }
      }
      else if (arg.find ('-') == 0) {
        std::string opt = arg.substr (1);
        bool unknown = false;
        for (size_t m = 0; m < opt.size(); ++m) {
          char c = opt[m];
          std::string optarg;
 
          Option_ptr option = find_option (c);
          if (option && (option->attribute() == Attribute::inactive)) {
            option = nullptr;
          }
          if (option) {
            if (option->argument_type() == Argument::required) {
              optarg = opt.substr (m + 1);
              if (optarg.empty() && n < argc - 1) {
                optarg = argv[++n];
              }
              m = opt.size();
            }
            else if (option->argument_type() == Argument::optional) {
              optarg = opt.substr (m + 1);
              m = opt.size();
            }
          }
 
          if (option) {
            option->parse (OptionName::short_name, optarg.c_str());
          }
          else {
            unknown = true;
          }
        }
        if (unknown) {
          unknown_options_.push_back (arg);
        }
      }
      else {
        non_option_args_.push_back (arg);
      }
    }
 
    for (auto & opt : options_) {
      if ( (opt->attribute() == Attribute::required) && !opt->is_set()) {
        std::string option = opt->long_name().empty() ? std::string (1, opt->short_name()) : opt->long_name();
        throw invalid_option (opt.get(), invalid_option::Error::missing_option, "option \"" + option + "\" is required");
      }
    }
  }
 
 
  inline std::string OptionParser::help (const Attribute& max_attribute) const {
    ConsoleOptionPrinter option_printer (this);
    return option_printer.print (max_attribute);
  }
 
 
 
 
 
  inline ConsoleOptionPrinter::ConsoleOptionPrinter (const OptionParser* option_parser) : OptionPrinter (option_parser) {
  }
 
 
  inline std::string ConsoleOptionPrinter::to_string (Option_ptr option) const {
    std::stringstream line;
    if (option->short_name() != 0) {
      line << "  -" << option->short_name();
      if (!option->long_name().empty()) {
        line << ", ";
      }
    }
    else {
      line << "  ";
    }
    if (!option->long_name().empty()) {
      line << "--" << option->long_name();
    }
 
    if (option->argument_type() == Argument::required) {
      line << " arg";
      std::stringstream defaultStr;
      if (option->get_default (defaultStr)) {
        if (!defaultStr.str().empty()) {
          line << " (=" << defaultStr.str() << ")";
        }
      }
    }
    else if (option->argument_type() == Argument::optional) {
      std::stringstream defaultStr;
      if (option->get_default (defaultStr)) {
        line << " [=arg(=" << defaultStr.str() << ")]";
      }
    }
 
    return line.str();
  }
 
 
  inline std::string ConsoleOptionPrinter::print (const Attribute& max_attribute) const {
    if (option_parser_ == nullptr) {
      return "";
    }
 
    if (max_attribute < Attribute::optional) {
      throw std::invalid_argument ("attribute must be 'optional', 'advanced', or 'default'");
    }
 
    std::stringstream s;
    if (!option_parser_->description().empty()) {
      s << option_parser_->description() << ":\n";
    }
 
    size_t optionRightMargin (20);
    const size_t maxDescriptionLeftMargin (40);
    //  const size_t descriptionRightMargin(80);
 
    for (const auto & option : option_parser_->options()) {
      optionRightMargin = std::max (optionRightMargin, to_string (option).size() + 2);
    }
    optionRightMargin = std::min (maxDescriptionLeftMargin - 2, optionRightMargin);
 
    for (const auto & option : option_parser_->options()) {
      if ( (option->attribute() <= Attribute::hidden) ||
           (option->attribute() > max_attribute)) {
        continue;
      }
      std::string optionStr = to_string (option);
      if (optionStr.size() < optionRightMargin) {
        optionStr.resize (optionRightMargin, ' ');
      }
      else {
        optionStr += "\n" + std::string (optionRightMargin, ' ');
      }
      s << optionStr;
 
      std::string line;
      std::vector<std::string> lines;
      std::stringstream description (option->description());
      while (std::getline (description, line, '\n')) {
        lines.push_back (line);
      }
 
      std::string empty (optionRightMargin, ' ');
      for (size_t n = 0; n < lines.size(); ++n) {
        if (n > 0) {
          s << "\n" << empty;
        }
        s << lines[n];
      }
      s << "\n";
    }
 
    return s.str();
  }
 
 
 
 
 
  inline GroffOptionPrinter::GroffOptionPrinter (const OptionParser* option_parser) : OptionPrinter (option_parser) {
  }
 
 
  inline std::string GroffOptionPrinter::to_string (Option_ptr option) const {
    std::stringstream line;
    if (option->short_name() != 0) {
      line << "-" << option->short_name();
      if (!option->long_name().empty()) {
        line << ", ";
      }
    }
    if (!option->long_name().empty()) {
      line << "--" << option->long_name();
    }
 
    if (option->argument_type() == Argument::required) {
      line << " arg";
      std::stringstream defaultStr;
      if (option->get_default (defaultStr)) {
        if (!defaultStr.str().empty()) {
          line << " (=" << defaultStr.str() << ")";
        }
      }
    }
    else if (option->argument_type() == Argument::optional) {
      std::stringstream defaultStr;
      if (option->get_default (defaultStr)) {
        line << " [=arg(=" << defaultStr.str() << ")]";
      }
    }
 
    return line.str();
  }
 
 
  inline std::string GroffOptionPrinter::print (const Attribute& max_attribute) const {
    if (option_parser_ == nullptr) {
      return "";
    }
 
    if (max_attribute < Attribute::optional) {
      throw std::invalid_argument ("attribute must be 'optional', 'advanced', or 'default'");
    }
 
    std::stringstream s;
    if (!option_parser_->description().empty()) {
      s << ".SS " << option_parser_->description() << ":\n";
    }
 
    for (const auto & option : option_parser_->options()) {
      if ( (option->attribute() <= Attribute::hidden) ||
           (option->attribute() > max_attribute)) {
        continue;
      }
      s << ".TP\n\\fB" << to_string (option) << "\\fR\n";
      if (!option->description().empty()) {
        s << option->description() << "\n";
      }
    }
 
    return s.str();
  }
 
 
 
 
 
  inline BashCompletionOptionPrinter::BashCompletionOptionPrinter (const OptionParser* option_parser, std::string program_name) : OptionPrinter (option_parser), program_name_ (std::move (program_name)) {
  }
 
 
  inline std::string BashCompletionOptionPrinter::print (const Attribute& /*max_attribute*/) const {
    if (option_parser_ == nullptr) {
      return "";
    }
 
    std::stringstream s;
    s << "_" << program_name_ << "()\n";
    s << R"({
      local cur prev opts
      COMPREPLY=()
      cur="$ {COMP_WORDS[COMP_CWORD]}"
      prev="$ {COMP_WORDS[COMP_CWORD - 1]}"
      opts=") ";
 
    for (const auto& option: option_parser_->options())
    {
    if (option->attribute() > Attribute::hidden)
    {
    if (option->short_name() != 0)
    s << " - " << option->short_name() << " ";
    if (!option->long_name().empty())
    s << "--" << option->long_name() << " ";
  }
  }
 
    s << R" ("
             if [[ ${cur} == -* ]] ; then
             COMPREPLY=( $(compgen -W "$ {opts}" -- ${cur}) )
             return 0
             fi
           }
             complete -F )";
    s << "_" << program_name_ << " " << program_name_ << "\n";
 
    return s.str();
  }
 
 
 
 
  static inline std::ostream& operator<< (std::ostream& out, const OptionParser& op) {
    return out << op.help();
  }
 
 
} // namespace Popl