Simplify musl's getopt, including removing optind, optopt, opterr, idx, and longonly

include/cli.hpp

@@ -7,6 +7,7 @@
 #include <string>
 
 #include "extern/getopt.hpp" // option
+#include "usage.hpp"
 
 void cli_ParseArgs(
     int argc,
@@ -14,7 +15,7 @@ void cli_ParseArgs(
     char const *shortOpts,
     option const *longOpts,
     void (*parseArg)(int, char *),
-    void (*fatal)(char const *, ...)
+    Usage usage
 );
 
 #endif // RGBDS_CLI_HPP

include/extern/getopt.hpp

@@ -12,7 +12,7 @@ static constexpr int optional_argument = 2;
 // clang-format on
 
 extern char *musl_optarg;
-extern int musl_optind, musl_opterr, musl_optopt, musl_optreset;
+extern int musl_optind, musl_optopt;
 
 struct option {
 	char const *name;
@@ -21,8 +21,6 @@ struct option {
 	int val;
 };
 
-int musl_getopt_long_only(
+int musl_getopt_long_only(int argc, char **argv, char const *optstring, option const *longopts);
-    int argc, char **argv, char const *optstring, option const *longopts, int *idx
-);
 
 #endif // RGBDS_EXTERN_GETOPT_HPP

src/asm/main.cpp

@@ -513,7 +513,7 @@ int main(int argc, char *argv[]) {
 		options.maxErrors = 100; // LCOV_EXCL_LINE
 	}
 
-	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, fatal);
+	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, usage);
 
 	if (!options.targetFileName && options.objectFileName) {
 		options.targetFileName = options.objectFileName;

src/cli.cpp

@@ -2,26 +2,30 @@
 
 #include <errno.h>
 #include <fstream>
+#include <stdio.h>
 #include <string.h>
 #include <string>
 #include <vector>
 
 #include "extern/getopt.hpp"
+#include "style.hpp"
+#include "usage.hpp"
 #include "util.hpp" // isBlankSpace
 
 using namespace std::literals;
 
 // Turn an at-file's contents into an argv that `getopt` can handle, appending them to `argPool`.
-static std::vector<size_t> readAtFile(
+static std::vector<size_t>
-    std::string const &path, std::vector<char> &argPool, void (*fatal)(char const *, ...)
+    readAtFile(std::string const &path, std::vector<char> &argPool, Usage usage) {
-) {
 	std::vector<size_t> argvOfs;
 
 	std::filebuf file;
 	if (!file.open(path, std::ios_base::in)) {
-		std::string msg = "Error reading at-file \""s + path + "\": " + strerror(errno);
+		style_Set(stderr, STYLE_RED, true);
-		fatal(msg.c_str());
+		fputs("FATAL: ", stderr);
-		return argvOfs; // Since we can't mark the `fatal` function pointer as [[noreturn]]
+		style_Reset(stderr);
+		fprintf(stderr, "Failed to open at-file \"%s\": %s\n", path.c_str(), strerror(errno));
+		usage.printAndExit(1);
 	}
 
 	for (;;) {
@@ -71,7 +75,7 @@ void cli_ParseArgs(
     char const *shortOpts,
     option const *longOpts,
     void (*parseArg)(int, char *),
-    void (*fatal)(char const *, ...)
+    Usage usage
 ) {
 	struct AtFileStackEntry {
 		int parentInd;            // Saved offset into parent argv
@@ -90,8 +94,7 @@ void cli_ParseArgs(
 	for (;;) {
 		char *atFileName = nullptr;
 		for (int ch;
-		     (ch = musl_getopt_long_only(curArgc, curArgv, optString.c_str(), longOpts, nullptr))
+		     (ch = musl_getopt_long_only(curArgc, curArgv, optString.c_str(), longOpts)) != -1;) {
-		     != -1;) {
 			if (ch == 1 && musl_optarg[0] == '@') {
 				atFileName = &musl_optarg[1];
 				break;
@@ -112,7 +115,7 @@ void cli_ParseArgs(
 
 			// It would be nice to compute the char pointers on the fly, but reallocs don't allow
 			// that; so we must compute the offsets after the pool is fixed
-			std::vector<size_t> offsets = readAtFile(&musl_optarg[1], argPool, fatal);
+			std::vector<size_t> offsets = readAtFile(&musl_optarg[1], argPool, usage);
 			stackEntry.argv.reserve(offsets.size() + 2); // Avoid a bunch of reallocs
 			for (size_t ofs : offsets) {
 				stackEntry.argv.push_back(&argPool.data()[ofs]);

src/extern/getopt.cpp

@@ -11,27 +11,24 @@
 #include <string.h>
 #include <wchar.h>
 
+#include "style.hpp"
+
 char *musl_optarg;
-int musl_optind = 1, musl_opterr = 1, musl_optopt;
+int musl_optind = 1, musl_optopt;
-int musl_optreset = 0;
+
 static int musl_optpos;
 
-static void musl_getopt_msg(char const *a, char const *b, char const *c, size_t l) {
+static void musl_getopt_msg(char const *msg, char const *param) {
-	FILE *f = stderr;
+	style_Set(stderr, STYLE_RED, true);
-
+	fputs("error: ", stderr);
-	if (fputs(a, f) >= 0 && fwrite(b, strlen(b), 1, f) && fwrite(c, 1, l, f) == l) {
+	style_Reset(stderr);
-		putc('\n', f);
+	fputs(msg, stderr);
-	}
+	fputs(param, stderr);
+	putc('\n', stderr);
 }
 
-static int getopt(int argc, char *argv[], char const *optstring) {
+static int musl_getopt(int argc, char *argv[], char const *optstring) {
-	int i;
+	if (!musl_optind) {
-	wchar_t c, d;
-	int k, l;
-	char *optchar;
-
-	if (!musl_optind || musl_optreset) {
-		musl_optreset = 0;
 		musl_optpos = 0;
 		musl_optind = 1;
 	}
@@ -40,7 +37,9 @@ static int getopt(int argc, char *argv[], char const *optstring) {
 		return -1;
 	}
 
-	if (argv[musl_optind][0] != '-') {
+	char *argi = argv[musl_optind];
+
+	if (argi[0] != '-') {
 		if (optstring[0] == '-') {
 			musl_optarg = argv[musl_optind++];
 			return 1;
@@ -48,26 +47,28 @@ static int getopt(int argc, char *argv[], char const *optstring) {
 		return -1;
 	}
 
-	if (!argv[musl_optind][1]) {
+	if (!argi[1]) {
 		return -1;
 	}
 
-	if (argv[musl_optind][1] == '-' && !argv[musl_optind][2]) {
+	if (argi[1] == '-' && !argi[2]) {
-		return musl_optind++, -1;
+		++musl_optind;
+		return -1;
 	}
 
 	if (!musl_optpos) {
 		++musl_optpos;
 	}
-	k = mbtowc(&c, argv[musl_optind] + musl_optpos, MB_LEN_MAX);
+	wchar_t c;
+	int k = mbtowc(&c, argi + musl_optpos, MB_LEN_MAX);
 	if (k < 0) {
 		k = 1;
 		c = 0xFFFD; // replacement char
 	}
-	optchar = argv[musl_optind] + musl_optpos;
+	char *optchar = argi + musl_optpos;
 	musl_optpos += k;
 
-	if (!argv[musl_optind][musl_optpos]) {
+	if (!argi[musl_optpos]) {
 		++musl_optind;
 		musl_optpos = 0;
 	}
@@ -76,8 +77,9 @@ static int getopt(int argc, char *argv[], char const *optstring) {
 		++optstring;
 	}
 
-	i = 0;
+	int i = 0;
-	d = 0;
+	wchar_t d = 0;
+	int l;
 	do {
 		l = mbtowc(&d, optstring + i, MB_LEN_MAX);
 		if (l > 0) {
@@ -89,8 +91,8 @@ static int getopt(int argc, char *argv[], char const *optstring) {
 
 	if (d != c || c == ':') {
 		musl_optopt = c;
-		if (optstring[0] != ':' && musl_opterr) {
+		if (optstring[0] != ':') {
-			musl_getopt_msg(argv[0], ": unrecognized option: ", optchar, k);
+			musl_getopt_msg("unrecognized option: ", optchar);
 		}
 		return '?';
 	}
@@ -105,9 +107,7 @@ static int getopt(int argc, char *argv[], char const *optstring) {
 			if (optstring[0] == ':') {
 				return ':';
 			}
-			if (musl_opterr) {
+			musl_getopt_msg("option requires an argument: ", optchar);
-				musl_getopt_msg(argv[0], ": option requires an argument: ", optchar, k);
-			}
 			return '?';
 		}
 	}
@@ -116,25 +116,106 @@ static int getopt(int argc, char *argv[], char const *optstring) {
 
 static void permute(char **argv, int dest, int src) {
 	char *tmp = argv[src];
-	int i;
+	for (int i = src; i > dest; --i) {
-
-	for (i = src; i > dest; --i) {
 		argv[i] = argv[i - 1];
 	}
 	argv[dest] = tmp;
 }
 
-static int musl_getopt_long_core(
+static int
-    int argc, char **argv, char const *optstring, option const *longopts, int *idx, int longonly
+    musl_getopt_long_core(int argc, char **argv, char const *optstring, option const *longopts) {
-);
+	musl_optarg = 0;
+	if (char *argi = argv[musl_optind];
+	    !longopts || argi[0] != '-'
+	    || ((!argi[1] || argi[1] == '-') && (argi[1] != '-' || !argi[2]))) {
+		return musl_getopt(argc, argv, optstring);
+	}
 
-static int musl_getopt_long(
+	bool colon = optstring[optstring[0] == '+' || optstring[0] == '-'] == ':';
-    int argc, char **argv, char const *optstring, option const *longopts, int *idx, int longonly
+	int i = 0, cnt = 0, match = 0;
-) {
+	char *arg = 0, *opt, *start = argv[musl_optind] + 1;
-	int ret, skipped, resumed;
 
-	if (!musl_optind || musl_optreset) {
+	for (; longopts[i].name; ++i) {
-		musl_optreset = 0;
+		char const *name = longopts[i].name;
+		opt = start;
+		if (*opt == '-') {
+			++opt;
+		}
+		while (*opt && *opt != '=' && *opt == *name) {
+			++name;
+			++opt;
+		}
+		if (*opt && *opt != '=') {
+			continue;
+		}
+		arg = opt;
+		match = i;
+		if (!*name) {
+			cnt = 1;
+			break;
+		}
+		++cnt;
+	}
+	if (cnt == 1 && arg - start == mblen(start, MB_LEN_MAX)) {
+		int l = arg - start;
+		for (i = 0; optstring[i]; ++i) {
+			int j = 0;
+			while (j < l && start[j] == optstring[i + j]) {
+				++j;
+			}
+			if (j == l) {
+				++cnt;
+				break;
+			}
+		}
+	}
+	if (cnt == 1) {
+		i = match;
+		opt = arg;
+		++musl_optind;
+		if (*opt == '=') {
+			if (!longopts[i].has_arg) {
+				musl_optopt = longopts[i].val;
+				if (colon) {
+					return '?';
+				}
+				musl_getopt_msg("option does not take an argument: ", longopts[i].name);
+				return '?';
+			}
+			musl_optarg = opt + 1;
+		} else if (longopts[i].has_arg == required_argument) {
+			musl_optarg = argv[musl_optind];
+			if (!musl_optarg) {
+				musl_optopt = longopts[i].val;
+				if (colon) {
+					return ':';
+				}
+				musl_getopt_msg("option requires an argument: ", longopts[i].name);
+				return '?';
+			}
+			++musl_optind;
+		}
+		if (longopts[i].flag) {
+			*longopts[i].flag = longopts[i].val;
+			return 0;
+		}
+		return longopts[i].val;
+	}
+	if (argv[musl_optind][1] == '-') {
+		musl_optopt = 0;
+		if (!colon) {
+			musl_getopt_msg(
+			    cnt ? "option is ambiguous: " : "unrecognized option: ", argv[musl_optind] + 2
+			);
+		}
+		++musl_optind;
+		return '?';
+	}
+	return musl_getopt(argc, argv, optstring);
+}
+
+int musl_getopt_long_only(int argc, char **argv, char const *optstring, option const *longopts) {
+	if (!musl_optind) {
 		musl_optpos = 0;
 		musl_optind = 1;
 	}
@@ -143,10 +224,10 @@ static int musl_getopt_long(
 		return -1;
 	}
 
-	skipped = musl_optind;
+	int skipped = musl_optind;
 	if (optstring[0] != '+' && optstring[0] != '-') {
-		int i;
+		int i = musl_optind;
-		for (i = musl_optind;; ++i) {
+		for (;; ++i) {
 			if (i >= argc || !argv[i]) {
 				return -1;
 			}
@@ -156,134 +237,14 @@ static int musl_getopt_long(
 		}
 		musl_optind = i;
 	}
-	resumed = musl_optind;
+	int resumed = musl_optind;
-	ret = musl_getopt_long_core(argc, argv, optstring, longopts, idx, longonly);
+	int ret = musl_getopt_long_core(argc, argv, optstring, longopts);
 	if (resumed > skipped) {
-		int i, cnt = musl_optind - resumed;
+		int cnt = musl_optind - resumed;
-
+		for (int i = 0; i < cnt; ++i) {
-		for (i = 0; i < cnt; ++i) {
 			permute(argv, skipped, musl_optind - 1);
 		}
 		musl_optind = skipped + cnt;
 	}
 	return ret;
 }
-
-static int musl_getopt_long_core(
-    int argc, char **argv, char const *optstring, option const *longopts, int *idx, int longonly
-) {
-	musl_optarg = 0;
-	if (longopts && argv[musl_optind][0] == '-'
-	    && ((longonly && argv[musl_optind][1] && argv[musl_optind][1] != '-')
-	        || (argv[musl_optind][1] == '-' && argv[musl_optind][2]))) {
-		int colon = optstring[optstring[0] == '+' || optstring[0] == '-'] == ':';
-		int i, cnt, match = 0;
-		char *arg = 0, *opt, *start = argv[musl_optind] + 1;
-
-		for (cnt = i = 0; longopts[i].name; ++i) {
-			char const *name = longopts[i].name;
-
-			opt = start;
-			if (*opt == '-') {
-				++opt;
-			}
-			while (*opt && *opt != '=' && *opt == *name) {
-				++name;
-				++opt;
-			}
-			if (*opt && *opt != '=') {
-				continue;
-			}
-			arg = opt;
-			match = i;
-			if (!*name) {
-				cnt = 1;
-				break;
-			}
-			++cnt;
-		}
-		if (cnt == 1 && longonly && arg - start == mblen(start, MB_LEN_MAX)) {
-			int l = arg - start;
-
-			for (i = 0; optstring[i]; ++i) {
-				int j = 0;
-
-				while (j < l && start[j] == optstring[i + j]) {
-					++j;
-				}
-				if (j == l) {
-					++cnt;
-					break;
-				}
-			}
-		}
-		if (cnt == 1) {
-			i = match;
-			opt = arg;
-			++musl_optind;
-			if (*opt == '=') {
-				if (!longopts[i].has_arg) {
-					musl_optopt = longopts[i].val;
-					if (colon || !musl_opterr) {
-						return '?';
-					}
-					musl_getopt_msg(
-					    argv[0],
-					    ": option does not take an argument: ",
-					    longopts[i].name,
-					    strlen(longopts[i].name)
-					);
-					return '?';
-				}
-				musl_optarg = opt + 1;
-			} else if (longopts[i].has_arg == required_argument) {
-				musl_optarg = argv[musl_optind];
-				if (!musl_optarg) {
-					musl_optopt = longopts[i].val;
-					if (colon) {
-						return ':';
-					}
-					if (!musl_opterr) {
-						return '?';
-					}
-					musl_getopt_msg(
-					    argv[0],
-					    ": option requires an argument: ",
-					    longopts[i].name,
-					    strlen(longopts[i].name)
-					);
-					return '?';
-				}
-				++musl_optind;
-			}
-			if (idx) {
-				*idx = i;
-			}
-			if (longopts[i].flag) {
-				*longopts[i].flag = longopts[i].val;
-				return 0;
-			}
-			return longopts[i].val;
-		}
-		if (argv[musl_optind][1] == '-') {
-			musl_optopt = 0;
-			if (!colon && musl_opterr) {
-				musl_getopt_msg(
-				    argv[0],
-				    cnt ? ": option is ambiguous: " : ": unrecognized option: ",
-				    argv[musl_optind] + 2,
-				    strlen(argv[musl_optind] + 2)
-				);
-			}
-			++musl_optind;
-			return '?';
-		}
-	}
-	return getopt(argc, argv, optstring);
-}
-
-int musl_getopt_long_only(
-    int argc, char **argv, char const *optstring, option const *longopts, int *idx
-) {
-	return musl_getopt_long(argc, argv, optstring, longopts, idx, 1);
-}

src/fix/main.cpp

@@ -346,7 +346,7 @@ static void initLogo() {
 }
 
 int main(int argc, char *argv[]) {
-	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, fatal);
+	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, usage);
 
 	if ((options.cartridgeType & 0xFF00) == TPP1 && !options.japanese) {
 		warning(

src/gfx/main.cpp

@@ -639,7 +639,7 @@ static void replaceExtension(std::string &path, char const *extension) {
 }
 
 int main(int argc, char *argv[]) {
-	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, fatal);
+	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, usage);
 
 	if (options.nbColorsPerPal == 0) {
 		options.nbColorsPerPal = 1u << options.bitDepth;

src/link/main.cpp

@@ -415,7 +415,7 @@ static void verboseOutputConfig() {
 // LCOV_EXCL_STOP
 
 int main(int argc, char *argv[]) {
-	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, fatal);
+	cli_ParseArgs(argc, argv, optstring, longopts, parseArg, usage);
 
 	verboseOutputConfig();