Commit 216f312

nsxiv216f312

add support for long-opts (#332)

Uses [optparse] to add support for long-opts. optparse is posix
compliant with getopt(3) and thus would be backwards compatible.
It does not have any dependency (not even the c standard library!) and
is C89 compatible and thus fits our current code-style.

[optparse]: https://github.com/skeeto/optparse

Note that we're using a couple `pragma`-s to silence some harmless
warnings. This should be portable because these pragma-s don't change the
behavior of the program. Furthermore, C standard mandates that unknown
pragma's should be ignored by the compiler and thus would not result in
build failure on compilers which do not recognize them.

Author: NRK
Date: 2022-08-16 10:43 +0200
Parent: d9f20a4
Commit: 216f312578be5c959527c03ccc70d27eebcc76aa

+500 −53

4 files changed

Browse files Patch

−Context 3+

M Makefile +1 −1
M etc/nsxiv.1 +28 −28
M options.c +68 −24
A optparse.h +403 −0

M Makefile View

M etc/nsxiv.1 View

M options.c View

A optparse.h View

		@@ -41,7 +41,7 @@ nsxiv: $(objs)
41	41		$(CC) $(CFLAGS) $(nsxiv_cppflags) -c -o $@ $<
42	42
43	43		$(objs): Makefile config.mk nsxiv.h config.h commands.h
44		−	options.o: version.h
	44	+	options.o: version.h optparse.h
45	45		window.o: icon/data.h utf8.h
46	46
47	47		config.h:

		@@ -34,84 +34,84 @@ Please note, that the fullscreen mode requires an EWMH/NetWM-compliant window
34	34		manager.
35	35		.SH OPTIONS
36	36		.TP
37		−	.BI "\-A " FRAMERATE
	37	+	.BI "\-A, \-\-framerate " FRAMERATE
38	38		Play animations with a constant frame rate set to
39	39		.IR FRAMERATE .
40	40		.TP
41		−	.B \-a
	41	+	.B "\-a, \-\-animate"
42	42		Play animations of multi-frame images.
43	43		.TP
44		−	.B \-b
	44	+	.B "\-b, \-\-no\-bar"
45	45		Do not show statusbar at the bottom of the window.
46	46		.TP
47		−	.B \-c
	47	+	.B "\-c, \-\-clean\-cache"
48	48		Remove all orphaned cache files from the thumbnail cache directory and exit.
49	49		.TP
50		−	.BI "\-e " WID
	50	+	.BI "\-e, \-\-embed " WID
51	51		Embed nsxiv's window into window whose ID is
52	52		.IR WID .
53	53		.TP
54		−	.B \-f
	54	+	.B "\-f, \-\-fullscreen"
55	55		Start in fullscreen mode.
56	56		.TP
57		−	.BI "\-G " GAMMA
	57	+	.BI "\-G, \-\-gamma " GAMMA
58	58		Set image gamma to GAMMA (\-32..32).
59	59		.TP
60		−	.BI "\-g " GEOMETRY
	60	+	.BI "\-g, \-\-geometry " GEOMETRY
61	61		Set window position and size. See section GEOMETRY SPECIFICATIONS of X(7) for
62	62		more information on GEOMETRY argument.
63	63		.TP
64		−	.BI "\-N " NAME
65		−	Set the resource name of nsxiv's X window to NAME.
66		−	.TP
67		−	.BI "\-n " NUM
68		−	Start at picture number NUM.
69		−	.TP
70		−	.B \-h
	64	+	.B "\-h, \-\-help"
71	65		Print brief usage information to standard output and exit.
72	66		.TP
73		−	.B \-i
	67	+	.B "\-i, \-\-stdin"
74	68		Read names of files to open from standard input. Also done if FILE is `-'.
75	69		.TP
76		−	.B \-o
	70	+	.BI "\-N, \-\-class " NAME
	71	+	Set the resource name (WM_CLASS) of nsxiv's X window to NAME.
	72	+	.TP
	73	+	.BI "\-n, \-\-start\-at " NUM
	74	+	Start at picture number NUM.
	75	+	.TP
	76	+	.B "\-o, \-\-stdout"
77	77		Write list of all marked files to standard output when quitting. In combination
78	78		with
79		−	.B \-i
	79	+	.B "\-i, \-\-stdin"
80	80		nsxiv can be used as a visual filter/pipe.
81	81		.TP
82		−	.B \-p
	82	+	.B "\-p, \-\-private"
83	83		Enable private mode, in which nsxiv does not write any cache or temporary files.
84	84		.TP
85		−	.B \-q
	85	+	.B "\-q, \-\-quiet"
86	86		Be quiet, and disable warnings to standard error stream.
87	87		.TP
88		−	.B \-r
	88	+	.B "\-r, \-\-recursive"
89	89		Search the given directories recursively for images to view.
90	90		.TP
91		−	.BI "\-S " DELAY
	91	+	.BI "\-S, \-\-ss\-delay " DELAY
92	92		Start in slideshow mode. Set the delay between images to
93	93		.I DELAY
94	94		seconds.
95	95		.I DELAY
96	96		may be a floating-point number.
97	97		.TP
98		−	.BI "\-s " MODE
	98	+	.BI "\-s, \-\-scale\-mode " MODE
99	99		Set scale mode according to MODE character. Supported modes are: [d]own,
100	100		[f]it, [F]ill, [w]idth, [h]eight.
101	101		.TP
102		−	.B \-t
	102	+	.B "\-t, \-\-thumbnail"
103	103		Start in thumbnail mode.
104	104		.TP
105		−	.B \-v
	105	+	.B "\-v, \-\-version"
106	106		Print version information to standard output and exit.
107	107		.TP
108		−	.B \-Z
	108	+	.B "\-Z, \-\-zoom\-100"
109	109		The same as `\-z 100'.
110	110		.TP
111		−	.BI "\-z " ZOOM
	111	+	.BI "\-z, \-\-zoom " ZOOM
112	112		Set zoom level to ZOOM percent.
113	113		.TP
114		−	.B \-0
	114	+	.B "\-0, \-\-null"
115	115		Use NULL-separator. With this option, output of \-o and file-list sent to the
116	116		key-handler and the input of \-i will be separated by a NULL character.
117	117		.SH KEYBOARD COMMANDS

		@@ -20,11 +20,20 @@
20	20		#include "nsxiv.h"
21	21		#include "version.h"
22	22
	23	+	#include <assert.h>
23	24		#include <stdio.h>
24	25		#include <stdlib.h>
25	26		#include <string.h>
26	27		#include <unistd.h>
27	28
	29	+	#define OPTPARSE_IMPLEMENTATION
	30	+	#define OPTPARSE_API static
	31	+	#pragma GCC diagnostic push /* also works on clang */
	32	+	#pragma GCC diagnostic ignored "-Wshadow"
	33	+	#pragma GCC diagnostic ignored "-Wunused-function"
	34	+	#include "optparse.h"
	35	+	#pragma GCC diagnostic pop
	36	+
28	37		const opt_t *options;
29	38
30	39		void print_usage(void)
		@@ -54,12 +63,41 @@ static void print_version(void)
54	63
55	64		void parse_options(int argc, char **argv)
56	65		{
	66	+	static const struct optparse_long longopts[] = {
	67	+	{ "framerate", 'A', OPTPARSE_REQUIRED },
	68	+	{ "animate", 'a', OPTPARSE_NONE },
	69	+	{ "no-bar", 'b', OPTPARSE_NONE },
	70	+	{ "clean-cache", 'c', OPTPARSE_NONE },
	71	+	{ "embed", 'e', OPTPARSE_REQUIRED },
	72	+	{ "fullscreen", 'f', OPTPARSE_NONE },
	73	+	{ "gamma", 'G', OPTPARSE_REQUIRED },
	74	+	{ "geometry", 'g', OPTPARSE_REQUIRED },
	75	+	{ "help", 'h', OPTPARSE_NONE },
	76	+	{ "stdin", 'i', OPTPARSE_NONE },
	77	+	{ "class", 'N', OPTPARSE_REQUIRED },
	78	+	{ "start-at", 'n', OPTPARSE_REQUIRED },
	79	+	{ "stdout", 'o', OPTPARSE_NONE },
	80	+	{ "private", 'p', OPTPARSE_NONE },
	81	+	{ "quiet", 'q', OPTPARSE_NONE },
	82	+	{ "recursive", 'r', OPTPARSE_NONE },
	83	+	{ "ss-delay", 'S', OPTPARSE_REQUIRED },
	84	+	{ "scale-mode", 's', OPTPARSE_REQUIRED },
	85	+	{ NULL, 'T', OPTPARSE_REQUIRED },
	86	+	{ "thumbnail", 't', OPTPARSE_NONE },
	87	+	{ "version", 'v', OPTPARSE_NONE },
	88	+	{ "zoom-100", 'Z', OPTPARSE_NONE },
	89	+	{ "zoom", 'z', OPTPARSE_REQUIRED },
	90	+	{ "null", '0', OPTPARSE_NONE },
	91	+	{ 0 }, /* end */
	92	+	};
	93	+
57	94		int n, opt;
58	95		char end, s;
59		−	const char *scalemodes = "dfFwh";
	96	+	struct optparse op;
	97	+	const char scalemodes[] = "dfFwh"; /* must be sorted according to scalemode_t */
60	98		static opt_t _options;
61		−	options = &_options;
62	99
	100	+	options = &_options;
63	101		progname = strrchr(argv[0], '/');
64	102		progname = progname ? progname + 1 : argv[0];
65	103
		@@ -87,15 +125,21 @@ void parse_options(int argc, char **argv)
87	125		_options.clean_cache = false;
88	126		_options.private_mode = false;
89	127
90		−	while ((opt = getopt(argc, argv, "A:abce:fG:g:hin:N:opqrS:s:T:tvZz:0")) != -1) {
	128	+	optparse_init(&op, argv);
	129	+	while ((opt = optparse_long(&op, longopts, NULL)) != -1) {
	130	+	for (n = 0; n < (int)ARRLEN(longopts); ++n) { /* clang-tidy finds some non-sensical branch and thinks optarg == NULL is possible */
	131	+	if (opt == longopts[n].shortname && longopts[n].argtype == OPTPARSE_REQUIRED)
	132	+	assert(op.optarg != NULL);
	133	+	}
91	134		switch (opt) {
92	135		case '?':
	136	+	fprintf(stderr, "%s\n", op.errmsg);
93	137		print_usage();
94	138		exit(EXIT_FAILURE);
95	139		case 'A':
96		−	n = strtol(optarg, &end, 0);
	140	+	n = strtol(op.optarg, &end, 0);
97	141		if (*end != '\0' \|\| n <= 0)
98		−	error(EXIT_FAILURE, 0, "Invalid argument for option -A: %s", optarg);
	142	+	error(EXIT_FAILURE, 0, "Invalid argument for option -A: %s", op.optarg);
99	143		_options.framerate = n;
100	144		/* fall through */
101	145		case 'a':
		@@ -108,22 +152,22 @@ void parse_options(int argc, char **argv)
108	152		_options.clean_cache = true;
109	153		break;
110	154		case 'e':
111		−	n = strtol(optarg, &end, 0);
	155	+	n = strtol(op.optarg, &end, 0);
112	156		if (*end != '\0')
113		−	error(EXIT_FAILURE, 0, "Invalid argument for option -e: %s", optarg);
	157	+	error(EXIT_FAILURE, 0, "Invalid argument for option -e: %s", op.optarg);
114	158		_options.embed = n;
115	159		break;
116	160		case 'f':
117	161		_options.fullscreen = true;
118	162		break;
119	163		case 'G':
120		−	n = strtol(optarg, &end, 0);
	164	+	n = strtol(op.optarg, &end, 0);
121	165		if (*end != '\0')
122		−	error(EXIT_FAILURE, 0, "Invalid argument for option -G: %s", optarg);
	166	+	error(EXIT_FAILURE, 0, "Invalid argument for option -G: %s", op.optarg);
123	167		_options.gamma = n;
124	168		break;
125	169		case 'g':
126		−	_options.geometry = optarg;
	170	+	_options.geometry = op.optarg;
127	171		break;
128	172		case 'h':
129	173		print_usage();
		@@ -132,13 +176,13 @@ void parse_options(int argc, char **argv)
132	176		_options.from_stdin = true;
133	177		break;
134	178		case 'n':
135		−	n = strtol(optarg, &end, 0);
	179	+	n = strtol(op.optarg, &end, 0);
136	180		if (*end != '\0' \|\| n <= 0)
137		−	error(EXIT_FAILURE, 0, "Invalid argument for option -n: %s", optarg);
	181	+	error(EXIT_FAILURE, 0, "Invalid argument for option -n: %s", op.optarg);
138	182		_options.startnum = n - 1;
139	183		break;
140	184		case 'N':
141		−	_options.res_name = optarg;
	185	+	_options.res_name = op.optarg;
142	186		break;
143	187		case 'o':
144	188		_options.to_stdout = true;
		@@ -153,15 +197,15 @@ void parse_options(int argc, char **argv)
153	197		_options.recursive = true;
154	198		break;
155	199		case 'S':
156		−	n = strtof(optarg, &end) * 10;
	200	+	n = strtof(op.optarg, &end) * 10;
157	201		if (*end != '\0' \|\| n <= 0)
158		−	error(EXIT_FAILURE, 0, "Invalid argument for option -S: %s", optarg);
	202	+	error(EXIT_FAILURE, 0, "Invalid argument for option -S: %s", op.optarg);
159	203		_options.slideshow = n;
160	204		break;
161	205		case 's':
162		−	s = strchr(scalemodes, optarg[0]);
163		−	if (s == NULL \|\| *s == '\0' \|\| strlen(optarg) != 1)
164		−	error(EXIT_FAILURE, 0, "Invalid argument for option -s: %s", optarg);
	206	+	s = strchr(scalemodes, op.optarg[0]);
	207	+	if (s == NULL \|\| *s == '\0' \|\| strlen(op.optarg) != 1)
	208	+	error(EXIT_FAILURE, 0, "Invalid argument for option -s: %s", op.optarg);
165	209		_options.scalemode = s - scalemodes;
166	210		break;
167	211		case 'T':
		@@ -175,14 +219,14 @@ void parse_options(int argc, char **argv)
175	219		exit(EXIT_SUCCESS);
176	220		case 'Z':
177	221		_options.scalemode = SCALE_ZOOM;
178		−	_options.zoom = 1.0;
	222	+	_options.zoom = 1.0f;
179	223		break;
180	224		case 'z':
181		−	n = strtol(optarg, &end, 0);
	225	+	n = strtol(op.optarg, &end, 0);
182	226		if (*end != '\0' \|\| n <= 0)
183		−	error(EXIT_FAILURE, 0, "Invalid argument for option -z: %s", optarg);
	227	+	error(EXIT_FAILURE, 0, "Invalid argument for option -z: %s", op.optarg);
184	228		_options.scalemode = SCALE_ZOOM;
185		−	_options.zoom = (float) n / 100.0;
	229	+	_options.zoom = (float) n / 100.0f;
186	230		break;
187	231		case '0':
188	232		_options.using_null = true;
		@@ -190,8 +234,8 @@ void parse_options(int argc, char **argv)
190	234		}
191	235		}
192	236
193		−	_options.filenames = argv + optind;
194		−	_options.filecnt = argc - optind;
	237	+	_options.filenames = argv + op.optind;
	238	+	_options.filecnt = argc - op.optind;
195	239
196	240		if (_options.filecnt == 1 && STREQ(_options.filenames[0], "-")) {
197	241		_options.filenames++;

	@@ -0,0 +1,403 @@
1	+	/* Optparse --- portable, reentrant, embeddable, getopt-like option parser
2	+	*
3	+	* This is free and unencumbered software released into the public domain.
4	+	*
5	+	* To get the implementation, define OPTPARSE_IMPLEMENTATION.
6	+	* Optionally define OPTPARSE_API to control the API's visibility
7	+	* and/or linkage (static, __attribute__, __declspec).
8	+	*
9	+	* The POSIX getopt() option parser has three fatal flaws. These flaws
10	+	* are solved by Optparse.
11	+	*
12	+	* 1) Parser state is stored entirely in global variables, some of
13	+	* which are static and inaccessible. This means only one thread can
14	+	* use getopt(). It also means it's not possible to recursively parse
15	+	* nested sub-arguments while in the middle of argument parsing.
16	+	* Optparse fixes this by storing all state on a local struct.
17	+	*
18	+	* 2) The POSIX standard provides no way to properly reset the parser.
19	+	* This means for portable code that getopt() is only good for one
20	+	* run, over one argv with one option string. It also means subcommand
21	+	* options cannot be processed with getopt(). Most implementations
22	+	* provide a method to reset the parser, but it's not portable.
23	+	* Optparse provides an optparse_arg() function for stepping over
24	+	* subcommands and continuing parsing of options with another option
25	+	* string. The Optparse struct itself can be passed around to
26	+	* subcommand handlers for additional subcommand option parsing. A
27	+	* full reset can be achieved by with an additional optparse_init().
28	+	*
29	+	* 3) Error messages are printed to stderr. This can be disabled with
30	+	* opterr, but the messages themselves are still inaccessible.
31	+	* Optparse solves this by writing an error message in its errmsg
32	+	* field. The downside to Optparse is that this error message will
33	+	* always be in English rather than the current locale.
34	+	*
35	+	* Optparse should be familiar with anyone accustomed to getopt(), and
36	+	* it could be a nearly drop-in replacement. The option string is the
37	+	* same and the fields have the same names as the getopt() global
38	+	* variables (optarg, optind, optopt).
39	+	*
40	+	* Optparse also supports GNU-style long options with optparse_long().
41	+	* The interface is slightly different and simpler than getopt_long().
42	+	*
43	+	* By default, argv is permuted as it is parsed, moving non-option
44	+	* arguments to the end. This can be disabled by setting the `permute`
45	+	* field to 0 after initialization.
46	+	*/
47	+	#ifndef OPTPARSE_H
48	+	#define OPTPARSE_H
49	+
50	+	#ifndef OPTPARSE_API
51	+	# define OPTPARSE_API
52	+	#endif
53	+
54	+	struct optparse {
55	+	char **argv;
56	+	int permute;
57	+	int optind;
58	+	int optopt;
59	+	char *optarg;
60	+	char errmsg[64];
61	+	int subopt;
62	+	};
63	+
64	+	enum optparse_argtype {
65	+	OPTPARSE_NONE,
66	+	OPTPARSE_REQUIRED,
67	+	OPTPARSE_OPTIONAL
68	+	};
69	+
70	+	struct optparse_long {
71	+	const char *longname;
72	+	int shortname;
73	+	enum optparse_argtype argtype;
74	+	};
75	+
76	+	/**
77	+	* Initializes the parser state.
78	+	*/
79	+	OPTPARSE_API
80	+	void optparse_init(struct optparse options, char *argv);
81	+
82	+	/**
83	+	* Read the next option in the argv array.
84	+	* @param optstring a getopt()-formatted option string.
85	+	* @return the next option character, -1 for done, or '?' for error
86	+	*
87	+	* Just like getopt(), a character followed by no colons means no
88	+	* argument. One colon means the option has a required argument. Two
89	+	* colons means the option takes an optional argument.
90	+	*/
91	+	OPTPARSE_API
92	+	int optparse(struct optparse options, const char optstring);
93	+
94	+	/**
95	+	* Handles GNU-style long options in addition to getopt() options.
96	+	* This works a lot like GNU's getopt_long(). The last option in
97	+	* longopts must be all zeros, marking the end of the array. The
98	+	* longindex argument may be NULL.
99	+	*/
100	+	OPTPARSE_API
101	+	int optparse_long(struct optparse *options,
102	+	const struct optparse_long *longopts,
103	+	int *longindex);
104	+
105	+	/**
106	+	* Used for stepping over non-option arguments.
107	+	* @return the next non-option argument, or NULL for no more arguments
108	+	*
109	+	* Argument parsing can continue with optparse() after using this
110	+	* function. That would be used to parse the options for the
111	+	* subcommand returned by optparse_arg(). This function allows you to
112	+	* ignore the value of optind.
113	+	*/
114	+	OPTPARSE_API
115	+	char optparse_arg(struct optparse options);
116	+
117	+	/* Implementation */
118	+	#ifdef OPTPARSE_IMPLEMENTATION
119	+
120	+	#define OPTPARSE_MSG_INVALID "invalid option"
121	+	#define OPTPARSE_MSG_MISSING "option requires an argument"
122	+	#define OPTPARSE_MSG_TOOMANY "option takes no arguments"
123	+
124	+	static int
125	+	optparse_error(struct optparse options, const char msg, const char *data)
126	+	{
127	+	unsigned p = 0;
128	+	const char *sep = " -- '";
129	+	while (*msg)
130	+	options->errmsg[p++] = *msg++;
131	+	while (*sep)
132	+	options->errmsg[p++] = *sep++;
133	+	while (p < sizeof(options->errmsg) - 2 && *data)
134	+	options->errmsg[p++] = *data++;
135	+	options->errmsg[p++] = '\'';
136	+	options->errmsg[p++] = '\0';
137	+	return '?';
138	+	}
139	+
140	+	OPTPARSE_API
141	+	void
142	+	optparse_init(struct optparse options, char *argv)
143	+	{
144	+	options->argv = argv;
145	+	options->permute = 1;
146	+	options->optind = argv[0] != 0;
147	+	options->subopt = 0;
148	+	options->optarg = 0;
149	+	options->errmsg[0] = '\0';
150	+	}
151	+
152	+	static int
153	+	optparse_is_dashdash(const char *arg)
154	+	{
155	+	return arg != 0 && arg[0] == '-' && arg[1] == '-' && arg[2] == '\0';
156	+	}
157	+
158	+	static int
159	+	optparse_is_shortopt(const char *arg)
160	+	{
161	+	return arg != 0 && arg[0] == '-' && arg[1] != '-' && arg[1] != '\0';
162	+	}
163	+
164	+	static int
165	+	optparse_is_longopt(const char *arg)
166	+	{
167	+	return arg != 0 && arg[0] == '-' && arg[1] == '-' && arg[2] != '\0';
168	+	}
169	+
170	+	static void
171	+	optparse_permute(struct optparse *options, int index)
172	+	{
173	+	char *nonoption = options->argv[index];
174	+	int i;
175	+	for (i = index; i < options->optind - 1; i++)
176	+	options->argv[i] = options->argv[i + 1];
177	+	options->argv[options->optind - 1] = nonoption;
178	+	}
179	+
180	+	static int
181	+	optparse_argtype(const char *optstring, char c)
182	+	{
183	+	int count = OPTPARSE_NONE;
184	+	if (c == ':')
185	+	return -1;
186	+	for (; optstring && c != optstring; optstring++);
187	+	if (!*optstring)
188	+	return -1;
189	+	if (optstring[1] == ':')
190	+	count += optstring[2] == ':' ? 2 : 1;
191	+	return count;
192	+	}
193	+
194	+	OPTPARSE_API
195	+	int
196	+	optparse(struct optparse options, const char optstring)
197	+	{
198	+	int type;
199	+	char *next;
200	+	char *option = options->argv[options->optind];
201	+	options->errmsg[0] = '\0';
202	+	options->optopt = 0;
203	+	options->optarg = 0;
204	+	if (option == 0) {
205	+	return -1;
206	+	} else if (optparse_is_dashdash(option)) {
207	+	options->optind++; /* consume "--" */
208	+	return -1;
209	+	} else if (!optparse_is_shortopt(option)) {
210	+	if (options->permute) {
211	+	int index = options->optind++;
212	+	int r = optparse(options, optstring);
213	+	optparse_permute(options, index);
214	+	options->optind--;
215	+	return r;
216	+	} else {
217	+	return -1;
218	+	}
219	+	}
220	+	option += options->subopt + 1;
221	+	options->optopt = option[0];
222	+	type = optparse_argtype(optstring, option[0]);
223	+	next = options->argv[options->optind + 1];
224	+	switch (type) {
225	+	case -1: {
226	+	char str[2] = {0, 0};
227	+	str[0] = option[0];
228	+	options->optind++;
229	+	return optparse_error(options, OPTPARSE_MSG_INVALID, str);
230	+	}
231	+	case OPTPARSE_NONE:
232	+	if (option[1]) {
233	+	options->subopt++;
234	+	} else {
235	+	options->subopt = 0;
236	+	options->optind++;
237	+	}
238	+	return option[0];
239	+	case OPTPARSE_REQUIRED:
240	+	options->subopt = 0;
241	+	options->optind++;
242	+	if (option[1]) {
243	+	options->optarg = option + 1;
244	+	} else if (next != 0) {
245	+	options->optarg = next;
246	+	options->optind++;
247	+	} else {
248	+	char str[2] = {0, 0};
249	+	str[0] = option[0];
250	+	options->optarg = 0;
251	+	return optparse_error(options, OPTPARSE_MSG_MISSING, str);
252	+	}
253	+	return option[0];
254	+	case OPTPARSE_OPTIONAL:
255	+	options->subopt = 0;
256	+	options->optind++;
257	+	if (option[1])
258	+	options->optarg = option + 1;
259	+	else
260	+	options->optarg = 0;
261	+	return option[0];
262	+	}
263	+	return 0;
264	+	}
265	+
266	+	OPTPARSE_API
267	+	char *
268	+	optparse_arg(struct optparse *options)
269	+	{
270	+	char *option = options->argv[options->optind];
271	+	options->subopt = 0;
272	+	if (option != 0)
273	+	options->optind++;
274	+	return option;
275	+	}
276	+
277	+	static int
278	+	optparse_longopts_end(const struct optparse_long *longopts, int i)
279	+	{
280	+	return !longopts[i].longname && !longopts[i].shortname;
281	+	}
282	+
283	+	static void
284	+	optparse_from_long(const struct optparse_long longopts, char optstring)
285	+	{
286	+	char *p = optstring;
287	+	int i;
288	+	for (i = 0; !optparse_longopts_end(longopts, i); i++) {
289	+	if (longopts[i].shortname && longopts[i].shortname < 127) {
290	+	int a;
291	+	*p++ = longopts[i].shortname;
292	+	for (a = 0; a < (int)longopts[i].argtype; a++)
293	+	*p++ = ':';
294	+	}
295	+	}
296	+	*p = '\0';
297	+	}
298	+
299	+	/* Unlike strcmp(), handles options containing "=". */
300	+	static int
301	+	optparse_longopts_match(const char longname, const char option)
302	+	{
303	+	const char a = option, n = longname;
304	+	if (longname == 0)
305	+	return 0;
306	+	for (; a && n && *a != '='; a++, n++)
307	+	if (a != n)
308	+	return 0;
309	+	return n == '\0' && (a == '\0' \|\| *a == '=');
310	+	}
311	+
312	+	/* Return the part after "=", or NULL. */
313	+	static char *
314	+	optparse_longopts_arg(char *option)
315	+	{
316	+	for (; option && option != '='; option++);
317	+	if (*option == '=')
318	+	return option + 1;
319	+	else
320	+	return 0;
321	+	}
322	+
323	+	static int
324	+	optparse_long_fallback(struct optparse *options,
325	+	const struct optparse_long *longopts,
326	+	int *longindex)
327	+	{
328	+	int result;
329	+	char optstring[96 * 3 + 1]; /* 96 ASCII printable characters */
330	+	optparse_from_long(longopts, optstring);
331	+	result = optparse(options, optstring);
332	+	if (longindex != 0) {
333	+	*longindex = -1;
334	+	if (result != -1) {
335	+	int i;
336	+	for (i = 0; !optparse_longopts_end(longopts, i); i++)
337	+	if (longopts[i].shortname == options->optopt)
338	+	*longindex = i;
339	+	}
340	+	}
341	+	return result;
342	+	}
343	+
344	+	OPTPARSE_API
345	+	int
346	+	optparse_long(struct optparse *options,
347	+	const struct optparse_long *longopts,
348	+	int *longindex)
349	+	{
350	+	int i;
351	+	char *option = options->argv[options->optind];
352	+	if (option == 0) {
353	+	return -1;
354	+	} else if (optparse_is_dashdash(option)) {
355	+	options->optind++; /* consume "--" */
356	+	return -1;
357	+	} else if (optparse_is_shortopt(option)) {
358	+	return optparse_long_fallback(options, longopts, longindex);
359	+	} else if (!optparse_is_longopt(option)) {
360	+	if (options->permute) {
361	+	int index = options->optind++;
362	+	int r = optparse_long(options, longopts, longindex);
363	+	optparse_permute(options, index);
364	+	options->optind--;
365	+	return r;
366	+	} else {
367	+	return -1;
368	+	}
369	+	}
370	+
371	+	/* Parse as long option. */
372	+	options->errmsg[0] = '\0';
373	+	options->optopt = 0;
374	+	options->optarg = 0;
375	+	option += 2; /* skip "--" */
376	+	options->optind++;
377	+	for (i = 0; !optparse_longopts_end(longopts, i); i++) {
378	+	const char *name = longopts[i].longname;
379	+	if (optparse_longopts_match(name, option)) {
380	+	char *arg;
381	+	if (longindex)
382	+	*longindex = i;
383	+	options->optopt = longopts[i].shortname;
384	+	arg = optparse_longopts_arg(option);
385	+	if (longopts[i].argtype == OPTPARSE_NONE && arg != 0) {
386	+	return optparse_error(options, OPTPARSE_MSG_TOOMANY, name);
387	+	} if (arg != 0) {
388	+	options->optarg = arg;
389	+	} else if (longopts[i].argtype == OPTPARSE_REQUIRED) {
390	+	options->optarg = options->argv[options->optind];
391	+	if (options->optarg == 0)
392	+	return optparse_error(options, OPTPARSE_MSG_MISSING, name);
393	+	else
394	+	options->optind++;
395	+	}
396	+	return options->optopt;
397	+	}
398	+	}
399	+	return optparse_error(options, OPTPARSE_MSG_INVALID, option);
400	+	}
401	+
402	+	#endif /* OPTPARSE_IMPLEMENTATION */
403	+	#endif /* OPTPARSE_H */

nsxiv/216f312

add support for long-opts (#332)

nsxiv216f312