1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// This may look like C, but it's really -*- C++ -*-
// $Id$
// ========================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// Arg_Shifter.h
//
// = AUTHOR
// Seth Widoff
//
// ========================================================================
#ifndef ACE_ARG_SHIFTER_H
#define ACE_ARG_SHIFTER_H
#include "ace/OS.h"
class ACE_Export ACE_Arg_Shifter
{
// = TITLE
// This ADT shifts known args to the back of the argv vector, so
// deeper levels of argument parsing can locate the yet
// unprocessed arguments at the beginning of the vector.
//
// = DESCRIPTION
// The <ACE_Arg_Shifter> copies the pointers of the argv vector
// into a temporary array. As the <ACE_Arg_Shifter> iterates over
// the temp, is places known arguments in the rear of the argv
// and unknown ones in the beginning. So, after having visited
// all the arguments in the temp vector, <ACE_Arg_Shifter> has
// placed all the unknown arguments in their original order at
// the front of argv.
public:
// = Initialization and termination methods.
ACE_Arg_Shifter (int& argc,
char** argv,
char** temp = 0);
// Initialize the <ACE_Arg_Shifter> to the vector over which to
// iterate, also providing the temporary array if the client doesn't
// want the arg_shifter to dynamically allocate its own. If internal
// dynamic allocation fails, the <ACE_Arg_Shifter> will set all the
// indices to the end of the vector, forbidding iteration. Following
// iteration over argv, the argc value will contain the number of
// unconsumed arguments.
~ACE_Arg_Shifter (void);
// Destructor.
char* get_current (void) const;
// Get the current head of the vector.
char* is_or_contains_ignore_case(const char* flag);
// Check if the current argument matches <flag>
//
// An argument matches if:
// - it STARTS with <flag>
// - any character may appear after the flag including
// - digits, spaces, characters or nothing at all
// - match is case insensitive.
// - ie: "-Foobar" "-FOOBAR" "-fOobAr" "-foobarVALUE"
// - all match the <flag> "-FooBar"
//
// If there is NOT a match, nil is returned
//
// If there IS a match:
// An attempt is made to return the <flag>'s parameter (or 'value')
//
// Case A: value is separated from flag with a space:
// Arg_Shifter calls consume_arg() (<flag>) and advances to the next arg
// If the new current argument passes is_parameter_next()
// - we return the 'new' current argument, ('value')
// else, we return nil
//
// Case B: value is mangled together with flag: ie: "-fooBarVALUE"
// A char* is returned - pointing to VALUE
//
// This operation consumes the current argument if:
// - there is a match &&
// - and the value for the flag is separated from the flag with a space.
// This operation does not consume the current argument if:
// - there is a match but
// - there is no space separating the value from the flag "-FooBarVALUE"
//
// This method is safe to call without checking for a valid
// current argument.
int consume_arg (int number = 1);
// Consume <number> argument(s) by sticking them/it on the end of
// the vector.
int ignore_arg (int number = 1);
// Place <number> arguments in the same relative order ahead of the
// known arguemnts in the vector.
int is_anything_left (void) const;
// Returns the number of args left to see in the vector.
int is_option_next (void) const;
// Returns 1 if there's a next item in the vector and it begins with
// '-'.
int is_parameter_next (void) const;
// Returns 1 if there's a next item in the vector and it doesn't
// begin with '-'.
int num_ignored_args (void) const;
// Returns the number of irrelevant args seen.
private:
int& argc_;
// The size of the argument vector.
int total_size_;
// The size of argv_.
char** temp_;
// The temporary array over which we traverse.
char** argv_;
// The array in which the arguments are reordered.
int current_index_;
// The element in <temp_> we're currently examining.
int back_;
// The index of <argv_> in which we'll stick the next unknown
// argument.
int front_;
// The index of <argv_> in which we'll stick the next known
// argument.
};
#endif /* ACE_ARG_SHIFTER_H */
|
