« back to all changes in this revision
Viewing changes to tests/test_multiple_cmd.c.test
- browse files at revision 11
- compare with another revision
- download diff
- download tarball
- view history from revision 11
- Committer: Bazaar Package Importer
- Author(s): Matthias Klose
- Date: 2008-01-29 14:55:40 UTC
- mfrom: (1.1.5 upstream)
- Revision ID: james.westby@ubuntu.com-20080129145540-bkah1bl330gpelmh
Tags: 2.22-1ubuntu1
* Merge with Debian; remaining changes:
- Fix build failures with g++-4.3.
- Fix build failures with g++-4.3.
- files added:
- doc/help_modes.output.texinfo
- files removed:
- config.rpath
- files modified:
- ChangeLog
added
removed
tests/test_multiple_cmd.c.test
34
34
" -i, --int=INT int option (mandatory)",
35
35
" -S, --short=SHORT short option",
36
36
" -l, --long=LONG long option",
37
" --longlong=LONGLONG long long option",
37
38
" -L, --limited=STRING limited multiple option",
38
39
" --limited-interval=STRING limited multiple option (with interval)",
39
40
" --big-limited-interval=STRING\n limited multiple option (with interval)",
49
50
0
50
51
};
51
52
53
typedef enum {ARG_NO
54
, ARG_STRING
55
, ARG_INT
56
, ARG_SHORT
57
, ARG_LONG
58
, ARG_FLOAT
59
, ARG_LONGLONG
60
} test_multiple_cmd_parser_arg_type;
61
52
62
static
53
63
void clear_given (struct gengetopt_args_info *args_info);
54
64
static
61
71
static int
62
72
test_multiple_cmd_parser_required2 (struct gengetopt_args_info *args_info, const char *prog_name, const char *additional_error);
63
73
64
struct float_list
65
{
66
float arg;
67
char *orig;
68
struct float_list * next;
69
};
70
71
struct int_list
72
{
73
int arg;
74
char *orig;
75
struct int_list * next;
76
};
77
78
struct long_list
79
{
80
long arg;
81
char *orig;
82
struct long_list * next;
83
};
84
85
struct short_list
86
{
87
short arg;
88
char *orig;
89
struct short_list * next;
90
};
91
92
struct string_list
93
{
94
char * arg;
95
char *orig;
96
struct string_list * next;
97
};
98
99
74
static char *
100
75
gengetopt_strdup (const char *s);
101
76
108
83
args_info->int_given = 0 ;
109
84
args_info->short_given = 0 ;
110
85
args_info->long_given = 0 ;
86
args_info->longlong_given = 0 ;
111
87
args_info->limited_given = 0 ;
112
88
args_info->limited_interval_given = 0 ;
113
89
args_info->big_limited_interval_given = 0 ;
133
109
args_info->short_orig = NULL;
134
110
args_info->long_arg = NULL;
135
111
args_info->long_orig = NULL;
112
args_info->longlong_arg = NULL;
113
args_info->longlong_orig = NULL;
136
114
args_info->limited_arg = NULL;
137
115
args_info->limited_orig = NULL;
138
116
args_info->limited_interval_arg = NULL;
159
137
static
160
138
void init_args_info(struct gengetopt_args_info *args_info)
161
139
{
140
141
162
142
args_info->help_help = gengetopt_args_info_help[0] ;
163
143
args_info->version_help = gengetopt_args_info_help[1] ;
164
144
args_info->string_help = gengetopt_args_info_help[2] ;
173
153
args_info->long_help = gengetopt_args_info_help[5] ;
174
154
args_info->long_min = -1;
175
155
args_info->long_max = -1;
176
args_info->limited_help = gengetopt_args_info_help[6] ;
156
args_info->longlong_help = gengetopt_args_info_help[6] ;
157
args_info->longlong_min = -1;
158
args_info->longlong_max = -1;
159
args_info->limited_help = gengetopt_args_info_help[7] ;
177
160
args_info->limited_min = 3;
178
161
args_info->limited_max = 3;
179
args_info->limited_interval_help = gengetopt_args_info_help[7] ;
162
args_info->limited_interval_help = gengetopt_args_info_help[8] ;
180
163
args_info->limited_interval_min = 1;
181
164
args_info->limited_interval_max = 3;
182
args_info->big_limited_interval_help = gengetopt_args_info_help[8] ;
165
args_info->big_limited_interval_help = gengetopt_args_info_help[9] ;
183
166
args_info->big_limited_interval_min = 1;
184
167
args_info->big_limited_interval_max = 30;
185
args_info->limited_open_right_help = gengetopt_args_info_help[9] ;
168
args_info->limited_open_right_help = gengetopt_args_info_help[10] ;
186
169
args_info->limited_open_right_min = 3;
187
170
args_info->limited_open_right_max = -1;
188
args_info->limited_open_left_help = gengetopt_args_info_help[10] ;
171
args_info->limited_open_left_help = gengetopt_args_info_help[11] ;
189
172
args_info->limited_open_left_min = -1;
190
173
args_info->limited_open_left_max = 3;
191
args_info->float_help = gengetopt_args_info_help[11] ;
174
args_info->float_help = gengetopt_args_info_help[12] ;
192
175
args_info->float_min = -1;
193
176
args_info->float_max = -1;
194
args_info->no_short_opt_help = gengetopt_args_info_help[12] ;
177
args_info->no_short_opt_help = gengetopt_args_info_help[13] ;
195
178
args_info->no_short_opt_min = -1;
196
179
args_info->no_short_opt_max = -1;
197
args_info->noarg_help = gengetopt_args_info_help[13] ;
180
args_info->noarg_help = gengetopt_args_info_help[14] ;
198
181
args_info->noarg_min = -1;
199
182
args_info->noarg_max = -1;
200
args_info->noarg_noshort_help = gengetopt_args_info_help[14] ;
183
args_info->noarg_noshort_help = gengetopt_args_info_help[15] ;
201
184
args_info->noarg_noshort_min = -1;
202
185
args_info->noarg_noshort_max = -1;
203
args_info->optarg_help = gengetopt_args_info_help[15] ;
186
args_info->optarg_help = gengetopt_args_info_help[16] ;
204
187
args_info->optarg_min = -1;
205
188
args_info->optarg_max = -1;
206
args_info->optarg_noshort_help = gengetopt_args_info_help[16] ;
189
args_info->optarg_noshort_help = gengetopt_args_info_help[17] ;
207
190
args_info->optarg_noshort_min = -1;
208
191
args_info->optarg_noshort_max = -1;
209
args_info->file_save_help = gengetopt_args_info_help[17] ;
192
args_info->file_save_help = gengetopt_args_info_help[18] ;
210
193
211
194
}
212
195
216
199
printf ("%s %s\n", TEST_MULTIPLE_CMD_PARSER_PACKAGE, TEST_MULTIPLE_CMD_PARSER_VERSION);
217
200
}
218
201
219
void
220
test_multiple_cmd_parser_print_help (void)
221
{
222
int i = 0;
202
static void print_help_common(void) {
223
203
test_multiple_cmd_parser_print_version ();
224
204
225
205
if (strlen(gengetopt_args_info_purpose) > 0)
226
206
printf("\n%s\n", gengetopt_args_info_purpose);
227
207
228
printf("\n%s\n\n", gengetopt_args_info_usage);
208
if (strlen(gengetopt_args_info_usage) > 0)
209
printf("\n%s\n", gengetopt_args_info_usage);
210
211
printf("\n");
229
212
230
213
if (strlen(gengetopt_args_info_description) > 0)
231
214
printf("%s\n", gengetopt_args_info_description);
215
}
232
216
217
void
218
test_multiple_cmd_parser_print_help (void)
219
{
220
int i = 0;
221
print_help_common();
233
222
while (gengetopt_args_info_help[i])
234
223
printf("%s\n", gengetopt_args_info_help[i++]);
235
224
}
245
234
args_info->inputs_num = 0;
246
235
}
247
236
248
struct test_multiple_cmd_parser_params *
249
test_multiple_cmd_parser_params_init()
237
void
238
test_multiple_cmd_parser_params_init(struct test_multiple_cmd_parser_params *params)
250
239
{
251
struct test_multiple_cmd_parser_params *params =
252
(struct test_multiple_cmd_parser_params *)malloc(sizeof(struct test_multiple_cmd_parser_params));
253
254
240
if (params)
255
241
{
256
242
params->override = 0;
257
params->initialize = 0;
258
params->check_required = 0;
243
params->initialize = 1;
244
params->check_required = 1;
259
245
params->check_ambiguity = 0;
246
params->print_errors = 1;
260
247
}
261
248
}
249
250
struct test_multiple_cmd_parser_params *
251
test_multiple_cmd_parser_params_create(void)
252
{
253
struct test_multiple_cmd_parser_params *params =
254
(struct test_multiple_cmd_parser_params *)malloc(sizeof(struct test_multiple_cmd_parser_params));
255
test_multiple_cmd_parser_params_init(params);
262
256
return params;
263
257
}
264
258
265
259
static void
260
free_string_field (char **s)
261
{
262
if (*s)
263
{
264
free (*s);
265
*s = 0;
266
}
267
}
268
269
/** @brief generic value variable */
270
union generic_value {
271
int int_arg;
272
short short_arg;
273
long long_arg;
274
float float_arg;
275
#ifdef HAVE_LONG_LONG
276
long long int longlong_arg;
277
#else
278
long longlong_arg;
279
#endif
280
char *string_arg;
281
};
282
283
/** @brief holds temporary values for multiple options */
284
struct generic_list
285
{
286
union generic_value arg;
287
char *orig;
288
struct generic_list *next;
289
};
290
291
/**
292
* @brief add a node at the head of the list
293
*/
294
static void add_node(struct generic_list **list) {
295
struct generic_list *new_node = (struct generic_list *) malloc (sizeof (struct generic_list));
296
new_node->next = *list;
297
*list = new_node;
298
new_node->arg.string_arg = NULL;
299
new_node->orig = NULL;
300
}
301
302
static void
303
free_multiple_field(unsigned int len, void **arg, char ***orig)
304
{
305
unsigned int i;
306
if (*arg) {
307
for (i = 0; i < len; ++i)
308
{
309
free_string_field(&((*orig)[i]));
310
}
311
312
free (*arg);
313
*arg = 0;
314
free (*orig);
315
*orig = 0;
316
}
317
}
318
319
static void
320
free_multiple_string_field(unsigned int len, char ***arg, char ***orig)
321
{
322
unsigned int i;
323
if (*arg) {
324
for (i = 0; i < len; ++i)
325
{
326
free_string_field(&((*arg)[i]));
327
free_string_field(&((*orig)[i]));
328
}
329
free_string_field(&((*arg)[0])); /* free default string */
330
331
free (*arg);
332
*arg = 0;
333
free (*orig);
334
*orig = 0;
335
}
336
}
337
338
static void
266
339
test_multiple_cmd_parser_release (struct gengetopt_args_info *args_info)
267
340
{
268
269
341
unsigned int i;
270
if (args_info->string_arg)
271
{
272
for (i = 0; i < args_info->string_given; ++i)
273
{
274
if (args_info->string_arg [i])
275
{
276
free (args_info->string_arg [i]); /* free previous argument */
277
args_info->string_arg [i] = 0;
278
}
279
if (args_info->string_orig [i])
280
{
281
free (args_info->string_orig [i]); /* free previous argument */
282
args_info->string_orig [i] = 0;
283
}
284
}
285
if (args_info->string_arg [0])
286
free (args_info->string_arg [0]); /* free default string */
287
free (args_info->string_arg); /* free previous argument */
288
args_info->string_arg = 0;
289
free (args_info->string_orig); /* free previous argument */
290
args_info->string_orig = 0;
291
}
292
if (args_info->int_arg)
293
{
294
for (i = 0; i < args_info->int_given; ++i)
295
{
296
if (args_info->int_orig [i])
297
{
298
free (args_info->int_orig [i]); /* free previous argument */
299
args_info->int_orig [i] = 0;
300
}
301
}
302
free (args_info->int_arg); /* free previous argument */
303
args_info->int_arg = 0;
304
free (args_info->int_orig); /* free previous argument */
305
args_info->int_orig = 0;
306
}
307
if (args_info->short_arg)
308
{
309
for (i = 0; i < args_info->short_given; ++i)
310
{
311
if (args_info->short_orig [i])
312
{
313
free (args_info->short_orig [i]); /* free previous argument */
314
args_info->short_orig [i] = 0;
315
}
316
}
317
free (args_info->short_arg); /* free previous argument */
318
args_info->short_arg = 0;
319
free (args_info->short_orig); /* free previous argument */
320
args_info->short_orig = 0;
321
}
322
if (args_info->long_arg)
323
{
324
for (i = 0; i < args_info->long_given; ++i)
325
{
326
if (args_info->long_orig [i])
327
{
328
free (args_info->long_orig [i]); /* free previous argument */
329
args_info->long_orig [i] = 0;
330
}
331
}
332
free (args_info->long_arg); /* free previous argument */
333
args_info->long_arg = 0;
334
free (args_info->long_orig); /* free previous argument */
335
args_info->long_orig = 0;
336
}
337
if (args_info->limited_arg)
338
{
339
for (i = 0; i < args_info->limited_given; ++i)
340
{
341
if (args_info->limited_arg [i])
342
{
343
free (args_info->limited_arg [i]); /* free previous argument */
344
args_info->limited_arg [i] = 0;
345
}
346
if (args_info->limited_orig [i])
347
{
348
free (args_info->limited_orig [i]); /* free previous argument */
349
args_info->limited_orig [i] = 0;
350
}
351
}
352
if (args_info->limited_arg [0])
353
free (args_info->limited_arg [0]); /* free default string */
354
free (args_info->limited_arg); /* free previous argument */
355
args_info->limited_arg = 0;
356
free (args_info->limited_orig); /* free previous argument */
357
args_info->limited_orig = 0;
358
}
359
if (args_info->limited_interval_arg)
360
{
361
for (i = 0; i < args_info->limited_interval_given; ++i)
362
{
363
if (args_info->limited_interval_arg [i])
364
{
365
free (args_info->limited_interval_arg [i]); /* free previous argument */
366
args_info->limited_interval_arg [i] = 0;
367
}
368
if (args_info->limited_interval_orig [i])
369
{
370
free (args_info->limited_interval_orig [i]); /* free previous argument */
371
args_info->limited_interval_orig [i] = 0;
372
}
373
}
374
if (args_info->limited_interval_arg [0])
375
free (args_info->limited_interval_arg [0]); /* free default string */
376
free (args_info->limited_interval_arg); /* free previous argument */
377
args_info->limited_interval_arg = 0;
378
free (args_info->limited_interval_orig); /* free previous argument */
379
args_info->limited_interval_orig = 0;
380
}
381
if (args_info->big_limited_interval_arg)
382
{
383
for (i = 0; i < args_info->big_limited_interval_given; ++i)
384
{
385
if (args_info->big_limited_interval_arg [i])
386
{
387
free (args_info->big_limited_interval_arg [i]); /* free previous argument */
388
args_info->big_limited_interval_arg [i] = 0;
389
}
390
if (args_info->big_limited_interval_orig [i])
391
{
392
free (args_info->big_limited_interval_orig [i]); /* free previous argument */
393
args_info->big_limited_interval_orig [i] = 0;
394
}
395
}
396
if (args_info->big_limited_interval_arg [0])
397
free (args_info->big_limited_interval_arg [0]); /* free default string */
398
free (args_info->big_limited_interval_arg); /* free previous argument */
399
args_info->big_limited_interval_arg = 0;
400
free (args_info->big_limited_interval_orig); /* free previous argument */
401
args_info->big_limited_interval_orig = 0;
402
}
403
if (args_info->limited_open_right_arg)
404
{
405
for (i = 0; i < args_info->limited_open_right_given; ++i)
406
{
407
if (args_info->limited_open_right_arg [i])
408
{
409
free (args_info->limited_open_right_arg [i]); /* free previous argument */
410
args_info->limited_open_right_arg [i] = 0;
411
}
412
if (args_info->limited_open_right_orig [i])
413
{
414
free (args_info->limited_open_right_orig [i]); /* free previous argument */
415
args_info->limited_open_right_orig [i] = 0;
416
}
417
}
418
if (args_info->limited_open_right_arg [0])
419
free (args_info->limited_open_right_arg [0]); /* free default string */
420
free (args_info->limited_open_right_arg); /* free previous argument */
421
args_info->limited_open_right_arg = 0;
422
free (args_info->limited_open_right_orig); /* free previous argument */
423
args_info->limited_open_right_orig = 0;
424
}
425
if (args_info->limited_open_left_arg)
426
{
427
for (i = 0; i < args_info->limited_open_left_given; ++i)
428
{
429
if (args_info->limited_open_left_arg [i])
430
{
431
free (args_info->limited_open_left_arg [i]); /* free previous argument */
432
args_info->limited_open_left_arg [i] = 0;
433
}
434
if (args_info->limited_open_left_orig [i])
435
{
436
free (args_info->limited_open_left_orig [i]); /* free previous argument */
437
args_info->limited_open_left_orig [i] = 0;
438
}
439
}
440
if (args_info->limited_open_left_arg [0])
441
free (args_info->limited_open_left_arg [0]); /* free default string */
442
free (args_info->limited_open_left_arg); /* free previous argument */
443
args_info->limited_open_left_arg = 0;
444
free (args_info->limited_open_left_orig); /* free previous argument */
445
args_info->limited_open_left_orig = 0;
446
}
447
if (args_info->float_arg)
448
{
449
for (i = 0; i < args_info->float_given; ++i)
450
{
451
if (args_info->float_orig [i])
452
{
453
free (args_info->float_orig [i]); /* free previous argument */
454
args_info->float_orig [i] = 0;
455
}
456
}
457
free (args_info->float_arg); /* free previous argument */
458
args_info->float_arg = 0;
459
free (args_info->float_orig); /* free previous argument */
460
args_info->float_orig = 0;
461
}
462
if (args_info->no_short_opt_arg)
463
{
464
for (i = 0; i < args_info->no_short_opt_given; ++i)
465
{
466
if (args_info->no_short_opt_arg [i])
467
{
468
free (args_info->no_short_opt_arg [i]); /* free previous argument */
469
args_info->no_short_opt_arg [i] = 0;
470
}
471
if (args_info->no_short_opt_orig [i])
472
{
473
free (args_info->no_short_opt_orig [i]); /* free previous argument */
474
args_info->no_short_opt_orig [i] = 0;
475
}
476
}
477
if (args_info->no_short_opt_arg [0])
478
free (args_info->no_short_opt_arg [0]); /* free default string */
479
free (args_info->no_short_opt_arg); /* free previous argument */
480
args_info->no_short_opt_arg = 0;
481
free (args_info->no_short_opt_orig); /* free previous argument */
482
args_info->no_short_opt_orig = 0;
483
}
484
if (args_info->optarg_arg)
485
{
486
for (i = 0; i < args_info->optarg_given; ++i)
487
{
488
if (args_info->optarg_arg [i])
489
{
490
free (args_info->optarg_arg [i]); /* free previous argument */
491
args_info->optarg_arg [i] = 0;
492
}
493
if (args_info->optarg_orig [i])
494
{
495
free (args_info->optarg_orig [i]); /* free previous argument */
496
args_info->optarg_orig [i] = 0;
497
}
498
}
499
if (args_info->optarg_arg [0])
500
free (args_info->optarg_arg [0]); /* free default string */
501
free (args_info->optarg_arg); /* free previous argument */
502
args_info->optarg_arg = 0;
503
free (args_info->optarg_orig); /* free previous argument */
504
args_info->optarg_orig = 0;
505
}
506
if (args_info->optarg_noshort_arg)
507
{
508
for (i = 0; i < args_info->optarg_noshort_given; ++i)
509
{
510
if (args_info->optarg_noshort_arg [i])
511
{
512
free (args_info->optarg_noshort_arg [i]); /* free previous argument */
513
args_info->optarg_noshort_arg [i] = 0;
514
}
515
if (args_info->optarg_noshort_orig [i])
516
{
517
free (args_info->optarg_noshort_orig [i]); /* free previous argument */
518
args_info->optarg_noshort_orig [i] = 0;
519
}
520
}
521
if (args_info->optarg_noshort_arg [0])
522
free (args_info->optarg_noshort_arg [0]); /* free default string */
523
free (args_info->optarg_noshort_arg); /* free previous argument */
524
args_info->optarg_noshort_arg = 0;
525
free (args_info->optarg_noshort_orig); /* free previous argument */
526
args_info->optarg_noshort_orig = 0;
527
}
528
if (args_info->file_save_arg)
529
{
530
free (args_info->file_save_arg); /* free previous argument */
531
args_info->file_save_arg = 0;
532
}
533
if (args_info->file_save_orig)
534
{
535
free (args_info->file_save_orig); /* free previous argument */
536
args_info->file_save_orig = 0;
537
}
342
free_multiple_string_field (args_info->string_given, &(args_info->string_arg), &(args_info->string_orig));
343
free_multiple_field (args_info->int_given, (void **)&(args_info->int_arg), &(args_info->int_orig));
344
free_multiple_field (args_info->short_given, (void **)&(args_info->short_arg), &(args_info->short_orig));
345
free_multiple_field (args_info->long_given, (void **)&(args_info->long_arg), &(args_info->long_orig));
346
free_multiple_field (args_info->longlong_given, (void **)&(args_info->longlong_arg), &(args_info->longlong_orig));
347
free_multiple_string_field (args_info->limited_given, &(args_info->limited_arg), &(args_info->limited_orig));
348
free_multiple_string_field (args_info->limited_interval_given, &(args_info->limited_interval_arg), &(args_info->limited_interval_orig));
349
free_multiple_string_field (args_info->big_limited_interval_given, &(args_info->big_limited_interval_arg), &(args_info->big_limited_interval_orig));
350
free_multiple_string_field (args_info->limited_open_right_given, &(args_info->limited_open_right_arg), &(args_info->limited_open_right_orig));
351
free_multiple_string_field (args_info->limited_open_left_given, &(args_info->limited_open_left_arg), &(args_info->limited_open_left_orig));
352
free_multiple_field (args_info->float_given, (void **)&(args_info->float_arg), &(args_info->float_orig));
353
free_multiple_string_field (args_info->no_short_opt_given, &(args_info->no_short_opt_arg), &(args_info->no_short_opt_orig));
354
free_multiple_string_field (args_info->optarg_given, &(args_info->optarg_arg), &(args_info->optarg_orig));
355
free_multiple_string_field (args_info->optarg_noshort_given, &(args_info->optarg_noshort_arg), &(args_info->optarg_noshort_orig));
356
free_string_field (&(args_info->file_save_arg));
357
free_string_field (&(args_info->file_save_orig));
358
538
359
539
360
for (i = 0; i < args_info->inputs_num; ++i)
540
361
free (args_info->inputs [i]);
541
362
542
363
if (args_info->inputs_num)
543
364
free (args_info->inputs);
544
365
545
366
clear_given (args_info);
546
367
}
547
368
369
370
static void
371
write_into_file(FILE *outfile, const char *opt, const char *arg, char *values[])
372
{
373
if (arg) {
374
fprintf(outfile, "%s=\"%s\"\n", opt, arg);
375
} else {
376
fprintf(outfile, "%s\n", opt);
377
}
378
}
379
380
static void
381
write_multiple_into_file(FILE *outfile, int len, const char *opt, char **arg, char *values[])
382
{
383
int i;
384
385
for (i = 0; i < len; ++i)
386
write_into_file(outfile, opt, (arg ? arg[i] : 0), values);
387
}
388
389
int
390
test_multiple_cmd_parser_dump(FILE *outfile, struct gengetopt_args_info *args_info)
391
{
392
int i = 0;
393
394
if (!outfile)
395
{
396
fprintf (stderr, "%s: cannot dump options to stream\n", TEST_MULTIPLE_CMD_PARSER_PACKAGE);
397
return EXIT_FAILURE;
398
}
399
400
if (args_info->help_given)
401
write_into_file(outfile, "help", 0, 0 );
402
if (args_info->version_given)
403
write_into_file(outfile, "version", 0, 0 );
404
write_multiple_into_file(outfile, args_info->string_given, "string", args_info->string_orig, 0);
405
write_multiple_into_file(outfile, args_info->int_given, "int", args_info->int_orig, 0);
406
write_multiple_into_file(outfile, args_info->short_given, "short", args_info->short_orig, 0);
407
write_multiple_into_file(outfile, args_info->long_given, "long", args_info->long_orig, 0);
408
write_multiple_into_file(outfile, args_info->longlong_given, "longlong", args_info->longlong_orig, 0);
409
write_multiple_into_file(outfile, args_info->limited_given, "limited", args_info->limited_orig, 0);
410
write_multiple_into_file(outfile, args_info->limited_interval_given, "limited-interval", args_info->limited_interval_orig, 0);
411
write_multiple_into_file(outfile, args_info->big_limited_interval_given, "big-limited-interval", args_info->big_limited_interval_orig, 0);
412
write_multiple_into_file(outfile, args_info->limited_open_right_given, "limited-open-right", args_info->limited_open_right_orig, 0);
413
write_multiple_into_file(outfile, args_info->limited_open_left_given, "limited-open-left", args_info->limited_open_left_orig, 0);
414
write_multiple_into_file(outfile, args_info->float_given, "float", args_info->float_orig, 0);
415
write_multiple_into_file(outfile, args_info->no_short_opt_given, "no-short-opt", args_info->no_short_opt_orig, 0);
416
write_multiple_into_file(outfile, args_info->noarg_given, "noarg", 0, 0);
417
write_multiple_into_file(outfile, args_info->noarg_noshort_given, "noarg-noshort", 0, 0);
418
write_multiple_into_file(outfile, args_info->optarg_given, "optarg", args_info->optarg_orig, 0);
419
write_multiple_into_file(outfile, args_info->optarg_noshort_given, "optarg-noshort", args_info->optarg_noshort_orig, 0);
420
if (args_info->file_save_given)
421
write_into_file(outfile, "file-save", args_info->file_save_orig, 0);
422
423
424
i = EXIT_SUCCESS;
425
return i;
426
}
427
548
428
int
549
429
test_multiple_cmd_parser_file_save(const char *filename, struct gengetopt_args_info *args_info)
550
430
{
559
439
return EXIT_FAILURE;
560
440
}
561
441
562
if (args_info->help_given) {
563
fprintf(outfile, "%s\n", "help");
564
}
565
if (args_info->version_given) {
566
fprintf(outfile, "%s\n", "version");
567
}
568
if (args_info->string_orig)
569
{
570
for (i = 0; i < args_info->string_given; ++i)
571
{
572
if (args_info->string_orig [i])
573
{
574
fprintf(outfile, "%s=\"%s\"\n", "string", args_info->string_orig [i]);
575
}
576
}
577
}
578
if (args_info->int_orig)
579
{
580
for (i = 0; i < args_info->int_given; ++i)
581
{
582
if (args_info->int_orig [i])
583
{
584
fprintf(outfile, "%s=\"%s\"\n", "int", args_info->int_orig [i]);
585
}
586
}
587
}
588
if (args_info->short_orig)
589
{
590
for (i = 0; i < args_info->short_given; ++i)
591
{
592
if (args_info->short_orig [i])
593
{
594
fprintf(outfile, "%s=\"%s\"\n", "short", args_info->short_orig [i]);
595
}
596
}
597
}
598
if (args_info->long_orig)
599
{
600
for (i = 0; i < args_info->long_given; ++i)
601
{
602
if (args_info->long_orig [i])
603
{
604
fprintf(outfile, "%s=\"%s\"\n", "long", args_info->long_orig [i]);
605
}
606
}
607
}
608
if (args_info->limited_orig)
609
{
610
for (i = 0; i < args_info->limited_given; ++i)
611
{
612
if (args_info->limited_orig [i])
613
{
614
fprintf(outfile, "%s=\"%s\"\n", "limited", args_info->limited_orig [i]);
615
}
616
}
617
}
618
if (args_info->limited_interval_orig)
619
{
620
for (i = 0; i < args_info->limited_interval_given; ++i)
621
{
622
if (args_info->limited_interval_orig [i])
623
{
624
fprintf(outfile, "%s=\"%s\"\n", "limited-interval", args_info->limited_interval_orig [i]);
625
}
626
}
627
}
628
if (args_info->big_limited_interval_orig)
629
{
630
for (i = 0; i < args_info->big_limited_interval_given; ++i)
631
{
632
if (args_info->big_limited_interval_orig [i])
633
{
634
fprintf(outfile, "%s=\"%s\"\n", "big-limited-interval", args_info->big_limited_interval_orig [i]);
635
}
636
}
637
}
638
if (args_info->limited_open_right_orig)
639
{
640
for (i = 0; i < args_info->limited_open_right_given; ++i)
641
{
642
if (args_info->limited_open_right_orig [i])
643
{
644
fprintf(outfile, "%s=\"%s\"\n", "limited-open-right", args_info->limited_open_right_orig [i]);
645
}
646
}
647
}
648
if (args_info->limited_open_left_orig)
649
{
650
for (i = 0; i < args_info->limited_open_left_given; ++i)
651
{
652
if (args_info->limited_open_left_orig [i])
653
{
654
fprintf(outfile, "%s=\"%s\"\n", "limited-open-left", args_info->limited_open_left_orig [i]);
655
}
656
}
657
}
658
if (args_info->float_orig)
659
{
660
for (i = 0; i < args_info->float_given; ++i)
661
{
662
if (args_info->float_orig [i])
663
{
664
fprintf(outfile, "%s=\"%s\"\n", "float", args_info->float_orig [i]);
665
}
666
}
667
}
668
if (args_info->no_short_opt_orig)
669
{
670
for (i = 0; i < args_info->no_short_opt_given; ++i)
671
{
672
if (args_info->no_short_opt_orig [i])
673
{
674
fprintf(outfile, "%s=\"%s\"\n", "no-short-opt", args_info->no_short_opt_orig [i]);
675
}
676
}
677
}
678
for (i = 0; i < args_info->noarg_given; ++i)
679
{
680
fprintf(outfile, "%s\n", "noarg");
681
682
}
683
for (i = 0; i < args_info->noarg_noshort_given; ++i)
684
{
685
fprintf(outfile, "%s\n", "noarg-noshort");
686
687
}
688
if (args_info->optarg_orig)
689
{
690
for (i = 0; i < args_info->optarg_given; ++i)
691
{
692
if (args_info->optarg_orig [i])
693
{
694
fprintf(outfile, "%s=\"%s\"\n", "optarg", args_info->optarg_orig [i]);
695
}
696
}
697
}
698
if (args_info->optarg_noshort_orig)
699
{
700
for (i = 0; i < args_info->optarg_noshort_given; ++i)
701
{
702
if (args_info->optarg_noshort_orig [i])
703
{
704
fprintf(outfile, "%s=\"%s\"\n", "optarg-noshort", args_info->optarg_noshort_orig [i]);
705
}
706
}
707
}
708
if (args_info->file_save_given) {
709
if (args_info->file_save_orig) {
710
fprintf(outfile, "%s=\"%s\"\n", "file-save", args_info->file_save_orig);
711
} else {
712
fprintf(outfile, "%s\n", "file-save");
713
}
714
}
715
442
i = test_multiple_cmd_parser_dump(outfile, args_info);
716
443
fclose (outfile);
717
444
718
i = EXIT_SUCCESS;
719
445
return i;
720
446
}
721
447
725
451
test_multiple_cmd_parser_release (args_info);
726
452
}
727
453
728
729
/* gengetopt_strdup() */
730
/* strdup.c replacement of strdup, which is not standard */
454
/** @brief replacement of strdup, which is not standard */
731
455
char *
732
456
gengetopt_strdup (const char *s)
733
457
{
909
633
params.initialize = initialize;
910
634
params.check_required = check_required;
911
635
params.check_ambiguity = 0;
636
params.print_errors = 1;
912
637
913
638
result = test_multiple_cmd_parser_internal (argc, argv, args_info, ¶ms, NULL);
914
639
962
687
if (check_multiple_option_occurrences(prog_name, args_info->long_given, args_info->long_min, args_info->long_max, "'--long' ('-l')"))
963
688
error = 1;
964
689
690
if (check_multiple_option_occurrences(prog_name, args_info->longlong_given, args_info->longlong_min, args_info->longlong_max, "'--longlong'"))
691
error = 1;
692
965
693
if (check_multiple_option_occurrences(prog_name, args_info->limited_given, args_info->limited_min, args_info->limited_max, "'--limited' ('-L')"))
966
694
error = 1;
967
695
1001
729
return error;
1002
730
}
1003
731
732
733
static char *package_name = 0;
734
735
/**
736
* @brief updates an option
737
* @param field the generic pointer to the field to update
738
* @param orig_field the pointer to the orig field
739
* @param field_given the pointer to the number of occurrence of this option
740
* @param prev_given the pointer to the number of occurrence already seen
741
* @param value the argument for this option (if null no arg was specified)
742
* @param possible_values the possible values for this option (if specified)
743
* @param default_value the default value (in case the option only accepts fixed values)
744
* @param arg_type the type of this option
745
* @param check_ambiguity @see test_multiple_cmd_parser_params.check_ambiguity
746
* @param override @see test_multiple_cmd_parser_params.override
747
* @param no_free whether to free a possible previous value
748
* @param multiple_option whether this is a multiple option
749
* @param long_opt the corresponding long option
750
* @param short_opt the corresponding short option (or '-' if none)
751
* @param additional_error possible further error specification
752
*/
753
static
754
int update_arg(void *field, char **orig_field,
755
unsigned int *field_given, unsigned int *prev_given,
756
char *value, char *possible_values[], const char *default_value,
757
test_multiple_cmd_parser_arg_type arg_type,
758
int check_ambiguity, int override,
759
int no_free, int multiple_option,
760
const char *long_opt, char short_opt,
761
const char *additional_error)
762
{
763
char *stop_char = 0;
764
const char *val = value;
765
int found;
766
char **string_field;
767
768
stop_char = 0;
769
found = 0;
770
771
if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given)))
772
{
773
if (short_opt != '-')
774
fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n",
775
package_name, long_opt, short_opt,
776
(additional_error ? additional_error : ""));
777
else
778
fprintf (stderr, "%s: `--%s' option given more than once%s\n",
779
package_name, long_opt,
780
(additional_error ? additional_error : ""));
781
return 1; /* failure */
782
}
783
784
785
if (field_given && *field_given && ! override)
786
return 0;
787
if (prev_given)
788
(*prev_given)++;
789
if (field_given)
790
(*field_given)++;
791
if (possible_values)
792
val = possible_values[found];
793
794
switch(arg_type) {
795
case ARG_INT:
796
if (val) *((int *)field) = strtol (val, &stop_char, 0);
797
break;
798
case ARG_SHORT:
799
if (val) *((short *)field) = (short)strtol (val, &stop_char, 0);
800
break;
801
case ARG_LONG:
802
if (val) *((long *)field) = (long)strtol (val, &stop_char, 0);
803
break;
804
case ARG_FLOAT:
805
if (val) *((float *)field) = (float)strtod (val, &stop_char);
806
break;
807
case ARG_LONGLONG:
808
#ifdef HAVE_LONG_LONG
809
if (val) *((long long int*)field) = (long long int) strtol (val, &stop_char, 0);
810
#else
811
if (val) *((long *)field) = (long)strtol (val, &stop_char, 0);
812
#endif
813
break;
814
case ARG_STRING:
815
if (val) {
816
string_field = (char **)field;
817
if (!no_free && *string_field)
818
free (*string_field); /* free previous string */
819
*string_field = gengetopt_strdup (val);
820
}
821
break;
822
default:
823
break;
824
};
825
826
/* check numeric conversion */
827
switch(arg_type) {
828
case ARG_INT:
829
case ARG_SHORT:
830
case ARG_LONG:
831
case ARG_FLOAT:
832
case ARG_LONGLONG:
833
if (val && !(stop_char && *stop_char == '\0')) {
834
fprintf(stderr, "%s: invalid numeric value: %s\n", package_name, val);
835
return 1; /* failure */
836
}
837
break;
838
default:
839
;
840
};
841
842
/* store the original value */
843
switch(arg_type) {
844
case ARG_NO:
845
break;
846
default:
847
if (value && orig_field) {
848
if (no_free) {
849
*orig_field = value;
850
} else {
851
if (*orig_field)
852
free (*orig_field); /* free previous string */
853
*orig_field = gengetopt_strdup (value);
854
}
855
}
856
};
857
858
return 0; /* OK */
859
}
860
861
/**
862
* @brief store information about a multiple option in a temporary list
863
* @param list where to (temporarily) store multiple options
864
*/
865
static
866
int update_multiple_arg_temp(struct generic_list **list,
867
unsigned int *prev_given, const char *val,
868
char *possible_values[], const char *default_value,
869
test_multiple_cmd_parser_arg_type arg_type,
870
const char *long_opt, char short_opt,
871
const char *additional_error)
872
{
873
char *multi_token, *multi_next; /* store single arguments */
874
875
if (arg_type == ARG_NO) {
876
(*prev_given)++;
877
return 0; /* OK */
878
}
879
880
multi_token = get_multiple_arg_token(val);
881
multi_next = get_multiple_arg_token_next (val);
882
883
while (1)
884
{
885
add_node (list);
886
if (update_arg((void *)&((*list)->arg), &((*list)->orig), 0,
887
prev_given, multi_token, possible_values, default_value,
888
arg_type, 0, 1, 1, 1, long_opt, short_opt, additional_error)) {
889
if (multi_token) free(multi_token);
890
return 1; /* failure */
891
}
892
893
if (multi_next)
894
{
895
multi_token = get_multiple_arg_token(multi_next);
896
multi_next = get_multiple_arg_token_next (multi_next);
897
}
898
else
899
break;
900
}
901
902
return 0; /* OK */
903
}
904
905
/**
906
* @brief free the passed list (including possible string argument)
907
*/
908
static
909
void free_list(struct generic_list *list, short string_arg)
910
{
911
if (list) {
912
struct generic_list *tmp;
913
while (list)
914
{
915
tmp = list;
916
if (string_arg && list->arg.string_arg)
917
free (list->arg.string_arg);
918
if (list->orig)
919
free (list->orig);
920
list = list->next;
921
free (tmp);
922
}
923
}
924
}
925
926
/**
927
* @brief updates a multiple option starting from the passed list
928
*/
929
static
930
void update_multiple_arg(void *field, char ***orig_field,
931
unsigned int field_given, unsigned int prev_given, union generic_value *default_value,
932
test_multiple_cmd_parser_arg_type arg_type,
933
struct generic_list *list)
934
{
935
int i;
936
struct generic_list *tmp;
937
938
if (prev_given && list) {
939
*orig_field = (char **) realloc (*orig_field, (field_given + prev_given) * sizeof (char *));
940
941
switch(arg_type) {
942
case ARG_INT:
943
*((int **)field) = (int *)realloc (*((int **)field), (field_given + prev_given) * sizeof (int)); break;
944
case ARG_SHORT:
945
*((short **)field) = (short *)realloc (*((short **)field), (field_given + prev_given) * sizeof (short)); break;
946
case ARG_LONG:
947
*((long **)field) = (long *)realloc (*((long **)field), (field_given + prev_given) * sizeof (long)); break;
948
case ARG_FLOAT:
949
*((float **)field) = (float *)realloc (*((float **)field), (field_given + prev_given) * sizeof (float)); break;
950
case ARG_LONGLONG:
951
#ifdef HAVE_LONG_LONG
952
*((long long int **)field) = (long long int *)realloc (*((long long int **)field), (field_given + prev_given) * sizeof (long long int)); break;
953
#else
954
*((long **)field) = (long *)realloc (*((long **)field), (field_given + prev_given) * sizeof (long)); break;
955
#endif
956
case ARG_STRING:
957
*((char ***)field) = (char **)realloc (*((char ***)field), (field_given + prev_given) * sizeof (char *)); break;
958
default:
959
break;
960
};
961
962
for (i = (prev_given - 1); i >= 0; --i)
963
{
964
tmp = list;
965
966
switch(arg_type) {
967
case ARG_INT:
968
(*((int **)field))[i + field_given] = tmp->arg.int_arg; break;
969
case ARG_SHORT:
970
(*((short **)field))[i + field_given] = tmp->arg.short_arg; break;
971
case ARG_LONG:
972
(*((long **)field))[i + field_given] = tmp->arg.long_arg; break;
973
case ARG_FLOAT:
974
(*((float **)field))[i + field_given] = tmp->arg.float_arg; break;
975
case ARG_LONGLONG:
976
#ifdef HAVE_LONG_LONG
977
(*((long long int **)field))[i + field_given] = tmp->arg.longlong_arg; break;
978
#else
979
(*((long **)field))[i + field_given] = tmp->arg.longlong_arg; break;
980
#endif
981
case ARG_STRING:
982
(*((char ***)field))[i + field_given] = tmp->arg.string_arg; break;
983
default:
984
break;
985
}
986
(*orig_field) [i + field_given] = list->orig;
987
list = list->next;
988
free (tmp);
989
}
990
} else { /* set the default value */
991
if (default_value && ! field_given) {
992
switch(arg_type) {
993
case ARG_INT:
994
if (! *((int **)field)) {
995
*((int **)field) = (int *)malloc (sizeof (int));
996
(*((int **)field))[0] = default_value->int_arg;
997
}
998
break;
999
case ARG_SHORT:
1000
if (! *((short **)field)) {
1001
*((short **)field) = (short *)malloc (sizeof (short));
1002
(*((short **)field))[0] = default_value->short_arg;
1003
}
1004
break;
1005
case ARG_LONG:
1006
if (! *((long **)field)) {
1007
*((long **)field) = (long *)malloc (sizeof (long));
1008
(*((long **)field))[0] = default_value->long_arg;
1009
}
1010
break;
1011
case ARG_FLOAT:
1012
if (! *((float **)field)) {
1013
*((float **)field) = (float *)malloc (sizeof (float));
1014
(*((float **)field))[0] = default_value->float_arg;
1015
}
1016
break;
1017
case ARG_LONGLONG:
1018
#ifdef HAVE_LONG_LONG
1019
if (! *((long long int **)field)) {
1020
*((long long int **)field) = (long long int *)malloc (sizeof (long long int));
1021
(*((long long int **)field))[0] = default_value->longlong_arg;
1022
}
1023
#else
1024
if (! *((long **)field)) {
1025
*((long **)field) = (long *)malloc (sizeof (long));
1026
(*((long **)field))[0] = default_value->longlong_arg;
1027
}
1028
#endif
1029
break;
1030
case ARG_STRING:
1031
if (! *((char ***)field)) {
1032
*((char ***)field) = (char **)malloc (sizeof (char *));
1033
(*((char ***)field))[0] = gengetopt_strdup(default_value->string_arg);
1034
}
1035
break;
1036
default: break;
1037
}
1038
if (!(*orig_field)) {
1039
*orig_field = (char **) malloc (sizeof (char *));
1040
(*orig_field)[0] = NULL;
1041
}
1042
}
1043
}
1044
}
1045
1004
1046
int
1005
1047
test_multiple_cmd_parser_internal (int argc, char * const *argv, struct gengetopt_args_info *args_info,
1006
1048
struct test_multiple_cmd_parser_params *params, const char *additional_error)
1007
1049
{
1008
1050
int c; /* Character of the parsed option. */
1009
char *multi_token, *multi_next; /* for multiple options */
1010
1011
int i; /* Counter */
1012
1013
struct string_list * string_list = NULL,* string_new = NULL;
1014
struct int_list * int_list = NULL,* int_new = NULL;
1015
struct short_list * short_list = NULL,* short_new = NULL;
1016
struct long_list * long_list = NULL,* long_new = NULL;
1017
struct string_list * limited_list = NULL,* limited_new = NULL;
1018
struct string_list * limited_interval_list = NULL,* limited_interval_new = NULL;
1019
struct string_list * big_limited_interval_list = NULL,* big_limited_interval_new = NULL;
1020
struct string_list * limited_open_right_list = NULL,* limited_open_right_new = NULL;
1021
struct string_list * limited_open_left_list = NULL,* limited_open_left_new = NULL;
1022
struct float_list * float_list = NULL,* float_new = NULL;
1023
struct string_list * no_short_opt_list = NULL,* no_short_opt_new = NULL;
1024
struct string_list * optarg_list = NULL,* optarg_new = NULL;
1025
struct string_list * optarg_noshort_list = NULL,* optarg_noshort_new = NULL;
1051
union generic_value multiple_default_value;
1052
1053
struct generic_list * string_list = NULL;
1054
struct generic_list * int_list = NULL;
1055
struct generic_list * short_list = NULL;
1056
struct generic_list * long_list = NULL;
1057
struct generic_list * longlong_list = NULL;
1058
struct generic_list * limited_list = NULL;
1059
struct generic_list * limited_interval_list = NULL;
1060
struct generic_list * big_limited_interval_list = NULL;
1061
struct generic_list * limited_open_right_list = NULL;
1062
struct generic_list * limited_open_left_list = NULL;
1063
struct generic_list * float_list = NULL;
1064
struct generic_list * no_short_opt_list = NULL;
1065
struct generic_list * optarg_list = NULL;
1066
struct generic_list * optarg_noshort_list = NULL;
1026
1067
int error = 0;
1027
1068
struct gengetopt_args_info local_args_info;
1028
1069
1031
1072
int check_required;
1032
1073
int check_ambiguity;
1033
1074
1075
package_name = argv[0];
1076
1034
1077
override = params->override;
1035
1078
initialize = params->initialize;
1036
1079
check_required = params->check_required;
1043
1086
1044
1087
optarg = 0;
1045
1088
optind = 0;
1046
opterr = 1;
1089
opterr = params->print_errors;
1047
1090
optopt = '?';
1048
1091
1049
1092
while (1)
1050
1093
{
1051
1094
int option_index = 0;
1052
char *stop_char;
1053
1095
1054
1096
static struct option long_options[] = {
1055
1097
{ "help", 0, NULL, 'h' },
1058
1100
{ "int", 1, NULL, 'i' },
1059
1101
{ "short", 1, NULL, 'S' },
1060
1102
{ "long", 1, NULL, 'l' },
1103
{ "longlong", 1, NULL, 0 },
1061
1104
{ "limited", 1, NULL, 'L' },
1062
1105
{ "limited-interval", 1, NULL, 0 },
1063
1106
{ "big-limited-interval", 1, NULL, 0 },
1073
1116
{ NULL, 0, NULL, 0 }
1074
1117
};
1075
1118
1076
stop_char = 0;
1077
1119
c = getopt_long (argc, argv, "hVs:i:S:l:L:f:nM::", long_options, &option_index);
1078
1120
1079
1121
if (c == -1) break; /* Exit from `while (1)' loop. */
1091
1133
exit (EXIT_SUCCESS);
1092
1134
1093
1135
case 's': /* string option. */
1094
local_args_info.string_given++;
1095
1096
multi_token = get_multiple_arg_token(optarg);
1097
multi_next = get_multiple_arg_token_next (optarg);
1098
1099
while (1)
1100
{
1101
string_new = (struct string_list *) malloc (sizeof (struct string_list));
1102
string_new->next = string_list;
1103
string_list = string_new;
1104
string_new->arg = gengetopt_strdup (multi_token);
1105
string_new->orig = multi_token;
1106
1107
if (multi_next)
1108
{
1109
multi_token = get_multiple_arg_token(multi_next);
1110
multi_next = get_multiple_arg_token_next (multi_next);
1111
local_args_info.string_given++;
1112
}
1113
else
1114
break;
1115
}
1136
1137
if (update_multiple_arg_temp(&string_list,
1138
&(local_args_info.string_given), optarg, 0, "foo", ARG_STRING,
1139
"string", 's',
1140
additional_error))
1141
goto failure;
1142
1116
1143
break;
1117
1118
1144
case 'i': /* int option. */
1119
local_args_info.int_given++;
1120
1121
multi_token = get_multiple_arg_token(optarg);
1122
multi_next = get_multiple_arg_token_next (optarg);
1123
1124
while (1)
1125
{
1126
int_new = (struct int_list *) malloc (sizeof (struct int_list));
1127
int_new->next = int_list;
1128
int_list = int_new;
1129
int_new->arg = strtol (multi_token, &stop_char, 0);
1130
if (!(stop_char && *stop_char == '\0')) {
1131
fprintf(stderr, "%s: invalid numeric value: %s\n", argv[0], multi_token);
1132
goto failure;
1133
}
1134
int_new->orig = multi_token;
1135
1136
if (multi_next)
1137
{
1138
multi_token = get_multiple_arg_token(multi_next);
1139
multi_next = get_multiple_arg_token_next (multi_next);
1140
local_args_info.int_given++;
1141
}
1142
else
1143
break;
1144
}
1145
1146
if (update_multiple_arg_temp(&int_list,
1147
&(local_args_info.int_given), optarg, 0, 0, ARG_INT,
1148
"int", 'i',
1149
additional_error))
1150
goto failure;
1151
1145
1152
break;
1146
1147
1153
case 'S': /* short option. */
1148
local_args_info.short_given++;
1149
1150
multi_token = get_multiple_arg_token(optarg);
1151
multi_next = get_multiple_arg_token_next (optarg);
1152
1153
while (1)
1154
{
1155
short_new = (struct short_list *) malloc (sizeof (struct short_list));
1156
short_new->next = short_list;
1157
short_list = short_new;
1158
short_new->arg = (short)strtol (multi_token, &stop_char, 0);
1159
if (!(stop_char && *stop_char == '\0')) {
1160
fprintf(stderr, "%s: invalid numeric value: %s\n", argv[0], multi_token);
1161
goto failure;
1162
}
1163
short_new->orig = multi_token;
1164
1165
if (multi_next)
1166
{
1167
multi_token = get_multiple_arg_token(multi_next);
1168
multi_next = get_multiple_arg_token_next (multi_next);
1169
local_args_info.short_given++;
1170
}
1171
else
1172
break;
1173
}
1154
1155
if (update_multiple_arg_temp(&short_list,
1156
&(local_args_info.short_given), optarg, 0, 0, ARG_SHORT,
1157
"short", 'S',
1158
additional_error))
1159
goto failure;
1160
1174
1161
break;
1175
1176
1162
case 'l': /* long option. */
1177
local_args_info.long_given++;
1178
1179
multi_token = get_multiple_arg_token(optarg);
1180
multi_next = get_multiple_arg_token_next (optarg);
1181
1182
while (1)
1183
{
1184
long_new = (struct long_list *) malloc (sizeof (struct long_list));
1185
long_new->next = long_list;
1186
long_list = long_new;
1187
long_new->arg = strtol (multi_token, &stop_char, 0);
1188
if (!(stop_char && *stop_char == '\0')) {
1189
fprintf(stderr, "%s: invalid numeric value: %s\n", argv[0], multi_token);
1190
goto failure;
1191
}
1192
long_new->orig = multi_token;
1193
1194
if (multi_next)
1195
{
1196
multi_token = get_multiple_arg_token(multi_next);
1197
multi_next = get_multiple_arg_token_next (multi_next);
1198
local_args_info.long_given++;
1199
}
1200
else
1201
break;
1202
}
1163
1164
if (update_multiple_arg_temp(&long_list,
1165
&(local_args_info.long_given), optarg, 0, 0, ARG_LONG,
1166
"long", 'l',
1167
additional_error))
1168
goto failure;
1169
1203
1170
break;
1204
1205
1171
case 'L': /* limited multiple option. */
1206
local_args_info.limited_given++;
1207
1208
multi_token = get_multiple_arg_token(optarg);
1209
multi_next = get_multiple_arg_token_next (optarg);
1210
1211
while (1)
1212
{
1213
limited_new = (struct string_list *) malloc (sizeof (struct string_list));
1214
limited_new->next = limited_list;
1215
limited_list = limited_new;
1216
limited_new->arg = gengetopt_strdup (multi_token);
1217
limited_new->orig = multi_token;
1218
1219
if (multi_next)
1220
{
1221
multi_token = get_multiple_arg_token(multi_next);
1222
multi_next = get_multiple_arg_token_next (multi_next);
1223
local_args_info.limited_given++;
1224
}
1225
else
1226
break;
1227
}
1172
1173
if (update_multiple_arg_temp(&limited_list,
1174
&(local_args_info.limited_given), optarg, 0, 0, ARG_STRING,
1175
"limited", 'L',
1176
additional_error))
1177
goto failure;
1178
1228
1179
break;
1229
1230
1180
case 'f': /* float option. */
1231
local_args_info.float_given++;
1232
1233
multi_token = get_multiple_arg_token(optarg);
1234
multi_next = get_multiple_arg_token_next (optarg);
1235
1236
while (1)
1237
{
1238
float_new = (struct float_list *) malloc (sizeof (struct float_list));
1239
float_new->next = float_list;
1240
float_list = float_new;
1241
float_new->arg = (float)strtod (multi_token, &stop_char);
1242
if (!(stop_char && *stop_char == '\0')) {
1243
fprintf(stderr, "%s: invalid numeric value: %s\n", argv[0], multi_token);
1244
goto failure;
1245
}
1246
float_new->orig = multi_token;
1247
1248
if (multi_next)
1249
{
1250
multi_token = get_multiple_arg_token(multi_next);
1251
multi_next = get_multiple_arg_token_next (multi_next);
1252
local_args_info.float_given++;
1253
}
1254
else
1255
break;
1256
}
1181
1182
if (update_multiple_arg_temp(&float_list,
1183
&(local_args_info.float_given), optarg, 0, "15000", ARG_FLOAT,
1184
"float", 'f',
1185
additional_error))
1186
goto failure;
1187
1257
1188
break;
1258
1259
1189
case 'n': /* multiple option with no arg. */
1190
1260
1191
local_args_info.noarg_given++;
1261
1192
1262
1193
break;
1263
1264
1194
case 'M': /* multi with optional args. */
1265
local_args_info.optarg_given++;
1266
1267
multi_token = get_multiple_arg_token(optarg);
1268
multi_next = get_multiple_arg_token_next (optarg);
1269
1270
while (1)
1271
{
1272
optarg_new = (struct string_list *) malloc (sizeof (struct string_list));
1273
optarg_new->next = optarg_list;
1274
optarg_list = optarg_new;
1275
optarg_new->arg = gengetopt_strdup (NULL);
1276
optarg_new->orig = NULL;
1277
if (multi_token)
1278
{
1279
optarg_new->arg = gengetopt_strdup (multi_token);
1280
optarg_new->orig = multi_token;
1281
}
1282
1283
if (multi_next)
1284
{
1285
multi_token = get_multiple_arg_token(multi_next);
1286
multi_next = get_multiple_arg_token_next (multi_next);
1287
local_args_info.optarg_given++;
1288
}
1289
else
1290
break;
1291
}
1195
1196
if (update_multiple_arg_temp(&optarg_list,
1197
&(local_args_info.optarg_given), optarg, 0, 0, ARG_STRING,
1198
"optarg", 'M',
1199
additional_error))
1200
goto failure;
1201
1292
1202
break;
1293
1203
1294
1295
1204
case 0: /* Long option with no short option */
1205
/* long long option. */
1206
if (strcmp (long_options[option_index].name, "longlong") == 0)
1207
{
1208
1209
if (update_multiple_arg_temp(&longlong_list,
1210
&(local_args_info.longlong_given), optarg, 0, 0, ARG_LONGLONG,
1211
"longlong", '-',
1212
additional_error))
1213
goto failure;
1214
1215
}
1296
1216
/* limited multiple option (with interval). */
1297
if (strcmp (long_options[option_index].name, "limited-interval") == 0)
1217
else if (strcmp (long_options[option_index].name, "limited-interval") == 0)
1298
1218
{
1299
local_args_info.limited_interval_given++;
1300
1301
multi_token = get_multiple_arg_token(optarg);
1302
multi_next = get_multiple_arg_token_next (optarg);
1303
1304
while (1)
1305
{
1306
limited_interval_new = (struct string_list *) malloc (sizeof (struct string_list));
1307
limited_interval_new->next = limited_interval_list;
1308
limited_interval_list = limited_interval_new;
1309
limited_interval_new->arg = gengetopt_strdup (multi_token);
1310
limited_interval_new->orig = multi_token;
1311
1312
if (multi_next)
1313
{
1314
multi_token = get_multiple_arg_token(multi_next);
1315
multi_next = get_multiple_arg_token_next (multi_next);
1316
local_args_info.limited_interval_given++;
1317
}
1318
else
1319
break;
1320
}
1321
break;
1219
1220
if (update_multiple_arg_temp(&limited_interval_list,
1221
&(local_args_info.limited_interval_given), optarg, 0, 0, ARG_STRING,
1222
"limited-interval", '-',
1223
additional_error))
1224
goto failure;
1225
1322
1226
}
1323
1227
/* limited multiple option (with interval). */
1324
1228
else if (strcmp (long_options[option_index].name, "big-limited-interval") == 0)
1325
1229
{
1326
local_args_info.big_limited_interval_given++;
1327
1328
multi_token = get_multiple_arg_token(optarg);
1329
multi_next = get_multiple_arg_token_next (optarg);
1330
1331
while (1)
1332
{
1333
big_limited_interval_new = (struct string_list *) malloc (sizeof (struct string_list));
1334
big_limited_interval_new->next = big_limited_interval_list;
1335
big_limited_interval_list = big_limited_interval_new;
1336
big_limited_interval_new->arg = gengetopt_strdup (multi_token);
1337
big_limited_interval_new->orig = multi_token;
1338
1339
if (multi_next)
1340
{
1341
multi_token = get_multiple_arg_token(multi_next);
1342
multi_next = get_multiple_arg_token_next (multi_next);
1343
local_args_info.big_limited_interval_given++;
1344
}
1345
else
1346
break;
1347
}
1348
break;
1230
1231
if (update_multiple_arg_temp(&big_limited_interval_list,
1232
&(local_args_info.big_limited_interval_given), optarg, 0, 0, ARG_STRING,
1233
"big-limited-interval", '-',
1234
additional_error))
1235
goto failure;
1236
1349
1237
}
1350
1238
/* limited multiple option (with interval right open). */
1351
1239
else if (strcmp (long_options[option_index].name, "limited-open-right") == 0)
1352
1240
{
1353
local_args_info.limited_open_right_given++;
1354
1355
multi_token = get_multiple_arg_token(optarg);
1356
multi_next = get_multiple_arg_token_next (optarg);
1357
1358
while (1)
1359
{
1360
limited_open_right_new = (struct string_list *) malloc (sizeof (struct string_list));
1361
limited_open_right_new->next = limited_open_right_list;
1362
limited_open_right_list = limited_open_right_new;
1363
limited_open_right_new->arg = gengetopt_strdup (multi_token);
1364
limited_open_right_new->orig = multi_token;
1365
1366
if (multi_next)
1367
{
1368
multi_token = get_multiple_arg_token(multi_next);
1369
multi_next = get_multiple_arg_token_next (multi_next);
1370
local_args_info.limited_open_right_given++;
1371
}
1372
else
1373
break;
1374
}
1375
break;
1241
1242
if (update_multiple_arg_temp(&limited_open_right_list,
1243
&(local_args_info.limited_open_right_given), optarg, 0, 0, ARG_STRING,
1244
"limited-open-right", '-',
1245
additional_error))
1246
goto failure;
1247
1376
1248
}
1377
1249
/* limited multiple option (with interval left open). */
1378
1250
else if (strcmp (long_options[option_index].name, "limited-open-left") == 0)
1379
1251
{
1380
local_args_info.limited_open_left_given++;
1381
1382
multi_token = get_multiple_arg_token(optarg);
1383
multi_next = get_multiple_arg_token_next (optarg);
1384
1385
while (1)
1386
{
1387
limited_open_left_new = (struct string_list *) malloc (sizeof (struct string_list));
1388
limited_open_left_new->next = limited_open_left_list;
1389
limited_open_left_list = limited_open_left_new;
1390
limited_open_left_new->arg = gengetopt_strdup (multi_token);
1391
limited_open_left_new->orig = multi_token;
1392
1393
if (multi_next)
1394
{
1395
multi_token = get_multiple_arg_token(multi_next);
1396
multi_next = get_multiple_arg_token_next (multi_next);
1397
local_args_info.limited_open_left_given++;
1398
}
1399
else
1400
break;
1401
}
1402
break;
1252
1253
if (update_multiple_arg_temp(&limited_open_left_list,
1254
&(local_args_info.limited_open_left_given), optarg, 0, 0, ARG_STRING,
1255
"limited-open-left", '-',
1256
additional_error))
1257
goto failure;
1258
1403
1259
}
1404
1260
/* string option with no short. */
1405
1261
else if (strcmp (long_options[option_index].name, "no-short-opt") == 0)
1406
1262
{
1407
local_args_info.no_short_opt_given++;
1408
1409
multi_token = get_multiple_arg_token(optarg);
1410
multi_next = get_multiple_arg_token_next (optarg);
1411
1412
while (1)
1413
{
1414
no_short_opt_new = (struct string_list *) malloc (sizeof (struct string_list));
1415
no_short_opt_new->next = no_short_opt_list;
1416
no_short_opt_list = no_short_opt_new;
1417
no_short_opt_new->arg = gengetopt_strdup (multi_token);
1418
no_short_opt_new->orig = multi_token;
1419
1420
if (multi_next)
1421
{
1422
multi_token = get_multiple_arg_token(multi_next);
1423
multi_next = get_multiple_arg_token_next (multi_next);
1424
local_args_info.no_short_opt_given++;
1425
}
1426
else
1427
break;
1428
}
1429
break;
1263
1264
if (update_multiple_arg_temp(&no_short_opt_list,
1265
&(local_args_info.no_short_opt_given), optarg, 0, 0, ARG_STRING,
1266
"no-short-opt", '-',
1267
additional_error))
1268
goto failure;
1269
1430
1270
}
1431
1271
/* multiple option with no arg and no short. */
1432
1272
else if (strcmp (long_options[option_index].name, "noarg-noshort") == 0)
1433
1273
{
1274
1434
1275
local_args_info.noarg_noshort_given++;
1435
1276
1436
break;
1437
1277
}
1438
1278
/* multi with optional args and no short. */
1439
1279
else if (strcmp (long_options[option_index].name, "optarg-noshort") == 0)
1440
1280
{
1441
local_args_info.optarg_noshort_given++;
1442
1443
multi_token = get_multiple_arg_token(optarg);
1444
multi_next = get_multiple_arg_token_next (optarg);
1445
1446
while (1)
1447
{
1448
optarg_noshort_new = (struct string_list *) malloc (sizeof (struct string_list));
1449
optarg_noshort_new->next = optarg_noshort_list;
1450
optarg_noshort_list = optarg_noshort_new;
1451
optarg_noshort_new->arg = gengetopt_strdup (NULL);
1452
optarg_noshort_new->orig = NULL;
1453
if (multi_token)
1454
{
1455
optarg_noshort_new->arg = gengetopt_strdup (multi_token);
1456
optarg_noshort_new->orig = multi_token;
1457
}
1458
1459
if (multi_next)
1460
{
1461
multi_token = get_multiple_arg_token(multi_next);
1462
multi_next = get_multiple_arg_token_next (multi_next);
1463
local_args_info.optarg_noshort_given++;
1464
}
1465
else
1466
break;
1467
}
1468
break;
1281
1282
if (update_multiple_arg_temp(&optarg_noshort_list,
1283
&(local_args_info.optarg_noshort_given), optarg, 0, 0, ARG_STRING,
1284
"optarg-noshort", '-',
1285
additional_error))
1286
goto failure;
1287
1469
1288
}
1470
1289
/* save the passed options into a file. */
1471
1290
else if (strcmp (long_options[option_index].name, "file-save") == 0)
1472
1291
{
1473
if (local_args_info.file_save_given || (check_ambiguity && args_info->file_save_given))
1474
{
1475
fprintf (stderr, "%s: `--file-save' option given more than once%s\n", argv[0], (additional_error ? additional_error : ""));
1476
goto failure;
1477
}
1478
if (args_info->file_save_given && ! override)
1479
continue;
1480
local_args_info.file_save_given = 1;
1481
args_info->file_save_given = 1;
1482
if (args_info->file_save_arg)
1483
free (args_info->file_save_arg); /* free previous string */
1484
args_info->file_save_arg = gengetopt_strdup (optarg);
1485
if (args_info->file_save_orig)
1486
free (args_info->file_save_orig); /* free previous string */
1487
args_info->file_save_orig = gengetopt_strdup (optarg);
1292
1293
1294
if (update_arg( (void *)&(args_info->file_save_arg),
1295
&(args_info->file_save_orig), &(args_info->file_save_given),
1296
&(local_args_info.file_save_given), optarg, 0, 0, ARG_STRING,
1297
check_ambiguity, override, 0, 0,
1298
"file-save", '-',
1299
additional_error))
1300
goto failure;
1301
1488
1302
}
1489
1303
1490
1304
break;
1499
1313
} /* while */
1500
1314
1501
1315
1502
if (local_args_info.string_given && string_list)
1503
{
1504
struct string_list *tmp;
1505
args_info->string_arg = (char * *) realloc (args_info->string_arg, (args_info->string_given + local_args_info.string_given) * sizeof (char *));
1506
args_info->string_orig = (char **) realloc (args_info->string_orig, (args_info->string_given + local_args_info.string_given) * sizeof (char *));
1507
for (i = (local_args_info.string_given - 1); i >= 0; --i)
1508
{
1509
tmp = string_list;
1510
args_info->string_arg [i + args_info->string_given] = string_list->arg;
1511
args_info->string_orig [i + args_info->string_given] = string_list->orig;
1512
string_list = string_list->next;
1513
free (tmp);
1514
}
1515
}
1516
else /* set the default value */
1517
{
1518
if (! args_info->string_arg && ! args_info->string_given)
1519
{
1520
args_info->string_arg = (char * *) malloc (sizeof (char *));
1521
args_info->string_arg [0] = gengetopt_strdup("foo");
1522
args_info->string_orig = (char **) malloc (sizeof (char *));
1523
args_info->string_orig [0] = NULL;
1524
}
1525
}
1526
1527
if (local_args_info.int_given && int_list)
1528
{
1529
struct int_list *tmp;
1530
args_info->int_arg = (int *) realloc (args_info->int_arg, (args_info->int_given + local_args_info.int_given) * sizeof (int));
1531
args_info->int_orig = (char **) realloc (args_info->int_orig, (args_info->int_given + local_args_info.int_given) * sizeof (char *));
1532
for (i = (local_args_info.int_given - 1); i >= 0; --i)
1533
{
1534
tmp = int_list;
1535
args_info->int_arg [i + args_info->int_given] = int_list->arg;
1536
args_info->int_orig [i + args_info->int_given] = int_list->orig;
1537
int_list = int_list->next;
1538
free (tmp);
1539
}
1540
}
1541
1542
if (local_args_info.short_given && short_list)
1543
{
1544
struct short_list *tmp;
1545
args_info->short_arg = (short *) realloc (args_info->short_arg, (args_info->short_given + local_args_info.short_given) * sizeof (short));
1546
args_info->short_orig = (char **) realloc (args_info->short_orig, (args_info->short_given + local_args_info.short_given) * sizeof (char *));
1547
for (i = (local_args_info.short_given - 1); i >= 0; --i)
1548
{
1549
tmp = short_list;
1550
args_info->short_arg [i + args_info->short_given] = short_list->arg;
1551
args_info->short_orig [i + args_info->short_given] = short_list->orig;
1552
short_list = short_list->next;
1553
free (tmp);
1554
}
1555
}
1556
1557
if (local_args_info.long_given && long_list)
1558
{
1559
struct long_list *tmp;
1560
args_info->long_arg = (long *) realloc (args_info->long_arg, (args_info->long_given + local_args_info.long_given) * sizeof (long));
1561
args_info->long_orig = (char **) realloc (args_info->long_orig, (args_info->long_given + local_args_info.long_given) * sizeof (char *));
1562
for (i = (local_args_info.long_given - 1); i >= 0; --i)
1563
{
1564
tmp = long_list;
1565
args_info->long_arg [i + args_info->long_given] = long_list->arg;
1566
args_info->long_orig [i + args_info->long_given] = long_list->orig;
1567
long_list = long_list->next;
1568
free (tmp);
1569
}
1570
}
1571
1572
if (local_args_info.limited_given && limited_list)
1573
{
1574
struct string_list *tmp;
1575
args_info->limited_arg = (char * *) realloc (args_info->limited_arg, (args_info->limited_given + local_args_info.limited_given) * sizeof (char *));
1576
args_info->limited_orig = (char **) realloc (args_info->limited_orig, (args_info->limited_given + local_args_info.limited_given) * sizeof (char *));
1577
for (i = (local_args_info.limited_given - 1); i >= 0; --i)
1578
{
1579
tmp = limited_list;
1580
args_info->limited_arg [i + args_info->limited_given] = limited_list->arg;
1581
args_info->limited_orig [i + args_info->limited_given] = limited_list->orig;
1582
limited_list = limited_list->next;
1583
free (tmp);
1584
}
1585
}
1586
1587
if (local_args_info.limited_interval_given && limited_interval_list)
1588
{
1589
struct string_list *tmp;
1590
args_info->limited_interval_arg = (char * *) realloc (args_info->limited_interval_arg, (args_info->limited_interval_given + local_args_info.limited_interval_given) * sizeof (char *));
1591
args_info->limited_interval_orig = (char **) realloc (args_info->limited_interval_orig, (args_info->limited_interval_given + local_args_info.limited_interval_given) * sizeof (char *));
1592
for (i = (local_args_info.limited_interval_given - 1); i >= 0; --i)
1593
{
1594
tmp = limited_interval_list;
1595
args_info->limited_interval_arg [i + args_info->limited_interval_given] = limited_interval_list->arg;
1596
args_info->limited_interval_orig [i + args_info->limited_interval_given] = limited_interval_list->orig;
1597
limited_interval_list = limited_interval_list->next;
1598
free (tmp);
1599
}
1600
}
1601
1602
if (local_args_info.big_limited_interval_given && big_limited_interval_list)
1603
{
1604
struct string_list *tmp;
1605
args_info->big_limited_interval_arg = (char * *) realloc (args_info->big_limited_interval_arg, (args_info->big_limited_interval_given + local_args_info.big_limited_interval_given) * sizeof (char *));
1606
args_info->big_limited_interval_orig = (char **) realloc (args_info->big_limited_interval_orig, (args_info->big_limited_interval_given + local_args_info.big_limited_interval_given) * sizeof (char *));
1607
for (i = (local_args_info.big_limited_interval_given - 1); i >= 0; --i)
1608
{
1609
tmp = big_limited_interval_list;
1610
args_info->big_limited_interval_arg [i + args_info->big_limited_interval_given] = big_limited_interval_list->arg;
1611
args_info->big_limited_interval_orig [i + args_info->big_limited_interval_given] = big_limited_interval_list->orig;
1612
big_limited_interval_list = big_limited_interval_list->next;
1613
free (tmp);
1614
}
1615
}
1616
1617
if (local_args_info.limited_open_right_given && limited_open_right_list)
1618
{
1619
struct string_list *tmp;
1620
args_info->limited_open_right_arg = (char * *) realloc (args_info->limited_open_right_arg, (args_info->limited_open_right_given + local_args_info.limited_open_right_given) * sizeof (char *));
1621
args_info->limited_open_right_orig = (char **) realloc (args_info->limited_open_right_orig, (args_info->limited_open_right_given + local_args_info.limited_open_right_given) * sizeof (char *));
1622
for (i = (local_args_info.limited_open_right_given - 1); i >= 0; --i)
1623
{
1624
tmp = limited_open_right_list;
1625
args_info->limited_open_right_arg [i + args_info->limited_open_right_given] = limited_open_right_list->arg;
1626
args_info->limited_open_right_orig [i + args_info->limited_open_right_given] = limited_open_right_list->orig;
1627
limited_open_right_list = limited_open_right_list->next;
1628
free (tmp);
1629
}
1630
}
1631
1632
if (local_args_info.limited_open_left_given && limited_open_left_list)
1633
{
1634
struct string_list *tmp;
1635
args_info->limited_open_left_arg = (char * *) realloc (args_info->limited_open_left_arg, (args_info->limited_open_left_given + local_args_info.limited_open_left_given) * sizeof (char *));
1636
args_info->limited_open_left_orig = (char **) realloc (args_info->limited_open_left_orig, (args_info->limited_open_left_given + local_args_info.limited_open_left_given) * sizeof (char *));
1637
for (i = (local_args_info.limited_open_left_given - 1); i >= 0; --i)
1638
{
1639
tmp = limited_open_left_list;
1640
args_info->limited_open_left_arg [i + args_info->limited_open_left_given] = limited_open_left_list->arg;
1641
args_info->limited_open_left_orig [i + args_info->limited_open_left_given] = limited_open_left_list->orig;
1642
limited_open_left_list = limited_open_left_list->next;
1643
free (tmp);
1644
}
1645
}
1646
1647
if (local_args_info.float_given && float_list)
1648
{
1649
struct float_list *tmp;
1650
args_info->float_arg = (float *) realloc (args_info->float_arg, (args_info->float_given + local_args_info.float_given) * sizeof (float));
1651
args_info->float_orig = (char **) realloc (args_info->float_orig, (args_info->float_given + local_args_info.float_given) * sizeof (char *));
1652
for (i = (local_args_info.float_given - 1); i >= 0; --i)
1653
{
1654
tmp = float_list;
1655
args_info->float_arg [i + args_info->float_given] = float_list->arg;
1656
args_info->float_orig [i + args_info->float_given] = float_list->orig;
1657
float_list = float_list->next;
1658
free (tmp);
1659
}
1660
}
1661
else /* set the default value */
1662
{
1663
if (! args_info->float_arg && ! args_info->float_given)
1664
{
1665
args_info->float_arg = (float *) malloc (sizeof (float));
1666
args_info->float_arg [0] = 15000;
1667
args_info->float_orig = (char **) malloc (sizeof (char *));
1668
args_info->float_orig [0] = NULL;
1669
}
1670
}
1671
1672
if (local_args_info.no_short_opt_given && no_short_opt_list)
1673
{
1674
struct string_list *tmp;
1675
args_info->no_short_opt_arg = (char * *) realloc (args_info->no_short_opt_arg, (args_info->no_short_opt_given + local_args_info.no_short_opt_given) * sizeof (char *));
1676
args_info->no_short_opt_orig = (char **) realloc (args_info->no_short_opt_orig, (args_info->no_short_opt_given + local_args_info.no_short_opt_given) * sizeof (char *));
1677
for (i = (local_args_info.no_short_opt_given - 1); i >= 0; --i)
1678
{
1679
tmp = no_short_opt_list;
1680
args_info->no_short_opt_arg [i + args_info->no_short_opt_given] = no_short_opt_list->arg;
1681
args_info->no_short_opt_orig [i + args_info->no_short_opt_given] = no_short_opt_list->orig;
1682
no_short_opt_list = no_short_opt_list->next;
1683
free (tmp);
1684
}
1685
}
1686
1687
if (local_args_info.optarg_given && optarg_list)
1688
{
1689
struct string_list *tmp;
1690
args_info->optarg_arg = (char * *) realloc (args_info->optarg_arg, (args_info->optarg_given + local_args_info.optarg_given) * sizeof (char *));
1691
args_info->optarg_orig = (char **) realloc (args_info->optarg_orig, (args_info->optarg_given + local_args_info.optarg_given) * sizeof (char *));
1692
for (i = (local_args_info.optarg_given - 1); i >= 0; --i)
1693
{
1694
tmp = optarg_list;
1695
args_info->optarg_arg [i + args_info->optarg_given] = optarg_list->arg;
1696
args_info->optarg_orig [i + args_info->optarg_given] = optarg_list->orig;
1697
optarg_list = optarg_list->next;
1698
free (tmp);
1699
}
1700
}
1701
1702
if (local_args_info.optarg_noshort_given && optarg_noshort_list)
1703
{
1704
struct string_list *tmp;
1705
args_info->optarg_noshort_arg = (char * *) realloc (args_info->optarg_noshort_arg, (args_info->optarg_noshort_given + local_args_info.optarg_noshort_given) * sizeof (char *));
1706
args_info->optarg_noshort_orig = (char **) realloc (args_info->optarg_noshort_orig, (args_info->optarg_noshort_given + local_args_info.optarg_noshort_given) * sizeof (char *));
1707
for (i = (local_args_info.optarg_noshort_given - 1); i >= 0; --i)
1708
{
1709
tmp = optarg_noshort_list;
1710
args_info->optarg_noshort_arg [i + args_info->optarg_noshort_given] = optarg_noshort_list->arg;
1711
args_info->optarg_noshort_orig [i + args_info->optarg_noshort_given] = optarg_noshort_list->orig;
1712
optarg_noshort_list = optarg_noshort_list->next;
1713
free (tmp);
1714
}
1715
}
1716
1316
multiple_default_value.string_arg = "foo";
1317
update_multiple_arg((void *)&(args_info->string_arg),
1318
&(args_info->string_orig), args_info->string_given,
1319
local_args_info.string_given, &multiple_default_value ,
1320
ARG_STRING, string_list);
1321
update_multiple_arg((void *)&(args_info->int_arg),
1322
&(args_info->int_orig), args_info->int_given,
1323
local_args_info.int_given, 0 ,
1324
ARG_INT, int_list);
1325
update_multiple_arg((void *)&(args_info->short_arg),
1326
&(args_info->short_orig), args_info->short_given,
1327
local_args_info.short_given, 0 ,
1328
ARG_SHORT, short_list);
1329
update_multiple_arg((void *)&(args_info->long_arg),
1330
&(args_info->long_orig), args_info->long_given,
1331
local_args_info.long_given, 0 ,
1332
ARG_LONG, long_list);
1333
update_multiple_arg((void *)&(args_info->longlong_arg),
1334
&(args_info->longlong_orig), args_info->longlong_given,
1335
local_args_info.longlong_given, 0 ,
1336
ARG_LONGLONG, longlong_list);
1337
update_multiple_arg((void *)&(args_info->limited_arg),
1338
&(args_info->limited_orig), args_info->limited_given,
1339
local_args_info.limited_given, 0 ,
1340
ARG_STRING, limited_list);
1341
update_multiple_arg((void *)&(args_info->limited_interval_arg),
1342
&(args_info->limited_interval_orig), args_info->limited_interval_given,
1343
local_args_info.limited_interval_given, 0 ,
1344
ARG_STRING, limited_interval_list);
1345
update_multiple_arg((void *)&(args_info->big_limited_interval_arg),
1346
&(args_info->big_limited_interval_orig), args_info->big_limited_interval_given,
1347
local_args_info.big_limited_interval_given, 0 ,
1348
ARG_STRING, big_limited_interval_list);
1349
update_multiple_arg((void *)&(args_info->limited_open_right_arg),
1350
&(args_info->limited_open_right_orig), args_info->limited_open_right_given,
1351
local_args_info.limited_open_right_given, 0 ,
1352
ARG_STRING, limited_open_right_list);
1353
update_multiple_arg((void *)&(args_info->limited_open_left_arg),
1354
&(args_info->limited_open_left_orig), args_info->limited_open_left_given,
1355
local_args_info.limited_open_left_given, 0 ,
1356
ARG_STRING, limited_open_left_list);
1357
multiple_default_value.float_arg = 15000;
1358
update_multiple_arg((void *)&(args_info->float_arg),
1359
&(args_info->float_orig), args_info->float_given,
1360
local_args_info.float_given, &multiple_default_value ,
1361
ARG_FLOAT, float_list);
1362
update_multiple_arg((void *)&(args_info->no_short_opt_arg),
1363
&(args_info->no_short_opt_orig), args_info->no_short_opt_given,
1364
local_args_info.no_short_opt_given, 0 ,
1365
ARG_STRING, no_short_opt_list);
1366
update_multiple_arg((void *)&(args_info->optarg_arg),
1367
&(args_info->optarg_orig), args_info->optarg_given,
1368
local_args_info.optarg_given, 0 ,
1369
ARG_STRING, optarg_list);
1370
update_multiple_arg((void *)&(args_info->optarg_noshort_arg),
1371
&(args_info->optarg_noshort_orig), args_info->optarg_noshort_given,
1372
local_args_info.optarg_noshort_given, 0 ,
1373
ARG_STRING, optarg_noshort_list);
1717
1374
1718
1375
args_info->string_given += local_args_info.string_given;
1719
1376
local_args_info.string_given = 0;
1723
1380
local_args_info.short_given = 0;
1724
1381
args_info->long_given += local_args_info.long_given;
1725
1382
local_args_info.long_given = 0;
1383
args_info->longlong_given += local_args_info.longlong_given;
1384
local_args_info.longlong_given = 0;
1726
1385
args_info->limited_given += local_args_info.limited_given;
1727
1386
local_args_info.limited_given = 0;
1728
1387
args_info->limited_interval_given += local_args_info.limited_interval_given;
1783
1442
return 0;
1784
1443
1785
1444
failure:
1786
if (string_list)
1787
{
1788
struct string_list *tmp;
1789
while (string_list)
1790
{
1791
tmp = string_list;
1792
free (string_list->arg);
1793
free (string_list->orig);
1794
string_list = string_list->next;
1795
free (tmp);
1796
}
1797
}
1798
if (int_list)
1799
{
1800
struct int_list *tmp;
1801
while (int_list)
1802
{
1803
tmp = int_list;
1804
free (int_list->orig);
1805
int_list = int_list->next;
1806
free (tmp);
1807
}
1808
}
1809
if (short_list)
1810
{
1811
struct short_list *tmp;
1812
while (short_list)
1813
{
1814
tmp = short_list;
1815
free (short_list->orig);
1816
short_list = short_list->next;
1817
free (tmp);
1818
}
1819
}
1820
if (long_list)
1821
{
1822
struct long_list *tmp;
1823
while (long_list)
1824
{
1825
tmp = long_list;
1826
free (long_list->orig);
1827
long_list = long_list->next;
1828
free (tmp);
1829
}
1830
}
1831
if (limited_list)
1832
{
1833
struct string_list *tmp;
1834
while (limited_list)
1835
{
1836
tmp = limited_list;
1837
free (limited_list->arg);
1838
free (limited_list->orig);
1839
limited_list = limited_list->next;
1840
free (tmp);
1841
}
1842
}
1843
if (limited_interval_list)
1844
{
1845
struct string_list *tmp;
1846
while (limited_interval_list)
1847
{
1848
tmp = limited_interval_list;
1849
free (limited_interval_list->arg);
1850
free (limited_interval_list->orig);
1851
limited_interval_list = limited_interval_list->next;
1852
free (tmp);
1853
}
1854
}
1855
if (big_limited_interval_list)
1856
{
1857
struct string_list *tmp;
1858
while (big_limited_interval_list)
1859
{
1860
tmp = big_limited_interval_list;
1861
free (big_limited_interval_list->arg);
1862
free (big_limited_interval_list->orig);
1863
big_limited_interval_list = big_limited_interval_list->next;
1864
free (tmp);
1865
}
1866
}
1867
if (limited_open_right_list)
1868
{
1869
struct string_list *tmp;
1870
while (limited_open_right_list)
1871
{
1872
tmp = limited_open_right_list;
1873
free (limited_open_right_list->arg);
1874
free (limited_open_right_list->orig);
1875
limited_open_right_list = limited_open_right_list->next;
1876
free (tmp);
1877
}
1878
}
1879
if (limited_open_left_list)
1880
{
1881
struct string_list *tmp;
1882
while (limited_open_left_list)
1883
{
1884
tmp = limited_open_left_list;
1885
free (limited_open_left_list->arg);
1886
free (limited_open_left_list->orig);
1887
limited_open_left_list = limited_open_left_list->next;
1888
free (tmp);
1889
}
1890
}
1891
if (float_list)
1892
{
1893
struct float_list *tmp;
1894
while (float_list)
1895
{
1896
tmp = float_list;
1897
free (float_list->orig);
1898
float_list = float_list->next;
1899
free (tmp);
1900
}
1901
}
1902
if (no_short_opt_list)
1903
{
1904
struct string_list *tmp;
1905
while (no_short_opt_list)
1906
{
1907
tmp = no_short_opt_list;
1908
free (no_short_opt_list->arg);
1909
free (no_short_opt_list->orig);
1910
no_short_opt_list = no_short_opt_list->next;
1911
free (tmp);
1912
}
1913
}
1914
if (optarg_list)
1915
{
1916
struct string_list *tmp;
1917
while (optarg_list)
1918
{
1919
tmp = optarg_list;
1920
free (optarg_list->arg);
1921
free (optarg_list->orig);
1922
optarg_list = optarg_list->next;
1923
free (tmp);
1924
}
1925
}
1926
if (optarg_noshort_list)
1927
{
1928
struct string_list *tmp;
1929
while (optarg_noshort_list)
1930
{
1931
tmp = optarg_noshort_list;
1932
free (optarg_noshort_list->arg);
1933
free (optarg_noshort_list->orig);
1934
optarg_noshort_list = optarg_noshort_list->next;
1935
free (tmp);
1936
}
1937
}
1445
free_list (string_list, 1 );
1446
free_list (int_list, 0 );
1447
free_list (short_list, 0 );
1448
free_list (long_list, 0 );
1449
free_list (longlong_list, 0 );
1450
free_list (limited_list, 1 );
1451
free_list (limited_interval_list, 1 );
1452
free_list (big_limited_interval_list, 1 );
1453
free_list (limited_open_right_list, 1 );
1454
free_list (limited_open_left_list, 1 );
1455
free_list (float_list, 0 );
1456
free_list (no_short_opt_list, 1 );
1457
free_list (optarg_list, 1 );
1458
free_list (optarg_noshort_list, 1 );
1938
1459
1939
1460
test_multiple_cmd_parser_release (&local_args_info);
1940
1461
return (EXIT_FAILURE);
Loggerhead is a web-based interface for Breezy
Version: 2.0.1