source: trunk/src/kash/options.c@ 1505

Last change on this file since 1505 was 1238, checked in by bird, 18 years ago

init psh->optlist.
  • 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
37static 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
74STATIC void options(shinstance *, int);
75STATIC void minus_o(shinstance *, char *, int);
76STATIC void setoption(shinstance *, int, int);
77STATIC int getopts(shinstance *, char *, char *, char **, char ***, char **);
78
79
80/*
81 * Process the shell command line arguments.
82 */
83
84void
85procargs(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
134void
135optschanged(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
149STATIC void
150options(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
195static void
196set_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
214STATIC void
215minus_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
235STATIC void
236setoption(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
252INCLUDE "options.h"
253
254INIT {
255 memcpy(&psh->optlist[0], &ro_optlist[0], sizeof(psh->optlist));
256}
257
258SHELLPROC {
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
273void
274setparam(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((nparam + 1) * sizeof *ap);
283 while (*argv) {
284 *ap++ = savestr(*argv++);
285 }
286 *ap = NULL;
287 freeparam(&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
299void
300freeparam(volatile struct shparam *param)
301{
302 char **ap;
303
304 if (param->malloc) {
305 for (ap = param->p ; *ap ; ap++)
306 ckfree(*ap);
307 ckfree(param->p);
308 }
309}
310
311
312
313/*
314 * The shift builtin command.
315 */
316
317int
318shiftcmd(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(*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
347int
348setcmd(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
363void
364getoptsreset(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
379int
380getoptscmd(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
401STATIC int
402getopts(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') {
417atend:
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
471bad:
472 ind = 1;
473 *optnext = NULL;
474 p = NULL;
475out:
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
502int
503nextopt(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.