options.c@ 1233

Last change on this file since 1233 was 1233, checked in by bird, 17 years ago
keywords.
Property svn:eol-style set to `LF` Property svn:keywords set to `Id`
File size: 11.8 KB

Line
1	/* $NetBSD: options.c,v 1.38 2005/03/20 21:38:17 dsl Exp $ */
2
3	/*-
4	* Copyright (c) 1991, 1993
5	* The Regents of the University of California. 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	#if 0
36	#ifndef lint
37	static char sccsid[] = "@(#)options.c 8.2 (Berkeley) 5/4/95";
38	#else
39	__RCSID("$NetBSD: options.c,v 1.38 2005/03/20 21:38:17 dsl Exp $");
40	#endif /* not lint */
41	#endif
42
43	#include <stdlib.h>
44
45	#include "shell.h"
46	#define DEFINE_OPTIONS
47	#include "options.h"
48	#undef DEFINE_OPTIONS
49	#include "nodes.h" /* for other header files */
50	#include "eval.h"
51	#include "jobs.h"
52	#include "input.h"
53	#include "output.h"
54	#include "trap.h"
55	#include "var.h"
56	#include "memalloc.h"
57	#include "error.h"
58	#include "mystring.h"
59	#ifndef SMALL
60	# include "myhistedit.h"
61	#endif
62	#include "show.h"
63	#include "shinstance.h"
64
65	//char arg0; / value of $0 */
66	//struct shparam shellparam; /* current positional parameters */
67	//char *argptr; / argument list for builtin commands */
68	//char optionarg; / set by nextopt (like getopt) */
69	//char optptr; / used by nextopt */
70
71	//char minusc; / argument to -c option */
72
73
74	STATIC void options(shinstance *, int);
75	STATIC void minus_o(shinstance , char , int);
76	STATIC void setoption(shinstance *, int, int);
77	STATIC int getopts(shinstance , char , char , char , char , char );
78
79
80	/*
81	* Process the shell command line arguments.
82	*/
83
84	void
85	procargs(shinstance psh, int argc, char *argv)
86	{
87	int i;
88
89	psh->argptr = argv;
90	if (argc > 0)
91	psh->argptr++;
92	for (i = 0; i < NOPTS; i++)
93	psh->optlist[i].val = 2;
94	options(psh, 1);
95	if (*psh->argptr == NULL && psh->minusc == NULL)
96	sflag(psh) = 1;
97	if (iflag(psh) == 2 && sflag(psh) == 1 && shfile_isatty(&psh->fdtab, 0) && shfile_isatty(&psh->fdtab, 1))
98	iflag(psh) = 1;
99	if (mflag(psh) == 2)
100	mflag(psh) = iflag(psh);
101	for (i = 0; i < NOPTS; i++)
102	if (psh->optlist[i].val == 2)
103	psh->optlist[i].val = 0;
104	#if DEBUG == 2
105	debug(psh) = 1;
106	#endif
107	psh->arg0 = argv[0];
108	if (sflag(psh) == 0 && psh->minusc == NULL) {
109	psh->commandname = argv[0];
110	psh->arg0 = *psh->argptr++;
111	setinputfile(psh, psh->arg0, 0);
112	psh->commandname = psh->arg0;
113	}
114	/* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
115	if (psh->minusc != NULL) {
116	if (psh->argptr == NULL \|\| *psh->argptr == NULL)
117	error(psh, "Bad -c option");
118	psh->minusc = *psh->argptr++;
119	if (*psh->argptr != 0)
120	psh->arg0 = *psh->argptr++;
121	}
122
123	psh->shellparam.p = psh->argptr;
124	psh->shellparam.reset = 1;
125	/* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
126	while (*psh->argptr) {
127	psh->shellparam.nparam++;
128	psh->argptr++;
129	}
130	optschanged(psh);
131	}
132
133
134	void
135	optschanged(shinstance *psh)
136	{
137	setinteractive(psh, iflag(psh));
138	#ifndef SMALL
139	histedit(psh);
140	#endif
141	setjobctl(psh, mflag(psh));
142	}
143
144	/*
145	* Process shell options. The global variable argptr contains a pointer
146	* to the argument list; we advance it past the options.
147	*/
148
149	STATIC void
150	options(shinstance *psh, int cmdline)
151	{
152	static char empty[] = "";
153	char *p;
154	int val;
155	int c;
156
157	if (cmdline)
158	psh->minusc = NULL;
159	while ((p = *psh->argptr) != NULL) {
160	psh->argptr++;
161	if ((c = *p++) == '-') {
162	val = 1;
163	if (p[0] == '\0' \|\| (p[0] == '-' && p[1] == '\0')) {
164	if (!cmdline) {
165	/* "-" means turn off -x and -v */
166	if (p[0] == '\0')
167	xflag(psh) = vflag(psh) = 0;
168	/* "--" means reset params */
169	else if (*psh->argptr == NULL)
170	setparam(psh, psh->argptr);
171	}
172	break; /* "-" or "--" terminates options */
173	}
174	} else if (c == '+') {
175	val = 0;
176	} else {
177	psh->argptr--;
178	break;
179	}
180	while ((c = *p++) != '\0') {
181	if (c == 'c' && cmdline) {
182	/* command is after shell args*/
183	psh->minusc = empty;
184	} else if (c == 'o') {
185	minus_o(psh, *psh->argptr, val);
186	if (*psh->argptr)
187	psh->argptr++;
188	} else {
189	setoption(psh, c, val);
190	}
191	}
192	}
193	}
194
195	static void
196	set_opt_val(shinstance *psh, int i, int val)
197	{
198	int j;
199	int flag;
200
201	if (val && (flag = psh->optlist[i].opt_set)) {
202	/* some options (eg vi/emacs) are mutually exclusive */
203	for (j = 0; j < NOPTS; j++)
204	if (psh->optlist[j].opt_set == flag)
205	psh->optlist[j].val = 0;
206	}
207	psh->optlist[i].val = val;
208	#ifdef DEBUG
209	if (&psh->optlist[i].val == &debug(psh))
210	opentrace(psh);
211	#endif
212	}
213
214	STATIC void
215	minus_o(shinstance psh, char name, int val)
216	{
217	int i;
218
219	if (name == NULL) {
220	out1str(psh, "Current option settings\n");
221	for (i = 0; i < NOPTS; i++)
222	out1fmt(psh, "%-16s%s\n", psh->optlist[i].name,
223	psh->optlist[i].val ? "on" : "off");
224	} else {
225	for (i = 0; i < NOPTS; i++)
226	if (equal(name, psh->optlist[i].name)) {
227	set_opt_val(psh, i, val);
228	return;
229	}
230	error(psh, "Illegal option -o %s", name);
231	}
232	}
233
234
235	STATIC void
236	setoption(shinstance *psh, int flag, int val)
237	{
238	int i;
239
240	for (i = 0; i < NOPTS; i++)
241	if (psh->optlist[i].letter == flag) {
242	set_opt_val(psh, i, val );
243	return;
244	}
245	error(psh, "Illegal option -%c", flag);
246	/* NOTREACHED */
247	}
248
249
250
251	#ifdef mkinit
252	INCLUDE "options.h"
253
254	SHELLPROC {
255	int i;
256
257	for (i = 0; psh->optlist[i].name; i++)
258	psh->optlist[i].val = 0;
259	optschanged(psh);
260
261	}
262	#endif
263
264
265	/*
266	* Set the shell parameters.
267	*/
268
269	void
270	setparam(shinstance psh, char *argv)
271	{
272	char **newparam;
273	char **ap;
274	int nparam;
275
276	for (nparam = 0 ; argv[nparam] ; nparam++)
277	continue;
278	ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
279	while (*argv) {
280	ap++ = savestr(argv++);
281	}
282	*ap = NULL;
283	freeparam(&psh->shellparam);
284	psh->shellparam.malloc = 1;
285	psh->shellparam.nparam = nparam;
286	psh->shellparam.p = newparam;
287	psh->shellparam.optnext = NULL;
288	}
289
290
291	/*
292	* Free the list of positional parameters.
293	*/
294
295	void
296	freeparam(volatile struct shparam *param)
297	{
298	char **ap;
299
300	if (param->malloc) {
301	for (ap = param->p ; *ap ; ap++)
302	ckfree(*ap);
303	ckfree(param->p);
304	}
305	}
306
307
308
309	/*
310	* The shift builtin command.
311	*/
312
313	int
314	shiftcmd(shinstance psh, int argc, char *argv)
315	{
316	int n;
317	char ap1, ap2;
318
319	n = 1;
320	if (argc > 1)
321	n = number(psh, argv[1]);
322	if (n > psh->shellparam.nparam)
323	error(psh, "can't shift that many");
324	INTOFF;
325	psh->shellparam.nparam -= n;
326	for (ap1 = psh->shellparam.p ; --n >= 0 ; ap1++) {
327	if (psh->shellparam.malloc)
328	ckfree(*ap1);
329	}
330	ap2 = psh->shellparam.p;
331	while ((ap2++ = ap1++) != NULL);
332	psh->shellparam.optnext = NULL;
333	INTON;
334	return 0;
335	}
336
337
338
339	/*
340	* The set command builtin.
341	*/
342
343	int
344	setcmd(shinstance psh, int argc, char *argv)
345	{
346	if (argc == 1)
347	return showvars(psh, 0, 0, 1);
348	INTOFF;
349	options(psh, 0);
350	optschanged(psh);
351	if (*psh->argptr != NULL) {
352	setparam(psh, psh->argptr);
353	}
354	INTON;
355	return 0;
356	}
357
358
359	void
360	getoptsreset(shinstance psh, const char value)
361	{
362	if (number(psh, value) == 1) {
363	psh->shellparam.optnext = NULL;
364	psh->shellparam.reset = 1;
365	}
366	}
367
368	/*
369	* The getopts builtin. Shellparam.optnext points to the next argument
370	* to be processed. Shellparam.optptr points to the next character to
371	* be processed in the current argument. If shellparam.optnext is NULL,
372	* then it's the first time getopts has been called.
373	*/
374
375	int
376	getoptscmd(shinstance psh, int argc, char *argv)
377	{
378	char **optbase;
379
380	if (argc < 3)
381	error(psh, "usage: getopts optstring var [arg]");
382	else if (argc == 3)
383	optbase = psh->shellparam.p;
384	else
385	optbase = &argv[3];
386
387	if (psh->shellparam.reset == 1) {
388	psh->shellparam.optnext = optbase;
389	psh->shellparam.optptr = NULL;
390	psh->shellparam.reset = 0;
391	}
392
393	return getopts(psh, argv[1], argv[2], optbase, &psh->shellparam.optnext,
394	&psh->shellparam.optptr);
395	}
396
397	STATIC int
398	getopts(shinstance psh, char optstr, char optvar, char optfirst, char optnext, char optpptr)
399	{
400	char p, q;
401	char c = '?';
402	int done = 0;
403	int ind = 0;
404	int err = 0;
405	char s[12];
406
407	if ((p = optpptr) == NULL \|\| p == '\0') {
408	/* Current word is done, advance */
409	if (*optnext == NULL)
410	return 1;
411	p = **optnext;
412	if (p == NULL \|\| p != '-' \|\| ++p == '\0') {
413	atend:
414	ind = (int)(*optnext - optfirst + 1);
415	*optnext = NULL;
416	p = NULL;
417	done = 1;
418	goto out;
419	}
420	(*optnext)++;
421	if (p[0] == '-' && p[1] == '\0') /* check for "--" */
422	goto atend;
423	}
424
425	c = *p++;
426	for (q = optstr; *q != c; ) {
427	if (*q == '\0') {
428	if (optstr[0] == ':') {
429	s[0] = c;
430	s[1] = '\0';
431	err \|= setvarsafe(psh, "OPTARG", s, 0);
432	} else {
433	outfmt(&psh->errout, "Illegal option -%c\n", c);
434	(void) unsetvar(psh, "OPTARG", 0);
435	}
436	c = '?';
437	goto bad;
438	}
439	if (*++q == ':')
440	q++;
441	}
442
443	if (*++q == ':') {
444	if (p == '\0' && (p = *optnext) == NULL) {
445	if (optstr[0] == ':') {
446	s[0] = c;
447	s[1] = '\0';
448	err \|= setvarsafe(psh, "OPTARG", s, 0);
449	c = ':';
450	} else {
451	outfmt(&psh->errout, "No arg for -%c option\n", c);
452	(void) unsetvar(psh, "OPTARG", 0);
453	c = '?';
454	}
455	goto bad;
456	}
457
458	if (p == **optnext)
459	(*optnext)++;
460	err \|= setvarsafe(psh, "OPTARG", p, 0);
461	p = NULL;
462	} else
463	err \|= setvarsafe(psh, "OPTARG", "", 0);
464	ind = (int)(*optnext - optfirst + 1);
465	goto out;
466
467	bad:
468	ind = 1;
469	*optnext = NULL;
470	p = NULL;
471	out:
472	*optpptr = p;
473	fmtstr(s, sizeof(s), "%d", ind);
474	err \|= setvarsafe(psh, "OPTIND", s, VNOFUNC);
475	s[0] = c;
476	s[1] = '\0';
477	err \|= setvarsafe(psh, optvar, s, 0);
478	if (err) {
479	*optnext = NULL;
480	*optpptr = NULL;
481	output_flushall(psh);
482	exraise(psh, EXERROR);
483	}
484	return done;
485	}
486
487	/*
488	* XXX - should get rid of. have all builtins use getopt(3). the
489	* library getopt must have the BSD extension static variable "optreset"
490	* otherwise it can't be used within the shell safely.
491	*
492	* Standard option processing (a la getopt) for builtin routines. The
493	* only argument that is passed to nextopt is the option string; the
494	* other arguments are unnecessary. It return the character, or '\0' on
495	* end of input.
496	*/
497
498	int
499	nextopt(shinstance psh, const char optstring)
500	{
501	char *p;
502	const char *q;
503	char c;
504
505	if ((p = psh->optptr) == NULL \|\| *p == '\0') {
506	p = *psh->argptr;
507	if (p == NULL \|\| p != '-' \|\| ++p == '\0')
508	return '\0';
509	psh->argptr++;
510	if (p[0] == '-' && p[1] == '\0') /* check for "--" */
511	return '\0';
512	}
513	c = *p++;
514	for (q = optstring ; *q != c ; ) {
515	if (*q == '\0')
516	error(psh, "Illegal option -%c", c);
517	if (*++q == ':')
518	q++;
519	}
520	if (*++q == ':') {
521	if (p == '\0' && (p = psh->argptr++) == NULL)
522	error(psh, "No arg for -%c option", c);
523	psh->optionarg = p;
524	p = NULL;
525	}
526	psh->optptr = p;
527	return c;
528	}

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/kash/options.c@ 1233

Download in other formats: