1/*	$NetBSD: c_ksh.c,v 1.17 2011/08/31 16:24:54 plunky Exp $	*/
2
3/*
4 * built-in Korn commands: c_*
5 */
6#include <sys/cdefs.h>
7
8#ifndef lint
9__RCSID("$NetBSD: c_ksh.c,v 1.17 2011/08/31 16:24:54 plunky Exp $");
10#endif
11
12#include "sh.h"
13#include "ksh_stat.h"
14#include <ctype.h>
15
16#ifdef __CYGWIN__
17#include <sys/cygwin.h>
18#endif /* __CYGWIN__ */
19
20int
21c_cd(wp)
22	char	**wp;
23{
24	int optc;
25	int physical = Flag(FPHYSICAL);
26	int cdnode;			/* was a node from cdpath added in? */
27	int printpath = 0;		/* print where we cd'd? */
28	int rval;
29	struct tbl *pwd_s, *oldpwd_s;
30	XString xs;
31	char *xp;
32	char *dir, *try, *pwd;
33	int phys_path;
34	char *cdpath;
35	char *fdir = NULL;
36
37	while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != EOF)
38		switch (optc) {
39		case 'L':
40			physical = 0;
41			break;
42		case 'P':
43			physical = 1;
44			break;
45		case '?':
46			return 1;
47		}
48	wp += builtin_opt.optind;
49
50	if (Flag(FRESTRICTED)) {
51		bi_errorf("restricted shell - can't cd");
52		return 1;
53	}
54
55	pwd_s = global("PWD");
56	oldpwd_s = global("OLDPWD");
57
58	if (!wp[0]) {
59		/* No arguments - go home */
60		if ((dir = str_val(global("HOME"))) == null) {
61			bi_errorf("no home directory (HOME not set)");
62			return 1;
63		}
64	} else if (!wp[1]) {
65		/* One argument: - or dir */
66		dir = wp[0];
67		if (strcmp(dir, "-") == 0) {
68			dir = str_val(oldpwd_s);
69			if (dir == null) {
70				bi_errorf("no OLDPWD");
71				return 1;
72			}
73			printpath++;
74		}
75	} else if (!wp[2]) {
76		/* Two arguments - substitute arg1 in PWD for arg2 */
77		int ilen, olen, nlen, elen;
78		char *cp;
79
80		if (!current_wd[0]) {
81			bi_errorf("don't know current directory");
82			return 1;
83		}
84		/* substitute arg1 for arg2 in current path.
85		 * if the first substitution fails because the cd fails
86		 * we could try to find another substitution. For now
87		 * we don't
88		 */
89		if ((cp = strstr(current_wd, wp[0])) == (char *) 0) {
90			bi_errorf("bad substitution");
91			return 1;
92		}
93		ilen = cp - current_wd;
94		olen = strlen(wp[0]);
95		nlen = strlen(wp[1]);
96		elen = strlen(current_wd + ilen + olen) + 1;
97		fdir = dir = alloc(ilen + nlen + elen, ATEMP);
98		memcpy(dir, current_wd, ilen);
99		memcpy(dir + ilen, wp[1], nlen);
100		memcpy(dir + ilen + nlen, current_wd + ilen + olen, elen);
101		printpath++;
102	} else {
103		bi_errorf("too many arguments");
104		return 1;
105	}
106
107	Xinit(xs, xp, PATH, ATEMP);
108	/* xp will have a bogus value after make_path() - set it to 0
109	 * so that if it's used, it will cause a dump
110	 */
111	xp = (char *) 0;
112
113	cdpath = str_val(global("CDPATH"));
114	do {
115		cdnode = make_path(current_wd, dir, &cdpath, &xs, &phys_path);
116#ifdef S_ISLNK
117		if (physical)
118			rval = chdir(try = Xstring(xs, xp) + phys_path);
119		else
120#endif /* S_ISLNK */
121		{
122			simplify_path(Xstring(xs, xp));
123			rval = chdir(try = Xstring(xs, xp));
124		}
125	} while (rval < 0 && cdpath != (char *) 0);
126
127	if (rval < 0) {
128		if (cdnode)
129			bi_errorf("%s: bad directory", dir);
130		else
131			bi_errorf("%s - %s", try, strerror(errno));
132		if (fdir)
133			afree(fdir, ATEMP);
134		return 1;
135	}
136
137	/* Clear out tracked aliases with relative paths */
138	flushcom(0);
139
140	/* Set OLDPWD (note: unsetting OLDPWD does not disable this
141	 * setting in at&t ksh)
142	 */
143	if (current_wd[0])
144		/* Ignore failure (happens if readonly or integer) */
145		setstr(oldpwd_s, current_wd, KSH_RETURN_ERROR);
146
147	if (!ISABSPATH(Xstring(xs, xp))) {
148#ifdef OS2
149		/* simplify_path() doesn't know about os/2's drive contexts,
150		 * so it can't set current_wd when changing to a:foo.
151		 * Handle this by calling getcwd()...
152		 */
153		pwd = ksh_get_wd((char *) 0, 0);
154#else /* OS2 */
155		pwd = (char *) 0;
156#endif /* OS2 */
157	} else
158#ifdef S_ISLNK
159	if (!physical || !(pwd = get_phys_path(Xstring(xs, xp))))
160#endif /* S_ISLNK */
161		pwd = Xstring(xs, xp);
162
163	/* Set PWD */
164	if (pwd) {
165#ifdef __CYGWIN__
166		char ptmp[PATH];  /* larger than MAX_PATH */
167		cygwin_conv_to_full_posix_path(pwd, ptmp);
168#else /* __CYGWIN__ */
169		char *ptmp = pwd;
170#endif /* __CYGWIN__ */
171		set_current_wd(ptmp);
172		/* Ignore failure (happens if readonly or integer) */
173		setstr(pwd_s, ptmp, KSH_RETURN_ERROR);
174	} else {
175		set_current_wd(null);
176		pwd = Xstring(xs, xp);
177		/* XXX unset $PWD? */
178	}
179	if (printpath || cdnode)
180		shprintf("%s\n", pwd);
181
182	if (fdir)
183		afree(fdir, ATEMP);
184
185	return 0;
186}
187
188int
189c_pwd(wp)
190	char	**wp;
191{
192	int optc;
193	int physical = Flag(FPHYSICAL);
194	char *p, *freep = NULL;
195
196	while ((optc = ksh_getopt(wp, &builtin_opt, "LP")) != EOF)
197		switch (optc) {
198		case 'L':
199			physical = 0;
200			break;
201		case 'P':
202			physical = 1;
203			break;
204		case '?':
205			return 1;
206		}
207	wp += builtin_opt.optind;
208
209	if (wp[0]) {
210		bi_errorf("too many arguments");
211		return 1;
212	}
213#ifdef S_ISLNK
214	p = current_wd[0] ? (physical ? get_phys_path(current_wd) : current_wd)
215			  : (char *) 0;
216#else /* S_ISLNK */
217	p = current_wd[0] ? current_wd : (char *) 0;
218#endif /* S_ISLNK */
219	if (p && eaccess(p, R_OK) < 0)
220		p = (char *) 0;
221	if (!p) {
222		freep = p = ksh_get_wd((char *) 0, 0);
223		if (!p) {
224			bi_errorf("can't get current directory - %s",
225				strerror(errno));
226			return 1;
227		}
228	}
229	shprintf("%s\n", p);
230	if (freep)
231		afree(freep, ATEMP);
232	return 0;
233}
234
235int
236c_print(wp)
237	char **wp;
238{
239#define PO_NL		BIT(0)	/* print newline */
240#define PO_EXPAND	BIT(1)	/* expand backslash sequences */
241#define PO_PMINUSMINUS	BIT(2)	/* print a -- argument */
242#define PO_HIST		BIT(3)	/* print to history instead of stdout */
243#define PO_COPROC	BIT(4)	/* printing to coprocess: block SIGPIPE */
244#define PO_FSLASH	BIT(5)  /* swap slash for backslash (for os2 ) */
245	int fd = 1;
246	int flags = PO_EXPAND|PO_NL;
247	char *s;
248	const char *emsg;
249	XString xs;
250	char *xp;
251
252	if (wp[0][0] == 'e') {	/* echo command */
253		int nflags = flags;
254
255		/* A compromise between sysV and BSD echo commands:
256		 * escape sequences are enabled by default, and
257		 * -n, -e and -E are recognized if they appear
258		 * in arguments with no illegal options (ie, echo -nq
259		 * will print -nq).
260		 * Different from sysV echo since options are recognized,
261		 * different from BSD echo since escape sequences are enabled
262		 * by default.
263		 */
264		wp += 1;
265		while ((s = *wp) && *s == '-' && s[1]) {
266			while (*++s)
267				if (*s == 'n')
268					nflags &= ~PO_NL;
269				else if (*s == 'e')
270					nflags |= PO_EXPAND;
271				else if (*s == 'E')
272					nflags &= ~PO_EXPAND;
273				else
274					/* bad option: don't use nflags, print
275					 * argument
276					 */
277					break;
278			if (*s)
279				break;
280			wp++;
281			flags = nflags;
282		}
283	} else {
284		int optc;
285#if OS2
286		const char *options = "Rnpfrsu,"; /* added f flag */
287#else
288		const char *options = "Rnprsu,";
289#endif
290		while ((optc = ksh_getopt(wp, &builtin_opt, options)) != EOF)
291			switch (optc) {
292			  case 'R': /* fake BSD echo command */
293				flags |= PO_PMINUSMINUS;
294				flags &= ~PO_EXPAND;
295				options = "ne";
296				break;
297			  case 'e':
298				flags |= PO_EXPAND;
299				break;
300#ifdef OS2
301			  case 'f':
302				flags |= PO_FSLASH;
303				break;
304#endif
305			  case 'n':
306				flags &= ~PO_NL;
307				break;
308#ifdef KSH
309			  case 'p':
310				if ((fd = coproc_getfd(W_OK, &emsg)) < 0) {
311					bi_errorf("-p: %s", emsg);
312					return 1;
313				}
314				break;
315#endif /* KSH */
316			  case 'r':
317				flags &= ~PO_EXPAND;
318				break;
319			  case 's':
320				flags |= PO_HIST;
321				break;
322			  case 'u':
323				if (!*(s = builtin_opt.optarg))
324					fd = 0;
325				else if ((fd = check_fd(s, W_OK, &emsg)) < 0) {
326					bi_errorf("-u: %s: %s", s, emsg);
327					return 1;
328				}
329				break;
330			  case '?':
331				return 1;
332			}
333		if (!(builtin_opt.info & GI_MINUSMINUS)) {
334			/* treat a lone - like -- */
335			if (wp[builtin_opt.optind]
336			    && strcmp(wp[builtin_opt.optind], "-") == 0)
337				builtin_opt.optind++;
338		} else if (flags & PO_PMINUSMINUS)
339			builtin_opt.optind--;
340		wp += builtin_opt.optind;
341	}
342
343	Xinit(xs, xp, 128, ATEMP);
344
345	while (*wp != NULL) {
346		register int c;
347		s = *wp;
348		while ((c = *s++) != '\0') {
349			Xcheck(xs, xp);
350#ifdef OS2
351			if ((flags & PO_FSLASH) && c == '\\')
352				if (*s == '\\')
353					*s++;
354				else
355					c = '/';
356#endif /* OS2 */
357			if ((flags & PO_EXPAND) && c == '\\') {
358				int i;
359
360				switch ((c = *s++)) {
361				/* Oddly enough, \007 seems more portable than
362				 * \a (due to HP-UX cc, Ultrix cc, old pcc's,
363				 * etc.).
364				 */
365				case 'a': c = '\007'; break;
366				case 'b': c = '\b'; break;
367				case 'c': flags &= ~PO_NL;
368					  continue; /* AT&T brain damage */
369				case 'f': c = '\f'; break;
370				case 'n': c = '\n'; break;
371				case 'r': c = '\r'; break;
372				case 't': c = '\t'; break;
373				case 'v': c = 0x0B; break;
374				case '0':
375					/* Look for an octal number: can have
376					 * three digits (not counting the
377					 * leading 0).  Truly burnt.
378					 */
379					c = 0;
380					for (i = 0; i < 3; i++) {
381						if (*s >= '0' && *s <= '7')
382							c = c*8 + *s++ - '0';
383						else
384							break;
385					}
386					break;
387				case '\0': s--; c = '\\'; break;
388				case '\\': break;
389				default:
390					Xput(xs, xp, '\\');
391				}
392			}
393			Xput(xs, xp, c);
394		}
395		if (*++wp != NULL)
396			Xput(xs, xp, ' ');
397	}
398	if (flags & PO_NL)
399		Xput(xs, xp, '\n');
400
401	if (flags & PO_HIST) {
402		Xput(xs, xp, '\0');
403		source->line++;
404		histsave(source->line, Xstring(xs, xp), 1);
405		Xfree(xs, xp);
406	} else {
407		int n, len = Xlength(xs, xp);
408		int UNINITIALIZED(opipe);
409#ifdef KSH
410
411		/* Ensure we aren't killed by a SIGPIPE while writing to
412		 * a coprocess.  at&t ksh doesn't seem to do this (seems
413		 * to just check that the co-process is alive, which is
414		 * not enough).
415		 */
416		if (coproc.write >= 0 && coproc.write == fd) {
417			flags |= PO_COPROC;
418			opipe = block_pipe();
419		}
420#endif /* KSH */
421		for (s = Xstring(xs, xp); len > 0; ) {
422			n = write(fd, s, len);
423			if (n < 0) {
424#ifdef KSH
425				if (flags & PO_COPROC)
426					restore_pipe(opipe);
427#endif /* KSH */
428				if (errno == EINTR) {
429					/* allow user to ^C out */
430					intrcheck();
431#ifdef KSH
432					if (flags & PO_COPROC)
433						opipe = block_pipe();
434#endif /* KSH */
435					continue;
436				}
437#ifdef KSH
438				/* This doesn't really make sense - could
439				 * break scripts (print -p generates
440				 * error message).
441				*if (errno == EPIPE)
442				*	coproc_write_close(fd);
443				 */
444#endif /* KSH */
445				return 1;
446			}
447			s += n;
448			len -= n;
449		}
450#ifdef KSH
451		if (flags & PO_COPROC)
452			restore_pipe(opipe);
453#endif /* KSH */
454	}
455
456	return 0;
457}
458
459int
460c_whence(wp)
461	char **wp;
462{
463	struct tbl *tp;
464	char *id;
465	int pflag = 0, vflag = 0, Vflag = 0;
466	int ret = 0;
467	int optc;
468	int iam_whence = wp[0][0] == 'w';
469	int fcflags;
470	const char *options = iam_whence ? "pv" : "pvV";
471
472	while ((optc = ksh_getopt(wp, &builtin_opt, options)) != EOF)
473		switch (optc) {
474		case 'p':
475			pflag = 1;
476			break;
477		case 'v':
478			vflag = 1;
479			break;
480		case 'V':
481			Vflag = 1;
482			break;
483		case '?':
484			return 1;
485		}
486	wp += builtin_opt.optind;
487
488
489	fcflags = FC_BI | FC_PATH | FC_FUNC;
490	if (!iam_whence) {
491		/* Note that -p on its own is deal with in comexec() */
492		if (pflag)
493			fcflags |= FC_DEFPATH;
494		/* Convert command options to whence options - note that
495		 * command -pV uses a different path search than whence -v
496		 * or whence -pv.  This should be considered a feature.
497		 */
498		vflag = Vflag;
499	}
500	if (pflag)
501		fcflags &= ~(FC_BI | FC_FUNC);
502
503	while ((vflag || ret == 0) && (id = *wp++) != NULL) {
504		tp = NULL;
505		if ((iam_whence || vflag) && !pflag)
506			tp = tsearch(&keywords, id, hash(id));
507		if (!tp && !pflag) {
508			tp = tsearch(&aliases, id, hash(id));
509			if (tp && !(tp->flag & ISSET))
510				tp = NULL;
511		}
512		if (!tp)
513			tp = findcom(id, fcflags);
514		if (vflag || (tp->type != CALIAS && tp->type != CEXEC
515			      && tp->type != CTALIAS))
516			shprintf("%s", id);
517		switch (tp->type) {
518		  case CKEYWD:
519			if (vflag)
520				shprintf(" is a reserved word");
521			break;
522		  case CALIAS:
523			if (vflag)
524				shprintf(" is an %salias for ",
525					(tp->flag & EXPORT) ? "exported "
526							    : null);
527			if (!iam_whence && !vflag)
528				shprintf("alias %s=", id);
529			print_value_quoted(tp->val.s);
530			break;
531		  case CFUNC:
532			if (vflag) {
533				shprintf(" is a");
534				if (tp->flag & EXPORT)
535					shprintf("n exported");
536				if (tp->flag & TRACE)
537					shprintf(" traced");
538				if (!(tp->flag & ISSET)) {
539					shprintf(" undefined");
540					if (tp->u.fpath)
541						shprintf(" (autoload from %s)",
542							tp->u.fpath);
543				}
544				shprintf(" function");
545			}
546			break;
547		  case CSHELL:
548			if (vflag)
549				shprintf(" is a%s shell builtin",
550				    (tp->flag & SPEC_BI) ? " special" : null);
551			break;
552		  case CTALIAS:
553		  case CEXEC:
554			if (tp->flag & ISSET) {
555				if (vflag) {
556					shprintf(" is ");
557					if (tp->type == CTALIAS)
558						shprintf(
559						    "a tracked %salias for ",
560							(tp->flag & EXPORT) ?
561								"exported "
562							      : null);
563				}
564				shprintf("%s", tp->val.s);
565			} else {
566				if (vflag)
567					shprintf(" not found");
568				ret = 1;
569			}
570			break;
571		  default:
572			shprintf("%s is *GOK*", id);
573			break;
574		}
575		if (vflag || !ret)
576			shprintf("%s", newline);
577	}
578	return ret;
579}
580
581/* Deal with command -vV - command -p dealt with in comexec() */
582int
583c_command(wp)
584	char **wp;
585{
586	/* Let c_whence do the work.  Note that c_command() must be
587	 * a distinct function from c_whence() (tested in comexec()).
588	 */
589	return c_whence(wp);
590}
591
592/* typeset, export, and readonly */
593int
594c_typeset(wp)
595	char **wp;
596{
597	struct block *l = e->loc;
598	struct tbl *vp, **p;
599	Tflag fset = 0, fclr = 0;
600	int thing = 0, func = 0, localv = 0;
601	const char *options = "L#R#UZ#fi#lprtux";	/* see comment below */
602	char *fieldstr, *basestr;
603	int field, base;
604	int optc;
605	Tflag flag;
606	int pflag = 0;
607
608	switch (**wp) {
609 	  case 'e':		/* export */
610 		fset |= EXPORT;
611		options = "p";
612 		break;
613 	  case 'r':		/* readonly */
614 		fset |= RDONLY;
615		options = "p";
616 		break;
617	  case 's':		/* set */
618		/* called with 'typeset -' */
619		break;
620 	  case 't':		/* typeset */
621 		localv = 1;
622 		break;
623 	}
624
625	fieldstr = basestr = (char *) 0;
626	builtin_opt.flags |= GF_PLUSOPT;
627	/* at&t ksh seems to have 0-9 as options, which are multiplied
628	 * to get a number that is used with -L, -R, -Z or -i (eg, -1R2
629	 * sets right justify in a field of 12).  This allows options
630	 * to be grouped in an order (eg, -Lu12), but disallows -i8 -L3 and
631	 * does not allow the number to be specified as a separate argument
632	 * Here, the number must follow the RLZi option, but is optional
633	 * (see the # kludge in ksh_getopt()).
634	 */
635	while ((optc = ksh_getopt(wp, &builtin_opt, options)) != EOF) {
636		flag = 0;
637		switch (optc) {
638		  case 'L':
639			flag = LJUST;
640			fieldstr = builtin_opt.optarg;
641			break;
642		  case 'R':
643			flag = RJUST;
644			fieldstr = builtin_opt.optarg;
645			break;
646		  case 'U':
647			/* at&t ksh uses u, but this conflicts with
648			 * upper/lower case.  If this option is changed,
649			 * need to change the -U below as well
650			 */
651			flag = INT_U;
652			break;
653		  case 'Z':
654			flag = ZEROFIL;
655			fieldstr = builtin_opt.optarg;
656			break;
657		  case 'f':
658			func = 1;
659			break;
660		  case 'i':
661			flag = INTEGER;
662			basestr = builtin_opt.optarg;
663			break;
664		  case 'l':
665			flag = LCASEV;
666			break;
667		  case 'p': /* posix export/readonly -p flag.
668			     * typeset -p is the same as typeset (in pdksh);
669			     * here for compatibility with ksh93.
670			     */
671			pflag = 1;
672			break;
673		  case 'r':
674			flag = RDONLY;
675			break;
676		  case 't':
677			flag = TRACE;
678			break;
679		  case 'u':
680			flag = UCASEV_AL;	/* upper case / autoload */
681			break;
682		  case 'x':
683			flag = EXPORT;
684			break;
685		  case '?':
686			return 1;
687		}
688		if (builtin_opt.info & GI_PLUS) {
689			fclr |= flag;
690			fset &= ~flag;
691			thing = '+';
692		} else {
693			fset |= flag;
694			fclr &= ~flag;
695			thing = '-';
696		}
697	}
698
699	field = 0;
700	if (fieldstr && !bi_getn(fieldstr, &field))
701		return 1;
702	base = 0;
703	if (basestr && !bi_getn(basestr, &base))
704		return 1;
705
706	if (!(builtin_opt.info & GI_MINUSMINUS) && wp[builtin_opt.optind]
707	    && (wp[builtin_opt.optind][0] == '-'
708		|| wp[builtin_opt.optind][0] == '+')
709	    && wp[builtin_opt.optind][1] == '\0')
710	{
711		thing = wp[builtin_opt.optind][0];
712		builtin_opt.optind++;
713	}
714
715	if (func && ((fset|fclr) & ~(TRACE|UCASEV_AL|EXPORT))) {
716		bi_errorf("only -t, -u and -x options may be used with -f");
717		return 1;
718	}
719	if (wp[builtin_opt.optind]) {
720		/* Take care of exclusions.
721		 * At this point, flags in fset are cleared in fclr and vise
722		 * versa.  This property should be preserved.
723		 */
724		if (fset & LCASEV)	/* LCASEV has priority over UCASEV_AL */
725			fset &= ~UCASEV_AL;
726		if (fset & LJUST)	/* LJUST has priority over RJUST */
727			fset &= ~RJUST;
728		if ((fset & (ZEROFIL|LJUST)) == ZEROFIL) { /* -Z implies -ZR */
729			fset |= RJUST;
730			fclr &= ~RJUST;
731		}
732		/* Setting these attributes clears the others, unless they
733		 * are also set in this command
734		 */
735		if (fset & (LJUST|RJUST|ZEROFIL|UCASEV_AL|LCASEV|INTEGER
736			    |INT_U|INT_L))
737			fclr |= ~fset &
738				(LJUST|RJUST|ZEROFIL|UCASEV_AL|LCASEV|INTEGER
739				 |INT_U|INT_L);
740	}
741
742	/* set variables and attributes */
743	if (wp[builtin_opt.optind]) {
744		int i;
745		int rval = 0;
746		struct tbl *f;
747
748		if (localv && !func)
749			fset |= LOCAL;
750		for (i = builtin_opt.optind; wp[i]; i++) {
751			if (func) {
752				f = findfunc(wp[i], hash(wp[i]),
753					     (fset&UCASEV_AL) ? TRUE : FALSE);
754				if (!f) {
755					/* at&t ksh does ++rval: bogus */
756					rval = 1;
757					continue;
758				}
759				if (fset | fclr) {
760					f->flag |= fset;
761					f->flag &= ~fclr;
762				} else
763					fptreef(shl_stdout, 0,
764						f->flag & FKSH ?
765						    "function %s %T\n"
766						    : "%s() %T\n"
767						,
768						wp[i], f->val.t);
769			} else if (!typeset(wp[i], fset, fclr, field, base)) {
770				bi_errorf("%s: not identifier", wp[i]);
771				return 1;
772			}
773		}
774		return rval;
775	}
776
777	/* list variables and attributes */
778	flag = fset | fclr; /* no difference at this point.. */
779	if (func) {
780	    for (l = e->loc; l; l = l->next) {
781		for (p = tsort(&l->funs); (vp = *p++); ) {
782		    if (flag && (vp->flag & flag) == 0)
783			    continue;
784		    if (thing == '-')
785			fptreef(shl_stdout, 0, vp->flag & FKSH ?
786						    "function %s %T\n"
787						    : "%s() %T\n",
788				vp->name, vp->val.t);
789		    else
790			shprintf("%s\n", vp->name);
791		}
792	    }
793	} else {
794	    for (l = e->loc; l; l = l->next) {
795		for (p = tsort(&l->vars); (vp = *p++); ) {
796		    struct tbl *tvp;
797		    int any_set = 0;
798		    /*
799		     * See if the parameter is set (for arrays, if any
800		     * element is set).
801		     */
802		    for (tvp = vp; tvp; tvp = tvp->u.array)
803			if (tvp->flag & ISSET) {
804			    any_set = 1;
805			    break;
806			}
807		    /*
808		     * Check attributes - note that all array elements
809		     * have (should have?) the same attributes, so checking
810		     * the first is sufficient.
811		     *
812		     * Report an unset param only if the user has
813		     * explicitly given it some attribute (like export);
814		     * otherwise, after "echo $FOO", we would report FOO...
815		     */
816		    if (!any_set && !(vp->flag & USERATTRIB))
817			continue;
818		    if (flag && (vp->flag & flag) == 0)
819			continue;
820		    for (; vp; vp = vp->u.array) {
821			/* Ignore array elements that aren't set unless there
822			 * are no set elements, in which case the first is
823			 * reported on
824			 */
825			if ((vp->flag&ARRAY) && any_set && !(vp->flag & ISSET))
826			    continue;
827			/* no arguments */
828			if (thing == 0 && flag == 0) {
829			    /* at&t ksh prints things like export, integer,
830			     * leftadj, zerofill, etc., but POSIX says must
831			     * be suitable for re-entry...
832			     */
833			    shprintf("typeset ");
834			    if ((vp->flag&INTEGER))
835				shprintf("-i ");
836			    if ((vp->flag&EXPORT))
837				shprintf("-x ");
838			    if ((vp->flag&RDONLY))
839				shprintf("-r ");
840			    if ((vp->flag&TRACE))
841				shprintf("-t ");
842			    if ((vp->flag&LJUST))
843				shprintf("-L%d ", vp->u2.field);
844			    if ((vp->flag&RJUST))
845				shprintf("-R%d ", vp->u2.field);
846			    if ((vp->flag&ZEROFIL))
847				shprintf("-Z ");
848			    if ((vp->flag&LCASEV))
849				shprintf("-l ");
850			    if ((vp->flag&UCASEV_AL))
851				shprintf("-u ");
852			    if ((vp->flag&INT_U))
853				shprintf("-U ");
854			    shprintf("%s\n", vp->name);
855			    if (vp->flag&ARRAY)
856				break;
857			} else {
858			    if (pflag)
859				shprintf("%s ",
860				    (flag & EXPORT) ?  "export" : "readonly");
861			    if ((vp->flag&ARRAY) && any_set)
862				shprintf("%s[%d]", vp->name, vp->index);
863			    else
864				shprintf("%s", vp->name);
865			    if (thing == '-' && (vp->flag&ISSET)) {
866				char *s = str_val(vp);
867
868				shprintf("=");
869				/* at&t ksh can't have justified integers.. */
870				if ((vp->flag & (INTEGER|LJUST|RJUST))
871								== INTEGER)
872				    shprintf("%s", s);
873				else
874				    print_value_quoted(s);
875			    }
876			    shprintf("%s", newline);
877			}
878			/* Only report first `element' of an array with
879			 * no set elements.
880			 */
881			if (!any_set)
882			    break;
883		    }
884		}
885	    }
886	}
887	return 0;
888}
889
890int
891c_alias(wp)
892	char **wp;
893{
894	struct table *t = &aliases;
895	int rv = 0, rflag = 0, tflag, Uflag = 0, pflag = 0;
896	int prefix = 0;
897	Tflag xflag = 0;
898	int optc;
899
900	builtin_opt.flags |= GF_PLUSOPT;
901	while ((optc = ksh_getopt(wp, &builtin_opt, "dprtUx")) != EOF) {
902		prefix = builtin_opt.info & GI_PLUS ? '+' : '-';
903		switch (optc) {
904		  case 'd':
905			t = &homedirs;
906			break;
907		  case 'p':
908			pflag = 1;
909			break;
910		  case 'r':
911			rflag = 1;
912			break;
913		  case 't':
914			t = &taliases;
915			break;
916		  case 'U': /* kludge for tracked alias initialization
917			     * (don't do a path search, just make an entry)
918			     */
919			Uflag = 1;
920			break;
921		  case 'x':
922			xflag = EXPORT;
923			break;
924		  case '?':
925			return 1;
926		}
927	}
928	wp += builtin_opt.optind;
929
930	if (!(builtin_opt.info & GI_MINUSMINUS) && *wp
931	    && (wp[0][0] == '-' || wp[0][0] == '+') && wp[0][1] == '\0')
932	{
933		prefix = wp[0][0];
934		wp++;
935	}
936
937	tflag = t == &taliases;
938
939	/* "hash -r" means reset all the tracked aliases.. */
940	if (rflag) {
941		static const char *const args[] = {
942			    "unalias", "-ta", (const char *) 0
943			};
944
945		if (!tflag || *wp) {
946			shprintf(
947	    "alias: -r flag can only be used with -t and without arguments\n");
948			return 1;
949		}
950		ksh_getopt_reset(&builtin_opt, GF_ERROR);
951		return c_unalias((char **)__UNCONST(args));
952	}
953
954
955	if (*wp == NULL) {
956		struct tbl *ap, **p;
957
958		for (p = tsort(t); (ap = *p++) != NULL; )
959			if ((ap->flag & (ISSET|xflag)) == (ISSET|xflag)) {
960				if (pflag)
961					shf_puts("alias ", shl_stdout);
962				shf_puts(ap->name, shl_stdout);
963				if (prefix != '+') {
964					shf_putc('=', shl_stdout);
965					print_value_quoted(ap->val.s);
966				}
967				shprintf("%s", newline);
968			}
969	}
970
971	for (; *wp != NULL; wp++) {
972		char *alias = *wp;
973		char *val = strchr(alias, '=');
974		char *newval;
975		struct tbl *ap;
976		int h;
977
978		if (val)
979			alias = str_nsave(alias, val++ - alias, ATEMP);
980		h = hash(alias);
981		if (val == NULL && !tflag && !xflag) {
982			ap = tsearch(t, alias, h);
983			if (ap != NULL && (ap->flag&ISSET)) {
984				if (pflag)
985					shf_puts("alias ", shl_stdout);
986				shf_puts(ap->name, shl_stdout);
987				if (prefix != '+') {
988					shf_putc('=', shl_stdout);
989					print_value_quoted(ap->val.s);
990				}
991				shprintf("%s", newline);
992			} else {
993				shprintf("%s alias not found\n", alias);
994				rv = 1;
995			}
996			continue;
997		}
998		ap = tenter(t, alias, h);
999		ap->type = tflag ? CTALIAS : CALIAS;
1000		/* Are we setting the value or just some flags? */
1001		if ((val && !tflag) || (!val && tflag && !Uflag)) {
1002			if (ap->flag&ALLOC) {
1003				ap->flag &= ~(ALLOC|ISSET);
1004				afree((void*)ap->val.s, APERM);
1005			}
1006			/* ignore values for -t (at&t ksh does this) */
1007			newval = tflag ? search(alias, path, X_OK, (int *) 0)
1008					: val;
1009			if (newval) {
1010				ap->val.s = str_save(newval, APERM);
1011				ap->flag |= ALLOC|ISSET;
1012			} else
1013				ap->flag &= ~ISSET;
1014		}
1015		ap->flag |= DEFINED;
1016		if (prefix == '+')
1017			ap->flag &= ~xflag;
1018		else
1019			ap->flag |= xflag;
1020		if (val)
1021			afree(alias, ATEMP);
1022	}
1023
1024	return rv;
1025}
1026
1027int
1028c_unalias(wp)
1029	char **wp;
1030{
1031	register struct table *t = &aliases;
1032	register struct tbl *ap;
1033	int rv = 0, all = 0;
1034	int optc;
1035
1036	while ((optc = ksh_getopt(wp, &builtin_opt, "adt")) != EOF)
1037		switch (optc) {
1038		  case 'a':
1039			all = 1;
1040			break;
1041		  case 'd':
1042			t = &homedirs;
1043			break;
1044		  case 't':
1045			t = &taliases;
1046			break;
1047		  case '?':
1048			return 1;
1049		}
1050	wp += builtin_opt.optind;
1051
1052	for (; *wp != NULL; wp++) {
1053		ap = tsearch(t, *wp, hash(*wp));
1054		if (ap == NULL) {
1055			rv = 1;	/* POSIX */
1056			continue;
1057		}
1058		if (ap->flag&ALLOC) {
1059			ap->flag &= ~(ALLOC|ISSET);
1060			afree((void*)ap->val.s, APERM);
1061		}
1062		ap->flag &= ~(DEFINED|ISSET|EXPORT);
1063	}
1064
1065	if (all) {
1066		struct tstate ts;
1067
1068		for (twalk(&ts, t); (ap = tnext(&ts)); ) {
1069			if (ap->flag&ALLOC) {
1070				ap->flag &= ~(ALLOC|ISSET);
1071				afree((void*)ap->val.s, APERM);
1072			}
1073			ap->flag &= ~(DEFINED|ISSET|EXPORT);
1074		}
1075	}
1076
1077	return rv;
1078}
1079
1080#ifdef KSH
1081int
1082c_let(wp)
1083	char **wp;
1084{
1085	int rv = 1;
1086	long val;
1087
1088	if (wp[1] == (char *) 0) /* at&t ksh does this */
1089		bi_errorf("no arguments");
1090	else
1091		for (wp++; *wp; wp++)
1092			if (!evaluate(*wp, &val, KSH_RETURN_ERROR)) {
1093				rv = 2;	/* distinguish error from zero result */
1094				break;
1095			} else
1096				rv = val == 0;
1097	return rv;
1098}
1099#endif /* KSH */
1100
1101int
1102c_jobs(wp)
1103	char **wp;
1104{
1105	int optc;
1106	int flag = 0;
1107	int nflag = 0;
1108	int rv = 0;
1109
1110	while ((optc = ksh_getopt(wp, &builtin_opt, "lpnz")) != EOF)
1111		switch (optc) {
1112		  case 'l':
1113			flag = 1;
1114			break;
1115		  case 'p':
1116			flag = 2;
1117			break;
1118		  case 'n':
1119			nflag = 1;
1120			break;
1121		  case 'z':	/* debugging: print zombies */
1122			nflag = -1;
1123			break;
1124		  case '?':
1125			return 1;
1126		}
1127	wp += builtin_opt.optind;
1128	if (!*wp) {
1129		if (j_jobs((char *) 0, flag, nflag))
1130			rv = 1;
1131	} else {
1132		for (; *wp; wp++)
1133			if (j_jobs(*wp, flag, nflag))
1134				rv = 1;
1135	}
1136	return rv;
1137}
1138
1139#ifdef JOBS
1140int
1141c_fgbg(wp)
1142	char **wp;
1143{
1144	int bg = strcmp(*wp, "bg") == 0;
1145	int UNINITIALIZED(rv);
1146
1147	if (!Flag(FMONITOR)) {
1148		bi_errorf("job control not enabled");
1149		return 1;
1150	}
1151	if (ksh_getopt(wp, &builtin_opt, null) == '?')
1152		return 1;
1153	wp += builtin_opt.optind;
1154	if (*wp)
1155		for (; *wp; wp++)
1156			rv = j_resume(*wp, bg);
1157	else
1158		rv = j_resume("%%", bg);
1159	/* POSIX says fg shall return 0 (unless an error occurs).
1160	 * at&t ksh returns the exit value of the job...
1161	 */
1162	return (bg || Flag(FPOSIX)) ? 0 : rv;
1163}
1164#endif
1165
1166struct kill_info {
1167	int num_width;
1168	int name_width;
1169};
1170static char *kill_fmt_entry ARGS((void *arg, int i, char *buf, int buflen));
1171
1172/* format a single kill item */
1173static char *
1174kill_fmt_entry(arg, i, buf, buflen)
1175	void *arg;
1176	int i;
1177	char *buf;
1178	int buflen;
1179{
1180	struct kill_info *ki = (struct kill_info *) arg;
1181
1182	i++;
1183	if (sigtraps[i].name)
1184		shf_snprintf(buf, buflen, "%*d %*s %s",
1185			ki->num_width, i,
1186			ki->name_width, sigtraps[i].name,
1187			sigtraps[i].mess);
1188	else
1189		shf_snprintf(buf, buflen, "%*d %*d %s",
1190			ki->num_width, i,
1191			ki->name_width, sigtraps[i].signal,
1192			sigtraps[i].mess);
1193	return buf;
1194}
1195
1196
1197int
1198c_kill(wp)
1199	char **wp;
1200{
1201	Trap *t = (Trap *) 0;
1202	char *p;
1203	int lflag = 0;
1204	int i, n, rv, sig;
1205
1206	/* assume old style options if -digits or -UPPERCASE */
1207	if ((p = wp[1]) && *p == '-'
1208	    && (digit(p[1]) || isupper((unsigned char)p[1]))) {
1209		if (!(t = gettrap(p + 1, TRUE))) {
1210			bi_errorf("bad signal `%s'", p + 1);
1211			return 1;
1212		}
1213		i = (wp[2] && strcmp(wp[2], "--") == 0) ? 3 : 2;
1214	} else {
1215		int optc;
1216
1217		while ((optc = ksh_getopt(wp, &builtin_opt, "ls:")) != EOF)
1218			switch (optc) {
1219			  case 'l':
1220				lflag = 1;
1221				break;
1222			  case 's':
1223				if (!(t = gettrap(builtin_opt.optarg, TRUE))) {
1224					bi_errorf("bad signal `%s'",
1225						builtin_opt.optarg);
1226					return 1;
1227				}
1228				break;
1229			  case '?':
1230				return 1;
1231			}
1232		i = builtin_opt.optind;
1233	}
1234	if ((lflag && t) || (!wp[i] && !lflag)) {
1235		shf_fprintf(shl_out,
1236"usage: kill [ -s signame | -signum | -signame ] {pid|job}...\n\
1237       kill -l [exit_status]\n"
1238			);
1239		bi_errorf("%s", null);
1240		return 1;
1241	}
1242
1243	if (lflag) {
1244		if (wp[i]) {
1245			for (; wp[i]; i++) {
1246				if (!bi_getn(wp[i], &n))
1247					return 1;
1248				if (n > 128 && n < 128 + SIGNALS)
1249					n -= 128;
1250				if (n > 0 && n < SIGNALS && sigtraps[n].name)
1251					shprintf("%s\n", sigtraps[n].name);
1252				else
1253					shprintf("%d\n", n);
1254			}
1255		} else if (Flag(FPOSIX)) {
1256			p = null;
1257			for (i = 1; i < SIGNALS; i++, p = space)
1258				if (sigtraps[i].name)
1259					shprintf("%s%s", p, sigtraps[i].name);
1260			shprintf("%s", newline);
1261		} else {
1262			int w, si;
1263			int mess_width;
1264			struct kill_info ki;
1265
1266			for (si = SIGNALS, ki.num_width = 1; si >= 10; si /= 10)
1267				ki.num_width++;
1268			ki.name_width = mess_width = 0;
1269			for (si = 0; si < SIGNALS; si++) {
1270				w = sigtraps[si].name ?
1271				    (int)strlen(sigtraps[si].name) :
1272				    ki.num_width;
1273				if (w > ki.name_width)
1274					ki.name_width = w;
1275				w = strlen(sigtraps[si].mess);
1276				if (w > mess_width)
1277					mess_width = w;
1278			}
1279
1280			print_columns(shl_stdout, SIGNALS - 1,
1281				kill_fmt_entry, (void *) &ki,
1282				ki.num_width + ki.name_width + mess_width + 3, 1);
1283		}
1284		return 0;
1285	}
1286	rv = 0;
1287	sig = t ? t->signal : SIGTERM;
1288	for (; (p = wp[i]); i++) {
1289		if (*p == '%') {
1290			if (j_kill(p, sig))
1291				rv = 1;
1292		} else if (!getn(p, &n)) {
1293			bi_errorf("%s: arguments must be jobs or process IDs",
1294				p);
1295			rv = 1;
1296		} else {
1297			/* use killpg if < -1 since -1 does special things for
1298			 * some non-killpg-endowed kills
1299			 */
1300			if ((n < -1 ? killpg(-n, sig) : kill(n, sig)) < 0) {
1301				bi_errorf("%s: %s", p, strerror(errno));
1302				rv = 1;
1303			}
1304		}
1305	}
1306	return rv;
1307}
1308
1309void
1310getopts_reset(val)
1311	int val;
1312{
1313	if (val >= 1) {
1314		ksh_getopt_reset(&user_opt,
1315			GF_NONAME | (Flag(FPOSIX) ? 0 : GF_PLUSOPT));
1316		user_opt.optind = user_opt.uoptind = val;
1317	}
1318}
1319
1320int
1321c_getopts(wp)
1322	char **wp;
1323{
1324	int	argc;
1325	const char *options;
1326	const char *var;
1327	int	optc;
1328	int	ret;
1329	char	buf[3];
1330	struct tbl *vq, *voptarg;
1331
1332	if (ksh_getopt(wp, &builtin_opt, null) == '?')
1333		return 1;
1334	wp += builtin_opt.optind;
1335
1336	options = *wp++;
1337	if (!options) {
1338		bi_errorf("missing options argument");
1339		return 1;
1340	}
1341
1342	var = *wp++;
1343	if (!var) {
1344		bi_errorf("missing name argument");
1345		return 1;
1346	}
1347	if (!*var || *skip_varname(var, TRUE)) {
1348		bi_errorf("%s: is not an identifier", var);
1349		return 1;
1350	}
1351
1352	if (e->loc->next == (struct block *) 0) {
1353		internal_errorf(0, "c_getopts: no argv");
1354		return 1;
1355	}
1356	/* Which arguments are we parsing... */
1357	if (*wp == (char *) 0)
1358		wp = e->loc->next->argv;
1359	else
1360		*--wp = e->loc->next->argv[0];
1361
1362	/* Check that our saved state won't cause a core dump... */
1363	for (argc = 0; wp[argc]; argc++)
1364		;
1365	if (user_opt.optind > argc
1366	    || (user_opt.p != 0
1367		&& user_opt.p > strlen(wp[user_opt.optind - 1])))
1368	{
1369	      bi_errorf("arguments changed since last call");
1370	      return 1;
1371	}
1372
1373	user_opt.optarg = (char *) 0;
1374	optc = ksh_getopt(wp, &user_opt, options);
1375
1376	if (optc >= 0 && optc != '?' && (user_opt.info & GI_PLUS)) {
1377		buf[0] = '+';
1378		buf[1] = optc;
1379		buf[2] = '\0';
1380	} else {
1381		/* POSIX says var is set to ? at end-of-options, at&t ksh
1382		 * sets it to null - we go with POSIX...
1383		 */
1384		buf[0] = optc < 0 ? '?' : optc;
1385		buf[1] = '\0';
1386	}
1387
1388	/* at&t ksh does not change OPTIND if it was an unknown option.
1389	 * Scripts counting on this are prone to break... (ie, don't count
1390	 * on this staying).
1391	 */
1392	if (optc != '?') {
1393		user_opt.uoptind = user_opt.optind;
1394	}
1395
1396	voptarg = global("OPTARG");
1397	voptarg->flag &= ~RDONLY;	/* at&t ksh clears ro and int */
1398	/* Paranoia: ensure no bizarre results. */
1399	if (voptarg->flag & INTEGER)
1400	    typeset("OPTARG", 0, INTEGER, 0, 0);
1401	if (user_opt.optarg == (char *) 0)
1402		unset(voptarg, 0);
1403	else
1404		/* This can't fail (have cleared readonly/integer) */
1405		setstr(voptarg, user_opt.optarg, KSH_RETURN_ERROR);
1406
1407	ret = 0;
1408
1409	vq = global(var);
1410	/* Error message already printed (integer, readonly) */
1411	if (!setstr(vq, buf, KSH_RETURN_ERROR))
1412	    ret = 1;
1413	if (Flag(FEXPORT))
1414		typeset(var, EXPORT, 0, 0, 0);
1415
1416	return optc < 0 ? 1 : ret;
1417}
1418
1419#ifdef EMACS
1420int
1421c_bind(wp)
1422	char **wp;
1423{
1424	int rv = 0, macro = 0, list = 0;
1425	register char *cp;
1426	int optc;
1427
1428	while ((optc = ksh_getopt(wp, &builtin_opt, "lm")) != EOF)
1429		switch (optc) {
1430		  case 'l':
1431			list = 1;
1432			break;
1433		  case 'm':
1434			macro = 1;
1435			break;
1436		  case '?':
1437			return 1;
1438		}
1439	wp += builtin_opt.optind;
1440
1441	if (*wp == NULL)	/* list all */
1442		rv = x_bind(NULL, NULL, 0, list);
1443
1444	for (; *wp != NULL; wp++) {
1445		cp = strchr(*wp, '=');
1446		if (cp != NULL)
1447			*cp++ = '\0';
1448		if (x_bind(*wp, cp, macro, 0))
1449			rv = 1;
1450	}
1451
1452	return rv;
1453}
1454#endif
1455
1456/* A leading = means assignments before command are kept;
1457 * a leading * means a POSIX special builtin;
1458 * a leading + means a POSIX regular builtin
1459 * (* and + should not be combined).
1460 */
1461const struct builtin kshbuiltins [] = {
1462	{"+alias", c_alias},	/* no =: at&t manual wrong */
1463	{"+cd", c_cd},
1464	{"+command", c_command},
1465	{"echo", c_print},
1466 	{"*=export", c_typeset},
1467#ifdef HISTORY
1468	{"+fc", c_fc},
1469#endif /* HISTORY */
1470	{"+getopts", c_getopts},
1471	{"+jobs", c_jobs},
1472	{"+kill", c_kill},
1473#ifdef KSH
1474	{"let", c_let},
1475#endif /* KSH */
1476	{"print", c_print},
1477	{"pwd", c_pwd},
1478 	{"*=readonly", c_typeset},
1479	{"=typeset", c_typeset},
1480	{"+unalias", c_unalias},
1481	{"whence", c_whence},
1482#ifdef JOBS
1483	{"+bg", c_fgbg},
1484	{"+fg", c_fgbg},
1485#endif
1486#ifdef EMACS
1487	{"bind", c_bind},
1488#endif
1489	{NULL, NULL}
1490};
1491