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