|
0
|
1 /*
|
|
|
2 * Simple commandline argument processing
|
|
|
3 * Programmed and designed by Matti 'ccr' Hamalainen
|
|
|
4 * (C) Copyright 2002-2008 Tecnic Software productions (TNSP)
|
|
|
5 *
|
|
|
6 * Please read file 'COPYING' for information on license and distribution.
|
|
|
7 */
|
|
|
8 /*
|
|
|
9 Description
|
|
|
10 ===========
|
|
|
11 Structures and functions for simple commandline argument processing,
|
|
|
12 option argument handling (short and long forms supported).
|
|
|
13
|
|
|
14 Output function for printing out short on-line help for said options
|
|
|
15 and program commandline usage.
|
|
|
16
|
|
|
17
|
|
|
18 Format for typical commandline:
|
|
|
19
|
|
|
20 $ program -a -b -c --long-d -e argument-for-e --long-f="argument for f"
|
|
|
21
|
|
|
22 where -a, -b and -c are short options without required arguments;
|
|
|
23 --long-d is a long option without argument; -e is short option with
|
|
|
24 argument and finally --long-f is long option with argument.
|
|
|
25
|
|
|
26
|
|
|
27 Introduction
|
|
|
28 ============
|
|
|
29 Handling of commandline options in th_args_process() has various
|
|
|
30 options, which effect how an option is handled. Also the error
|
|
|
31 situations (unknown option/no required argument) can be handled
|
|
|
32 in different ways.
|
|
|
33
|
|
|
34 Typically th_args_process() is called as follows:
|
|
|
35
|
|
|
36 BOOL optionHandlerCallback(int optionNumber, char *optionArgument, char *optionName)
|
|
|
37 {
|
|
|
38 if (option is OK)
|
|
|
39 return TRUE;
|
|
|
40 else
|
|
|
41 return FALSE;
|
|
|
42 }
|
|
|
43
|
|
|
44 BOOL nonoptionHandlerCallback(char *argumentString)
|
|
|
45 {
|
|
|
46 // return value same as in optionHandlerCallback
|
|
|
47 }
|
|
|
48
|
|
|
49
|
|
|
50 int main(int argc, char *argv[])
|
|
|
51 {
|
|
|
52 if (th_args_process(argc, argv, optList, optListN,
|
|
|
53 optionHandlerCallback, nonoptionHandlerCallback)) {
|
|
|
54 ... arguments OK ...
|
|
|
55 } else {
|
|
|
56 ... arguments invalid or required arguments missing ...
|
|
|
57 }
|
|
|
58 }
|
|
|
59
|
|
|
60
|
|
|
61 NOTICE!
|
|
|
62 -------
|
|
|
63 The return value from handler callbacks affects the return value of
|
|
|
64 th_args_process(). Additionally, a failure in callback (returns FALSE)
|
|
|
65 effects the argument processing if bailOut argument of th_args_process()
|
|
|
66 is TRUE!
|
|
|
67
|
|
|
68 If bailOut is TRUE, any error/failure in argument processing (including
|
|
|
69 callbacks) immediately stops the argument processing and FALSE is
|
|
|
70 returned from th_args_process().
|
|
|
71
|
|
|
72 If bailOut is FALSE, most errors are "ignored", but FALSE is still returned
|
|
|
73 if any errors occured.
|
|
|
74
|
|
|
75
|
|
|
76 NOTICE #2!
|
|
|
77 ----------
|
|
|
78 A small temporary buffer of N*sizeof(BOOL) (where N is number of
|
|
|
79 options in optList[]) is allocated for processing required options.
|
|
|
80 If this allocation fails, the program is immediately exited with
|
|
|
81 code 128.
|
|
|
82
|
|
|
83
|
|
|
84 Examples
|
|
|
85 ========
|
|
|
86 Example of different options, in a fictional optionlist struct:
|
|
|
87
|
|
|
88 optarg_t optList[] = {
|
|
|
89 // Option without arguments
|
|
|
90 { 0, '?', "help", "Show this help", OPT_NONE },
|
|
|
91
|
|
|
92 // Option with a required argument
|
|
|
93 { 1, 'o', "output", "Output file name", OPT_ARGREQ },
|
|
|
94
|
|
|
95 // Option with optional argument
|
|
|
96 { 2, 'f', "foobar", "Use foobar, with optional string", OPT_ARGOPT },
|
|
|
97
|
|
|
98 // This option is required to be given, though without other flags
|
|
|
99 // it may not make much sense.
|
|
|
100 { 4, 'S', "stupid", "You must give this option", OPT_REQUIRED },
|
|
|
101
|
|
|
102 // The flags can be combined with OR operator: this option is both
|
|
|
103 // required to be specified, and also requires argument (the filename)
|
|
|
104 { 5, 'i', "input", "Input file name", OPT_REQUIRED | OPT_ARGREQ },
|
|
|
105
|
|
|
106
|
|
|
107 // Option with only long form
|
|
|
108 { 0, 0, "only-long", "Long option", OPT_NONE },
|
|
|
109
|
|
|
110 // Option with only short form
|
|
|
111 { 0, 's', NULL, "Short option", OPT_NONE },
|
|
|
112
|
|
|
113 };
|
|
|
114
|
|
|
115 const int optListN = (sizeof(optList) / sizeof(optarg_t));
|
|
|
116
|
|
|
117
|
|
|
118 */
|
|
|
119 #ifndef TH_EXTERNAL
|
|
|
120 #include "th_util.h"
|
|
|
121 #include "th_args.h"
|
|
|
122 #include "th_string.h"
|
|
|
123 #endif
|
|
|
124
|
|
|
125
|
|
|
126 /* Check if option requires an argument
|
|
|
127 */
|
|
|
128 static BOOL th_args_check_arg(const optarg_t *o, const char *optArg)
|
|
|
129 {
|
|
|
130 if ((o->flags & OPT_ARGMASK) == OPT_ARGREQ && optArg == NULL)
|
|
|
131 {
|
|
|
132 if (o->optShort != 0 && o->optLong != NULL)
|
|
|
133 {
|
|
|
134 THERR("Option '-%c ARG' (--%s=ARG) requires an argument!\n",
|
|
|
135 o->optShort, o->optLong);
|
|
|
136 }
|
|
|
137 else if (o->optShort != 0)
|
|
|
138 {
|
|
|
139 THERR("Option '-%c ARG' requires an argument!\n", o->optShort);
|
|
|
140 }
|
|
|
141 else if (o->optLong != NULL)
|
|
|
142 {
|
|
|
143 THERR("Option --%s=ARG requires an argument!\n", o->optLong);
|
|
|
144 }
|
|
|
145
|
|
|
146 return FALSE;
|
|
|
147 }
|
|
|
148 else
|
|
|
149 return TRUE;
|
|
|
150 }
|
|
|
151
|
|
|
152
|
|
|
153 /* Handle short options
|
|
|
154 */
|
|
|
155 static BOOL th_args_process_short(char *currArg, int *newArgIndex,
|
|
|
156 BOOL *wasGiven, int argc, char *argv[],
|
|
|
157 optarg_t optList[], int optListN,
|
|
|
158 BOOL (*handleOpt)(int, char *, char *))
|
|
|
159 {
|
|
|
160 char *tmpArg = currArg, *optArg;
|
|
|
161 int optN;
|
|
|
162 BOOL isFound;
|
|
|
163
|
|
|
164 // Short options can be combined: -a -b -c == -abc
|
|
|
165 while (*tmpArg)
|
|
|
166 {
|
|
|
167 for (optN = 0, isFound = FALSE; (optN < optListN) && !isFound; optN++)
|
|
|
168 if (*tmpArg == optList[optN].optShort)
|
|
|
169 {
|
|
|
170 // Get possible option argument, if needed
|
|
|
171 if ((optList[optN].flags & OPT_ARGMASK) != 0
|
|
|
172 && (++(*newArgIndex) < argc))
|
|
|
173 optArg = argv[*newArgIndex];
|
|
|
174 else
|
|
|
175 optArg = NULL;
|
|
|
176
|
|
|
177 // Check if option argument is required
|
|
|
178 if (!th_args_check_arg(&optList[optN], optArg))
|
|
|
179 return FALSE;
|
|
|
180 else
|
|
|
181 {
|
|
|
182 char tmpStr[2] = { 0, 0 };
|
|
|
183
|
|
|
184 // Option was given succesfully, try to handle it
|
|
|
185 wasGiven[optN] = TRUE;
|
|
|
186
|
|
|
187 tmpStr[0] = *tmpArg;
|
|
|
188
|
|
|
189 if (!handleOpt(optList[optN].id, optArg, tmpStr))
|
|
|
190 return FALSE;
|
|
|
191 }
|
|
|
192
|
|
|
193 isFound = TRUE;
|
|
|
194 }
|
|
|
195
|
|
|
196 if (!isFound)
|
|
|
197 {
|
|
|
198 THERR("Unknown short option '%c' in argument '-%s'\n",
|
|
|
199 *tmpArg, currArg);
|
|
|
200 return FALSE;
|
|
|
201 }
|
|
|
202
|
|
|
203 tmpArg++;
|
|
|
204 }
|
|
|
205
|
|
|
206 return TRUE;
|
|
|
207 }
|
|
|
208
|
|
|
209
|
|
|
210 /* Handle long options
|
|
|
211 */
|
|
|
212 static BOOL th_args_process_long(char *currArg, int *newArgIndex,
|
|
|
213 BOOL *wasGiven, int argc, char *argv[],
|
|
|
214 optarg_t optList[], int optListN,
|
|
|
215 BOOL (*handleOpt)(int, char *, char *))
|
|
|
216 {
|
|
|
217 int optN, optLen, i;
|
|
|
218 char *optArg;
|
|
|
219
|
|
|
220 (void) argc;
|
|
|
221 (void) argv;
|
|
|
222 (void) newArgIndex;
|
|
|
223
|
|
|
224 // Long option
|
|
|
225 for (optN = -1, optLen = i = 0; (i < optListN) && (optN < 0); i++)
|
|
|
226 if (optList[i].optLong)
|
|
|
227 {
|
|
|
228 optLen = strlen(optList[i].optLong);
|
|
|
229 if (strncmp(currArg, optList[i].optLong, optLen) == 0)
|
|
|
230 optN = i;
|
|
|
231 }
|
|
|
232
|
|
|
233 // Get possible option argument, if needed
|
|
|
234 if (optN >= 0)
|
|
|
235 {
|
|
|
236 if ((optList[optN].flags & OPT_ARGMASK) != 0)
|
|
|
237 {
|
|
|
238 if (currArg[optLen] == '=')
|
|
|
239 optArg = &currArg[optLen + 1];
|
|
|
240 else
|
|
|
241 optArg = NULL;
|
|
|
242 }
|
|
|
243 else
|
|
|
244 optArg = NULL;
|
|
|
245
|
|
|
246 // Check if option argument is required
|
|
|
247 if (!th_args_check_arg(&optList[optN], optArg))
|
|
|
248 return FALSE;
|
|
|
249 else
|
|
|
250 {
|
|
|
251 // Option was given succesfully, try to handle it
|
|
|
252 wasGiven[optN] = TRUE;
|
|
|
253 if (!handleOpt(optList[optN].id, optArg, currArg))
|
|
|
254 return FALSE;
|
|
|
255 }
|
|
|
256 }
|
|
|
257 else
|
|
|
258 {
|
|
|
259 THERR("Unknown long option '--%s'\n", currArg);
|
|
|
260 return FALSE;
|
|
|
261 }
|
|
|
262
|
|
|
263 return TRUE;
|
|
|
264 }
|
|
|
265
|
|
|
266
|
|
|
267 /* Process arguments, handling short and long options by
|
|
|
268 * calling the given callback functions.
|
|
|
269 */
|
|
|
270 BOOL th_args_process(int argc, char *argv[],
|
|
|
271 optarg_t optList[], int optListN,
|
|
|
272 BOOL(*handleOpt) (int, char *, char *),
|
|
|
273 BOOL(*handleNonOption) (char *), BOOL bailOut)
|
|
|
274 {
|
|
|
275 BOOL endOptions, optionsOK;
|
|
|
276 int argIndex, newArgIndex, i;
|
|
|
277 char *currArg;
|
|
|
278 BOOL *wasGiven;
|
|
|
279
|
|
|
280 // Allocate wasGiven
|
|
|
281 wasGiven = (BOOL *) th_calloc(optListN, sizeof(BOOL));
|
|
|
282 if (!wasGiven)
|
|
|
283 {
|
|
|
284 THERR("FATAL ERROR! Could not allocate wasGiven in th_args_process()!\n");
|
|
|
285 exit(128);
|
|
|
286 }
|
|
|
287
|
|
|
288 // Parse arguments
|
|
|
289 argIndex = 1;
|
|
|
290 optionsOK = TRUE;
|
|
|
291 endOptions = FALSE;
|
|
|
292 while (argIndex < argc)
|
|
|
293 {
|
|
|
294 currArg = argv[argIndex];
|
|
|
295 if ((currArg[0] == '-') && !endOptions)
|
|
|
296 {
|
|
|
297 newArgIndex = argIndex;
|
|
|
298 currArg++;
|
|
|
299 if (*currArg == '-')
|
|
|
300 {
|
|
|
301 // Check for "--", which ends the options-list
|
|
|
302 currArg++;
|
|
|
303 if (*currArg == 0)
|
|
|
304 {
|
|
|
305 endOptions = TRUE;
|
|
|
306 continue;
|
|
|
307 }
|
|
|
308
|
|
|
309 // Long options
|
|
|
310 if (!th_args_process_long(currArg, &newArgIndex,
|
|
|
311 wasGiven, argc, argv, optList,
|
|
|
312 optListN, handleOpt))
|
|
|
313 optionsOK = FALSE;
|
|
|
314 }
|
|
|
315 else
|
|
|
316 {
|
|
|
317 // Short options
|
|
|
318 if (!th_args_process_short(currArg, &newArgIndex,
|
|
|
319 wasGiven, argc, argv, optList,
|
|
|
320 optListN, handleOpt))
|
|
|
321 optionsOK = FALSE;
|
|
|
322 }
|
|
|
323
|
|
|
324 argIndex = newArgIndex;
|
|
|
325 }
|
|
|
326 else
|
|
|
327 {
|
|
|
328 // Was not option argument
|
|
|
329 if (handleNonOption == NULL
|
|
|
330 || (handleNonOption != NULL && !handleNonOption(currArg)))
|
|
|
331 {
|
|
|
332 THERR("Invalid argument '%s'\n", currArg);
|
|
|
333 optionsOK = FALSE;
|
|
|
334 }
|
|
|
335 }
|
|
|
336
|
|
|
337 // Check if we bail out on invalid argument
|
|
|
338 if (!optionsOK && bailOut)
|
|
|
339 {
|
|
|
340 th_free(wasGiven);
|
|
|
341 return FALSE;
|
|
|
342 }
|
|
|
343
|
|
|
344 argIndex++;
|
|
|
345 }
|
|
|
346
|
|
|
347 // Check wasGiven by isRequired
|
|
|
348 for (i = 0; i < optListN; i++)
|
|
|
349 if ((optList[i].flags & OPT_REQUIRED) != 0 && !wasGiven[i])
|
|
|
350 {
|
|
|
351 THERR("Option -%s (--%s) is required.\n",
|
|
|
352 optList[i].optShort, optList[i].optLong);
|
|
|
353
|
|
|
354 optionsOK = FALSE;
|
|
|
355 if (bailOut)
|
|
|
356 break;
|
|
|
357 }
|
|
|
358
|
|
|
359 th_free(wasGiven);
|
|
|
360 return optionsOK;
|
|
|
361 }
|
|
|
362
|
|
|
363
|
|
|
364 /* Print help for commandline arguments/options
|
|
|
365 */
|
|
|
366 void th_args_help(FILE *outFile, optarg_t optList[], int optListN)
|
|
|
367 {
|
|
|
368 int i, nrequired;
|
|
|
369
|
|
|
370 for (i = nrequired = 0; i < optListN; i++)
|
|
|
371 {
|
|
|
372 optarg_t *o = &optList[i];
|
|
|
373
|
|
|
374 // Print short option
|
|
|
375 if (o->optShort != 0)
|
|
|
376 fprintf(outFile, " -%c, ", o->optShort);
|
|
|
377 else
|
|
|
378 fprintf(outFile, " ");
|
|
|
379
|
|
|
380 // Print long option
|
|
|
381 if (o->optLong)
|
|
|
382 {
|
|
|
383 char tmpStr[64], *p;
|
|
|
384
|
|
|
385 if ((o->flags & OPT_ARGMASK) == OPT_ARGOPT)
|
|
|
386 {
|
|
|
387 snprintf(tmpStr, sizeof(tmpStr), "%s[=ARG]",
|
|
|
388 optList[i].optLong);
|
|
|
389 p = tmpStr;
|
|
|
390 }
|
|
|
391 else if ((o->flags & OPT_ARGMASK) == OPT_ARGREQ)
|
|
|
392 {
|
|
|
393 snprintf(tmpStr, sizeof(tmpStr), "%s=ARG",
|
|
|
394 optList[i].optLong);
|
|
|
395 p = tmpStr;
|
|
|
396 }
|
|
|
397 else
|
|
|
398 p = o->optLong;
|
|
|
399
|
|
|
400 fprintf(outFile, "--%-15s", p);
|
|
|
401 }
|
|
|
402 else
|
|
|
403 fprintf(outFile, " ");
|
|
|
404
|
|
|
405 fprintf(outFile, " %s.", optList[i].desc);
|
|
|
406
|
|
|
407 if (o->flags & OPT_REQUIRED)
|
|
|
408 {
|
|
|
409 fprintf(outFile, " [*]\n");
|
|
|
410 nrequired++;
|
|
|
411 }
|
|
|
412 else
|
|
|
413 fprintf(outFile, "\n");
|
|
|
414 }
|
|
|
415
|
|
|
416 if (nrequired > 0)
|
|
|
417 fprintf(outFile, "(Options marked with [*] are required)\n");
|
|
|
418 }
|
