Commit | Line | Data |
---|---|---|
bf2e821a CC |
1 | /* |
2 | * getopt.c | |
3 | * | |
4 | * getopt_long(), or at least a common subset thereof: | |
5 | * | |
6 | * - Option reordering is not supported | |
7 | * - -W foo is not supported | |
8 | * - First optstring character "-" not supported. | |
eb078db3 JA |
9 | * |
10 | * This file was imported from the klibc library from hpa | |
bf2e821a CC |
11 | */ |
12 | ||
13 | #include <stdint.h> | |
14 | #include <unistd.h> | |
15 | #include <string.h> | |
eb078db3 JA |
16 | |
17 | #include "getopt.h" | |
bf2e821a | 18 | |
5be4c944 JA |
19 | char *optarg = NULL; |
20 | int optind = 0, opterr = 0, optopt = 0; | |
21 | ||
bf2e821a CC |
22 | static struct getopt_private_state { |
23 | const char *optptr; | |
24 | const char *last_optstring; | |
25 | char *const *last_argv; | |
26 | } pvt; | |
27 | ||
28 | static inline const char *option_matches(const char *arg_str, | |
29 | const char *opt_name) | |
30 | { | |
31 | while (*arg_str != '\0' && *arg_str != '=') { | |
32 | if (*arg_str++ != *opt_name++) | |
33 | return NULL; | |
34 | } | |
35 | ||
36 | if (*opt_name) | |
37 | return NULL; | |
38 | ||
39 | return arg_str; | |
40 | } | |
41 | ||
42 | int getopt_long_only(int argc, char *const *argv, const char *optstring, | |
43 | const struct option *longopts, int *longindex) | |
44 | { | |
45 | const char *carg; | |
46 | const char *osptr; | |
47 | int opt; | |
48 | ||
49 | /* getopt() relies on a number of different global state | |
50 | variables, which can make this really confusing if there is | |
51 | more than one use of getopt() in the same program. This | |
52 | attempts to detect that situation by detecting if the | |
53 | "optstring" or "argv" argument have changed since last time | |
54 | we were called; if so, reinitialize the query state. */ | |
55 | ||
56 | if (optstring != pvt.last_optstring || argv != pvt.last_argv || | |
57 | optind < 1 || optind > argc) { | |
58 | /* optind doesn't match the current query */ | |
59 | pvt.last_optstring = optstring; | |
60 | pvt.last_argv = argv; | |
61 | optind = 1; | |
62 | pvt.optptr = NULL; | |
63 | } | |
64 | ||
65 | carg = argv[optind]; | |
66 | ||
67 | /* First, eliminate all non-option cases */ | |
68 | ||
69 | if (!carg || carg[0] != '-' || !carg[1]) | |
70 | return -1; | |
71 | ||
72 | if (carg[1] == '-') { | |
73 | const struct option *lo; | |
74 | const char *opt_end = NULL; | |
75 | ||
76 | optind++; | |
77 | ||
78 | /* Either it's a long option, or it's -- */ | |
79 | if (!carg[2]) { | |
80 | /* It's -- */ | |
81 | return -1; | |
82 | } | |
83 | ||
84 | for (lo = longopts; lo->name; lo++) { | |
85 | if ((opt_end = option_matches(carg+2, lo->name))) | |
86 | break; | |
87 | } | |
88 | if (!opt_end) | |
89 | return '?'; | |
90 | ||
91 | if (longindex) | |
92 | *longindex = lo-longopts; | |
93 | ||
94 | if (*opt_end == '=') { | |
95 | if (lo->has_arg) | |
96 | optarg = (char *)opt_end+1; | |
97 | else | |
98 | return '?'; | |
99 | } else if (lo->has_arg == 1) { | |
100 | if (!(optarg = argv[optind])) | |
101 | return '?'; | |
102 | optind++; | |
103 | } | |
104 | ||
105 | if (lo->flag) { | |
106 | *lo->flag = lo->val; | |
107 | return 0; | |
108 | } else { | |
109 | return lo->val; | |
110 | } | |
111 | } | |
112 | ||
113 | if ((uintptr_t) (pvt.optptr - carg) > (uintptr_t) strlen(carg)) { | |
114 | /* Someone frobbed optind, change to new opt. */ | |
115 | pvt.optptr = carg + 1; | |
116 | } | |
117 | ||
118 | opt = *pvt.optptr++; | |
119 | ||
120 | if (opt != ':' && (osptr = strchr(optstring, opt))) { | |
121 | if (osptr[1] == ':') { | |
122 | if (*pvt.optptr) { | |
123 | /* Argument-taking option with attached | |
124 | argument */ | |
125 | optarg = (char *)pvt.optptr; | |
126 | optind++; | |
127 | } else { | |
128 | /* Argument-taking option with non-attached | |
129 | argument */ | |
9f170691 JA |
130 | if (osptr[2] == ':') { |
131 | if (argv[optind + 1]) { | |
132 | optarg = (char *)argv[optind+1]; | |
133 | optind += 2; | |
134 | } else { | |
135 | optarg = NULL; | |
136 | optind++; | |
137 | } | |
138 | return opt; | |
139 | } else if (argv[optind + 1]) { | |
bf2e821a CC |
140 | optarg = (char *)argv[optind+1]; |
141 | optind += 2; | |
142 | } else { | |
143 | /* Missing argument */ | |
144 | optind++; | |
145 | return (optstring[0] == ':') | |
146 | ? ':' : '?'; | |
147 | } | |
148 | } | |
149 | return opt; | |
150 | } else { | |
151 | /* Non-argument-taking option */ | |
152 | /* pvt.optptr will remember the exact position to | |
153 | resume at */ | |
154 | if (!*pvt.optptr) | |
155 | optind++; | |
156 | return opt; | |
157 | } | |
158 | } else { | |
159 | /* Unknown option */ | |
160 | optopt = opt; | |
161 | if (!*pvt.optptr) | |
162 | optind++; | |
163 | return '?'; | |
164 | } | |
165 | } |