452 lines · cpp
1//===-- GetOptInc.cpp -----------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "lldb/Host/common/GetOptInc.h"10 11#if defined(REPLACE_GETOPT) || defined(REPLACE_GETOPT_LONG) || \12 defined(REPLACE_GETOPT_LONG_ONLY)13 14// getopt.cpp15#include <cerrno>16#include <cstdlib>17#include <cstring>18 19#if defined(REPLACE_GETOPT)20int opterr = 1; /* if error message should be printed */21int optind = 1; /* index into parent argv vector */22int optopt = '?'; /* character checked for validity */23int optreset; /* reset getopt */24char *optarg; /* argument associated with option */25#endif26 27#define PRINT_ERROR ((opterr) && (*options != ':'))28 29#define FLAG_PERMUTE 0x01 /* permute non-options to the end of argv */30#define FLAG_ALLARGS 0x02 /* treat non-options as args to option "-1" */31#define FLAG_LONGONLY 0x04 /* operate as getopt_long_only */32 33/* return values */34#define BADCH (int)'?'35#define BADARG ((*options == ':') ? (int)':' : (int)'?')36#define INORDER (int)137 38#define EMSG ""39 40static int getopt_internal(int, char *const *, const char *,41 const struct option *, int *, int);42static int parse_long_options(char *const *, const char *,43 const struct option *, int *, int);44static int gcd(int, int);45static void permute_args(int, int, int, char *const *);46 47static const char *place = EMSG; /* option letter processing */48 49/* XXX: set optreset to 1 rather than these two */50static int nonopt_start = -1; /* first non option argument (for permute) */51static int nonopt_end = -1; /* first option after non options (for permute) */52 53/*54* Compute the greatest common divisor of a and b.55*/56static int gcd(int a, int b) {57 int c;58 59 c = a % b;60 while (c != 0) {61 a = b;62 b = c;63 c = a % b;64 }65 66 return (b);67}68 69static void pass() {}70#define warnx(a, ...) pass();71 72/*73* Exchange the block from nonopt_start to nonopt_end with the block74* from nonopt_end to opt_end (keeping the same order of arguments75* in each block).76*/77static void permute_args(int panonopt_start, int panonopt_end, int opt_end,78 char *const *nargv) {79 int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;80 char *swap;81 82 /*83 * compute lengths of blocks and number and size of cycles84 */85 nnonopts = panonopt_end - panonopt_start;86 nopts = opt_end - panonopt_end;87 ncycle = gcd(nnonopts, nopts);88 cyclelen = (opt_end - panonopt_start) / ncycle;89 90 for (i = 0; i < ncycle; i++) {91 cstart = panonopt_end + i;92 pos = cstart;93 for (j = 0; j < cyclelen; j++) {94 if (pos >= panonopt_end)95 pos -= nnonopts;96 else97 pos += nopts;98 swap = nargv[pos];99 /* LINTED const cast */100 const_cast<char **>(nargv)[pos] = nargv[cstart];101 /* LINTED const cast */102 const_cast<char **>(nargv)[cstart] = swap;103 }104 }105}106 107/*108* parse_long_options --109* Parse long options in argc/argv argument vector.110* Returns -1 if short_too is set and the option does not match long_options.111*/112static int parse_long_options(char *const *nargv, const char *options,113 const struct option *long_options, int *idx,114 int short_too) {115 char *current_argv, *has_equal;116 size_t current_argv_len;117 int i, match;118 119 current_argv = const_cast<char *>(place);120 match = -1;121 122 optind++;123 124 if ((has_equal = strchr(current_argv, '=')) != NULL) {125 /* argument found (--option=arg) */126 current_argv_len = has_equal - current_argv;127 has_equal++;128 } else129 current_argv_len = strlen(current_argv);130 131 for (i = 0; long_options[i].name; i++) {132 /* find matching long option */133 if (strncmp(current_argv, long_options[i].name, current_argv_len))134 continue;135 136 if (strlen(long_options[i].name) == current_argv_len) {137 /* exact match */138 match = i;139 break;140 }141 /*142 * If this is a known short option, don't allow143 * a partial match of a single character.144 */145 if (short_too && current_argv_len == 1)146 continue;147 148 if (match == -1) /* partial match */149 match = i;150 else {151 /* ambiguous abbreviation */152 if (PRINT_ERROR)153 warnx(ambig, (int)current_argv_len, current_argv);154 optopt = 0;155 return (BADCH);156 }157 }158 if (match != -1) { /* option found */159 if (long_options[match].has_arg == no_argument && has_equal) {160 if (PRINT_ERROR)161 warnx(noarg, (int)current_argv_len, current_argv);162 /*163 * XXX: GNU sets optopt to val regardless of flag164 */165 if (long_options[match].flag == NULL)166 optopt = long_options[match].val;167 else168 optopt = 0;169 return (BADARG);170 }171 if (long_options[match].has_arg == required_argument ||172 long_options[match].has_arg == optional_argument) {173 if (has_equal)174 optarg = has_equal;175 else if (long_options[match].has_arg == required_argument) {176 /*177 * optional argument doesn't use next nargv178 */179 optarg = nargv[optind++];180 }181 }182 if ((long_options[match].has_arg == required_argument) &&183 (optarg == NULL)) {184 /*185 * Missing argument; leading ':' indicates no error186 * should be generated.187 */188 if (PRINT_ERROR)189 warnx(recargstring, current_argv);190 /*191 * XXX: GNU sets optopt to val regardless of flag192 */193 if (long_options[match].flag == NULL)194 optopt = long_options[match].val;195 else196 optopt = 0;197 --optind;198 return (BADARG);199 }200 } else { /* unknown option */201 if (short_too) {202 --optind;203 return (-1);204 }205 if (PRINT_ERROR)206 warnx(illoptstring, current_argv);207 optopt = 0;208 return (BADCH);209 }210 if (idx)211 *idx = match;212 if (long_options[match].flag) {213 *long_options[match].flag = long_options[match].val;214 return (0);215 } else216 return (long_options[match].val);217}218 219/*220* getopt_internal --221* Parse argc/argv argument vector. Called by user level routines.222*/223static int getopt_internal(int nargc, char *const *nargv, const char *options,224 const struct option *long_options, int *idx,225 int flags) {226 const char *oli; /* option letter list index */227 int optchar, short_too;228 static int posixly_correct = -1;229 230 if (options == NULL)231 return (-1);232 233 /*234 * XXX Some GNU programs (like cvs) set optind to 0 instead of235 * XXX using optreset. Work around this braindamage.236 */237 if (optind == 0)238 optind = optreset = 1;239 240 /*241 * Disable GNU extensions if POSIXLY_CORRECT is set or options242 * string begins with a '+'.243 */244 if (posixly_correct == -1 || optreset)245 posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);246 if (*options == '-')247 flags |= FLAG_ALLARGS;248 else if (posixly_correct || *options == '+')249 flags &= ~FLAG_PERMUTE;250 if (*options == '+' || *options == '-')251 options++;252 253 optarg = NULL;254 if (optreset)255 nonopt_start = nonopt_end = -1;256start:257 if (optreset || !*place) { /* update scanning pointer */258 optreset = 0;259 if (optind >= nargc) { /* end of argument vector */260 place = EMSG;261 if (nonopt_end != -1) {262 /* do permutation, if we have to */263 permute_args(nonopt_start, nonopt_end, optind, nargv);264 optind -= nonopt_end - nonopt_start;265 } else if (nonopt_start != -1) {266 /*267 * If we skipped non-options, set optind268 * to the first of them.269 */270 optind = nonopt_start;271 }272 nonopt_start = nonopt_end = -1;273 return (-1);274 }275 if (*(place = nargv[optind]) != '-' ||276 (place[1] == '\0' && strchr(options, '-') == NULL)) {277 place = EMSG; /* found non-option */278 if (flags & FLAG_ALLARGS) {279 /*280 * GNU extension:281 * return non-option as argument to option 1282 */283 optarg = nargv[optind++];284 return (INORDER);285 }286 if (!(flags & FLAG_PERMUTE)) {287 /*288 * If no permutation wanted, stop parsing289 * at first non-option.290 */291 return (-1);292 }293 /* do permutation */294 if (nonopt_start == -1)295 nonopt_start = optind;296 else if (nonopt_end != -1) {297 permute_args(nonopt_start, nonopt_end, optind, nargv);298 nonopt_start = optind - (nonopt_end - nonopt_start);299 nonopt_end = -1;300 }301 optind++;302 /* process next argument */303 goto start;304 }305 if (nonopt_start != -1 && nonopt_end == -1)306 nonopt_end = optind;307 308 /*309 * If we have "-" do nothing, if "--" we are done.310 */311 if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {312 optind++;313 place = EMSG;314 /*315 * We found an option (--), so if we skipped316 * non-options, we have to permute.317 */318 if (nonopt_end != -1) {319 permute_args(nonopt_start, nonopt_end, optind, nargv);320 optind -= nonopt_end - nonopt_start;321 }322 nonopt_start = nonopt_end = -1;323 return (-1);324 }325 }326 327 /*328 * Check long options if:329 * 1) we were passed some330 * 2) the arg is not just "-"331 * 3) either the arg starts with -- we are getopt_long_only()332 */333 if (long_options != NULL && place != nargv[optind] &&334 (*place == '-' || (flags & FLAG_LONGONLY))) {335 short_too = 0;336 if (*place == '-')337 place++; /* --foo long option */338 else if (*place != ':' && strchr(options, *place) != NULL)339 short_too = 1; /* could be short option too */340 341 optchar = parse_long_options(nargv, options, long_options, idx, short_too);342 if (optchar != -1) {343 place = EMSG;344 return (optchar);345 }346 }347 348 if ((optchar = (int)*place++) == (int)':' ||349 (optchar == (int)'-' && *place != '\0') ||350 (oli = strchr(options, optchar)) == NULL) {351 /*352 * If the user specified "-" and '-' isn't listed in353 * options, return -1 (non-option) as per POSIX.354 * Otherwise, it is an unknown option character (or ':').355 */356 if (optchar == (int)'-' && *place == '\0')357 return (-1);358 if (!*place)359 ++optind;360 if (PRINT_ERROR)361 warnx(illoptchar, optchar);362 optopt = optchar;363 return (BADCH);364 }365 if (long_options != NULL && optchar == 'W' && oli[1] == ';') {366 /* -W long-option */367 if (*place) /* no space */368 /* NOTHING */;369 else if (++optind >= nargc) { /* no arg */370 place = EMSG;371 if (PRINT_ERROR)372 warnx(recargchar, optchar);373 optopt = optchar;374 return (BADARG);375 } else /* white space */376 place = nargv[optind];377 optchar = parse_long_options(nargv, options, long_options, idx, 0);378 place = EMSG;379 return (optchar);380 }381 if (*++oli != ':') { /* doesn't take argument */382 if (!*place)383 ++optind;384 } else { /* takes (optional) argument */385 optarg = NULL;386 if (*place) /* no white space */387 optarg = const_cast<char *>(place);388 else if (oli[1] != ':') { /* arg not optional */389 if (++optind >= nargc) { /* no arg */390 place = EMSG;391 if (PRINT_ERROR)392 warnx(recargchar, optchar);393 optopt = optchar;394 return (BADARG);395 } else396 optarg = nargv[optind];397 }398 place = EMSG;399 ++optind;400 }401 /* dump back option letter */402 return (optchar);403}404 405/*406* getopt --407* Parse argc/argv argument vector.408*409* [eventually this will replace the BSD getopt]410*/411#if defined(REPLACE_GETOPT)412int getopt(int nargc, char *const *nargv, const char *options) {413 414 /*415 * We don't pass FLAG_PERMUTE to getopt_internal() since416 * the BSD getopt(3) (unlike GNU) has never done this.417 *418 * Furthermore, since many privileged programs call getopt()419 * before dropping privileges it makes sense to keep things420 * as simple (and bug-free) as possible.421 */422 return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));423}424#endif425 426/*427* getopt_long --428* Parse argc/argv argument vector.429*/430#if defined(REPLACE_GETOPT_LONG)431int getopt_long(int nargc, char *const *nargv, const char *options,432 const struct option *long_options, int *idx) {433 return (434 getopt_internal(nargc, nargv, options, long_options, idx, FLAG_PERMUTE));435}436#endif437 438/*439* getopt_long_only --440* Parse argc/argv argument vector.441*/442#if defined(REPLACE_GETOPT_LONG_ONLY)443int getopt_long_only(int nargc, char *const *nargv, const char *options,444 const struct option *long_options, int *idx) {445 446 return (getopt_internal(nargc, nargv, options, long_options, idx,447 FLAG_PERMUTE | FLAG_LONGONLY));448}449#endif450 451#endif452