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