usr/dash/options.c

/*-
 * Copyright (c) 1991, 1993
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1997-2005
 *	Herbert Xu <herbert@gondor.apana.org.au>.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Kenneth Almquist.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <signal.h>
#include <unistd.h>
#include <stdlib.h>

#include "shell.h"
#define DEFINE_OPTIONS
#include "options.h"
#undef DEFINE_OPTIONS
#include "nodes.h"	/* for other header files */
#include "eval.h"
#include "jobs.h"
#include "input.h"
#include "output.h"
#include "trap.h"
#include "var.h"
#include "memalloc.h"
#include "error.h"
#include "mystring.h"
#ifndef SMALL
#include "myhistedit.h"
#endif
#include "show.h"

char *arg0;			/* value of $0 */
struct shparam shellparam;	/* current positional parameters */
char **argptr;			/* argument list for builtin commands */
char *optionarg;		/* set by nextopt (like getopt) */
char *optptr;			/* used by nextopt */

char *minusc;			/* argument to -c option */

static const char *const optnames[NOPTS] = {
	"errexit",
	"noglob",
	"ignoreeof",
	"interactive",
	"monitor",
	"noexec",
	"stdin",
	"xtrace",
	"verbose",
	"vi",
	"emacs",
	"noclobber",
	"allexport",
	"notify",
	"nounset",
	"nolog",
	"debug",
};

const char optletters[NOPTS] = {
	'e',
	'f',
	'I',
	'i',
	'm',
	'n',
	's',
	'x',
	'v',
	'V',
	'E',
	'C',
	'a',
	'b',
	'u',
	0,
	0,
};

char optlist[NOPTS];


static int options(int);
STATIC void minus_o(char *, int);
STATIC void setoption(int, int);
STATIC int getopts(char *, char *, char **);


/*
 * Process the shell command line arguments.
 */

int
procargs(int argc, char **argv)
{
	int i;
	const char *xminusc;
	char **xargv;
	int login;

	xargv = argv;
	login = xargv[0] && xargv[0][0] == '-';
	arg0 = xargv[0];
	if (argc > 0)
		xargv++;
	for (i = 0; i < NOPTS; i++)
		optlist[i] = 2;
	argptr = xargv;
	login |= options(1);
	xargv = argptr;
	xminusc = minusc;
	if (*xargv == NULL) {
		if (xminusc)
			sh_error("-c requires an argument");
		sflag = 1;
	}
	if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
		iflag = 1;
	if (mflag == 2)
		mflag = iflag;
	for (i = 0; i < NOPTS; i++)
		if (optlist[i] == 2)
			optlist[i] = 0;
#if DEBUG == 2
	debug = 1;
#endif
	/* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
	if (xminusc) {
		minusc = *xargv++;
		if (*xargv)
			goto setarg0;
	} else if (!sflag) {
		setinputfile(*xargv, 0);
setarg0:
		arg0 = *xargv++;
		commandname = arg0;
	}

	shellparam.p = xargv;
	shellparam.optind = 1;
	shellparam.optoff = -1;
	/* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
	while (*xargv) {
		shellparam.nparam++;
		xargv++;
	}
	optschanged();

	return login;
}


void
optschanged(void)
{
#ifdef DEBUG
	opentrace();
#endif
	setinteractive(iflag);
#ifndef SMALL
	histedit();
#endif
	setjobctl(mflag);
}

/*
 * Process shell options.  The global variable argptr contains a pointer
 * to the argument list; we advance it past the options.
 */

STATIC int
options(int cmdline)
{
	char *p;
	int val;
	int c;
	int login = 0;

	if (cmdline)
		minusc = NULL;
	while ((p = *argptr) != NULL) {
		argptr++;
		if ((c = *p++) == '-') {
			val = 1;
                        if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
                                if (!cmdline) {
                                        /* "-" means turn off -x and -v */
                                        if (p[0] == '\0')
                                                xflag = vflag = 0;
                                        /* "--" means reset params */
                                        else if (*argptr == NULL)
						setparam(argptr);
                                }
				break;	  /* "-" or  "--" terminates options */
			}
		} else if (c == '+') {
			val = 0;
		} else {
			argptr--;
			break;
		}
		while ((c = *p++) != '\0') {
			if (c == 'c' && cmdline) {
				minusc = p;	/* command is after shell args*/
			} else if (c == 'l' && cmdline) {
				login = 1;
			} else if (c == 'o') {
				minus_o(*argptr, val);
				if (*argptr)
					argptr++;
			} else {
				setoption(c, val);
			}
		}
	}

	return login;
}

