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