Home | History | Annotate | Download | only in oslib 
      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 
     28 static inline const char *option_matches(const char *arg_str,
     29 					 const char *opt_name, int smatch)
     30 {
     31 	while (*arg_str != '\0' && *arg_str != '=') {
     32 		if (*arg_str++ != *opt_name++)
     33 			return NULL;
     34 	}
     35 
     36 	if (*opt_name && !smatch)
     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 	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 			opt_end = option_matches(carg+2, lo->name, 0);
     88 			if (opt_end)
     89 			    break;
     90 		}
     91 		/*
     92 		 * The GNU getopt_long_only() apparently allows a short match,
     93 		 * if it's unique and if we don't have a full match. Let's
     94 		 * do the same here, search and see if there is one (and only
     95 		 * one) short match.
     96 		 */
     97 		if (!opt_end) {
     98 			const struct option *lo_match = NULL;
     99 
    100 			for (lo = longopts; lo->name; lo++) {
    101 				const char *ret;
    102 
    103 				ret = option_matches(carg+2, lo->name, 1);
    104 				if (!ret)
    105 					continue;
    106 				if (!opt_end) {
    107 					opt_end = ret;
    108 					lo_match = lo;
    109 				} else {
    110 					opt_end = NULL;
    111 					break;
    112 				}
    113 			}
    114 			if (!opt_end)
    115 				return '?';
    116 			lo = lo_match;
    117 		}
    118 
    119 		if (longindex)
    120 			*longindex = lo-longopts;
    121 
    122 		if (*opt_end == '=') {
    123 			if (lo->has_arg)
    124 				optarg = (char *)opt_end+1;
    125 			else
    126 				return '?';
    127 		} else if (lo->has_arg == 1) {
    128 			if (!(optarg = argv[optind]))
    129 				return '?';
    130 			optind++;
    131 		}
    132 
    133 		if (lo->flag) {
    134 			*lo->flag = lo->val;
    135 			return 0;
    136 		} else {
    137 			return lo->val;
    138 		}
    139 	}
    140 
    141 	if ((uintptr_t) (pvt.optptr - carg) > (uintptr_t) strlen(carg)) {
    142 		/* Someone frobbed optind, change to new opt. */
    143 		pvt.optptr = carg + 1;
    144 	}
    145 
    146 	opt = *pvt.optptr++;
    147 
    148 	if (opt != ':' && (osptr = strchr(optstring, opt))) {
    149 		if (osptr[1] == ':') {
    150 			if (*pvt.optptr) {
    151 				/* Argument-taking option with attached
    152 				   argument */
    153 				optarg = (char *)pvt.optptr;
    154 				optind++;
    155 			} else {
    156 				/* Argument-taking option with non-attached
    157 				   argument */
    158 				if (osptr[2] == ':') {
    159 					if (argv[optind + 1]) {
    160 						optarg = (char *)argv[optind+1];
    161 						optind += 2;
    162 					} else {
    163 						optarg = NULL;
    164 						optind++;
    165 					}
    166 					return opt;
    167 				} else if (argv[optind + 1]) {
    168 					optarg = (char *)argv[optind+1];
    169 					optind += 2;
    170 				} else {
    171 					/* Missing argument */
    172 					optind++;
    173 					return (optstring[0] == ':')
    174 						? ':' : '?';
    175 				}
    176 			}
    177 			return opt;
    178 		} else {
    179 			/* Non-argument-taking option */
    180 			/* pvt.optptr will remember the exact position to
    181 			   resume at */
    182 			if (!*pvt.optptr)
    183 				optind++;
    184 			return opt;
    185 		}
    186 	} else {
    187 		/* Unknown option */
    188 		optopt = opt;
    189 		if (!*pvt.optptr)
    190 			optind++;
    191 		return '?';
    192 	}
    193 }
    194