STATIC void
minus_o(char *name, int val)
{
	int i;

	if (name == NULL) {
		if (val) {
			out1str("Current option settings\n");
			for (i = 0; i < NOPTS; i++)
				out1fmt("%-16s%s\n", optnames[i],
					optlist[i] ? "on" : "off");
		} else {
			for (i = 0; i < NOPTS; i++)
				out1fmt("set %s %s\n",
					optlist[i] ? "-o" : "+o",
					optnames[i]);

		}
	} else {
		for (i = 0; i < NOPTS; i++)
			if (equal(name, optnames[i])) {
				optlist[i] = val;
				return;
			}
		sh_error("Illegal option -o %s", name);
	}
}


STATIC void
setoption(int flag, int val)
{
	int i;

	for (i = 0; i < NOPTS; i++)
		if (optletters[i] == flag) {
			optlist[i] = val;
			if (val) {
				/* #%$ hack for ksh semantics */
				if (flag == 'V')
					Eflag = 0;
				else if (flag == 'E')
					Vflag = 0;
			}
			return;
		}
	sh_error("Illegal option -%c", flag);
	/* NOTREACHED */
}


/*
 * Set the shell parameters.
 */

void
setparam(char **argv)
{
	char **newparam;
	char **ap;
	int nparam;

	for (nparam = 0 ; argv[nparam] ; nparam++);
	ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
	while (*argv) {
		*ap++ = savestr(*argv++);
	}
	*ap = NULL;
	freeparam(&shellparam);
	shellparam.malloc = 1;
	shellparam.nparam = nparam;
	shellparam.p = newparam;
	shellparam.optind = 1;
	shellparam.optoff = -1;
}


/*
 * Free the list of positional parameters.
 */

void
freeparam(volatile struct shparam *param)
{
	char **ap;

	if (param->malloc) {
		for (ap = param->p ; *ap ; ap++)
			ckfree(*ap);
		ckfree(param->p);
	}
}


/*
 * The shift builtin command.
 */

int
shiftcmd(int argc, char **argv)
{
	int n;
	char **ap1, **ap2;

	n = 1;
	if (argc > 1)
		n = number(argv[1]);
	if (n > shellparam.nparam)
		sh_error("can't shift that many");
	INTOFF;
	shellparam.nparam -= n;
	for (ap1 = shellparam.p ; --n >= 0 ; ap1++) {
		if (shellparam.malloc)
			ckfree(*ap1);
	}
	ap2 = shellparam.p;
	while ((*ap2++ = *ap1++) != NULL);
	shellparam.optind = 1;
	shellparam.optoff = -1;
	INTON;
	return 0;
}


/*
 * The set command builtin.
 */

int
setcmd(int argc, char **argv)
{
	if (argc == 1)
		return showvars(nullstr, 0, VUNSET);
	INTOFF;
	options(0);
	optschanged();
	if (*argptr != NULL) {
		setparam(argptr);
	}
	INTON;
	return 0;
}


void
getoptsreset(value)
	const char *value;
{
	shellparam.optind = number(value) ?: 1;
	shellparam.optoff = -1;
}

