1 /*
2 * *****************************************************************************
3 *
4 * SPDX-License-Identifier: BSD-2-Clause
5 *
6 * Copyright (c) 2018-2021 Gavin D. Howard and contributors.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *
11 * * Redistributions of source code must retain the above copyright notice, this
12 * list of conditions and the following disclaimer.
13 *
14 * * Redistributions in binary form must reproduce the above copyright notice,
15 * this list of conditions and the following disclaimer in the documentation
16 * and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 *
30 * *****************************************************************************
31 *
32 * Adapted from https://github.com/skeeto/optparse
33 *
34 * *****************************************************************************
35 *
36 * Code for getopt_long() replacement. It turns out that getopt_long() has
37 * different behavior on different platforms.
38 *
39 */
40
41 #include <assert.h>
42 #include <stdbool.h>
43 #include <stdlib.h>
44 #include <string.h>
45
46 #include <status.h>
47 #include <opt.h>
48 #include <vm.h>
49
50 /**
51 * Returns true if index @a i is the end of the longopts array.
52 * @param longopts The long options array.
53 * @param i The index to test.
54 * @return True if @a i is the last index, false otherwise.
55 */
bc_opt_longoptsEnd(const BcOptLong * longopts,size_t i)56 static inline bool bc_opt_longoptsEnd(const BcOptLong *longopts, size_t i) {
57 return !longopts[i].name && !longopts[i].val;
58 }
59
60 /**
61 * Returns the name of the long option that matches the character @a c.
62 * @param longopts The long options array.
63 * @param c The character to match against.
64 * @return The name of the long option that matches @a c, or "NULL".
65 */
bc_opt_longopt(const BcOptLong * longopts,int c)66 static const char* bc_opt_longopt(const BcOptLong *longopts, int c) {
67
68 size_t i;
69
70 for (i = 0; !bc_opt_longoptsEnd(longopts, i); ++i) {
71 if (longopts[i].val == c) return longopts[i].name;
72 }
73
74 BC_UNREACHABLE
75
76 return "NULL";
77 }
78
79 /**
80 * Issues a fatal error for an option parsing failure.
81 * @param err The error.
82 * @param c The character for the failing option.
83 * @param str Either the string for the failing option, or the invalid
84 * option.
85 * @param use_short True if the short option should be used for error printing,
86 * false otherwise.
87 */
bc_opt_error(BcErr err,int c,const char * str,bool use_short)88 static void bc_opt_error(BcErr err, int c, const char *str, bool use_short) {
89
90 if (err == BC_ERR_FATAL_OPTION) {
91
92 if (use_short) {
93
94 char short_str[2];
95
96 short_str[0] = (char) c;
97 short_str[1] = '\0';
98
99 bc_error(err, 0, short_str);
100 }
101 else bc_error(err, 0, str);
102 }
103 else bc_error(err, 0, (int) c, str);
104 }
105
106 /**
107 * Returns the type of the long option that matches @a c.
108 * @param longopts The long options array.
109 * @param c The character to match against.
110 * @return The type of the long option as an integer, or -1 if none.
111 */
bc_opt_type(const BcOptLong * longopts,char c)112 static int bc_opt_type(const BcOptLong *longopts, char c) {
113
114 size_t i;
115
116 if (c == ':') return -1;
117
118 for (i = 0; !bc_opt_longoptsEnd(longopts, i) && longopts[i].val != c; ++i);
119
120 if (bc_opt_longoptsEnd(longopts, i)) return -1;
121
122 return (int) longopts[i].type;
123 }
124
125 /**
126 * Parses a short option.
127 * @param o The option parser.
128 * @param longopts The long options array.
129 * @return The character for the short option, or -1 if none left.
130 */
bc_opt_parseShort(BcOpt * o,const BcOptLong * longopts)131 static int bc_opt_parseShort(BcOpt *o, const BcOptLong *longopts) {
132
133 int type;
134 char *next;
135 char *option = o->argv[o->optind];
136 int ret = -1;
137
138 // Make sure to clear these.
139 o->optopt = 0;
140 o->optarg = NULL;
141
142 // Get the next option.
143 option += o->subopt + 1;
144 o->optopt = option[0];
145
146 // Get the type and the next data.
147 type = bc_opt_type(longopts, option[0]);
148 next = o->argv[o->optind + 1];
149
150 switch (type) {
151
152 case -1:
153 case BC_OPT_BC_ONLY:
154 case BC_OPT_DC_ONLY:
155 {
156 // Check for invalid option and barf if so.
157 if (type == -1 || (type == BC_OPT_BC_ONLY && BC_IS_DC) ||
158 (type == BC_OPT_DC_ONLY && BC_IS_BC))
159 {
160 char str[2] = {0, 0};
161
162 str[0] = option[0];
163 o->optind += 1;
164
165 bc_opt_error(BC_ERR_FATAL_OPTION, option[0], str, true);
166 }
167 }
168 // Fallthrough.
169 BC_FALLTHROUGH
170
171 case BC_OPT_NONE:
172 {
173 // If there is something else, update the suboption.
174 if (option[1]) o->subopt += 1;
175 else {
176
177 // Go to the next argument.
178 o->subopt = 0;
179 o->optind += 1;
180 }
181
182 ret = (int) option[0];
183
184 break;
185 }
186
187 case BC_OPT_REQUIRED_BC_ONLY:
188 {
189 if (BC_IS_DC)
190 bc_opt_error(BC_ERR_FATAL_OPTION, option[0],
191 bc_opt_longopt(longopts, option[0]), true);
192 }
193 // Fallthrough
194 BC_FALLTHROUGH
195
196 case BC_OPT_REQUIRED:
197 {
198 // Always go to the next argument.
199 o->subopt = 0;
200 o->optind += 1;
201
202 // Use the next characters, if they exist.
203 if (option[1]) o->optarg = option + 1;
204 else if (next != NULL) {
205
206 // USe the next.
207 o->optarg = next;
208 o->optind += 1;
209 }
210 // No argument, barf.
211 else bc_opt_error(BC_ERR_FATAL_OPTION_NO_ARG, option[0],
212 bc_opt_longopt(longopts, option[0]), true);
213
214
215 ret = (int) option[0];
216
217 break;
218 }
219 }
220
221 return ret;
222 }
223
224 /**
225 * Ensures that a long option argument matches a long option name, regardless of
226 * "=<data>" at the end.
227 * @param name The name to match.
228 * @param option The command-line argument.
229 * @return True if @a option matches @a name, false otherwise.
230 */
bc_opt_longoptsMatch(const char * name,const char * option)231 static bool bc_opt_longoptsMatch(const char *name, const char *option) {
232
233 const char *a = option, *n = name;
234
235 // Can never match a NULL name.
236 if (name == NULL) return false;
237
238 // Loop through.
239 for (; *a && *n && *a != '='; ++a, ++n) {
240 if (*a != *n) return false;
241 }
242
243 // Ensure they both end at the same place.
244 return (*n == '\0' && (*a == '\0' || *a == '='));
245 }
246
247 /**
248 * Returns a pointer to the argument of a long option, or NULL if it not in the
249 * same argument.
250 * @param option The option to find the argument of.
251 * @return A pointer to the argument of the option, or NULL if none.
252 */
bc_opt_longoptsArg(char * option)253 static char* bc_opt_longoptsArg(char *option) {
254
255 // Find the end or equals sign.
256 for (; *option && *option != '='; ++option);
257
258 if (*option == '=') return option + 1;
259 else return NULL;
260 }
261
bc_opt_parse(BcOpt * o,const BcOptLong * longopts)262 int bc_opt_parse(BcOpt *o, const BcOptLong *longopts) {
263
264 size_t i;
265 char *option;
266 bool empty;
267
268 // This just eats empty options.
269 do {
270
271 option = o->argv[o->optind];
272 if (option == NULL) return -1;
273
274 empty = !strcmp(option, "");
275 o->optind += empty;
276
277 } while (empty);
278
279 // If the option is just a "--".
280 if (BC_OPT_ISDASHDASH(option)) {
281
282 // Consume "--".
283 o->optind += 1;
284 return -1;
285 }
286 // Parse a short option.
287 else if (BC_OPT_ISSHORTOPT(option)) return bc_opt_parseShort(o, longopts);
288 // If the option is not long at this point, we are done.
289 else if (!BC_OPT_ISLONGOPT(option)) return -1;
290
291 // Clear these.
292 o->optopt = 0;
293 o->optarg = NULL;
294
295 // Skip "--" at beginning of the option.
296 option += 2;
297 o->optind += 1;
298
299 // Loop through the valid long options.
300 for (i = 0; !bc_opt_longoptsEnd(longopts, i); i++) {
301
302 const char *name = longopts[i].name;
303
304 // If we have a match...
305 if (bc_opt_longoptsMatch(name, option)) {
306
307 char *arg;
308
309 // Get the option char and the argument.
310 o->optopt = longopts[i].val;
311 arg = bc_opt_longoptsArg(option);
312
313 // Error if the option is invalid..
314 if ((longopts[i].type == BC_OPT_BC_ONLY && BC_IS_DC) ||
315 (longopts[i].type == BC_OPT_REQUIRED_BC_ONLY && BC_IS_DC) ||
316 (longopts[i].type == BC_OPT_DC_ONLY && BC_IS_BC))
317 {
318 bc_opt_error(BC_ERR_FATAL_OPTION, o->optopt, name, false);
319 }
320
321 // Error if we have an argument and should not.
322 if (longopts[i].type == BC_OPT_NONE && arg != NULL)
323 {
324 bc_opt_error(BC_ERR_FATAL_OPTION_ARG, o->optopt, name, false);
325 }
326
327 // Set the argument, or check the next argument if we don't have
328 // one.
329 if (arg != NULL) o->optarg = arg;
330 else if (longopts[i].type == BC_OPT_REQUIRED ||
331 longopts[i].type == BC_OPT_REQUIRED_BC_ONLY)
332 {
333 // Get the next argument.
334 o->optarg = o->argv[o->optind];
335
336 // All's good if it exists; otherwise, barf.
337 if (o->optarg != NULL) o->optind += 1;
338 else bc_opt_error(BC_ERR_FATAL_OPTION_NO_ARG,
339 o->optopt, name, false);
340 }
341
342 return o->optopt;
343 }
344 }
345
346 // If we reach this point, the option is invalid.
347 bc_opt_error(BC_ERR_FATAL_OPTION, 0, option, false);
348
349 BC_UNREACHABLE
350
351 return -1;
352 }
353
bc_opt_init(BcOpt * o,char * argv[])354 void bc_opt_init(BcOpt *o, char *argv[]) {
355 o->argv = argv;
356 o->optind = 1;
357 o->subopt = 0;
358 o->optarg = NULL;
359 }
360