path: root/libbuild2/b-options.hxx

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

#ifndef LIBBUILD2_B_OPTIONS_HXX
#define LIBBUILD2_B_OPTIONS_HXX

// Begin prologue.
//
#include <libbuild2/export.hxx>
//
// End prologue.

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

#ifndef CLI_POTENTIALLY_UNUSED
#  if defined(_MSC_VER) || defined(__xlC__)
#    define CLI_POTENTIALLY_UNUSED(x) (void*)&x
#  else
#    define CLI_POTENTIALLY_UNUSED(x) (void)x
#  endif
#endif

namespace build2
{
  namespace build
  {
    namespace cli
    {
      class usage_para
      {
        public:
        enum value
        {
          none,
          text,
          option
        };

        usage_para (value);

        operator value () const 
        {
          return v_;
        }

        private:
        value v_;
      };

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

        unknown_mode (value);

        operator value () const 
        {
          return v_;
        }

        private:
        value v_;
      };

      // Exceptions.
      //

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

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

      class LIBBUILD2_SYMEXPORT 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 LIBBUILD2_SYMEXPORT 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 LIBBUILD2_SYMEXPORT 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 LIBBUILD2_SYMEXPORT invalid_value: public exception
      {
        public:
        virtual
        ~invalid_value () throw ();

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

        const std::string&
        option () const;

        const std::string&
        value () const;

        const std::string&
        message () const;

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

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

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

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

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

      class LIBBUILD2_SYMEXPORT 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 LIBBUILD2_SYMEXPORT 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_;
      };

      // Command line argument scanner interface.
      //
      // The values returned by next() are guaranteed to be valid
      // for the two previous arguments up until a call to a third
      // peek() or next().
      //
      // The position() function returns a monotonically-increasing
      // number which, if stored, can later be used to determine the
      // relative position of the argument returned by the following
      // call to next(). Note that if multiple scanners are used to
      // extract arguments from multiple sources, then the end
      // position of the previous scanner should be used as the
      // start position of the next.
      //
      class LIBBUILD2_SYMEXPORT scanner
      {
        public:
        virtual
        ~scanner ();

        virtual bool
        more () = 0;

        virtual const char*
        peek () = 0;

        virtual const char*
        next () = 0;

        virtual void
        skip () = 0;

        virtual std::size_t
        position () = 0;
      };

      class LIBBUILD2_SYMEXPORT argv_scanner: public scanner
      {
        public:
        argv_scanner (int& argc,
                      char** argv,
                      bool erase = false,
                      std::size_t start_position = 0);

        argv_scanner (int start,
                      int& argc,
                      char** argv,
                      bool erase = false,
                      std::size_t start_position = 0);

        int
        end () const;

        virtual bool
        more ();

        virtual const char*
        peek ();

        virtual const char*
        next ();

        virtual void
        skip ();

        virtual std::size_t
        position ();

        protected:
        std::size_t start_position_;
        int i_;
        int& argc_;
        char** argv_;
        bool erase_;
      };

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

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

        argv_file_scanner (const std::string& file,
                           const std::string& option,
                           std::size_t start_position = 0);

        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,
                            std::size_t start_position = 0);

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

        argv_file_scanner (const std::string& file,
                           const option_info* options = 0,
                           std::size_t options_count = 0,
                           std::size_t start_position = 0);

        virtual bool
        more ();

        virtual const char*
        peek ();

        virtual const char*
        next ();

        virtual void
        skip ();

        virtual std::size_t
        position ();

        // Return the file path if the peeked at argument came from a file and
        // the empty string otherwise. The reference is guaranteed to be valid
        // till the end of the scanner lifetime.
        //
        const std::string&
        peek_file ();

        // Return the 1-based line number if the peeked at argument came from
        // a file and zero otherwise.
        //
        std::size_t
        peek_line ();

        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_;

        struct arg
        {
          std::string value;
          const std::string* file;
          std::size_t line;
        };

        std::deque<arg> args_;
        std::list<std::string> files_;

        // Circular buffer of two arguments.
        //
        std::string hold_[2];
        std::size_t i_;

        bool skip_;

        static int zero_argc_;
        static std::string empty_string_;
      };

      template <typename X>
      struct parser;
    }
  }
}

#include <set>

#include <libbuild2/types.hxx>

namespace build2
{
  class LIBBUILD2_SYMEXPORT options
  {
    public:
    options ();

    // Return true if anything has been parsed.
    //
    bool
    parse (int& argc,
           char** argv,
           bool erase = false,
           ::build2::build::cli::unknown_mode option = ::build2::build::cli::unknown_mode::fail,
           ::build2::build::cli::unknown_mode argument = ::build2::build::cli::unknown_mode::stop);

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

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

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

    bool
    parse (::build2::build::cli::scanner&,
           ::build2::build::cli::unknown_mode option = ::build2::build::cli::unknown_mode::fail,
           ::build2::build::cli::unknown_mode argument = ::build2::build::cli::unknown_mode::stop);

    // Merge options from the specified instance appending/overriding
    // them as if they appeared after options in this instance.
    //
    void
    merge (const options&);

    // Option accessors.
    //
    const uint64_t&
    build2_metadata () const;

    bool
    build2_metadata_specified () const;

    const bool&
    v () const;

    const bool&
    V () const;

    const bool&
    quiet () const;

    const bool&
    silent () const;

    const uint16_t&
    verbose () const;

    bool
    verbose_specified () const;

    const bool&
    stat () const;

    const std::set<string>&
    dump () const;

    bool
    dump_specified () const;

    const bool&
    progress () const;

    const bool&
    no_progress () const;

    const size_t&
    jobs () const;

    bool
    jobs_specified () const;

    const size_t&
    max_jobs () const;

    bool
    max_jobs_specified () const;

    const size_t&
    queue_depth () const;

    bool
    queue_depth_specified () const;

    const string&
    file_cache () const;

    bool
    file_cache_specified () const;

    const size_t&
    max_stack () const;

    bool
    max_stack_specified () const;

    const bool&
    serial_stop () const;

    const bool&
    dry_run () const;

    const bool&
    match_only () const;

    const bool&
    no_external_modules () const;

    const bool&
    structured_result () const;

    const bool&
    mtime_check () const;

    const bool&
    no_mtime_check () const;

    const bool&
    no_column () const;

    const bool&
    no_line () const;

    const path&
    buildfile () const;

    bool
    buildfile_specified () const;

    const path&
    config_guess () const;

    bool
    config_guess_specified () const;

    const path&
    config_sub () const;

    bool
    config_sub_specified () const;

    const string&
    pager () const;

    bool
    pager_specified () const;

    const strings&
    pager_option () const;

    bool
    pager_option_specified () const;

    const string&
    options_file () const;

    bool
    options_file_specified () const;

    const dir_path&
    default_options () const;

    bool
    default_options_specified () const;

    const bool&
    no_default_options () const;

    const bool&
    help () const;

    const bool&
    version () const;

    // Print usage information.
    //
    static ::build2::build::cli::usage_para
    print_usage (::std::ostream&,
                 ::build2::build::cli::usage_para = ::build2::build::cli::usage_para::none);

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

    private:
    bool
    _parse (::build2::build::cli::scanner&,
            ::build2::build::cli::unknown_mode option,
            ::build2::build::cli::unknown_mode argument);

    public:
    uint64_t build2_metadata_;
    bool build2_metadata_specified_;
    bool v_;
    bool V_;
    bool quiet_;
    bool silent_;
    uint16_t verbose_;
    bool verbose_specified_;
    bool stat_;
    std::set<string> dump_;
    bool dump_specified_;
    bool progress_;
    bool no_progress_;
    size_t jobs_;
    bool jobs_specified_;
    size_t max_jobs_;
    bool max_jobs_specified_;
    size_t queue_depth_;
    bool queue_depth_specified_;
    string file_cache_;
    bool file_cache_specified_;
    size_t max_stack_;
    bool max_stack_specified_;
    bool serial_stop_;
    bool dry_run_;
    bool match_only_;
    bool no_external_modules_;
    bool structured_result_;
    bool mtime_check_;
    bool no_mtime_check_;
    bool no_column_;
    bool no_line_;
    path buildfile_;
    bool buildfile_specified_;
    path config_guess_;
    bool config_guess_specified_;
    path config_sub_;
    bool config_sub_specified_;
    string pager_;
    bool pager_specified_;
    strings pager_option_;
    bool pager_option_specified_;
    string options_file_;
    bool options_file_specified_;
    dir_path default_options_;
    bool default_options_specified_;
    bool no_default_options_;
    bool help_;
    bool version_;
  };
}

// Print page usage information.
//
namespace build2
{
  LIBBUILD2_SYMEXPORT ::build2::build::cli::usage_para
  print_b_usage (::std::ostream&,
                 ::build2::build::cli::usage_para = ::build2::build::cli::usage_para::none);
}

#include <libbuild2/b-options.ixx>

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

#endif // LIBBUILD2_B_OPTIONS_HXX