00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #ifndef _GNU_SOURCE
00022 # define _GNU_SOURCE 1
00023 #endif
00024
00025 #ifdef HAVE_CONFIG_H
00026 #include <config.h>
00027 #endif
00028
00029
00030 #ifndef __GNUC__
00031 # if HAVE_ALLOCA_H
00032 # include <alloca.h>
00033 # else
00034 # ifdef _AIX
00035 #pragma alloca
00036 # else
00037 # ifndef alloca
00038 char *alloca ();
00039 # endif
00040 # endif
00041 # endif
00042 #endif
00043
00044 #include <stdlib.h>
00045 #include <string.h>
00046 #include <unistd.h>
00047 #include <limits.h>
00048 #include <assert.h>
00049 #ifdef _WIN32
00050 #include <malloc.h>
00051 #endif
00052
00053 #ifndef _
00054
00055
00056 # if defined HAVE_LIBINTL_H || defined _LIBC
00057 # include <libintl.h>
00058 # ifdef _LIBC
00059 # undef dgettext
00060 # define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
00061 # endif
00062 # else
00063 # define dgettext(domain, msgid) (msgid)
00064 # define gettext(msgid) (msgid)
00065 # endif
00066 #endif
00067 #ifndef N_
00068 # define N_(msgid) (msgid)
00069 #endif
00070
00071 #if _LIBC - 0
00072 #include <bits/libc-lock.h>
00073 #else
00074 #ifdef HAVE_CTHREADS_H
00075 #include <cthreads.h>
00076 #endif
00077 #endif
00078
00079 #include "argp.h"
00080 #include "argp-namefrob.h"
00081
00082
00083
00084
00085 #define QUOTE "--"
00086
00087
00088 #define EBADKEY ARGP_ERR_UNKNOWN
00089
00090
00091
00092
00093
00094
00095
00096
00097 volatile int _argp_hang;
00098
00099 #define OPT_PROGNAME -2
00100 #define OPT_USAGE -3
00101 #define OPT_HANG -4
00102
00103 static const struct argp_option argp_default_options[] =
00104 {
00105 {"help", '?', 0, 0, N_("Give this help list"), -1},
00106 {"usage", OPT_USAGE, 0, 0, N_("Give a short usage message"), 0 },
00107 {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN,
00108 N_("Set the program name"), 0},
00109 {"HANG", OPT_HANG, "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
00110 N_("Hang for SECS seconds (default 3600)"), 0 },
00111 {0, 0, 0, 0, 0, 0}
00112 };
00113
00114 static error_t
00115 argp_default_parser (int key, char *arg, struct argp_state *state)
00116 {
00117 switch (key)
00118 {
00119 case '?':
00120 __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
00121 break;
00122 case OPT_USAGE:
00123 __argp_state_help (state, state->out_stream,
00124 ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
00125 break;
00126
00127 case OPT_PROGNAME:
00128 #if HAVE_DECL_PROGRAM_INVOCATION_NAME
00129 program_invocation_name = arg;
00130 #endif
00131
00132
00133
00134
00135
00136
00137 state->name = __argp_basename(arg);
00138
00139 #if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
00140 program_invocation_short_name = state->name;
00141 #endif
00142
00143 if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
00144 == ARGP_PARSE_ARGV0)
00145
00146 state->argv[0] = arg;
00147
00148 break;
00149
00150 case OPT_HANG:
00151 _argp_hang = atoi (arg ? arg : "3600");
00152 fprintf(state->err_stream, "%s: pid = %ld\n",
00153 state->name, (long) getpid());
00154 while (_argp_hang-- > 0)
00155 __sleep(1);
00156 break;
00157
00158 default:
00159 return EBADKEY;
00160 }
00161 return 0;
00162 }
00163
00164 static const struct argp argp_default_argp =
00165 {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
00166
00167
00168 static const struct argp_option argp_version_options[] =
00169 {
00170 {"version", 'V', 0, 0, N_("Print program version"), -1},
00171 {0, 0, 0, 0, 0, 0 }
00172 };
00173
00174 static error_t
00175 argp_version_parser (int key, char *arg UNUSED, struct argp_state *state)
00176 {
00177 switch (key)
00178 {
00179 case 'V':
00180 if (argp_program_version_hook)
00181 (*argp_program_version_hook) (state->out_stream, state);
00182 else if (argp_program_version)
00183 fprintf (state->out_stream, "%s\n", argp_program_version);
00184 else
00185 __argp_error (state, dgettext (state->root_argp->argp_domain,
00186 "(PROGRAM ERROR) No version known!?"));
00187 if (! (state->flags & ARGP_NO_EXIT))
00188 exit (0);
00189 break;
00190 default:
00191 return EBADKEY;
00192 }
00193 return 0;
00194 }
00195
00196 static const struct argp argp_version_argp =
00197 {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
00198
00199
00200
00201
00202
00203
00204 struct group
00205 {
00206
00207 argp_parser_t parser;
00208
00209
00210 const struct argp *argp;
00211
00212
00213 unsigned args_processed;
00214
00215
00216 struct group *parent;
00217 unsigned parent_index;
00218
00219
00220
00221 void *input, **child_inputs;
00222 void *hook;
00223 };
00224
00225
00226
00227
00228 static error_t
00229 group_parse (struct group *group, struct argp_state *state, int key, char *arg)
00230 {
00231 if (group->parser)
00232 {
00233 error_t err;
00234 state->hook = group->hook;
00235 state->input = group->input;
00236 state->child_inputs = group->child_inputs;
00237 state->arg_num = group->args_processed;
00238 err = (*group->parser)(key, arg, state);
00239 group->hook = state->hook;
00240 return err;
00241 }
00242 else
00243 return EBADKEY;
00244 }
00245
00246 struct parser
00247 {
00248 const struct argp *argp;
00249
00250 const char *posixly_correct;
00251
00252
00253
00254
00255
00256 int args_only;
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283 enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering;
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294 int first_nonopt;
00295 int last_nonopt;
00296
00297
00298
00299 char *short_opts;
00300
00301
00302 char *nextchar;
00303
00304
00305 struct group *groups;
00306
00307 struct group *egroup;
00308
00309 void **child_inputs;
00310
00311
00312 struct argp_state state;
00313
00314
00315 void *storage;
00316 };
00317
00318
00319 static const struct argp_option *
00320 find_short_option(struct parser *parser, int key, struct group **p)
00321 {
00322 struct group *group;
00323
00324 assert(key >= 0);
00325 assert(isascii(key));
00326
00327 for (group = parser->groups; group < parser->egroup; group++)
00328 {
00329 const struct argp_option *opts;
00330
00331 for (opts = group->argp->options; !__option_is_end(opts); opts++)
00332 if (opts->key == key)
00333 {
00334 *p = group;
00335 return opts;
00336 }
00337 }
00338 return NULL;
00339 }
00340
00341 enum match_result { MATCH_EXACT, MATCH_PARTIAL, MATCH_NO };
00342
00343
00344 #ifndef ARGP_COMPLETE
00345 #define ARGP_COMPLETE 0
00346 #endif
00347
00348
00349
00350 static enum match_result
00351 match_option(const char *arg, const char *name)
00352 {
00353 unsigned i, j;
00354 for (i = j = 0;; i++, j++)
00355 {
00356 switch(arg[i])
00357 {
00358 case '\0':
00359 case '=':
00360 return name[j] ? MATCH_PARTIAL : MATCH_EXACT;
00361 #if ARGP_COMPLETE
00362 case '-':
00363 while (name[j] != '-')
00364 if (!name[j++])
00365 return MATCH_NO;
00366 break;
00367 #endif
00368 default:
00369 if (arg[i] != name[j])
00370 return MATCH_NO;
00371 }
00372 }
00373 }
00374
00375 static const struct argp_option *
00376 find_long_option(struct parser *parser,
00377 const char *arg,
00378 struct group **p)
00379 {
00380 struct group *group;
00381
00382
00383 struct group *matched_group = NULL;
00384 const struct argp_option *matched_option = NULL;
00385
00386
00387 int num_partial = 0;
00388
00389 for (group = parser->groups; group < parser->egroup; group++)
00390 {
00391 const struct argp_option *opts;
00392
00393 for (opts = group->argp->options; !__option_is_end(opts); opts++)
00394 {
00395 if (!opts->name)
00396 continue;
00397 switch (match_option(arg, opts->name))
00398 {
00399 case MATCH_NO:
00400 break;
00401 case MATCH_PARTIAL:
00402 num_partial++;
00403
00404 matched_group = group;
00405 matched_option = opts;
00406
00407 break;
00408 case MATCH_EXACT:
00409
00410 *p = group;
00411 return opts;
00412 }
00413 }
00414 }
00415 if (num_partial == 1)
00416 {
00417 *p = matched_group;
00418 return matched_option;
00419 }
00420
00421 return NULL;
00422 }
00423
00424
00425
00426
00427 struct parser_convert_state
00428 {
00429 struct parser *parser;
00430 char *short_end;
00431 void **child_inputs_end;
00432 };
00433
00434
00435
00436
00437 static struct group *
00438 convert_options (const struct argp *argp,
00439 struct group *parent, unsigned parent_index,
00440 struct group *group, struct parser_convert_state *cvt)
00441 {
00442 const struct argp_option *opt = argp->options;
00443 const struct argp_child *children = argp->children;
00444
00445 if (opt || argp->parser)
00446 {
00447
00448 if (cvt->short_end)
00449 {
00450
00451 for ( ; !__option_is_end (opt); opt++)
00452 if (__option_is_short(opt))
00453 *cvt->short_end++ = opt->key;
00454 }
00455
00456 group->parser = argp->parser;
00457 group->argp = argp;
00458 group->args_processed = 0;
00459 group->parent = parent;
00460 group->parent_index = parent_index;
00461 group->input = 0;
00462 group->hook = 0;
00463 group->child_inputs = 0;
00464
00465 if (children)
00466
00467
00468 {
00469 unsigned num_children = 0;
00470 while (children[num_children].argp)
00471 num_children++;
00472 group->child_inputs = cvt->child_inputs_end;
00473 cvt->child_inputs_end += num_children;
00474 }
00475 parent = group++;
00476 }
00477 else
00478 parent = 0;
00479
00480 if (children)
00481 {
00482 unsigned index = 0;
00483 while (children->argp)
00484 group =
00485 convert_options (children++->argp, parent, index++, group, cvt);
00486 }
00487
00488 return group;
00489 }
00490
00491
00492
00493 static void
00494 parser_convert (struct parser *parser, const struct argp *argp)
00495 {
00496 struct parser_convert_state cvt;
00497
00498 cvt.parser = parser;
00499 cvt.short_end = parser->short_opts;
00500 cvt.child_inputs_end = parser->child_inputs;
00501
00502 parser->argp = argp;
00503
00504 if (argp)
00505 parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
00506 else
00507 parser->egroup = parser->groups;
00508
00509 if (parser->short_opts)
00510 *cvt.short_end ='\0';
00511 }
00512
00513
00514 struct parser_sizes
00515 {
00516
00517 size_t short_len;
00518
00519 size_t num_groups;
00520 size_t num_child_inputs;
00521 };
00522
00523
00524
00525
00526 static void
00527 calc_sizes (const struct argp *argp, struct parser_sizes *szs)
00528 {
00529 const struct argp_child *child = argp->children;
00530 const struct argp_option *opt = argp->options;
00531
00532 if (opt || argp->parser)
00533 {
00534
00535 szs->num_groups++;
00536 if (opt)
00537 {
00538 while (__option_is_short (opt++))
00539 szs->short_len++;
00540 }
00541 }
00542
00543 if (child)
00544 while (child->argp)
00545 {
00546 calc_sizes ((child++)->argp, szs);
00547 szs->num_child_inputs++;
00548 }
00549 }
00550
00551
00552 static error_t
00553 parser_init (struct parser *parser, const struct argp *argp,
00554 int argc, char **argv, int flags, void *input)
00555 {
00556 error_t err = 0;
00557 struct group *group;
00558 struct parser_sizes szs;
00559
00560 parser->posixly_correct = getenv ("POSIXLY_CORRECT");
00561
00562 if (flags & ARGP_IN_ORDER)
00563 parser->ordering = RETURN_IN_ORDER;
00564 else if (flags & ARGP_NO_ARGS)
00565 parser->ordering = REQUIRE_ORDER;
00566 else if (parser->posixly_correct)
00567 parser->ordering = REQUIRE_ORDER;
00568 else
00569 parser->ordering = PERMUTE;
00570
00571 szs.short_len = 0;
00572 szs.num_groups = 0;
00573 szs.num_child_inputs = 0;
00574
00575 if (argp)
00576 calc_sizes (argp, &szs);
00577
00578 if (!(flags & ARGP_LONG_ONLY))
00579
00580 szs.short_len = 0;
00581
00582
00583 #define GLEN (szs.num_groups + 1) * sizeof (struct group)
00584 #define CLEN (szs.num_child_inputs * sizeof (void *))
00585 #define SLEN (szs.short_len + 1)
00586 #define STORAGE(offset) ((void *) (((char *) parser->storage) + (offset)))
00587
00588 parser->storage = malloc (GLEN + CLEN + SLEN);
00589 if (! parser->storage)
00590 return ENOMEM;
00591
00592 parser->groups = parser->storage;
00593
00594 parser->child_inputs = STORAGE(GLEN);
00595 memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
00596
00597 if (flags & ARGP_LONG_ONLY)
00598 parser->short_opts = STORAGE(GLEN + CLEN);
00599 else
00600 parser->short_opts = NULL;
00601
00602 parser_convert (parser, argp);
00603
00604 memset (&parser->state, 0, sizeof (struct argp_state));
00605
00606 parser->state.root_argp = parser->argp;
00607 parser->state.argc = argc;
00608 parser->state.argv = argv;
00609 parser->state.flags = flags;
00610 parser->state.err_stream = stderr;
00611 parser->state.out_stream = stdout;
00612 parser->state.pstate = parser;
00613
00614 parser->args_only = 0;
00615 parser->nextchar = NULL;
00616 parser->first_nonopt = parser->last_nonopt = 0;
00617
00618
00619
00620 if (parser->groups < parser->egroup)
00621 parser->groups->input = input;
00622 for (group = parser->groups;
00623 group < parser->egroup && (!err || err == EBADKEY);
00624 group++)
00625 {
00626 if (group->parent)
00627
00628 group->input = group->parent->child_inputs[group->parent_index];
00629
00630 if (!group->parser
00631 && group->argp->children && group->argp->children->argp)
00632
00633
00634
00635 group->child_inputs[0] = group->input;
00636
00637 err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
00638 }
00639 if (err == EBADKEY)
00640 err = 0;
00641
00642 if (err)
00643 return err;
00644
00645 if (argv[0] && !(parser->state.flags & ARGP_PARSE_ARGV0))
00646
00647 {
00648 parser->state.name = __argp_basename(argv[0]);
00649
00650
00651 parser->state.next = 1;
00652 }
00653 else
00654 parser->state.name = __argp_short_program_name(NULL);
00655
00656 return 0;
00657 }
00658
00659
00660 static error_t
00661 parser_finalize (struct parser *parser,
00662 error_t err, int arg_ebadkey, int *end_index)
00663 {
00664 struct group *group;
00665
00666 if (err == EBADKEY && arg_ebadkey)
00667
00668 err = 0;
00669
00670 if (! err)
00671 {
00672 if (parser->state.next == parser->state.argc)
00673
00674
00675 {
00676 for (group = parser->groups;
00677 group < parser->egroup && (!err || err==EBADKEY);
00678 group++)
00679 if (group->args_processed == 0)
00680 err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
00681 for (group = parser->egroup - 1;
00682 group >= parser->groups && (!err || err==EBADKEY);
00683 group--)
00684 err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
00685
00686 if (err == EBADKEY)
00687 err = 0;
00688
00689
00690 if (end_index)
00691 *end_index = parser->state.next;
00692 }
00693 else if (end_index)
00694
00695 *end_index = parser->state.next;
00696 else
00697
00698 {
00699 if (!(parser->state.flags & ARGP_NO_ERRS)
00700 && parser->state.err_stream)
00701 fprintf (parser->state.err_stream,
00702 dgettext (parser->argp->argp_domain,
00703 "%s: Too many arguments\n"),
00704 parser->state.name);
00705 err = EBADKEY;
00706 }
00707 }
00708
00709
00710
00711
00712 if (err)
00713 {
00714
00715 if (err == EBADKEY)
00716
00717
00718 __argp_state_help (&parser->state, parser->state.err_stream,
00719 ARGP_HELP_STD_ERR);
00720
00721
00722 for (group = parser->groups; group < parser->egroup; group++)
00723 group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
00724 }
00725 else
00726
00727 {
00728
00729
00730
00731 for (group = parser->egroup - 1
00732 ; group >= parser->groups && (!err || err == EBADKEY)
00733 ; group--)
00734 err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
00735 if (err == EBADKEY)
00736 err = 0;
00737 }
00738
00739
00740 for (group = parser->egroup - 1; group >= parser->groups; group--)
00741 group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
00742
00743 if (err == EBADKEY)
00744 err = EINVAL;
00745
00746 free (parser->storage);
00747
00748 return err;
00749 }
00750
00751
00752
00753
00754
00755
00756 static error_t
00757 parser_parse_arg (struct parser *parser, char *val)
00758 {
00759
00760 int index = parser->state.next;
00761 error_t err = EBADKEY;
00762 struct group *group;
00763 int key = 0;
00764
00765
00766 for (group = parser->groups
00767 ; group < parser->egroup && err == EBADKEY
00768 ; group++)
00769 {
00770 parser->state.next++;
00771 key = ARGP_KEY_ARG;
00772 err = group_parse (group, &parser->state, key, val);
00773
00774 if (err == EBADKEY)
00775
00776 {
00777 parser->state.next--;
00778 key = ARGP_KEY_ARGS;
00779 err = group_parse (group, &parser->state, key, 0);
00780 }
00781 }
00782
00783 if (! err)
00784 {
00785 if (key == ARGP_KEY_ARGS)
00786
00787
00788
00789 parser->state.next = parser->state.argc;
00790
00791 if (parser->state.next > index)
00792
00793
00794
00795 (--group)->args_processed += (parser->state.next - index);
00796 else
00797
00798 parser->args_only = 0;
00799 }
00800
00801 return err;
00802 }
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813 static void
00814 exchange (struct parser *parser)
00815 {
00816 int bottom = parser->first_nonopt;
00817 int middle = parser->last_nonopt;
00818 int top = parser->state.next;
00819 char **argv = parser->state.argv;
00820
00821 char *tem;
00822
00823
00824
00825
00826
00827
00828 while (top > middle && middle > bottom)
00829 {
00830 if (top - middle > middle - bottom)
00831 {
00832
00833 int len = middle - bottom;
00834 register int i;
00835
00836
00837 for (i = 0; i < len; i++)
00838 {
00839 tem = argv[bottom + i];
00840 argv[bottom + i] = argv[top - (middle - bottom) + i];
00841 argv[top - (middle - bottom) + i] = tem;
00842 }
00843
00844 top -= len;
00845 }
00846 else
00847 {
00848
00849 int len = top - middle;
00850 register int i;
00851
00852
00853 for (i = 0; i < len; i++)
00854 {
00855 tem = argv[bottom + i];
00856 argv[bottom + i] = argv[middle + i];
00857 argv[middle + i] = tem;
00858 }
00859
00860 bottom += len;
00861 }
00862 }
00863
00864
00865
00866 parser->first_nonopt += (parser->state.next - parser->last_nonopt);
00867 parser->last_nonopt = parser->state.next;
00868 }
00869
00870
00871
00872 enum arg_type { ARG_ARG, ARG_SHORT_OPTION,
00873 ARG_LONG_OPTION, ARG_LONG_ONLY_OPTION,
00874 ARG_QUOTE };
00875
00876 static enum arg_type
00877 classify_arg(struct parser *parser, char *arg, char **opt)
00878 {
00879 if (arg[0] == '-')
00880
00881 switch (arg[1])
00882 {
00883 case '\0':
00884
00885 return ARG_ARG;
00886 case '-':
00887
00888 if (!arg[2])
00889 return ARG_QUOTE;
00890
00891
00892 if (opt)
00893 *opt = arg + 2;
00894 return ARG_LONG_OPTION;
00895
00896 default:
00897
00898
00899 if (opt)
00900 *opt = arg + 1;
00901
00902 if (parser->state.flags & ARGP_LONG_ONLY)
00903 {
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919 assert(parser->short_opts);
00920
00921 if (arg[2] || !strchr(parser->short_opts, arg[1]))
00922 return ARG_LONG_ONLY_OPTION;
00923 }
00924
00925 return ARG_SHORT_OPTION;
00926 }
00927
00928 else
00929 return ARG_ARG;
00930 }
00931
00932
00933
00934
00935
00936 static error_t
00937 parser_parse_next (struct parser *parser, int *arg_ebadkey)
00938 {
00939 if (parser->state.quoted && parser->state.next < parser->state.quoted)
00940
00941
00942
00943
00944 parser->state.quoted = parser->args_only = 0;
00945
00946
00947
00948 if (parser->last_nonopt > parser->state.next)
00949 parser->last_nonopt = parser->state.next;
00950 if (parser->first_nonopt > parser->state.next)
00951 parser->first_nonopt = parser->state.next;
00952
00953 if (parser->nextchar)
00954
00955 {
00956 struct group *group;
00957 char c;
00958 const struct argp_option *option;
00959 char *value = NULL;;
00960
00961 assert(!parser->args_only);
00962
00963 c = *parser->nextchar++;
00964
00965 option = find_short_option(parser, c, &group);
00966 if (!option)
00967 {
00968 if (parser->posixly_correct)
00969
00970 fprintf (parser->state.err_stream,
00971 dgettext(parser->state.root_argp->argp_domain,
00972 "%s: illegal option -- %c\n"),
00973 parser->state.name, c);
00974 else
00975 fprintf (parser->state.err_stream,
00976 dgettext(parser->state.root_argp->argp_domain,
00977 "%s: invalid option -- %c\n"),
00978 parser->state.name, c);
00979
00980 *arg_ebadkey = 0;
00981 return EBADKEY;
00982 }
00983
00984 if (!*parser->nextchar)
00985 parser->nextchar = NULL;
00986
00987 if (option->arg)
00988 {
00989 value = parser->nextchar;
00990 parser->nextchar = NULL;
00991
00992 if (!value
00993 && !(option->flags & OPTION_ARG_OPTIONAL))
00994
00995 {
00996 if (parser->state.next == parser->state.argc)
00997
00998 {
00999
01000 fprintf (parser->state.err_stream,
01001 dgettext(parser->state.root_argp->argp_domain,
01002 "%s: option requires an argument -- %c\n"),
01003 parser->state.name, c);
01004
01005 *arg_ebadkey = 0;
01006 return EBADKEY;
01007 }
01008 value = parser->state.argv[parser->state.next++];
01009 }
01010 }
01011 return group_parse(group, &parser->state,
01012 option->key, value);
01013 }
01014 else
01015
01016 {
01017 if (parser->args_only)
01018 {
01019 *arg_ebadkey = 1;
01020 if (parser->state.next >= parser->state.argc)
01021
01022 return EBADKEY;
01023 else
01024 return parser_parse_arg(parser,
01025 parser->state.argv[parser->state.next]);
01026 }
01027
01028 if (parser->state.next >= parser->state.argc)
01029
01030
01031 {
01032 *arg_ebadkey = 1;
01033 if (parser->first_nonopt != parser->last_nonopt)
01034 {
01035 exchange(parser);
01036
01037
01038 parser->state.next = parser->first_nonopt;
01039
01040 parser->first_nonopt = parser->last_nonopt = 0;
01041
01042 parser->args_only = 1;
01043 return 0;
01044 }
01045 else
01046
01047 return EBADKEY;
01048 }
01049 else
01050
01051 {
01052 char *arg = parser->state.argv[parser->state.next];
01053
01054 char *optstart;
01055 enum arg_type token = classify_arg(parser, arg, &optstart);
01056
01057 switch (token)
01058 {
01059 case ARG_ARG:
01060 switch (parser->ordering)
01061 {
01062 case PERMUTE:
01063 if (parser->first_nonopt == parser->last_nonopt)
01064
01065 parser->first_nonopt = parser->last_nonopt = parser->state.next;
01066
01067 else if (parser->last_nonopt != parser->state.next)
01068
01069
01070 exchange(parser);
01071
01072 assert(parser->last_nonopt == parser->state.next);
01073
01074
01075 parser->state.next++;
01076 parser->last_nonopt = parser->state.next;
01077
01078 return 0;
01079
01080 case REQUIRE_ORDER:
01081
01082 parser->args_only = 1;
01083 return 0;
01084
01085 case RETURN_IN_ORDER:
01086 *arg_ebadkey = 1;
01087 return parser_parse_arg(parser, arg);
01088
01089 default:
01090 abort();
01091 }
01092 case ARG_QUOTE:
01093
01094 parser->state.next++;
01095 assert (parser->last_nonopt != parser->state.next);
01096
01097 if (parser->first_nonopt != parser->last_nonopt)
01098 {
01099 exchange(parser);
01100
01101
01102
01103
01104 parser->state.quoted = parser->state.next = parser->first_nonopt;
01105
01106
01107
01108 parser->first_nonopt = parser->last_nonopt = 0;
01109 }
01110 else
01111 parser->state.quoted = parser->state.next;
01112
01113 parser->args_only = 1;
01114 return 0;
01115
01116 case ARG_LONG_ONLY_OPTION:
01117 case ARG_LONG_OPTION:
01118 {
01119 struct group *group;
01120 const struct argp_option *option;
01121 char *value;
01122
01123 parser->state.next++;
01124 option = find_long_option(parser, optstart, &group);
01125
01126 if (!option)
01127 {
01128
01129 fprintf (parser->state.err_stream,
01130 dgettext(parser->state.root_argp->argp_domain,
01131 "%s: unrecognized option `%s'\n"),
01132 parser->state.name, arg);
01133 *arg_ebadkey = 0;
01134 return EBADKEY;
01135 }
01136
01137 value = strchr(optstart, '=');
01138 if (value)
01139 value++;
01140
01141 if (value && !option->arg)
01142
01143 {
01144 if (token == ARG_LONG_OPTION)
01145
01146 fprintf (parser->state.err_stream,
01147 dgettext(parser->state.root_argp->argp_domain,
01148 "%s: option `--%s' doesn't allow an argument\n"),
01149 parser->state.name, option->name);
01150 else
01151
01152 fprintf (parser->state.err_stream,
01153 dgettext(parser->state.root_argp->argp_domain,
01154 "%s: option `%c%s' doesn't allow an argument\n"),
01155 parser->state.name, arg[0], option->name);
01156
01157 *arg_ebadkey = 0;
01158 return EBADKEY;
01159 }
01160
01161 if (option->arg && !value
01162 && !(option->flags & OPTION_ARG_OPTIONAL))
01163
01164 {
01165 if (parser->state.next == parser->state.argc)
01166
01167 {
01168 if (token == ARG_LONG_OPTION)
01169
01170 fprintf (parser->state.err_stream,
01171 dgettext(parser->state.root_argp->argp_domain,
01172 "%s: option `--%s' requires an argument\n"),
01173 parser->state.name, option->name);
01174 else
01175
01176 fprintf (parser->state.err_stream,
01177 dgettext(parser->state.root_argp->argp_domain,
01178 "%s: option `%c%s' requires an argument\n"),
01179 parser->state.name, arg[0], option->name);
01180
01181 *arg_ebadkey = 0;
01182 return EBADKEY;
01183 }
01184
01185 value = parser->state.argv[parser->state.next++];
01186 }
01187 *arg_ebadkey = 0;
01188 return group_parse(group, &parser->state,
01189 option->key, value);
01190 }
01191 case ARG_SHORT_OPTION:
01192 parser->state.next++;
01193 parser->nextchar = optstart;
01194 return 0;
01195
01196 default:
01197 abort();
01198 }
01199 }
01200 }
01201 }
01202
01203
01204
01205
01206
01207
01208 error_t
01209 __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
01210 int *end_index, void *input)
01211 {
01212 error_t err;
01213 struct parser parser;
01214
01215
01216
01217 int arg_ebadkey = 0;
01218
01219 if (! (flags & ARGP_NO_HELP))
01220
01221 {
01222 struct argp_child *child = alloca (4 * sizeof (struct argp_child));
01223 struct argp *top_argp = alloca (sizeof (struct argp));
01224
01225
01226
01227 memset (top_argp, 0, sizeof (*top_argp));
01228 top_argp->children = child;
01229
01230 memset (child, 0, 4 * sizeof (struct argp_child));
01231
01232 if (argp)
01233 (child++)->argp = argp;
01234 (child++)->argp = &argp_default_argp;
01235 if (argp_program_version || argp_program_version_hook)
01236 (child++)->argp = &argp_version_argp;
01237 child->argp = 0;
01238
01239 argp = top_argp;
01240 }
01241
01242
01243 err = parser_init (&parser, argp, argc, argv, flags, input);
01244
01245 if (! err)
01246
01247 {
01248 while (! err)
01249 err = parser_parse_next (&parser, &arg_ebadkey);
01250 err = parser_finalize (&parser, err, arg_ebadkey, end_index);
01251 }
01252
01253 return err;
01254 }
01255 #ifdef weak_alias
01256 weak_alias (__argp_parse, argp_parse)
01257 #endif
01258
01259
01260
01261 void *
01262 __argp_input (const struct argp *argp, const struct argp_state *state)
01263 {
01264 if (state)
01265 {
01266 struct group *group;
01267 struct parser *parser = state->pstate;
01268
01269 for (group = parser->groups; group < parser->egroup; group++)
01270 if (group->argp == argp)
01271 return group->input;
01272 }
01273
01274 return 0;
01275 }
01276 #ifdef weak_alias
01277 weak_alias (__argp_input, _argp_input)
01278 #endif
01279
01280
01281
01282 void
01283 __argp_usage (__const struct argp_state *__state)
01284 {
01285 __argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE);
01286 }
01287
01288 int
01289 __option_is_short (__const struct argp_option *__opt)
01290 {
01291 if (__opt->flags & OPTION_DOC)
01292 return 0;
01293 else
01294 {
01295 int __key = __opt->key;
01296
01297
01298 return __key > 0 && isprint (__key);
01299 }
01300 }
01301
01302 int
01303 __option_is_end (__const struct argp_option *__opt)
01304 {
01305 return !__opt->key && !__opt->name && !__opt->doc && !__opt->group;
01306 }