/*
 * The getopts builtin.  Shellparam.optnext points to the next argument
 * to be processed.  Shellparam.optptr points to the next character to
 * be processed in the current argument.  If shellparam.optnext is NULL,
 * then it's the first time getopts has been called.
 */

int
getoptscmd(int argc, char **argv)
{
	char **optbase;

	if (argc < 3)
		sh_error("Usage: getopts optstring var [arg]");
	else if (argc == 3) {
		optbase = shellparam.p;
		if ((unsigned)shellparam.optind > shellparam.nparam + 1) {
			shellparam.optind = 1;
			shellparam.optoff = -1;
		}
	}
	else {
		optbase = &argv[3];
		if ((unsigned)shellparam.optind > argc - 2) {
			shellparam.optind = 1;
			shellparam.optoff = -1;
		}
	}

	return getopts(argv[1], argv[2], optbase);
}

STATIC int
getopts(char *optstr, char *optvar, char **optfirst)
{
	char *p, *q;
	char c = '?';
	int done = 0;
	char s[2];
	char **optnext;
	int ind = shellparam.optind;
	int off = shellparam.optoff;

	shellparam.optind = -1;
	optnext = optfirst + ind - 1;

	if (ind <= 1 || off < 0 || strlen(optnext[-1]) < off)
		p = NULL;
	else
		p = optnext[-1] + off;
	if (p == NULL || *p == '\0') {
		/* Current word is done, advance */
		p = *optnext;
		if (p == NULL || *p != '-' || *++p == '\0') {
atend:
			p = NULL;
			done = 1;
			goto out;
		}
		optnext++;
		if (p[0] == '-' && p[1] == '\0')	/* check for "--" */
			goto atend;
	}

	c = *p++;
	for (q = optstr; *q != c; ) {
		if (*q == '\0') {
			if (optstr[0] == ':') {
				s[0] = c;
				s[1] = '\0';
				setvar("OPTARG", s, 0);
			} else {
				outfmt(&errout, "Illegal option -%c\n", c);
				(void) unsetvar("OPTARG");
			}
			c = '?';
			goto out;
		}
		if (*++q == ':')
			q++;
	}

	if (*++q == ':') {
		if (*p == '\0' && (p = *optnext) == NULL) {
			if (optstr[0] == ':') {
				s[0] = c;
				s[1] = '\0';
				setvar("OPTARG", s, 0);
				c = ':';
			} else {
				outfmt(&errout, "No arg for -%c option\n", c);
				(void) unsetvar("OPTARG");
				c = '?';
			}
			goto out;
		}

		if (p == *optnext)
			optnext++;
		setvar("OPTARG", p, 0);
		p = NULL;
	} else
		setvar("OPTARG", nullstr, 0);

out:
	ind = optnext - optfirst + 1;
	setvarint("OPTIND", ind, VNOFUNC);
	s[0] = c;
	s[1] = '\0';
	setvar(optvar, s, 0);

	shellparam.optoff = p ? p - *(optnext - 1) : -1;
	shellparam.optind = ind;

	return done;
}

/*
 * XXX - should get rid of.  have all builtins use getopt(3).  the
 * library getopt must have the BSD extension static variable "optreset"
 * otherwise it can't be used within the shell safely.
 *
 * Standard option processing (a la getopt) for builtin routines.  The
 * only argument that is passed to nextopt is the option string; the
 * other arguments are unnecessary.  It return the character, or '\0' on
 * end of input.
 */

