options.c@ 2390

Last change on this file since 2390 was 2290, checked in by bird, 16 years ago
kash: malloc/free/friends gets a psh.
Property svn:eol-style set to `LF` Property svn:keywords set to `Id`
File size: 11.9 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	INIT {
255	memcpy(&psh->optlist[0], &ro_optlist[0], sizeof(psh->optlist));
256	}
257
258	SHELLPROC {
259	int i;
260
261	for (i = 0; psh->optlist[i].name; i++)
262	psh->optlist[i].val = 0;
263	optschanged(psh);
264
265	}
266	#endif
267
268
269	/*
270	* Set the shell parameters.
271	*/
272
273	void
274	setparam(shinstance psh, char *argv)
275	{
276	char **newparam;
277	char **ap;
278	int nparam;
279
280	for (nparam = 0 ; argv[nparam] ; nparam++)
281	continue;
282	ap = newparam = ckmalloc(psh, (nparam + 1) * sizeof *ap);
283	while (*argv) {
284	ap++ = savestr(psh, argv++);
285	}
286	*ap = NULL;
287	freeparam(psh, &psh->shellparam);
288	psh->shellparam.malloc = 1;
289	psh->shellparam.nparam = nparam;
290	psh->shellparam.p = newparam;
291	psh->shellparam.optnext = NULL;
292	}
293
294
295	/*
296	* Free the list of positional parameters.
297	*/
298
299	void
300	freeparam(shinstance psh, volatile struct shparam param)
301	{
302	char **ap;
303
304	if (param->malloc) {
305	for (ap = param->p ; *ap ; ap++)
306	ckfree(psh, *ap);
307	ckfree(psh, param->p);
308	}
309	}
310
311
312
313	/*
314	* The shift builtin command.
315	*/
316
317	int
318	shiftcmd(shinstance psh, int argc, char *argv)
319	{
320	int n;
321	char ap1, ap2;
322
323	n = 1;
324	if (argc > 1)
325	n = number(psh, argv[1]);
326	if (n > psh->shellparam.nparam)
327	error(psh, "can't shift that many");
328	INTOFF;
329	psh->shellparam.nparam -= n;
330	for (ap1 = psh->shellparam.p ; --n >= 0 ; ap1++) {
331	if (psh->shellparam.malloc)
332	ckfree(psh, *ap1);
333	}
334	ap2 = psh->shellparam.p;
335	while ((ap2++ = ap1++) != NULL);
336	psh->shellparam.optnext = NULL;
337	INTON;
338	return 0;
339	}
340
341
342
343	/*
344	* The set command builtin.
345	*/
346
347	int
348	setcmd(shinstance psh, int argc, char *argv)
349	{
350	if (argc == 1)
351	return showvars(psh, 0, 0, 1);
352	INTOFF;
353	options(psh, 0);
354	optschanged(psh);
355	if (*psh->argptr != NULL) {
356	setparam(psh, psh->argptr);
357	}
358	INTON;
359	return 0;
360	}
361
362
363	void
364	getoptsreset(shinstance psh, const char value)
365	{
366	if (number(psh, value) == 1) {
367	psh->shellparam.optnext = NULL;
368	psh->shellparam.reset = 1;
369	}
370	}
371
372	/*
373	* The getopts builtin. Shellparam.optnext points to the next argument
374	* to be processed. Shellparam.optptr points to the next character to
375	* be processed in the current argument. If shellparam.optnext is NULL,
376	* then it's the first time getopts has been called.
377	*/
378
379	int
380	getoptscmd(shinstance psh, int argc, char *argv)
381	{
382	char **optbase;
383
384	if (argc < 3)
385	error(psh, "usage: getopts optstring var [arg]");
386	else if (argc == 3)
387	optbase = psh->shellparam.p;
388	else
389	optbase = &argv[3];
390
391	if (psh->shellparam.reset == 1) {
392	psh->shellparam.optnext = optbase;
393	psh->shellparam.optptr = NULL;
394	psh->shellparam.reset = 0;
395	}
396
397	return getopts(psh, argv[1], argv[2], optbase, &psh->shellparam.optnext,
398	&psh->shellparam.optptr);
399	}
400
401	STATIC int
402	getopts(shinstance psh, char optstr, char optvar, char optfirst, char optnext, char optpptr)
403	{
404	char p, q;
405	char c = '?';
406	int done = 0;
407	int ind = 0;
408	int err = 0;
409	char s[12];
410
411	if ((p = optpptr) == NULL \|\| p == '\0') {
412	/* Current word is done, advance */
413	if (*optnext == NULL)
414	return 1;
415	p = **optnext;
416	if (p == NULL \|\| p != '-' \|\| ++p == '\0') {
417	atend:
418	ind = (int)(*optnext - optfirst + 1);
419	*optnext = NULL;
420	p = NULL;
421	done = 1;
422	goto out;
423	}
424	(*optnext)++;
425	if (p[0] == '-' && p[1] == '\0') /* check for "--" */
426	goto atend;
427	}
428
429	c = *p++;
430	for (q = optstr; *q != c; ) {
431	if (*q == '\0') {
432	if (optstr[0] == ':') {
433	s[0] = c;
434	s[1] = '\0';
435	err \|= setvarsafe(psh, "OPTARG", s, 0);
436	} else {
437	outfmt(&psh->errout, "Illegal option -%c\n", c);
438	(void) unsetvar(psh, "OPTARG", 0);
439	}
440	c = '?';
441	goto bad;
442	}
443	if (*++q == ':')
444	q++;
445	}
446
447	if (*++q == ':') {
448	if (p == '\0' && (p = *optnext) == NULL) {
449	if (optstr[0] == ':') {
450	s[0] = c;
451	s[1] = '\0';
452	err \|= setvarsafe(psh, "OPTARG", s, 0);
453	c = ':';
454	} else {
455	outfmt(&psh->errout, "No arg for -%c option\n", c);
456	(void) unsetvar(psh, "OPTARG", 0);
457	c = '?';
458	}
459	goto bad;
460	}
461
462	if (p == **optnext)
463	(*optnext)++;
464	err \|= setvarsafe(psh, "OPTARG", p, 0);
465	p = NULL;
466	} else
467	err \|= setvarsafe(psh, "OPTARG", "", 0);
468	ind = (int)(*optnext - optfirst + 1);
469	goto out;
470
471	bad:
472	ind = 1;
473	*optnext = NULL;
474	p = NULL;
475	out:
476	*optpptr = p;
477	fmtstr(s, sizeof(s), "%d", ind);
478	err \|= setvarsafe(psh, "OPTIND", s, VNOFUNC);
479	s[0] = c;
480	s[1] = '\0';
481	err \|= setvarsafe(psh, optvar, s, 0);
482	if (err) {
483	*optnext = NULL;
484	*optpptr = NULL;
485	output_flushall(psh);
486	exraise(psh, EXERROR);
487	}
488	return done;
489	}
490
491	/*
492	* XXX - should get rid of. have all builtins use getopt(3). the
493	* library getopt must have the BSD extension static variable "optreset"
494	* otherwise it can't be used within the shell safely.
495	*
496	* Standard option processing (a la getopt) for builtin routines. The
497	* only argument that is passed to nextopt is the option string; the
498	* other arguments are unnecessary. It return the character, or '\0' on
499	* end of input.
500	*/
501
502	int
503	nextopt(shinstance psh, const char optstring)
504	{
505	char *p;
506	const char *q;
507	char c;
508
509	if ((p = psh->optptr) == NULL \|\| *p == '\0') {
510	p = *psh->argptr;
511	if (p == NULL \|\| p != '-' \|\| ++p == '\0')
512	return '\0';
513	psh->argptr++;
514	if (p[0] == '-' && p[1] == '\0') /* check for "--" */
515	return '\0';
516	}
517	c = *p++;
518	for (q = optstring ; *q != c ; ) {
519	if (*q == '\0')
520	error(psh, "Illegal option -%c", c);
521	if (*++q == ':')
522	q++;
523	}
524	if (*++q == ':') {
525	if (p == '\0' && (p = psh->argptr++) == NULL)
526	error(psh, "No arg for -%c option", c);
527	psh->optionarg = p;
528	p = NULL;
529	}
530	psh->optptr = p;
531	return c;
532	}

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

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

Download in other formats: