$NetBSD: patch-az,v 1.1.1.1 2000/08/25 16:15:53 jlam Exp $ --- src/lib/cmdline.h.orig Thu Jan 2 13:33:32 1997 +++ src/lib/cmdline.h @@ -16,16 +16,26 @@ // - Added cmd_description field to CmdLine // - Added exit_handler() and quit() member-functions to CmdLine // - Added ALLOW_PLUS to list of CmdLine configuration flags +// +// 08/16/00 Johnny Lam +// - Wrapped in namespace cmdline +// - Updated to follow ISO C++ standard +// - Add declarations from arglist.h. //-^^--------------------------------------------------------------------- #ifndef _usr_include_cmdline_h #define _usr_include_cmdline_h -class ostream ; -class istream ; +#include +#include + +namespace cmdline { + +class CmdArg ; class CmdLine ; -class CmdArgListIter ; -class CmdArgListList ; + +DECLARE_FIFO_LIST(CmdArgList, CmdArg); +DECLARE_FIFO_LIST(CmdArgListList, CmdArgList); //----------------------------------------------------------------------------- @@ -110,7 +120,7 @@ const char * keyword, const char * value, const char * description, - unsigned syntax_flags =isOPTVALREQ); + unsigned int syntax_flags =isOPTVALREQ); // Create an option that takes no value. // @@ -123,7 +133,7 @@ CmdArg(char optchar, const char * keyword, const char * description, - unsigned syntax_flags =isOPT); + unsigned int syntax_flags =isOPT); // Create a positional argument. // @@ -142,18 +152,18 @@ // CmdArg(const char * value, const char * description, - unsigned syntax_flags =isPOSVALREQ); + unsigned int syntax_flags =isPOSVALREQ); CmdArg(const CmdArg & cp); - virtual ~CmdArg(void); + virtual ~CmdArg(); // over-ride this function to return a non-zero value if you // wish the argument to be ignored (except for usage messages). // virtual int - is_dummy(void); + is_dummy(); // Here is the "primary" function that makes everything work ... // @@ -204,12 +214,12 @@ operator()(const char * & arg, CmdLine & cmd) = 0; // Retrieve the syntax flags for this argument. - unsigned - syntax(void) const { return arg_syntax; } + unsigned int + syntax() const { return arg_syntax; } // Get the flags that say how this argument was specified. - unsigned - flags(void) const { return arg_flags; } + unsigned int + flags() const { return arg_flags; } // Get the sequence number corresponding to the last // time this argument was matched on the command-line. @@ -218,65 +228,65 @@ // will be zero, otherwise it will be 'N' where the last // time this argument was matched, it was the 'N'th argument // encountered. - unsigned - sequence(void) const { return arg_sequence; } + unsigned int + sequence() const { return arg_sequence; } // Get the character (short-option) name of this argument. // Returns '\0' if there isnt one. char - char_name(void) const { return arg_char_name; } + char_name() const { return arg_char_name; } // Get the keyword (long-option) name of this argument // Returns NULL if there isnt one. const char * - keyword_name(void) const { return arg_keyword_name; } + keyword_name() const { return arg_keyword_name; } // Get the value name of this argument. // Returns NULL if this argument takes no value. const char * - value_name(void) const { return arg_value_name; } + value_name() const { return arg_value_name; } // Get the description (help-message) of this argument. const char * - description(void) const { return arg_description; } + description() const { return arg_description; } // If we were compiled for dubugging, then dump this argument virtual void - dump(ostream & os, unsigned level =0) const; + dump(std::ostream & os, unsigned int level =0) const; private: // Member functions for internal use void - adjust_syntax(void); + adjust_syntax(); void - parse_description(void); + parse_description(); void - parse_value(void); + parse_value(); void - flags(unsigned newflags) { arg_flags = newflags; } + flags(unsigned int newflags) { arg_flags = newflags; } void - set(unsigned flags) { arg_flags |= flags; } + set(unsigned int flags) { arg_flags |= flags; } void - clear(unsigned flags =~0) { arg_flags &= ~flags; } + clear(unsigned int flags =~0) { arg_flags &= ~flags; } // set sequence number void - sequence(unsigned num) { arg_sequence = num; } + sequence(unsigned int num) { arg_sequence = num; } // Private data members - unsigned alloc_value_name : 1 ; + unsigned int alloc_value_name : 1 ; - unsigned arg_flags : 8 ; - unsigned arg_syntax : 8 ; + unsigned int arg_flags : 8 ; + unsigned int arg_syntax : 8 ; - unsigned arg_sequence; + unsigned int arg_sequence; char arg_char_name; const char * arg_keyword_name; @@ -293,19 +303,19 @@ // class CmdLineArgIter { public: - CmdLineArgIter(void); + CmdLineArgIter(); - virtual ~CmdLineArgIter(void); + virtual ~CmdLineArgIter(); // Return the current argument and advance to the next one. // Returns NULL if we are already at the end of the arguments // virtual const char * - operator()(void) = 0; + operator()() = 0; // Are the args returned by operator() pointing to temporary storage? virtual int - is_temporary(void) const = 0; + is_temporary() const = 0; private: CmdLineArgIter(const CmdLineArgIter &) ; @@ -326,14 +336,14 @@ CmdArgvIter(const char * const argv[]) : array(argv), index(0), count(-1) {} - virtual ~CmdArgvIter(void); + virtual ~CmdArgvIter(); virtual const char * - operator()(void); + operator()(); // is_temporary returns 0 for CmdArgvIter virtual int - is_temporary(void) const; + is_temporary() const; // Restart using a different string array. void @@ -367,10 +377,10 @@ public: CmdStrTokIter(const char * tokens, const char * delimiters =0); - virtual ~CmdStrTokIter(void); + virtual ~CmdStrTokIter(); virtual const char * - operator()(void); + operator()(); // Reset using a new token-string and delimiter set. void @@ -378,7 +388,7 @@ // Get the current delimiter set const char * - delimiters(void) const { return seps; } + delimiters() const { return seps; } // Change the current delimiter set void @@ -386,7 +396,7 @@ // is_temporary returns 1 for CmdStrTokIter virtual int - is_temporary(void) const; + is_temporary() const; private: CmdStrTokIter(const CmdStrTokIter &) ; @@ -411,21 +421,21 @@ // class CmdIstreamIter : public CmdLineArgIter { public: - static const unsigned MAX_LINE_LEN ; + static const unsigned int MAX_LINE_LEN ; - CmdIstreamIter(istream & input); + CmdIstreamIter(std::istream & input); - virtual ~CmdIstreamIter(void); + virtual ~CmdIstreamIter(); virtual const char * - operator()(void); + operator()(); // is_temporary returns 1 for CmdIstreamIter virtual int - is_temporary(void) const; + is_temporary() const; private: - istream & is ; + std::istream & is ; CmdStrTokIter * tok_iter ; } ; @@ -496,11 +506,11 @@ CmdLine(CmdArg * cmdarg1 ...); // last arg should be NULL - virtual ~CmdLine(void); + virtual ~CmdLine(); // Get the command name. const char * - name(void) const { return cmd_name; } + name() const { return cmd_name; } // Specify a command name. void @@ -508,7 +518,7 @@ // Get the command description. const char * - description(void) const { return cmd_description; } + description() const { return cmd_description; } // Specify a command description. void @@ -548,11 +558,11 @@ } ; // Print usage on the given output stream using the given verboseness - ostream & - usage(ostream & os, CmdUsageLevel level =DEFAULT_USAGE) const ; + std::ostream & + usage(std::ostream & os, CmdUsageLevel level =DEFAULT_USAGE) const ; // Print usage on the CmdLine's error-outstream - ostream & + std::ostream & usage(CmdUsageLevel level =DEFAULT_USAGE) const ; // Obtain the current status of the command. The status will be @@ -560,8 +570,8 @@ // to a combination of CmdStatus bitmasks telling us precisely // what went wrong. // - unsigned - status(void) const { return cmd_status; } + unsigned int + status() const { return cmd_status; } // Print an error message prefix on the error output stream // associated with this command. The prefix printed is the @@ -577,8 +587,8 @@ // (which may be useful if you wish only to obtain a reference // this CmdLine's error-outstream). // - ostream & - error(unsigned quiet =0) const; + std::ostream & + error(unsigned int quiet =0) const; // If the QUIET-flag is not set, then we need to know where // to print any error messages (the default is cerr). @@ -587,27 +597,27 @@ // for error messages. // void - error(ostream & os) { cmd_err = &os; } + error(std::ostream & os) { cmd_err = &os; } // // Get & set the command-parsing-flags // // Get the current set of command-flags - unsigned - flags(void) const { return cmd_flags; } + unsigned int + flags() const { return cmd_flags; } // Specify a new set of command-flags void - flags(unsigned newflags) { cmd_flags = newflags; } + flags(unsigned int newflags) { cmd_flags = newflags; } // Set only the given command-flags void - set(unsigned flags) { cmd_flags |= flags; } + set(unsigned int flags) { cmd_flags |= flags; } // Clear only the given command-flags void - clear(unsigned flags =~0) { cmd_flags &= ~flags; } + clear(unsigned int flags =~0) { cmd_flags &= ~flags; } // // We are somewhat flexible in the way we parse arguments. @@ -632,33 +642,33 @@ // enum { NO_PROCESSING = 0, AUTO_PROCESSING = 1 } ; - unsigned + unsigned int parse(CmdLineArgIter & arg_iter, int processing =AUTO_PROCESSING) ; // Perform the necessary pre-processing. // Return the resultant command status. // - unsigned - prologue(void) ; + unsigned int + prologue() ; // Parse a single argument (pre- and post- processing is // NOT performed). // - unsigned + unsigned int parse_arg(const char * arg) ; // Perform the necessary post-processing. // Return the resultant command status. // - unsigned - epilogue(void) ; + unsigned int + epilogue() ; // // Find out the number of arguments parsed so far // - unsigned - nargs_parsed(void) const { return cmd_nargs_parsed; } + unsigned int + nargs_parsed() const { return cmd_nargs_parsed; } // // Exception handling (well -- not really) @@ -685,7 +695,7 @@ // Get the current quit-handler (returns NULL if there isnt one) // quit_func_t - quit_handler(void) const { return cmd_quit_handler; } + quit_handler() const { return cmd_quit_handler; } // @@ -714,16 +724,16 @@ // // get the release number - static unsigned - release(void); + static unsigned int + release(); // get the patchlevel number - static unsigned - patchlevel(void); + static unsigned int + patchlevel(); // get the SCCS identifier string static const char * - ident(void); + ident(); // // These next few functions are used internally but are general @@ -740,7 +750,7 @@ // partial-match, and str_NONE otherwise. // static strmatch_t - strmatch(const char * src, const char * attempt, unsigned len =0); + strmatch(const char * src, const char * attempt, unsigned int len =0); // Print a hanging indented paragraph on an outstream. Long lines // are broken at word boundaries and are wrapped to line up with @@ -753,12 +763,12 @@ // is the second sentence. etc ... // static void - strindent(ostream & os, - unsigned maxcols, - unsigned margin, - const char * title, - unsigned indent, - const char * text); + strindent(std::ostream & os, + unsigned int maxcols, + unsigned int margin, + const char * title, + unsigned int indent, + const char * text); // // Debugging stuff ... @@ -766,24 +776,24 @@ // If we were compiled for dubugging, then dump this command virtual void - dump(ostream & os, unsigned level =0) const; + dump(std::ostream & os, unsigned int level =0) const; // If we were compiled for dubugging, then dump the argument list virtual void - dump_args(ostream & os, unsigned level =0) const; + dump_args(std::ostream & os, unsigned int level =0) const; private: // Private data members - unsigned cmd_parse_state : 8 ; - unsigned cmd_state : 8 ; - unsigned cmd_flags : 16 ; - unsigned cmd_status : 16 ; - unsigned cmd_nargs_parsed ; + unsigned int cmd_parse_state : 8 ; + unsigned int cmd_state : 8 ; + unsigned int cmd_flags : 16 ; + unsigned int cmd_status : 16 ; + unsigned int cmd_nargs_parsed ; const char * cmd_name ; const char * cmd_description ; CmdArg * cmd_matched_arg ; CmdArgListList * cmd_args ; - ostream * cmd_err ; + std::ostream * cmd_err ; quit_func_t cmd_quit_handler ; // Disallow copying and assignment @@ -803,16 +813,16 @@ handle_arg(CmdArg * cmdarg, const char * & arg); void - ck_need_val(void); + ck_need_val(); CmdLineSyntax - syntax(void) const; + syntax() const; - unsigned + unsigned int prompt_user(CmdArg * cmdarg); - unsigned - missing_args(void); + unsigned int + missing_args(); CmdArg * opt_match(char optchar) const; @@ -824,47 +834,47 @@ int match_value =0) const; CmdArg * - pos_match(void) const; + pos_match() const; - unsigned + unsigned int parse_option(const char * arg); - unsigned + unsigned int parse_keyword(const char * arg); - unsigned + unsigned int parse_value(const char * arg); - ostream & + std::ostream & arg_error(const char * error_str, const CmdArg * cmdarg) const; - unsigned + unsigned int fmt_arg(const CmdArg * cmdarg, char * buf, - unsigned bufsize, + unsigned int bufsize, CmdLineSyntax syntax, CmdUsageLevel level) const; static CmdUsageLevel - get_usage_level(void); + get_usage_level(); - unsigned - print_synopsis(CmdLineSyntax syntax, - ostream & os, - int cols) const; + unsigned int + print_synopsis(CmdLineSyntax syntax, + std::ostream & os, + int cols) const; void print_descriptions(CmdLineSyntax syntax, - ostream & os, + std::ostream & os, int cols, - unsigned longest) const; + unsigned int longest) const; } ; // "os << cmd" is equivalent to "cmd.usage(os)" -inline ostream & -operator <<(ostream & os, CmdLine & cmd) { return cmd.usage(os); } +inline std::ostream & +operator <<(std::ostream & os, CmdLine & cmd) { return cmd.usage(os); } //----------------------------------------------------------------------------- @@ -879,13 +889,13 @@ CmdLineCmdArgIter(CmdLine * cmd); - virtual ~CmdLineCmdArgIter(void); + virtual ~CmdLineCmdArgIter(); // Return the current argument and advance to the next one. // Returns NULL if we are already at the end of the list. // CmdArg * - operator()(void); + operator()(); private: CmdLineCmdArgIter(const CmdLineCmdArgIter &); @@ -895,5 +905,7 @@ CmdArgListIter * iter; } ; + +} // namespace cmdline #endif /* _usr_include_cmdline_h */