Gnash
0.8.11dev
Main Page
Related Pages
Namespaces
Classes
Files
Examples
File List
File Members
libbase
arg_parser.h
Go to the documentation of this file.
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, 2011, 2012 Free Software Foundation, Inc.
4
//
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.
9
//
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.
14
//
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/>.
17
//
18
//
19
// Arg_parser reads the arguments in `argv' and creates a number of
20
// option codes, option arguments and non-option arguments.
21
//
22
// In case of error, `error' returns a non-empty error message.
23
//
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
27
// long-only option.
28
//
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.
34
//
35
// The argument `--' terminates all options; any following arguments are
36
// treated as non-option arguments, even if they begin with a hyphen.
37
//
38
// The syntax for optional option arguments is `-<short_option><argument>'
39
// (without whitespace), or `--<long_option>=<argument>'.
40
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
46
// happen. <bwy>
47
48
#include "
dsodefs.h
"
49
#include <vector>
50
#include <sstream>
51
52
class
Arg_parser
53
{
54
public
:
55
enum
Has_arg
{
no
,
yes
,
maybe
};
56
57
struct
Option
58
{
59
int
code
;
// Short option letter or code ( code != 0 )
60
const
char
*
name
;
// Long option name (maybe null)
61
Has_arg
has_arg
;
62
};
63
64
class
ArgParserException
:
public
std::exception
65
{
66
public
:
67
ArgParserException
(
const
std::string&
s
)
68
:
69
_msg(s)
70
{}
71
72
virtual
~ArgParserException
() throw() {}
73
74
const
char
*
what
()
const
throw() {
return
_msg.c_str(); }
75
76
private
:
77
78
std::string _msg;
79
};
80
81
private
:
82
struct
Record
83
{
84
int
code
;
85
std::string
argument
;
86
Record(
const
int
c
= 0 ) :
code
(
c
) {}
87
};
88
89
std::string _error;
90
std::vector< Record > data;
91
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
();
96
97
public
:
98
DSOEXPORT
Arg_parser
(
const
int
argc,
const
char
*
const
argv[],
99
const
Option options[],
const
bool
in_order =
false
) throw();
100
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();
104
105
const std::
string
&
error
() const throw() {
return
_error; }
106
107
// The number of arguments parsed (may be different from argc)
108
int
arguments
()
const
throw() {
return
data.size(); }
109
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
()
113
{
114
if
(
i
>= 0 &&
i
<
arguments
() )
return
data[
i
].code;
115
else
return
0;
116
}
117
118
std::string
argument
(
const
int
i
)
const
throw
(
ArgParserException
)
119
{
120
if
(
i
>= 0 &&
i
<
arguments
() )
return
data[
i
].argument;
121
else
return
_error;
122
}
123
124
template
<
typename
T>
125
T
argument
(
const
int
i
)
const
throw
(
ArgParserException
)
126
{
127
T
t
= 0;
128
if
(
i
>= 0 &&
i
<
arguments
() )
129
{
130
std::istringstream in(data[
i
].
argument
);
131
in >>
t
;
132
return
t
;
133
}
134
else
throw
ArgParserException
(
"Code out of range"
);
135
}
136
};
137
138
139
// local Variables:
140
// mode: C++
141
// indent-tabs-mode: t
142
// End:
Generated on Wed Jan 22 2014 22:47:18 for Gnash by
1.8.1.2