Gnash  0.8.11dev
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 
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)
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: