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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
/* Hierarchial options parsing, layered over getopt
Copyright (C) 1995 Free Software Foundation, Inc.
Written by Miles Bader <miles@gnu.ai.mit.edu>
This file is part of the GNU Hurd.
The GNU Hurd is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2, or (at
your option) any later version.
The GNU Hurd is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdlib.h>
#include <string.h>
#include <limits.h> /* for CHAR_BIT */
#include <getopt.h>
#include <cthreads.h>
#include "options.h"
#define EOF (-1)
/* The number of bits we steal in a long-option value for our own use. */
#define GROUP_BITS CHAR_BIT
/* The number of bits available for the user value. */
#define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
#define USER_MASK ((1 << USER_BITS) - 1)
/* ---------------------------------------------------------------- */
/* Returns the offset into LONG_OPTIONS of a long option with called NAME, or
-1 if none is found. Passing NULL as NAME will return the number of
options. */
static int
find_long_option (struct option *long_options, const char *name)
{
struct option *l = long_options;
while (l->name != NULL)
if (name != NULL && strcmp (l->name, name) == 0)
return l - long_options;
else
l++;
if (name == NULL)
return l - long_options;
else
return -1;
}
/* ---------------------------------------------------------------- */
/* Used to regulate access to the getopt routines, which are non-reentrant. */
static struct mutex getopt_lock = MUTEX_INITIALIZER;
/* Parse the options strings in ARGC & ARGV according to the options in
OPTIONS. FLAGS is one of the OPTIONS_ flags above. If OPTIND is
non-NULL, the index in ARGV of the first unparsed option is returned in
it. If an unknown option is present, EINVAL is returned; if some parser
routine returned a non-zero value, it is returned; otherwise 0 is
returned. */
error_t
options_parse (struct options *options,
int argc, char **argv,
unsigned flags, int *arg_index)
{
int opt;
struct options *o;
/* SHORT_OPTS is the getopt short options string for the union of all the
groups of options. */
char *short_opts;
/* GROUP_SHORT_STARTS is an array pointing to the part of SHORT_OPTS
corresponding to each different group of options. We use it to
determine from which groupa particular short options is from. */
char **group_short_starts;
/* LONG_OPTS is the array of getop long option structures for the union of
all the groups of options. */
struct option *long_opts;
error_t err = 0;
/* Find the merged set of short options. */
{
char *short_end;
int short_len = (flags & OPTIONS_PARSE_ARGS) ? 1 : 0;
int num_groups = 0, group;
/* Find the (maximum) amount of space necessary to store all combined
short options, plus the number of options groups in the chain. */
for (o = options; o != NULL; o = o->parent)
{
num_groups++;
short_len += strlen (o->short_options);
}
short_opts = short_end = alloca (short_len + 1);
if (flags & OPTIONS_PARSE_ARGS)
*short_end++ = '-'; /* Tell getopt we want to do this. */
*short_end = '\0';
group_short_starts = alloca (num_groups * sizeof (char *));
for (o = options, group = 0; o != NULL; o = o->parent, group++)
{
char *s;
group_short_starts[group] = short_end;
for (s = o->short_options; *s != '\0'; s++)
/* We add *S to our set of short options only if it hasn't already
been added by some previous group. */
if (*s != ':' && !index (short_opts, *s))
{
*short_end++ = *s;
/* Copy all the colon modifiers following the option. */
while (s[1] == ':')
*short_end++ = *++s;
*short_end = '\0';
}
}
}
/* Find the merged set of long options, with keys appropiately prefixed. */
{
struct option *long_end;
int group;
int long_len = 0;
for (o = options; o != NULL; o = o->parent)
long_len += find_long_option (o->long_options, NULL);
long_opts = long_end = alloca ((long_len + 1) * sizeof (struct option));
long_end->name = NULL;
/* Note that GROUP starts at 1 because 0 is for short options. */
for (o = options, group = 1; o != NULL; o = o->parent, group++)
{
struct option *l;
for (l = o->long_options; l->name != NULL; l++)
/* Only add the long option L if it hasn't been already. */
if (find_long_option (long_opts, l->name) < 0)
{
*long_end = *l;
if (long_end->flag == NULL)
/* In the case where a long option returns a key from getopt,
we add a disambiguating code to all the user's values
(which is removed before we actually call the function to
parse the value); this means that the user loses use of
the high 8 bits in all his values (the sign of the lower
bits is preserved however)... */
long_end->val = (l->val & USER_MASK) + (group << USER_BITS);
/* Keep the LONG_OPTS list terminated. */
(++long_end)->name = NULL;
}
}
}
/* Getopt is (currently) non-reentrant. */
mutex_lock (&getopt_lock);
/* Tell getopt to initialize. */
optind = 0;
if (flags & OPTIONS_PRINT_ERRS)
opterr = 1; /* Print error messages. */
else
{
opterr = 0;
if (!(flags & OPTIONS_SKIP_ARG0))
/* getopt always skips ARGV[0], so we have to fake it out. As long
as opterr is 0, then it shouldn't actually try to access it. */
argv--, argc++;
}
/* Now use getopt on our coalesced options lists. */
while ((opt = getopt_long (argc, argv, short_opts, long_opts, 0)) != EOF)
{
int group = opt >> USER_BITS;
err = EINVAL; /* until otherwise asserted */
if (opt == 1)
/* A non-option argument; try each parser in turn. */
for (o = options; o != NULL && err == EINVAL; o = o->parent)
err = (*o->parser)(0, optarg);
else if (group == 0)
/* A short option. */
{
/* By comparing OPT's position in SHORT_OPTS to the various
starting positions in GROUP_SHORT_STARTS, we can determine which
group OPT came from. */
char *short_index = index (short_opts, opt);
if (short_index)
for (o = options, group = 0; o != NULL; o = o->parent, group++)
if (o->parent == NULL
|| group_short_starts[group + 1] > short_index)
{
err = (*o->parser)(opt, optarg);
break;
}
}
else
/* A long option. */
for (o = options; o != NULL; o = o->parent)
if (--group == 0)
{
/* We use shifts instead of masking for extracting the user value
in order to preserve the sign. */
err = (*o->parser)(((opt << GROUP_BITS) >> GROUP_BITS), optarg);
break;
}
if (err)
break;
}
if (arg_index != NULL)
*arg_index = optind;
mutex_unlock (&getopt_lock);
return err;
}
|
