// -*- C++ -*-
//
// This file was generated by CLI, a command line interface
// compiler for C++.
//

#ifndef CLI_OPTIONS_HXX
#define CLI_OPTIONS_HXX

// Begin prologue.
//
//
// End prologue.

#include <deque>
#include <iosfwd>
#include <string>
#include <cstddef>
#include <exception>

namespace cli
{
  class unknown_mode
  {
    public:
    enum value
    {
      skip,
      stop,
      fail
    };

    unknown_mode (value v);

    operator value () const 
    {
      return v_;
    }

    private:
    value v_;
  };

  // Exceptions.
  //

  class exception: public std::exception
  {
    public:
    virtual void
    print (::std::ostream&) const = 0;
  };

  ::std::ostream&
  operator<< (::std::ostream&, const exception&);

  class unknown_option: public exception
  {
    public:
    virtual
    ~unknown_option () throw ();

    unknown_option (const std::string& option);

    const std::string&
    option () const;

    virtual void
    print (::std::ostream&) const;

    virtual const char*
    what () const throw ();

    private:
    std::string option_;
  };

  class unknown_argument: public exception
  {
    public:
    virtual
    ~unknown_argument () throw ();

    unknown_argument (const std::string& argument);

    const std::string&
    argument () const;

    virtual void
    print (::std::ostream&) const;

    virtual const char*
    what () const throw ();

    private:
    std::string argument_;
  };

  class missing_value: public exception
  {
    public:
    virtual
    ~missing_value () throw ();

    missing_value (const std::string& option);

    const std::string&
    option () const;

    virtual void
    print (::std::ostream&) const;

    virtual const char*
    what () const throw ();

    private:
    std::string option_;
  };

  class invalid_value: public exception
  {
    public:
    virtual
    ~invalid_value () throw ();

    invalid_value (const std::string& option,
                   const std::string& value);

    const std::string&
    option () const;

    const std::string&
    value () const;

    virtual void
    print (::std::ostream&) const;

    virtual const char*
    what () const throw ();

    private:
    std::string option_;
    std::string value_;
  };

  class eos_reached: public exception
  {
    public:
    virtual void
    print (::std::ostream&) const;

    virtual const char*
    what () const throw ();
  };

  class file_io_failure: public exception
  {
    public:
    virtual
    ~file_io_failure () throw ();

    file_io_failure (const std::string& file);

    const std::string&
    file () const;

    virtual void
    print (::std::ostream&) const;

    virtual const char*
    what () const throw ();

    private:
    std::string file_;
  };

  class unmatched_quote: public exception
  {
    public:
    virtual
    ~unmatched_quote () throw ();

    unmatched_quote (const std::string& argument);

    const std::string&
    argument () const;

    virtual void
    print (::std::ostream&) const;

    virtual const char*
    what () const throw ();

    private:
    std::string argument_;
  };

  class scanner
  {
    public:
    virtual
    ~scanner ();

    virtual bool
    more () = 0;

    virtual const char*
    peek () = 0;

    virtual const char*
    next () = 0;

    virtual void
    skip () = 0;
  };

  class argv_scanner: public scanner
  {
    public:
    argv_scanner (int& argc, char** argv, bool erase = false);
    argv_scanner (int start, int& argc, char** argv, bool erase = false);

    int
    end () const;

    virtual bool
    more ();

    virtual const char*
    peek ();

    virtual const char*
    next ();

    virtual void
    skip ();

    private:
    int i_;
    int& argc_;
    char** argv_;
    bool erase_;
  };

  class argv_file_scanner: public argv_scanner
  {
    public:
    argv_file_scanner (int& argc,
                       char** argv,
                       const std::string& option,
                       bool erase = false);

    argv_file_scanner (int start,
                       int& argc,
                       char** argv,
                       const std::string& option,
                       bool erase = false);

    struct option_info
    {
      // If search_func is not NULL, it is called, with the arg
      // value as the second argument, to locate the options file.
      // If it returns an empty string, then the file is ignored.
      //
      const char* option;
      std::string (*search_func) (const char*, void* arg);
      void* arg;
    };

    argv_file_scanner (int& argc,
                        char** argv,
                        const option_info* options,
                        std::size_t options_count,
                        bool erase = false);

    argv_file_scanner (int start,
                       int& argc,
                       char** argv,
                       const option_info* options,
                       std::size_t options_count,
                       bool erase = false);

    virtual bool
    more ();

    virtual const char*
    peek ();

    virtual const char*
    next ();

    virtual void
    skip ();

    private:
    const option_info*
    find (const char*) const;

    void
    load (const std::string& file);

    typedef argv_scanner base;

    const std::string option_;
    option_info option_info_;
    const option_info* options_;
    std::size_t options_count_;

    std::string hold_;
    std::deque<std::string> args_;
    bool skip_;
  };

  template <typename X>
  struct parser;
}

#include <map>

#include <string>

#include <vector>

#include <cstddef>

class options
{
  public:
  options ();

  options (int& argc,
           char** argv,
           bool erase = false,
           ::cli::unknown_mode option = ::cli::unknown_mode::fail,
           ::cli::unknown_mode argument = ::cli::unknown_mode::stop);

  options (int start,
           int& argc,
           char** argv,
           bool erase = false,
           ::cli::unknown_mode option = ::cli::unknown_mode::fail,
           ::cli::unknown_mode argument = ::cli::unknown_mode::stop);

  options (int& argc,
           char** argv,
           int& end,
           bool erase = false,
           ::cli::unknown_mode option = ::cli::unknown_mode::fail,
           ::cli::unknown_mode argument = ::cli::unknown_mode::stop);

  options (int start,
           int& argc,
           char** argv,
           int& end,
           bool erase = false,
           ::cli::unknown_mode option = ::cli::unknown_mode::fail,
           ::cli::unknown_mode argument = ::cli::unknown_mode::stop);

  options (::cli::scanner&,
           ::cli::unknown_mode option = ::cli::unknown_mode::fail,
           ::cli::unknown_mode argument = ::cli::unknown_mode::stop);

  // Option accessors.
  //
  const bool&
  help () const;

  const bool&
  version () const;

  const std::vector<std::string>&
  include_path () const;

  const std::string&
  output_dir () const;

  const bool&
  generate_modifier () const;

  const bool&
  generate_specifier () const;

  const bool&
  generate_parse () const;

  const bool&
  generate_description () const;

  const bool&
  generate_file_scanner () const;

  const bool&
  suppress_inline () const;

  const std::string&
  ostream_type () const;

  const bool&
  suppress_undocumented () const;

  const bool&
  suppress_usage () const;

  const bool&
  long_usage () const;

  const bool&
  short_usage () const;

  const std::size_t&
  option_length () const;

  const bool&
  exclude_base () const;

  const std::string&
  cli_namespace () const;

  const bool&
  generate_cxx () const;

  const bool&
  generate_man () const;

  const bool&
  generate_html () const;

  const std::vector<std::string>&
  hxx_prologue () const;

  const std::vector<std::string>&
  ixx_prologue () const;

  const std::vector<std::string>&
  cxx_prologue () const;

  const std::vector<std::string>&
  man_prologue () const;

  const std::vector<std::string>&
  html_prologue () const;

  const std::vector<std::string>&
  hxx_epilogue () const;

  const std::vector<std::string>&
  ixx_epilogue () const;

  const std::vector<std::string>&
  cxx_epilogue () const;

  const std::vector<std::string>&
  man_epilogue () const;

  const std::vector<std::string>&
  html_epilogue () const;

  const std::string&
  hxx_prologue_file () const;

  const std::string&
  ixx_prologue_file () const;

  const std::string&
  cxx_prologue_file () const;

  const std::string&
  man_prologue_file () const;

  const std::string&
  html_prologue_file () const;

  const std::string&
  hxx_epilogue_file () const;

  const std::string&
  ixx_epilogue_file () const;

  const std::string&
  cxx_epilogue_file () const;

  const std::string&
  man_epilogue_file () const;

  const std::string&
  html_epilogue_file () const;

  const std::vector<std::string>&
  class_ () const;

  const bool&
  stdout_ () const;

  const std::string&
  hxx_suffix () const;

  const std::string&
  ixx_suffix () const;

  const std::string&
  cxx_suffix () const;

  const std::string&
  man_suffix () const;

  const std::string&
  html_suffix () const;

  const std::string&
  option_prefix () const;

  const std::string&
  option_separator () const;

  const bool&
  include_with_brackets () const;

  const std::string&
  include_prefix () const;

  const std::string&
  guard_prefix () const;

  const std::map<std::string, std::string>&
  reserved_name () const;

  const std::string&
  options_file () const;

  // Print usage information.
  //
  static void
  print_usage (::std::ostream&);

  // Implementation details.
  //
  protected:
  bool
  _parse (const char*, ::cli::scanner&);

  private:
  void
  _parse (::cli::scanner&,
          ::cli::unknown_mode option,
          ::cli::unknown_mode argument);

  public:
  bool help_;
  bool version_;
  std::vector<std::string> include_path_;
  std::string output_dir_;
  bool generate_modifier_;
  bool generate_specifier_;
  bool generate_parse_;
  bool generate_description_;
  bool generate_file_scanner_;
  bool suppress_inline_;
  std::string ostream_type_;
  bool suppress_undocumented_;
  bool suppress_usage_;
  bool long_usage_;
  bool short_usage_;
  std::size_t option_length_;
  bool exclude_base_;
  std::string cli_namespace_;
  bool generate_cxx_;
  bool generate_man_;
  bool generate_html_;
  std::vector<std::string> hxx_prologue_;
  std::vector<std::string> ixx_prologue_;
  std::vector<std::string> cxx_prologue_;
  std::vector<std::string> man_prologue_;
  std::vector<std::string> html_prologue_;
  std::vector<std::string> hxx_epilogue_;
  std::vector<std::string> ixx_epilogue_;
  std::vector<std::string> cxx_epilogue_;
  std::vector<std::string> man_epilogue_;
  std::vector<std::string> html_epilogue_;
  std::string hxx_prologue_file_;
  std::string ixx_prologue_file_;
  std::string cxx_prologue_file_;
  std::string man_prologue_file_;
  std::string html_prologue_file_;
  std::string hxx_epilogue_file_;
  std::string ixx_epilogue_file_;
  std::string cxx_epilogue_file_;
  std::string man_epilogue_file_;
  std::string html_epilogue_file_;
  std::vector<std::string> class__;
  bool stdout__;
  std::string hxx_suffix_;
  std::string ixx_suffix_;
  std::string cxx_suffix_;
  std::string man_suffix_;
  std::string html_suffix_;
  std::string option_prefix_;
  std::string option_separator_;
  bool include_with_brackets_;
  std::string include_prefix_;
  std::string guard_prefix_;
  std::map<std::string, std::string> reserved_name_;
  std::string options_file_;
};

#include "options.ixx"

// Begin epilogue.
//
//
// End epilogue.

#endif // CLI_OPTIONS_HXX