cmdline.h

Go to the documentation of this file.

/*******************************************************************\
 
Module:
 
Author: Daniel Kroening, kroening@kroening.com
 
\*******************************************************************/
 
 
#ifndef CPROVER_UTIL_CMDLINE_H
#define CPROVER_UTIL_CMDLINE_H
 
#include <limits>
#include <list>
#include <optional>
#include <string>
#include <vector>
 
class cmdlinet
{
public:
  virtual bool parse(int argc, const char **argv, const char *optstring);
 
  std::string get_value(char option) const;
  std::string get_value(const char *option) const;
 
  std::optional<std::string> value_opt(char option) const;
  std::optional<std::string> value_opt(const char *option) const;
 
  const std::list<std::string> &get_values(const std::string &option) const;
  const std::list<std::string> &get_values(char option) const;
 
  std::list<std::string> get_comma_separated_values(const char *option) const;
 
  virtual bool isset(char option) const;
  virtual bool isset(const char *option) const;
  virtual void set(const std::string &option, bool value = true);
  virtual void set(const std::string &option, const std::string &value);
  virtual void set(const std::string &option, const char *value)
  {
    set(option, std::string{value});
  }
 
  virtual void clear();
 
  bool has_option(const std::string &option) const
  {
    return getoptnr(option).has_value();
  }
 
  struct option_namest
  {
    explicit option_namest(const cmdlinet &command_line);
    struct option_names_iteratort
    {
      // These types are defined such that the class is compatible with being
      // treated as an STL iterator. For this to work, they must not be renamed.
      using iterator_category = std::forward_iterator_tag;
      using value_type = std::string;
      using difference_type = std::ptrdiff_t;
      using pointer = const std::string *;
      using reference = const std::string &;
 
      option_names_iteratort() = default;
      explicit option_names_iteratort(
        const cmdlinet *command_line,
        std::size_t index);
      option_names_iteratort(const option_names_iteratort &other) = default;
      option_names_iteratort(option_names_iteratort &&other) = default;
      option_names_iteratort &
      operator=(const option_names_iteratort &) = default;
      option_names_iteratort &operator=(option_names_iteratort &&) = default;
 
      option_names_iteratort &operator++();
      const option_names_iteratort operator++(int);
      const std::string &operator*();
 
      bool operator==(const option_names_iteratort &other);
      bool operator!=(const option_names_iteratort &other);
 
    private:
      const cmdlinet *command_line = nullptr;
      std::size_t index = std::numeric_limits<std::size_t>::max();
      bool is_valid_index() const;
      void goto_next_valid_index();
    };
    option_names_iteratort begin();
    option_names_iteratort end();
 
  private:
    const cmdlinet &command_line;
  };
 
  option_namest option_names() const;
 
  typedef std::vector<std::string> argst;
  argst args;
  std::string unknown_arg;
 
  cmdlinet();
  virtual ~cmdlinet();
 
  std::vector<std::string>
  get_argument_suggestions(const std::string &unknown_argument);
 
protected:
  struct optiont
  {
    bool isset;
    bool hasval;
    bool islong;
    char optchar;
    std::string optstring;
    std::list<std::string> values;
  public:
    optiont():
      isset(false),
      hasval(false),
      islong(false),
      optchar(0)
    {}
  };
 
  void parse_optstring(const char *optstring);
 
  bool parse_arguments(int argc, const char **argv);
 
  std::vector<optiont> options;
 
  std::optional<std::size_t> getoptnr(char option) const;
  std::optional<std::size_t> getoptnr(const std::string &option) const;
};
 
#endif // CPROVER_UTIL_CMDLINE_H