int
nextopt(const char *optstring)
{
	char *p;
	const char *q;
	char c;

	if ((p = optptr) == NULL || *p == '\0') {
		p = *argptr;
		if (p == NULL || *p != '-' || *++p == '\0')
			return '\0';
		argptr++;
		if (p[0] == '-' && p[1] == '\0')	/* check for "--" */
			return '\0';
	}
	c = *p++;
	for (q = optstring ; *q != c ; ) {
		if (*q == '\0')
			sh_error("Illegal option -%c", c);
		if (*++q == ':')
			q++;
	}
	if (*++q == ':') {
		if (*p == '\0' && (p = *argptr++) == NULL)
			sh_error("No arg for -%c option", c);
		optionarg = p;
		p = NULL;
	}
	optptr = p;
	return c;
}
1	niro	532	/*-
2			* Copyright (c) 1991, 1993
3			* The Regents of the University of California. All rights reserved.
4			* Copyright (c) 1997-2005
5			* Herbert Xu <herbert@gondor.apana.org.au>. All rights reserved.
6			*
7			* This code is derived from software contributed to Berkeley by
8			* Kenneth Almquist.
9			*
10			* Redistribution and use in source and binary forms, with or without
11			* modification, are permitted provided that the following conditions
12			* are met:
13			* 1. Redistributions of source code must retain the above copyright
14			* notice, this list of conditions and the following disclaimer.
15			* 2. Redistributions in binary form must reproduce the above copyright
16			* notice, this list of conditions and the following disclaimer in the
17			* documentation and/or other materials provided with the distribution.
18			* 3. Neither the name of the University nor the names of its contributors
19			* may be used to endorse or promote products derived from this software
20			* without specific prior written permission.
21			*
22			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32			* SUCH DAMAGE.
33			*/
34
35			#include <signal.h>
36			#include <unistd.h>
37			#include <stdlib.h>
38
39			#include "shell.h"
40			#define DEFINE_OPTIONS
41			#include "options.h"
42			#undef DEFINE_OPTIONS
43			#include "nodes.h" /* for other header files */
44			#include "eval.h"
45			#include "jobs.h"
46			#include "input.h"
47			#include "output.h"
48			#include "trap.h"
49			#include "var.h"
50			#include "memalloc.h"
51			#include "error.h"
52			#include "mystring.h"
53			#ifndef SMALL
54			#include "myhistedit.h"
55			#endif
56			#include "show.h"
57
58			char arg0; / value of $0 */
59			struct shparam shellparam; /* current positional parameters */
60			char *argptr; / argument list for builtin commands */
61			char optionarg; / set by nextopt (like getopt) */
62			char optptr; / used by nextopt */
63
64			char minusc; / argument to -c option */
65
66			static const char *const optnames[NOPTS] = {
67			"errexit",
68			"noglob",
69			"ignoreeof",
70			"interactive",
71			"monitor",
72			"noexec",
73			"stdin",
74			"xtrace",
75			"verbose",
76			"vi",
77			"emacs",
78			"noclobber",
79			"allexport",
80			"notify",
81			"nounset",
82			"nolog",
83			"debug",
84			};
85
86			const char optletters[NOPTS] = {
87			'e',
88			'f',
89			'I',
90			'i',
91			'm',
92			'n',
93			's',
94			'x',
95			'v',
96			'V',
97			'E',
98			'C',
99			'a',
100			'b',
101			'u',
102			0,
103			0,
104			};
105
106			char optlist[NOPTS];
107
108
109	niro	1122	static int options(int);
110	niro	532	STATIC void minus_o(char *, int);
111			STATIC void setoption(int, int);
112	niro	1122	STATIC int getopts(char , char , char **);
113	niro	532
114
115			/*
116			* Process the shell command line arguments.
117			*/
118
119	niro	1122	int
120	niro	532	procargs(int argc, char **argv)
121			{
122			int i;
123			const char *xminusc;
124			char **xargv;
125	niro	1122	int login;
126	niro	532
127			xargv = argv;
128	niro	1122	login = xargv[0] && xargv[0][0] == '-';
129	niro	532	arg0 = xargv[0];
130			if (argc > 0)
131			xargv++;
132			for (i = 0; i < NOPTS; i++)
133			optlist[i] = 2;
134			argptr = xargv;
135	niro	1122	login \|= options(1);
136	niro	532	xargv = argptr;
137			xminusc = minusc;
138			if (*xargv == NULL) {
139			if (xminusc)
140			sh_error("-c requires an argument");
141			sflag = 1;
142			}
143			if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
144			iflag = 1;
145			if (mflag == 2)
146			mflag = iflag;
147			for (i = 0; i < NOPTS; i++)
148			if (optlist[i] == 2)
149			optlist[i] = 0;
150			#if DEBUG == 2
151			debug = 1;
152			#endif
153			/* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
154			if (xminusc) {
155			minusc = *xargv++;
156			if (*xargv)
157			goto setarg0;
158			} else if (!sflag) {
159			setinputfile(*xargv, 0);
160			setarg0:
161			arg0 = *xargv++;
162			commandname = arg0;
163			}
164
165			shellparam.p = xargv;
166			shellparam.optind = 1;
167			shellparam.optoff = -1;
168			/* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
169			while (*xargv) {
170			shellparam.nparam++;
171			xargv++;
172			}
173			optschanged();
174	niro	1122
175			return login;
176	niro	532	}
177
178
179			void
180			optschanged(void)
181			{
182			#ifdef DEBUG
183			opentrace();
184			#endif
185			setinteractive(iflag);
186			#ifndef SMALL
187			histedit();
188			#endif
189			setjobctl(mflag);
190			}
191
192			/*
193			* Process shell options. The global variable argptr contains a pointer
194			* to the argument list; we advance it past the options.
195			*/
196
197	niro	1122	STATIC int
198	niro	532	options(int cmdline)
199			{
200			char *p;
201			int val;
202			int c;
203	niro	1122	int login = 0;
204	niro	532
205			if (cmdline)
206			minusc = NULL;
207			while ((p = *argptr) != NULL) {
208			argptr++;
209			if ((c = *p++) == '-') {
210			val = 1;
211			if (p[0] == '\0' \|\| (p[0] == '-' && p[1] == '\0')) {
212			if (!cmdline) {
213			/* "-" means turn off -x and -v */
214			if (p[0] == '\0')
215			xflag = vflag = 0;
216			/* "--" means reset params */
217			else if (*argptr == NULL)
218			setparam(argptr);
219			}
220			break; /* "-" or "--" terminates options */
221			}
222			} else if (c == '+') {
223			val = 0;
224			} else {
225			argptr--;
226			break;
227			}
228			while ((c = *p++) != '\0') {
229			if (c == 'c' && cmdline) {
230			minusc = p; /* command is after shell args*/
231	niro	1122	} else if (c == 'l' && cmdline) {
232			login = 1;
233	niro	532	} else if (c == 'o') {
234			minus_o(*argptr, val);
235			if (*argptr)
236			argptr++;
237			} else {
238			setoption(c, val);
239			}
240			}
241			}
242	niro	1122
243			return login;
244	niro	532	}
245
246			STATIC void
247			minus_o(char *name, int val)
248			{
249			int i;
250
251			if (name == NULL) {
252	niro	1122	if (val) {
253			out1str("Current option settings\n");
254			for (i = 0; i < NOPTS; i++)
255			out1fmt("%-16s%s\n", optnames[i],
256			optlist[i] ? "on" : "off");
257			} else {
258			for (i = 0; i < NOPTS; i++)
259			out1fmt("set %s %s\n",
260			optlist[i] ? "-o" : "+o",
261			optnames[i]);
262
263			}
264	niro	532	} else {
265			for (i = 0; i < NOPTS; i++)
266			if (equal(name, optnames[i])) {
267			optlist[i] = val;
268			return;
269			}
270			sh_error("Illegal option -o %s", name);
271			}
272			}
273
274
275			STATIC void
276			setoption(int flag, int val)
277			{
278			int i;
279
280			for (i = 0; i < NOPTS; i++)
281			if (optletters[i] == flag) {
282			optlist[i] = val;
283			if (val) {
284			/* #%$ hack for ksh semantics */
285			if (flag == 'V')
286			Eflag = 0;
287			else if (flag == 'E')
288			Vflag = 0;
289			}
290			return;
291			}
292			sh_error("Illegal option -%c", flag);
293			/* NOTREACHED */
294			}
295
296
297
298			/*
299			* Set the shell parameters.
300			*/
301
302			void
303			setparam(char **argv)
304			{
305			char **newparam;
306			char **ap;
307			int nparam;
308
309			for (nparam = 0 ; argv[nparam] ; nparam++);
310			ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
311			while (*argv) {
312			ap++ = savestr(argv++);
313			}
314			*ap = NULL;
315			freeparam(&shellparam);
316			shellparam.malloc = 1;
317			shellparam.nparam = nparam;
318			shellparam.p = newparam;
319			shellparam.optind = 1;
320			shellparam.optoff = -1;
321			}
322
323
324			/*
325			* Free the list of positional parameters.
326			*/
327
328			void
329			freeparam(volatile struct shparam *param)
330			{
331			char **ap;
332
333			if (param->malloc) {
334			for (ap = param->p ; *ap ; ap++)
335			ckfree(*ap);
336			ckfree(param->p);
337			}
338			}
339
340
341
342			/*
343			* The shift builtin command.
344			*/
345
346			int
347			shiftcmd(int argc, char **argv)
348			{
349			int n;
350			char ap1, ap2;
351
352			n = 1;
353			if (argc > 1)
354			n = number(argv[1]);
355			if (n > shellparam.nparam)
356			sh_error("can't shift that many");
357			INTOFF;
358			shellparam.nparam -= n;
359			for (ap1 = shellparam.p ; --n >= 0 ; ap1++) {
360			if (shellparam.malloc)
361			ckfree(*ap1);
362			}
363			ap2 = shellparam.p;
364			while ((ap2++ = ap1++) != NULL);
365			shellparam.optind = 1;
366			shellparam.optoff = -1;
367			INTON;
368			return 0;
369			}
370
371
372
373			/*
374			* The set command builtin.
375			*/
376
377			int
378			setcmd(int argc, char **argv)
379			{
380			if (argc == 1)
381			return showvars(nullstr, 0, VUNSET);
382			INTOFF;
383			options(0);
384			optschanged();
385			if (*argptr != NULL) {
386			setparam(argptr);
387			}
388			INTON;
389			return 0;
390			}
391
392
393			void
394			getoptsreset(value)
395			const char *value;
396			{
397	niro	1122	shellparam.optind = number(value) ?: 1;
398	niro	532	shellparam.optoff = -1;
399			}
400
401			/*
402			* The getopts builtin. Shellparam.optnext points to the next argument
403			* to be processed. Shellparam.optptr points to the next character to
404			* be processed in the current argument. If shellparam.optnext is NULL,
405			* then it's the first time getopts has been called.
406			*/
407
408			int
409			getoptscmd(int argc, char **argv)
410			{
411			char **optbase;
412
413			if (argc < 3)
414			sh_error("Usage: getopts optstring var [arg]");
415			else if (argc == 3) {
416			optbase = shellparam.p;
417	niro	1122	if ((unsigned)shellparam.optind > shellparam.nparam + 1) {
418	niro	532	shellparam.optind = 1;
419			shellparam.optoff = -1;
420			}
421			}
422			else {
423			optbase = &argv[3];
424	niro	1122	if ((unsigned)shellparam.optind > argc - 2) {
425	niro	532	shellparam.optind = 1;
426			shellparam.optoff = -1;
427			}
428			}
429
430	niro	1122	return getopts(argv[1], argv[2], optbase);
431	niro	532	}
432
433			STATIC int
434	niro	1122	getopts(char optstr, char optvar, char **optfirst)
435	niro	532	{
436			char p, q;
437			char c = '?';
438			int done = 0;
439	niro	1122	char s[2];
440	niro	532	char **optnext;
441	niro	1122	int ind = shellparam.optind;
442			int off = shellparam.optoff;
443	niro	532
444	niro	1122	shellparam.optind = -1;
445			optnext = optfirst + ind - 1;
446	niro	532
447	niro	1122	if (ind <= 1 \|\| off < 0 \|\| strlen(optnext[-1]) < off)
448	niro	532	p = NULL;
449			else
450	niro	1122	p = optnext[-1] + off;
451	niro	532	if (p == NULL \|\| *p == '\0') {
452			/* Current word is done, advance */
453			p = *optnext;
454			if (p == NULL \|\| p != '-' \|\| ++p == '\0') {
455			atend:
456			p = NULL;
457			done = 1;
458			goto out;
459			}
460			optnext++;
461			if (p[0] == '-' && p[1] == '\0') /* check for "--" */
462			goto atend;
463			}
464
465			c = *p++;
466			for (q = optstr; *q != c; ) {
467			if (*q == '\0') {
468			if (optstr[0] == ':') {
469			s[0] = c;
470			s[1] = '\0';
471	niro	1122	setvar("OPTARG", s, 0);
472	niro	532	} else {
473			outfmt(&errout, "Illegal option -%c\n", c);
474			(void) unsetvar("OPTARG");
475			}
476			c = '?';
477			goto out;
478			}
479			if (*++q == ':')
480			q++;
481			}
482
483			if (*++q == ':') {
484			if (p == '\0' && (p = optnext) == NULL) {
485			if (optstr[0] == ':') {
486			s[0] = c;
487			s[1] = '\0';
488	niro	1122	setvar("OPTARG", s, 0);
489	niro	532	c = ':';
490			} else {
491			outfmt(&errout, "No arg for -%c option\n", c);
492			(void) unsetvar("OPTARG");
493			c = '?';
494			}
495			goto out;
496			}
497
498			if (p == *optnext)
499			optnext++;
500	niro	1122	setvar("OPTARG", p, 0);
501	niro	532	p = NULL;
502			} else
503	niro	1122	setvar("OPTARG", nullstr, 0);
504	niro	532
505			out:
506	niro	1122	ind = optnext - optfirst + 1;
507			setvarint("OPTIND", ind, VNOFUNC);
508	niro	532	s[0] = c;
509			s[1] = '\0';
510	niro	1122	setvar(optvar, s, 0);
511
512			shellparam.optoff = p ? p - *(optnext - 1) : -1;
513			shellparam.optind = ind;
514
515	niro	532	return done;
516			}
517
518			/*
519			* XXX - should get rid of. have all builtins use getopt(3). the
520			* library getopt must have the BSD extension static variable "optreset"
521			* otherwise it can't be used within the shell safely.
522			*
523			* Standard option processing (a la getopt) for builtin routines. The
524			* only argument that is passed to nextopt is the option string; the
525			* other arguments are unnecessary. It return the character, or '\0' on
526			* end of input.
527			*/
528
529			int
530			nextopt(const char *optstring)
531			{
532			char *p;
533			const char *q;
534			char c;
535
536			if ((p = optptr) == NULL \|\| *p == '\0') {
537			p = *argptr;
538			if (p == NULL \|\| p != '-' \|\| ++p == '\0')
539			return '\0';
540			argptr++;
541			if (p[0] == '-' && p[1] == '\0') /* check for "--" */
542			return '\0';
543			}
544			c = *p++;
545			for (q = optstring ; *q != c ; ) {
546			if (*q == '\0')
547			sh_error("Illegal option -%c", c);
548			if (*++q == ':')
549			q++;
550			}
551			if (*++q == ':') {
552			if (p == '\0' && (p = argptr++) == NULL)
553			sh_error("No arg for -%c option", c);
554			optionarg = p;
555			p = NULL;
556			}
557			optptr = p;
558			return c;
559			}