1 // Arg_parser - A POSIX/GNU command line argument parser.
2 // Copyright (C) 2006, 2007, 2008, 2009, 2010 Antonio Diaz Diaz.
3 // Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
5 // This program is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
15 // You should have received a copy of the GNU General Public License
16 // along with this program. If not, see <http://www.gnu.org/licenses/>.
19 // Arg_parser reads the arguments in `argv' and creates a number of
20 // option codes, option arguments and non-option arguments.
22 // In case of error, `error' returns a non-empty error message.
24 // `options' is an array of `struct Option' terminated by an element
25 // containing a code which is zero. A null name means a short-only
26 // option. A code value outside the unsigned char range means a
29 // Arg_parser normally makes it appear as if all the option arguments
30 // were specified before all the non-option arguments for the purposes
31 // of parsing, even if the user of your program intermixed option and
32 // non-option arguments. If you want the arguments in the exact order
33 // the user typed them, call `Arg_parser' with `in_order' = true.
35 // The argument `--' terminates all options; any following arguments are
36 // treated as non-option arguments, even if they begin with a hyphen.
38 // The syntax for optional option arguments is `-<short_option><argument>'
39 // (without whitespace), or `--<long_option>=<argument>'.
41 // This class has been modified with a templated parser.argument<>
42 // method, allowing typesafe handling of different return types, and
43 // saving using strto* on the user side. I've added an exception class
44 // because I'd like to know if we call an argument outside the range
45 // of argument - there's no reasonable situation in which that would
55 enum Has_arg
{ no
, yes
, maybe
};
59 int code
; // Short option letter or code ( code != 0 )
60 const char * name
; // Long option name (maybe null)
64 class ArgParserException
: public std::exception
67 ArgParserException(const std::string
& s
)
72 virtual ~ArgParserException() throw() {}
74 const char* what() const throw() { return _msg
.c_str(); }
86 Record( const int c
= 0 ) : code( c
) {}
90 std::vector
< Record
> data
;
92 bool parse_long_option( const char * const opt
, const char * const arg
,
93 const Option options
[], int & argind
) throw();
94 bool parse_short_option( const char * const opt
, const char * const arg
,
95 const Option options
[], int & argind
) throw();
98 DSOEXPORT
Arg_parser( const int argc
, const char * const argv
[],
99 const Option options
[], const bool in_order
= false ) throw();
101 // Restricted constructor. Parses a single token and argument (if any)
102 DSOEXPORT
Arg_parser( const char * const opt
, const char * const arg
,
103 const Option options
[] ) throw();
105 const std::string
& error() const throw() { return _error
; }
107 // The number of arguments parsed (may be different from argc)
108 int arguments() const throw() { return data
.size(); }
110 // If code( i ) is 0, argument( i ) is a non-option.
111 // Else argument( i ) is the option's argument (or empty).
112 int code( const int i
) const throw()
114 if( i
>= 0 && i
< arguments() ) return data
[i
].code
;
118 std::string
argument(const int i
) const throw(ArgParserException
)
120 if( i
>= 0 && i
< arguments() ) return data
[i
].argument
;
125 T
argument(const int i
) const throw (ArgParserException
)
128 if( i
>= 0 && i
< arguments() )
130 std::istringstream
in(data
[i
].argument
);
134 else throw ArgParserException("Code out of range");
141 // indent-tabs-mode: t