Attachment #8043 for bug #15319

View | Details | Raw Unified | Return to bug 15319
Collapse All | Expand All

Lines 60-67 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/alias.c (-93 / +73 lines)
60	struct alias *atab[ATABSIZE];	60	struct alias *atab[ATABSIZE];
61		61
62	STATIC void setalias __P((char , char ));	62	STATIC void setalias __P((char , char ));
63	STATIC int unalias __P((char *));	63	STATIC struct alias *hashalias __P((const char ));
64	STATIC struct alias *hashalias __P((char ));	64	STATIC struct alias freealias __P((struct alias ));
		65	STATIC struct alias *__lookupalias __P((const char ));
65		66
66	STATIC	67	STATIC
67	void	68	void
Lines 70-179 Link Here
70	{	71	{
71	struct alias ap, *app;	72	struct alias ap, *app;
72		73
73	app = hashalias(name);	74	app = __lookupalias(name);
74	for (ap = *app; ap; ap = ap->next) {	75	ap = *app;
75	if (equal(name, ap->name)) {
76	INTOFF;	76	INTOFF;
		77	if (ap) {
		78	if (!(ap->flag & ALIASINUSE)) {
77	ckfree(ap->val);	79	ckfree(ap->val);
78	ap->val = savestr(val);
79	INTON;
80	return;
81	}
82	}	80	}
		81	ap->val = savestr(val);
		82	ap->flag &= ~ALIASDEAD;
		83	} else {
83	/* not found */	84	/* not found */
84	INTOFF;
85	ap = ckmalloc(sizeof (struct alias));	85	ap = ckmalloc(sizeof (struct alias));
86	ap->name = savestr(name);	86	ap->name = savestr(name);
87	/*
88	* XXX - HACK: in order that the parser will not finish reading the
89	* alias value off the input before processing the next alias, we
90	* dummy up an extra space at the end of the alias. This is a crock
91	* and should be re-thought. The idea (if you feel inclined to help)
92	* is to avoid alias recursions. The mechanism used is: when
93	* expanding an alias, the value of the alias is pushed back on the
94	* input as a string and a pointer to the alias is stored with the
95	* string. The alias is marked as being in use. When the input
96	* routine finishes reading the string, it markes the alias not
97	* in use. The problem is synchronization with the parser. Since
98	* it reads ahead, the alias is marked not in use before the
99	* resulting token(s) is next checked for further alias sub. The
100	* H A C K is that we add a little fluff after the alias value
101	* so that the string will not be exhausted. This is a good
102	* idea ------- *NOT*
103	*/
104	#ifdef notyet
105	ap->val = savestr(val);	87	ap->val = savestr(val);
106	#else /* hack */	88	ap->flag = 0;
107	{	89	ap->next = 0;
108	int len = strlen(val);
109	ap->val = ckmalloc(len + 2);
110	memcpy(ap->val, val, len);
111	ap->val[len] = ' '; /* fluff */
112	ap->val[len+1] = '\0';
113	}
114	#endif
115	ap->next = *app;
116	*app = ap;	90	*app = ap;
		91	}
117	INTON;	92	INTON;
118	}	93	}
119		94
120	STATIC int	95	int
121	unalias(name)	96	unalias(name)
122	char *name;	97	char *name;
123	{	98	{
124	struct alias ap, *app;	99	struct alias **app;
125		100
126	app = hashalias(name);	101	app = __lookupalias(name);
127		102
128	for (ap = *app; ap; app = &(ap->next), ap = ap->next) {	103	if (*app) {
129	if (equal(name, ap->name)) {
130	/*
131	* if the alias is currently in use (i.e. its
132	* buffer is being used by the input routine) we
133	* just null out the name instead of freeing it.
134	* We could clear it out later, but this situation
135	* is so rare that it hardly seems worth it.
136	*/
137	if (ap->flag & ALIASINUSE)
138	*ap->name = '\0';
139	else {
140	INTOFF;	104	INTOFF;
141	*app = ap->next;	105	app = freealias(app);
142	ckfree(ap->name);
143	ckfree(ap->val);
144	ckfree(ap);
145	INTON;	106	INTON;
146	}
147	return (0);	107	return (0);
148	}	108	}
149	}
150		109
151	return (1);	110	return (1);
152	}	111	}
153		112
154	#ifdef mkinit
155	MKINIT void rmaliases __P((void));
156
157	SHELLPROC {
158	rmaliases();
159	}
160	#endif
161
162	void	113	void
163	rmaliases() {	114	rmaliases() {
164	struct alias ap, tmp;	115	struct alias ap, *app;
165	int i;	116	int i;
166		117
167	INTOFF;	118	INTOFF;
168	for (i = 0; i < ATABSIZE; i++) {	119	for (i = 0; i < ATABSIZE; i++) {
169	ap = atab[i];	120	app = &atab[i];
170	atab[i] = NULL;	121	for (ap = app; ap; ap = app) {
171	while (ap) {	122	app = freealias(app);
172	ckfree(ap->name);	123	if (ap == *app) {
173	ckfree(ap->val);	124	app = &ap->next;
174	tmp = ap;	125	}
175	ap = ap->next;
176	ckfree(tmp);
177	}	126	}
178	}	127	}
179	INTON;	128	INTON;
Lines 181-200 Link Here
181		130
182	struct alias *	131	struct alias *
183	lookupalias(name, check)	132	lookupalias(name, check)
184	char *name;	133	const char *name;
185	int check;	134	int check;
186	{	135	{
187	struct alias ap = hashalias(name);	136	struct alias ap = __lookupalias(name);
188		137
189	for (; ap; ap = ap->next) {	138	if (check && ap && (ap->flag & ALIASINUSE))
190	if (equal(name, ap->name)) {
191	if (check && (ap->flag & ALIASINUSE))
192	return (NULL);	139	return (NULL);
193	return (ap);	140	return (ap);
194	}
195	}
196
197	return (NULL);
198	}	141	}
199		142
200	/*	143	/*
Lines 214-231 Link Here
214		157
215	for (i = 0; i < ATABSIZE; i++)	158	for (i = 0; i < ATABSIZE; i++)
216	for (ap = atab[i]; ap; ap = ap->next) {	159	for (ap = atab[i]; ap; ap = ap->next) {
217	if (*ap->name != '\0')	160	printalias(ap);
218	out1fmt("alias %s=%s\n", ap->name, ap->val);
219	}	161	}
220	return (0);	162	return (0);
221	}	163	}
222	while ((n = *++argv) != NULL) {	164	while ((n = *++argv) != NULL) {
223	if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */	165	if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
224	if ((ap = lookupalias(n, 0)) == NULL) {	166	if ((ap = *__lookupalias(n)) == NULL) {
225	outfmt(out2, "alias: %s not found\n", n);	167	outfmt(out2, "%s: %s not found\n", "alias", n);
226	ret = 1;	168	ret = 1;
227	} else	169	} else
228	out1fmt("alias %s=%s\n", n, ap->val);	170	printalias(ap);
229	}	171	}
230	else {	172	else {
231	*v++ = '\0';	173	*v++ = '\0';
Lines 249-263 Link Here
249	return (0);	191	return (0);
250	}	192	}
251	}	193	}
252	for (i = 0; *argptr; argptr++)	194	for (i = 0; *argptr; argptr++) {
253	i = unalias(*argptr);	195	if (unalias(*argptr)) {
		196	outfmt(out2, "%s: %s not found\n", "unalias", *argptr);
		197	i = 1;
		198	}
		199	}
254		200
255	return (i);	201	return (i);
256	}	202	}
257		203
258	STATIC struct alias **	204	STATIC struct alias **
259	hashalias(p)	205	hashalias(p)
260	char *p;	206	const char *p;
261	{	207	{
262	unsigned int hashval;	208	unsigned int hashval;
263		209
Lines 266-268 Link Here
266	hashval+= *p++;	212	hashval+= *p++;
267	return &atab[hashval % ATABSIZE];	213	return &atab[hashval % ATABSIZE];
268	}	214	}
		215
		216	STATIC struct alias *
		217	freealias(struct alias *ap) {
		218	struct alias *next;
		219
		220	if (ap->flag & ALIASINUSE) {
		221	ap->flag \|= ALIASDEAD;
		222	return ap;
		223	}
		224
		225	next = ap->next;
		226	ckfree(ap->name);
		227	ckfree(ap->val);
		228	ckfree(ap);
		229	return next;
		230	}
		231
		232	void
		233	printalias(const struct alias *ap) {
		234	out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
		235	}
		236
		237	STATIC struct alias **
		238	__lookupalias(const char *name) {
		239	struct alias **app = hashalias(name);
		240
		241	for (; app; app = &(app)->next) {
		242	if (equal(name, (*app)->name)) {
		243	break;
		244	}
		245	}
		246
		247	return app;
		248	}

Lines 39-44 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/alias.h (-1 / +4 lines)
39	*/	39	*/
40		40
41	#define ALIASINUSE 1	41	#define ALIASINUSE 1
		42	#define ALIASDEAD 2
42		43
43	struct alias {	44	struct alias {
44	struct alias *next;	45	struct alias *next;
Lines 47-53 Link Here
47	int flag;	48	int flag;
48	};	49	};
49		50
50	struct alias lookupalias __P((char , int));	51	struct alias lookupalias __P((const char , int));
51	int aliascmd __P((int, char **));	52	int aliascmd __P((int, char **));
52	int unaliascmd __P((int, char **));	53	int unaliascmd __P((int, char **));
53	void rmaliases __P((void));	54	void rmaliases __P((void));
		55	int unalias __P((char *));
		56	void printalias __P((const struct alias *));

Lines 52-58 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/arith_lex.l (-2 / +2 lines)
52	#include "expand.h"	52	#include "expand.h"
53		53
54	extern int yylval;	54	extern int yylval;
55	extern char arith_buf, arith_startbuf;	55	extern const char arith_buf, arith_startbuf;
56	#undef YY_INPUT	56	#undef YY_INPUT
57	#define YY_INPUT(buf,result,max) \	57	#define YY_INPUT(buf,result,max) \
58	result = (buf = arith_buf++) ? 1 : YY_NULL;	58	result = (buf = arith_buf++) ? 1 : YY_NULL;
Lines 84-90 Link Here
84	"-" { return(ARITH_SUB); }	84	"-" { return(ARITH_SUB); }
85	"~" { return(ARITH_BNOT); }	85	"~" { return(ARITH_BNOT); }
86	"!" { return(ARITH_NOT); }	86	"!" { return(ARITH_NOT); }
87	. { error("arith: syntax error: \"%s\"\n", arith_startbuf); }	87	. { error("arith: syntax error: \"%s\"", arith_startbuf); }
88	%%	88	%%
89		89
90	void	90	void





const char *arith_buf, *arith_startbuf;

int yyparse __P((void));
void yyerror __P((const char *));
#ifdef TESTARITH
int main __P((int , char *[]));



expr:	ARITH_LPAREN expr ARITH_RPAREN = { $$ = $2; }
	| expr ARITH_OR expr	= { $$ = $1 || $3; }
	| expr ARITH_AND expr	= { $$ = $1 && $3; }
	| expr ARITH_BOR expr	= { $$ = $1 | $3; }
	| expr ARITH_BXOR expr	= { $$ = $1 ^ $3; }
	| expr ARITH_BAND expr	= { $$ = $1 & $3; }

			p = grabstackstr(concat);
		}
	} else
		p = nullstr;

	i = arith(p);





/*	$Id: arith_yylex.c,v 1.3 2002/10/26 11:37:45 herbert Exp $	*/

/*-
 * Copyright (c) 2002
 *	Herbert Xu.
 * Copyright (c) 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Kenneth Almquist.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <stdlib.h>
#include "arith.h"
#include "expand.h"
#include "error.h"

extern int yylval;
extern const char *arith_buf, *arith_startbuf;

int
yylex()
{
	int value;
	const char *buf = arith_buf;

	for (;;) {
		switch (*buf) {
		case ' ':
		case '\t':
		case '\n':
			buf++;
			continue;
		default:
err:
			error("arith: syntax error: \"%s\"", arith_startbuf);
			/* NOTREACHED */
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			yylval = strtol(buf, (char **) &arith_buf, 0);
			return ARITH_NUM;
		case '=':
			if (*++buf != '=') {
				goto err;
			}
			value = ARITH_EQ;
			break;
		case '>':
			switch (*++buf) {
			case '=':
				value = ARITH_GE;
				break;
			case '>':
				value = ARITH_RSHIFT;
				break;
			default:
				value = ARITH_GT;
				goto out;
			}
			break;
		case '<':
			switch (*++buf) {
			case '=':
				value = ARITH_LE;
				break;
			case '<':
				value = ARITH_LSHIFT;
				break;
			default:
				value = ARITH_LT;
				goto out;
			}
			break;
		case '|':
			if (*++buf != '|') {
				value = ARITH_BOR;
				goto out;
			}
			value = ARITH_OR;
			break;
		case '&':
			if (*++buf != '&') {
				value = ARITH_BAND;
				goto out;
			}
			value = ARITH_AND;
			break;
		case '!':
			if (*++buf != '=') {
				value = ARITH_NOT;
				goto out;
			}
			value = ARITH_NE;
			break;
		case 0:
			value = 0;
			goto out;
		case '(':
			value = ARITH_LPAREN;
			break;
		case ')':
			value = ARITH_RPAREN;
			break;
		case '*':
			value = ARITH_MUL;
			break;
		case '/':
			value = ARITH_DIV;
			break;
		case '%':
			value = ARITH_REM;
			break;
		case '+':
			value = ARITH_ADD;
			break;
		case '-':
			value = ARITH_SUB;
			break;
		case '~':
			value = ARITH_BNOT;
			break;
		}
		break;
	}

	buf++;
out:
	arith_buf = buf;
	return value;
}

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/assignbltins.def (+4 lines)
	1	alias
	2	export
	3	local
	4	readonly

Lines 47-53 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/bltin/bltin.h (-7 / +5 lines)
47	#include "../shell.h"	47	#include "../shell.h"
48	#include "../mystring.h"	48	#include "../mystring.h"
49	#ifdef SHELL	49	#ifdef SHELL
		50	#include "../error.h"
		51	#include "../memalloc.h"
50	#include "../output.h"	52	#include "../output.h"
		53	#ifndef USE_GLIBC_STDIO
51	#define stdout out1	54	#define stdout out1
52	#define stderr out2	55	#define stderr out2
53	#define printf out1fmt	56	#define printf out1fmt
Lines 56-67 Link Here
56	#define fprintf outfmt	59	#define fprintf outfmt
57	#define fputs outstr	60	#define fputs outstr
58	#define fflush flushout	61	#define fflush flushout
		62	#define ferror outerr
		63	#endif
59	#define INITARGS(argv)	64	#define INITARGS(argv)
60	#define warnx(a, b, c) { \
61	char buf[64]; \
62	(void)snprintf(buf, sizeof(buf), a, b, c); \
63	error("%s", buf); \
64	}
65		65
66	#else	66	#else
67	#undef NULL	67	#undef NULL
Lines 70-77 Link Here
70	#define INITARGS(argv) if ((commandname = argv[0]) == NULL) {fputs("Argc is zero\n", stderr); exit(2);} else	70	#define INITARGS(argv) if ((commandname = argv[0]) == NULL) {fputs("Argc is zero\n", stderr); exit(2);} else
71	#endif	71	#endif
72		72
73	pointer stalloc __P((int));
74	void error __P((char *, ...));
75	int echocmd __P((int, char **));	73	int echocmd __P((int, char **));
76		74
77		75





#define main echocmd

#ifdef USE_GLIBC_STDIO
#include <stdio.h>

#include "../mystring.h"
#else
#include "bltin.h"
#endif

int print_escape_str(const char *);

int
main(int argc, char **argv) {
	register char **ap;
	register char *p;
	register char c;
	int count;
	int nflag = 0;
	int c = ' ';
	int eflag = 0;
#endif

	argv++;
	if (*argv && equal(*argv, "-n")) {
		argv++;
		nflag = 1;
		if (equal(p, "-n")) {
			nflag++;
			ap++;
		} else if (equal(p, "-e")) {
#ifndef eflag
			eflag++;
#endif
			ap++;
		}

	if (!*argv) {
		goto end;
	}

	do {
		if (print_escape_str(*argv)) {
				switch (*p++) {
				case 'b':  c = '\b';  break;
				case 'c':  return 0;		/* exit */
				case 'f':  c = '\f';  break;
				case 'n':  c = '\n';  break;
				case 'r':  c = '\r';  break;
				case 't':  c = '\t';  break;
				case 'v':  c = '\v';  break;
				case '\\':  break;		/* c = '\\' */
				case '0':
					c = 0;
					count = 3;
					while (--count >= 0 && (unsigned)(*p - '0') < 8)
						c = (c << 3) + (*p++ - '0');
					break;
		}
		if (!*++argv) {
end:
			if (nflag) {
					break;
				}
			c = '\n';
			}
			putchar(c);
	} while (c == ' ');
#ifdef SHELL
			putchar(' ');
	}
	if (! nflag)
		putchar('\n');
	return 0;
#else
	fflush(stdout);
	return ferror(stdout);
#endif
}




.\"	$NetBSD: printf.1,v 1.15 2002/02/08 01:36:31 ross Exp $
.\"
.\" Copyright (c) 1989, 1990, 1993
.\"	The Regents of the University of California.  All rights reserved.
.\"
.\" This code is derived from software contributed to Berkeley by
.\" the Institute of Electrical and Electronics Engineers, Inc.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\" 3. All advertising materials mentioning features or use of this software
.\"    must display the following acknowledgement:
.\"	This product includes software developed by the University of
.\"	California, Berkeley and its contributors.
.\" 4. Neither the name of the University nor the names of its contributors
.\"    may be used to endorse or promote products derived from this software
.\"    without specific prior written permission.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.\"	from: @(#)printf.1	8.1 (Berkeley) 6/6/93
.\"
.Dd November 5, 1993
.Dt PRINTF 1
.Os
.Sh NAME
.Nm printf
.Nd formatted output
.Sh SYNOPSIS
.Nm
.Ar format
.Op Ar arguments  ...
.Sh DESCRIPTION
.Nm
formats and prints its arguments, after the first, under control
of the
.Ar format  .
The
.Ar format
is a character string which contains three types of objects: plain characters,
which are simply copied to standard output, character escape sequences which
are converted and copied to the standard output, and format specifications,
each of which causes printing of the next successive
.Ar argument  .
.Pp
The
.Ar arguments
after the first are treated as strings if the corresponding format is
either
.Cm b ,
.Cm c
or
.Cm s ;
otherwise it is evaluated as a C constant, with the following extensions:
.Pp
.Bl -bullet -offset indent -compact
.It
A leading plus or minus sign is allowed.
.It
If the leading character is a single or double quote, the value is the
.Tn ASCII
code of the next character.
.El
.Pp
The format string is reused as often as necessary to satisfy the
.Ar arguments  .
Any extra format specifications are evaluated with zero or the null
string.
.Pp
Character escape sequences are in backslash notation as defined in
.St -ansiC .
The characters and their meanings
are as follows:
.Bl -tag -width Ds -offset indent
.It Cm \ee
Write an \*[Lt]escape\*[Gt] character.
.It Cm \ea
Write a \*[Lt]bell\*[Gt] character.
.It Cm \eb
Write a \*[Lt]backspace\*[Gt] character.
.It Cm \ef
Write a \*[Lt]form-feed\*[Gt] character.
.It Cm \en
Write a \*[Lt]new-line\*[Gt] character.
.It Cm \er
Write a \*[Lt]carriage return\*[Gt] character.
.It Cm \et
Write a \*[Lt]tab\*[Gt] character.
.It Cm \ev
Write a \*[Lt]vertical tab\*[Gt] character.
.It Cm \e\'
Write a \*[Lt]single quote\*[Gt] character.
.It Cm \e\e
Write a backslash character.
.It Cm \e Ns Ar num
Write an 8-bit character whose
.Tn ASCII
value is the 1-, 2-, or 3-digit
octal number
.Ar num .
.El
.Pp
Each format specification is introduced by the percent character
(``%'').
The remainder of the format specification includes,
in the following order:
.Bl -tag -width Ds
.It "Zero or more of the following flags:"
.Bl -tag -width Ds
.It Cm #
A `#' character
specifying that the value should be printed in an ``alternative form''.
For
.Cm c  ,
.Cm d ,
and
.Cm s  ,
formats, this option has no effect.  For the
.Cm o
formats the precision of the number is increased to force the first
character of the output string to a zero.  For the
.Cm x
.Pq Cm X
format, a non-zero result has the string
.Li 0x
.Pq Li 0X
prepended to it.  For
.Cm e  ,
.Cm E ,
.Cm f  ,
.Cm g ,
and
.Cm G  ,
formats, the result will always contain a decimal point, even if no
digits follow the point (normally, a decimal point only appears in the
results of those formats if a digit follows the decimal point).  For
.Cm g
and
.Cm G
formats, trailing zeros are not removed from the result as they
would otherwise be;
.It Cm \&\-
A minus sign `\-' which specifies
.Em left adjustment
of the output in the indicated field;
.It Cm \&+
A `+' character specifying that there should always be
a sign placed before the number when using signed formats.
.It Sq \&\ \&
A space specifying that a blank should be left before a positive number
for a signed format.  A `+' overrides a space if both are used;
.It Cm \&0
A zero `0' character indicating that zero-padding should be used
rather than blank-padding.  A `\-' overrides a `0' if both are used;
.El
.It "Field Width:"
An optional digit string specifying a
.Em field width ;
if the output string has fewer characters than the field width it will
be blank-padded on the left (or right, if the left-adjustment indicator
has been given) to make up the field width (note that a leading zero
is a flag, but an embedded zero is part of a field width);
.It Precision :
An optional period,
.Sq Cm \&.\& ,
followed by an optional digit string giving a
.Em precision
which specifies the number of digits to appear after the decimal point,
for
.Cm e
and
.Cm f
formats, or the maximum number of characters to be printed
from a string; if the digit string is missing, the precision is treated
as zero;
.It Format :
A character which indicates the type of format to use (one of
.Cm diouxXfwEgGbcs ) .
.El
.Pp
A field width or precision may be
.Sq Cm \&*
instead of a digit string.
In this case an
.Ar argument
supplies the field width or precision.
.Pp
The format characters and their meanings are:
.Bl -tag -width Fl
.It Cm diouXx
The
.Ar argument
is printed as a signed decimal (d or i), unsigned octal, unsigned decimal,
or unsigned hexadecimal (X or x), respectively.
.It Cm f
The
.Ar argument
is printed in the style
.Sm off
.Pf [\-]ddd Cm \&. No ddd
.Sm on
where the number of d's
after the decimal point is equal to the precision specification for
the argument.
If the precision is missing, 6 digits are given; if the precision
is explicitly 0, no digits and no decimal point are printed.
.It Cm eE
The
.Ar argument
is printed in the style
.Sm off
.Pf [\-]d Cm \&. No ddd Cm e No \\*(Pmdd
.Sm on
where there
is one digit before the decimal point and the number after is equal to
the precision specification for the argument; when the precision is
missing, 6 digits are produced.
An upper-case E is used for an `E' format.
.It Cm gG
The
.Ar argument
is printed in style
.Cm f
or in style
.Cm e
.Pq Cm E
whichever gives full precision in minimum space.
.It Cm b
Characters from the string
.Ar argument
are printed with backslash-escape sequences expanded.
.It Cm c
The first character of
.Ar argument
is printed.
.It Cm s
Characters from the string
.Ar argument
are printed until the end is reached or until the number of characters
indicated by the precision specification is reached; however if the
precision is 0 or missing, all characters in the string are printed.
.It Cm \&%
Print a `%'; no argument is used.
.El
.Pp
In no case does a non-existent or small field width cause truncation of
a field; padding takes place only if the specified field width exceeds
the actual width.
.Sh EXIT STATUS
.Nm
exits 0 on success, 1 on failure.
.Sh SEE ALSO
.Xr echo 1 ,
.Xr printf 3 ,
.Xr printf 9
.Sh STANDARDS
The
.Nm
utility conforms to
.St -p1003.2-92 .
.Sh BUGS
Since the floating point numbers are translated from
.Tn ASCII
to floating-point and
then back again, floating-point precision may be lost.




/*	$NetBSD: printf.c,v 1.24 2002/06/14 11:32:15 tron Exp $	*/

/*
 * Copyright (c) 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
#if !defined(BUILTIN) && !defined(SHELL)
__COPYRIGHT("@(#) Copyright (c) 1989, 1993\n\
	The Regents of the University of California.  All rights reserved.\n");
#endif
#endif

#ifndef lint
#if 0
static char sccsid[] = "@(#)printf.c	8.2 (Berkeley) 3/22/95";
#else
__RCSID("$NetBSD: printf.c,v 1.24 2002/06/14 11:32:15 tron Exp $");
#endif
#endif /* not lint */

#include <sys/types.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <locale.h>
#include <stdarg.h>
#ifndef SHELL
#include <stdio.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int		 print_escape_str(const char *);
static size_t	 print_escape(const char *);

static int	 getchr(void);
static double	 getdouble(void);
static intmax_t	 getintmax(void);
static uintmax_t getuintmax __P ((void));
static char	*getstr(void);
static char	*mklong(const char *, int); 
static void      check_conversion(const char *, const char *);
static void	 usage(void); 
     
static int	rval;
static char  **gargv;

#ifdef BUILTIN
int progprintf(int, char **);
#else
int main(int, char **);
#endif

#define isodigit(c)	((c) >= '0' && (c) <= '7')
#define octtobin(c)	((c) - '0')
#define hextobin(c)	((c) >= 'A' && (c) <= 'F' ? c - 'A' + 10 : (c) >= 'a' && (c) <= 'f' ? c - 'a' + 10 : c - '0')

#ifdef SHELL
#define main printfcmd
#include "bltin.h"
#else
#define nullstr ""
#endif

#define PF(f, func) { \
	switch (param - array) { \
	case 0: \
		(void)printf(f, func); \
		break; \
	case 1: \
		(void)printf(f, array[0], func); \
		break; \
	default: \
		(void)printf(f, array[0], array[1], func); \
		break; \
	} \
}

int
#ifdef BUILTIN
progprintf(int argc, char **argv)
#else
main(int argc, char **argv)
#endif
{
	char *fmt;
	char *format;

#if !defined(SHELL) && !defined(BUILTIN)
	(void)setlocale (LC_ALL, "");
#endif

	if (--argc < 1) {
		usage();
		return (1);
	}

	format = *++argv;
	gargv = ++argv;

#define SKIP1	"#-+ 0"
#define SKIP2	"*0123456789"
	do {
		/*
		 * Basic algorithm is to scan the format string for conversion
		 * specifications -- once one is found, find out if the field
		 * width or precision is a '*'; if it is, gather up value. 
		 * Note, format strings are reused as necessary to use up the
		 * provided arguments, arguments of zero/null string are 
		 * provided to use up the format string.
		 */

		/* find next format specification */
		for (fmt = format; *fmt; fmt++) {
			switch (*fmt) {
			case '%': {
				char *start;
				char convch, nextch;
				int array[2];
				int *param;

				start = fmt++;

				if (*fmt == '%') {
					(void)putchar('%');
					break;
				} else if (*fmt == 'b') {
					char *p = getstr();
					if (print_escape_str(p)) {
						return (rval);
					}
					break;
				}

				param = array;

				/* skip to field width */
				fmt += strspn(fmt, SKIP1);
				if (*fmt == '*')
					*param++ = getintmax();

				/* skip to possible '.', get following precision */
				fmt += strspn(fmt, SKIP2);
				if (*fmt == '.')
					++fmt;
				if (*fmt == '*')
					*param++ = getintmax();

				fmt += strspn(fmt, SKIP2);
				if (!*fmt) {
					warnx ("missing format character");
					return(1);
				}

				convch = *fmt;
				nextch = *(fmt + 1);
				*(fmt + 1) = '\0';
				switch(convch) {
				case 'c': {
					char p = getchr();
					PF(start, p);
					break;
				}
				case 's': {
					char *p = getstr();
					PF(start, p);
					break;
				}
				case 'd':
				case 'i': {
					char *f = mklong(start, convch);
					intmax_t p = getintmax();
					PF(f, p);
					break;
				}
				case 'o':
				case 'u':
				case 'x':
				case 'X': {
					char *f = mklong(start, convch);
					uintmax_t p = getuintmax();
					PF(f, p);
					break;
				}
				case 'e':
				case 'E':
				case 'f':
				case 'g':
				case 'G': {
					double p = getdouble();
					PF(start, p);
					break;
				}
				default:
					warnx ("%s: invalid directive", start);
					return(1);
				}
				*(fmt + 1) = nextch;
				break;
			}

			case '\\':
				fmt += print_escape(fmt);
				break;

			default:
				(void)putchar(*fmt);
				break;
			}
		}
	} while (gargv > argv && *gargv);

#ifdef SHELL
	return (rval);
#else
	fflush(stdout);
	return (rval ? rval : ferror(stdout));
#endif
}


/*
 * Print SysV echo(1) style escape string 
 *	Halts processing string and returns 1 if a \c escape is encountered.
 */
int
print_escape_str(const char *str)
{
	char value;
	char c;

	for (; (value = *str); str++) {
		if (value == '\\') {
			c = *++str;
			/* 
			 * %b string octal constants are not like those in C.
			 * They start with a \0, and are followed by 0, 1, 2, 
			 * or 3 octal digits. 
			 */
			if (c == '0') {
				unsigned j;
				unsigned char i;
				i = 3;
				j = 0;
				do {
					unsigned k = octtobin(*++str);
					if (k > 7) {
						str--;
						break;
					}
					j <<= 3;
					j += k;
				} while (--i);
				value = j;
			} else if (c == 'c') {
				return 1;
			} else {
				str--;			
				str += print_escape(str);
				continue;
			}
		}
		putchar(value);
	}

	return 0;
}

/*
 * Print "standard" escape characters 
 */
static size_t
print_escape(const char *str)
{
	const char *start = str;
	int value;
	size_t c = 1;

	str++;

	switch (*str) {
	case '0': case '1': case '2': case '3':
	case '4': case '5': case '6': case '7':
		for (c = 4, value = 0; --c && isodigit(*str); str++) {
			value <<= 3;
			value += octtobin(*str);
		}
		c = str - start - 1;
		break;

#ifdef notrequired
	case 'x':
		str++;
		for (value = 0; isxdigit((unsigned char)*str); str++) {
			value <<= 4;
			value += hextobin(*str);
		}
		if (value > UCHAR_MAX) {
			warnx ("escape sequence out of range for character");
			rval = 1;
		}
		c = str - start - 1;
		break;
#endif

	case '\\':			/* backslash */
		value = '\\';
		break;

#ifdef notrequired
	case '\'':			/* single quote */
		value = '\'';
		break;

	case '"':			/* double quote */
		value = '"';
		break;
#endif

	case 'a':			/* alert */
		value = '\a';
		break;

	case 'b':			/* backspace */
		value = '\b';
		break;

#ifdef notrequired
	case 'e':			/* escape */
#ifdef __GNUC__
		value = '\e';
#else
		value = 033;
#endif
		break;
#endif

	case 'f':			/* form-feed */
		value = '\f';
		break;

	case 'n':			/* newline */
		value = '\n';
		break;

	case 'r':			/* carriage-return */
		value = '\r';
		break;

	case 't':			/* tab */
		value = '\t';
		break;

	case 'v':			/* vertical-tab */
		value = '\v';
		break;

	default:
#if 0
		value = *str;
		warnx("unknown escape sequence `\\%c'", *str);
		rval = 1;
#else
		value = '\\';
		c = 0;
#endif
		break;
	}

	putchar(value);
	return c;
}

static char *
mklong(const char *str, int ch)
{
	static char copy[64];
	size_t len;	

	len = strlen(str) + 2;
	(void)memmove(copy, str, len - 3);
	copy[len - 3] = 'j';
	copy[len - 2] = ch;
	copy[len - 1] = '\0';
	return (copy);	
}

static int
getchr(void)
{
	int val = 0;

	if (*gargv)
		val = **gargv++;
	return val;
}

static char *
getstr(void)
{
	char *val = nullstr;

	if (*gargv)
		val = *gargv++;
	return val;
}

static intmax_t
getintmax(void)
{
	intmax_t val = 0;
	char *ep;
	const char *arg = *gargv;

	if (!arg)
		goto out;

	gargv++;

	val = (unsigned char) arg[1];
	if (*arg == '\"' || *arg == '\'')
		goto out;

	errno = 0;
	val = strtoimax(arg, &ep, 0);
	check_conversion(arg, ep);
out:
	return val;
}

static uintmax_t
getuintmax(void)
{
	uintmax_t val = 0;
	char *ep;
	const char *arg = *gargv;

	if (!arg)
		goto out;

	gargv++;

	val = (unsigned char) arg[1];
	if (*arg == '\"' || *arg == '\'')
		goto out;

	errno = 0;
	val = strtoumax(arg, &ep, 0);
	check_conversion(arg, ep);
out:
	return val;
}

static double
getdouble(void)
{
	double val = 0;
	char *ep;
	const char *arg = *gargv;

	if (!arg)
		goto out;

	gargv++;

	if (*arg == '\"' || *arg == '\'') {
		val = (unsigned char) arg[1];
		goto out;
	}

	errno = 0;
	val = strtod(arg, &ep);
	check_conversion(arg, ep);
out:
	return val;
}

static void
check_conversion(const char *s, const char *ep)
{
	if (*ep) {
		if (ep == s)
			warnx ("%s: expected numeric value", s);
		else
			warnx ("%s: not completely converted", s);
		rval = 1;
	} else if (errno == ERANGE) {
		warnx ("%s: %s", s, strerror(ERANGE));
		rval = 1;
	}
}

static void
usage(void)
{
	(void)fprintf(stderr, "usage: printf format [arg ...]\n");
}




.\"	$NetBSD: test.1,v 1.17 2002/02/08 01:22:01 ross Exp $
.\"
.\" Copyright (c) 1991, 1993
.\"	The Regents of the University of California.  All rights reserved.
.\"
.\" This code is derived from software contributed to Berkeley by
.\" the Institute of Electrical and Electronics Engineers, Inc.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\" 3. All advertising materials mentioning features or use of this software
.\"    must display the following acknowledgement:
.\"	This product includes software developed by the University of
.\"	California, Berkeley and its contributors.
.\" 4. Neither the name of the University nor the names of its contributors
.\"    may be used to endorse or promote products derived from this software
.\"    without specific prior written permission.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.\"     @(#)test.1	8.1 (Berkeley) 5/31/93
.\"
.Dd May 31, 1993
.Dt TEST 1
.Os
.Sh NAME
.Nm test ,
.Nm \&[
.Nd condition evaluation utility
.Sh SYNOPSIS
.Nm test
.Ar expression
.Nm \&[
.Ar expression Cm ]
.Sh DESCRIPTION
The
.Nm test
utility evaluates the expression and, if it evaluates
to true, returns a zero (true) exit status; otherwise
it returns 1 (false).
If there is no expression, test also
returns 1 (false).
.Pp
All operators and flags are separate arguments to the
.Nm test
utility.
.Pp
The following primaries are used to construct expression:
.Bl -tag -width Ar
.It Fl b Ar file
True if
.Ar file
exists and is a block special
file.
.It Fl c Ar file
True if
.Ar file
exists and is a character
special file.
.It Fl d Ar file
True if
.Ar file
exists and is a directory.
.It Fl e Ar file
True if
.Ar file
exists (regardless of type).
.It Fl f Ar file
True if
.Ar file
exists and is a regular file.
.It Fl g Ar file
True if
.Ar file
exists and its set group ID flag
is set.
.It Fl h Ar file
True if
.Ar file
exists and is a symbolic link.
.It Fl k Ar file
True if
.Ar file
exists and its sticky bit is set.
.It Fl n Ar string
True if the length of
.Ar string
is nonzero.
.It Fl p Ar file
True if
.Ar file
is a named pipe
.Po Tn FIFO Pc .
.It Fl r Ar file
True if
.Ar file
exists and is readable.
.It Fl s Ar file
True if
.Ar file
exists and has a size greater
than zero.
.It Fl t Ar file_descriptor
True if the file whose file descriptor number
is
.Ar file_descriptor
is open and is associated with a terminal.
.It Fl u Ar file
True if
.Ar file
exists and its set user ID flag
is set.
.It Fl w Ar file
True if
.Ar file
exists and is writable.
True
indicates only that the write flag is on.
The file is not writable on a read-only file
system even if this test indicates true.
.It Fl x Ar file
True if
.Ar file
exists and is executable.
True
indicates only that the execute flag is on.
If
.Ar file
is a directory, true indicates that
.Ar file
can be searched.
.It Fl z Ar string
True if the length of
.Ar string
is zero.
.It Fl L Ar file
True if
.Ar file
exists and is a symbolic link.
This operator is retained for compatibility with previous versions of
this program. Do not rely on its existence; use
.Fl h
instead.
.It Fl O Ar file
True if
.Ar file
exists and its owner matches the effective user id of this process.
.It Fl G Ar file
True if
.Ar file
exists and its group matches the effective group id of this process.
.It Fl S Ar file
True if
.Ar file
exists and is a socket.
.It Ar file1 Fl nt Ar file2
True if
.Ar file1
exists and is newer than
.Ar file2 .
.It Ar file1 Fl ot Ar file2
True if
.Ar file1
exists and is older than
.Ar file2 .
.It Ar file1 Fl ef Ar file2
True if
.Ar file1
and
.Ar file2
exist and refer to the same file.
.It Ar string
True if
.Ar string
is not the null
string.
.It Ar \&s\&1 Cm \&= Ar \&s\&2
True if the strings
.Ar \&s\&1
and
.Ar \&s\&2
are identical.
.It Ar \&s\&1 Cm \&!= Ar \&s\&2
True if the strings
.Ar \&s\&1
and
.Ar \&s\&2
are not identical.
.It Ar \&s\&1 Cm \&\*[Lt] Ar \&s\&2
True if string
.Ar \&s\&1
comes before
.Ar \&s\&2
based on the ASCII value of their characters.
.It Ar \&s\&1 Cm \&\*[Gt] Ar \&s\&2
True if string
.Ar \&s\&1
comes after
.Ar \&s\&2
based on the ASCII value of their characters.
.It Ar \&n\&1 Fl \&eq Ar \&n\&2
True if the integers
.Ar \&n\&1
and
.Ar \&n\&2
are algebraically
equal.
.It Ar \&n\&1 Fl \&ne Ar \&n\&2
True if the integers
.Ar \&n\&1
and
.Ar \&n\&2
are not
algebraically equal.
.It Ar \&n\&1 Fl \&gt Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically
greater than the integer
.Ar \&n\&2 .
.It Ar \&n\&1 Fl \&ge Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically
greater than or equal to the integer
.Ar \&n\&2 .
.It Ar \&n\&1 Fl \&lt Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically less
than the integer
.Ar \&n\&2 .
.It Ar \&n\&1 Fl \&le Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically less
than or equal to the integer
.Ar \&n\&2 .
.El
.Pp
These primaries can be combined with the following operators:
.Bl -tag -width Ar
.It Cm \&! Ar expression
True if
.Ar expression
is false.
.It Ar expression1 Fl a Ar expression2
True if both
.Ar expression1
and
.Ar expression2
are true.
.It Ar expression1 Fl o Ar expression2
True if either
.Ar expression1
or
.Ar expression2
are true.
.It Cm \&( Ns Ar expression Ns Cm \&)
True if expression is true.
.El
.Pp
The
.Fl a
operator has higher precedence than the
.Fl o
operator.
.Sh GRAMMAR AMBIGUITY
The
.Nm test
grammar is inherently ambiguous.  In order to assure a degree of consistency,
the cases described in
.St -p1003.2
section 4.62.4,
are evaluated consistently according to the rules specified in the
standards document.  All other cases are subject to the ambiguity in the
command semantics.
.Sh EXIT STATUS
The
.Nm test
utility exits with one of the following values:
.Bl -tag -width Ds
.It 0
expression evaluated to true.
.It 1
expression evaluated to false or expression was
missing.
.It \*[Gt]1
An error occurred.
.El
.Sh STANDARDS
The
.Nm test
utility implements a superset of the
.St -p1003.2
specification.




/* $NetBSD: test.c,v 1.25 2002/05/25 23:12:16 wiz Exp $ */

/*
 * test(1); version 7-like  --  author Erik Baalbergen
 * modified by Eric Gisin to be used as built-in.
 * modified by Arnold Robbins to add SVR3 compatibility
 * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
 * modified by J.T. Conklin for NetBSD.
 *
 * This program is in the Public Domain.
 */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: test.c,v 1.25 2002/05/25 23:12:16 wiz Exp $");
#endif

#include <sys/stat.h>
#include <sys/types.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdarg.h>
#include "bltin.h"

/* test(1) accepts the following grammar:
	oexpr	::= aexpr | aexpr "-o" oexpr ;
	aexpr	::= nexpr | nexpr "-a" aexpr ;
	nexpr	::= primary | "!" primary
	primary	::= unary-operator operand
		| operand binary-operator operand
		| operand
		| "(" oexpr ")"
		;
	unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
		"-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";

	binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
			"-nt"|"-ot"|"-ef";
	operand ::= <any legal UNIX file name>
*/

enum token {
	EOI,
	FILRD,
	FILWR,
	FILEX,
	FILEXIST,
	FILREG,
	FILDIR,
	FILCDEV,
	FILBDEV,
	FILFIFO,
	FILSOCK,
	FILSYM,
	FILGZ,
	FILTT,
	FILSUID,
	FILSGID,
	FILSTCK,
	FILNT,
	FILOT,
	FILEQ,
	FILUID,
	FILGID,
	STREZ,
	STRNZ,
	STREQ,
	STRNE,
	STRLT,
	STRGT,
	INTEQ,
	INTNE,
	INTGE,
	INTGT,
	INTLE,
	INTLT,
	UNOT,
	BAND,
	BOR,
	LPAREN,
	RPAREN,
	OPERAND
};

enum token_types {
	UNOP,
	BINOP,
	BUNOP,
	BBINOP,
	PAREN
};

static struct t_op {
	const char *op_text;
	short op_num, op_type;
} const ops [] = {
	{"-r",	FILRD,	UNOP},
	{"-w",	FILWR,	UNOP},
	{"-x",	FILEX,	UNOP},
	{"-e",	FILEXIST,UNOP},
	{"-f",	FILREG,	UNOP},
	{"-d",	FILDIR,	UNOP},
	{"-c",	FILCDEV,UNOP},
	{"-b",	FILBDEV,UNOP},
	{"-p",	FILFIFO,UNOP},
	{"-u",	FILSUID,UNOP},
	{"-g",	FILSGID,UNOP},
	{"-k",	FILSTCK,UNOP},
	{"-s",	FILGZ,	UNOP},
	{"-t",	FILTT,	UNOP},
	{"-z",	STREZ,	UNOP},
	{"-n",	STRNZ,	UNOP},
	{"-h",	FILSYM,	UNOP},		/* for backwards compat */
	{"-O",	FILUID,	UNOP},
	{"-G",	FILGID,	UNOP},
	{"-L",	FILSYM,	UNOP},
	{"-S",	FILSOCK,UNOP},
	{"=",	STREQ,	BINOP},
	{"!=",	STRNE,	BINOP},
	{"<",	STRLT,	BINOP},
	{">",	STRGT,	BINOP},
	{"-eq",	INTEQ,	BINOP},
	{"-ne",	INTNE,	BINOP},
	{"-ge",	INTGE,	BINOP},
	{"-gt",	INTGT,	BINOP},
	{"-le",	INTLE,	BINOP},
	{"-lt",	INTLT,	BINOP},
	{"-nt",	FILNT,	BINOP},
	{"-ot",	FILOT,	BINOP},
	{"-ef",	FILEQ,	BINOP},
	{"!",	UNOT,	BUNOP},
	{"-a",	BAND,	BBINOP},
	{"-o",	BOR,	BBINOP},
	{"(",	LPAREN,	PAREN},
	{")",	RPAREN,	PAREN},
	{0,	0,	0}
};

static char **t_wp;
static struct t_op const *t_wp_op;

static void syntax(const char *, const char *);
static int oexpr(enum token);
static int aexpr(enum token);
static int nexpr(enum token);
static int primary(enum token);
static int binop(void);
static int filstat(char *, enum token);
static enum token t_lex(char *);
static int isoperand(void);
static int getn(const char *);
static int newerf(const char *, const char *);
static int olderf(const char *, const char *);
static int equalf(const char *, const char *);
static int test_eaccess(const char *, int);
static int bash_group_member(gid_t);

#ifndef SHELL
static void error(const char *, ...) __attribute__((__noreturn__));

static void
error(const char *msg, ...)
{
	va_list ap;

	va_start(ap, msg);
	verrx(2, msg, ap);
	/*NOTREACHED*/
	va_end(ap);
}
#endif

#ifdef SHELL
int testcmd(int, char **);

int
testcmd(int argc, char **argv)
#else
int main(int, char *[]);

int
main(int argc, char *argv[])
#endif
{
	int res;

#ifndef SHELL
	setprogname(argv[0]);
#endif
	if (strcmp(argv[0], "[") == 0) {
		if (strcmp(argv[--argc], "]"))
			error("missing ]");
		argv[argc] = NULL;
	}

	if (argc < 2)
		return 1;

	t_wp = &argv[1];
	res = !oexpr(t_lex(*t_wp));

	if (*t_wp != NULL && *++t_wp != NULL)
		syntax(*t_wp, "unexpected operator");

	return res;
}

static void
syntax(const char *op, const char *msg)
{
	if (op && *op)
		error("%s: %s", op, msg);
	else
		error("%s", msg);
}

static int
oexpr(enum token n)
{
	int res;

	res = aexpr(n);
	if (t_lex(*++t_wp) == BOR)
		return oexpr(t_lex(*++t_wp)) || res;
	t_wp--;
	return res;
}

static int
aexpr(enum token n)
{
	int res;

	res = nexpr(n);
	if (t_lex(*++t_wp) == BAND)
		return aexpr(t_lex(*++t_wp)) && res;
	t_wp--;
	return res;
}

static int
nexpr(enum token n)
{
	if (n == UNOT)
		return !nexpr(t_lex(*++t_wp));
	return primary(n);
}

static int
primary(enum token n)
{
	enum token nn;
	int res;

	if (n == EOI)
		return 0;		/* missing expression */
	if (n == LPAREN) {
		if ((nn = t_lex(*++t_wp)) == RPAREN)
			return 0;	/* missing expression */
		res = oexpr(nn);
		if (t_lex(*++t_wp) != RPAREN)
			syntax(NULL, "closing paren expected");
		return res;
	}
	if (t_wp_op && t_wp_op->op_type == UNOP) {
		/* unary expression */
		if (*++t_wp == NULL)
			syntax(t_wp_op->op_text, "argument expected");
		switch (n) {
		case STREZ:
			return strlen(*t_wp) == 0;
		case STRNZ:
			return strlen(*t_wp) != 0;
		case FILTT:
			return isatty(getn(*t_wp));
		default:
			return filstat(*t_wp, n);
		}
	}

	if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) {
		return binop();
	}	  

	return strlen(*t_wp) > 0;
}

static int
binop(void)
{
	const char *opnd1, *opnd2;
	struct t_op const *op;

	opnd1 = *t_wp;
	(void) t_lex(*++t_wp);
	op = t_wp_op;

	if ((opnd2 = *++t_wp) == (char *)0)
		syntax(op->op_text, "argument expected");
		
	switch (op->op_num) {
	case STREQ:
		return strcmp(opnd1, opnd2) == 0;
	case STRNE:
		return strcmp(opnd1, opnd2) != 0;
	case STRLT:
		return strcmp(opnd1, opnd2) < 0;
	case STRGT:
		return strcmp(opnd1, opnd2) > 0;
	case INTEQ:
		return getn(opnd1) == getn(opnd2);
	case INTNE:
		return getn(opnd1) != getn(opnd2);
	case INTGE:
		return getn(opnd1) >= getn(opnd2);
	case INTGT:
		return getn(opnd1) > getn(opnd2);
	case INTLE:
		return getn(opnd1) <= getn(opnd2);
	case INTLT:
		return getn(opnd1) < getn(opnd2);
	case FILNT:
		return newerf (opnd1, opnd2);
	case FILOT:
		return olderf (opnd1, opnd2);
	case FILEQ:
		return equalf (opnd1, opnd2);
	default:
		abort();
		/* NOTREACHED */
	}
}

static int
filstat(char *nm, enum token mode)
{
	struct stat64 s;

	if (mode == FILSYM ? lstat64(nm, &s) : stat64(nm, &s))
		return 0;

	switch (mode) {
	case FILRD:
		return test_eaccess(nm, R_OK) == 0;
	case FILWR:
		return test_eaccess(nm, W_OK) == 0;
	case FILEX:
		return test_eaccess(nm, X_OK) == 0;
	case FILEXIST:
		return 1;
	case FILREG:
		return S_ISREG(s.st_mode);
	case FILDIR:
		return S_ISDIR(s.st_mode);
	case FILCDEV:
		return S_ISCHR(s.st_mode);
	case FILBDEV:
		return S_ISBLK(s.st_mode);
	case FILFIFO:
		return S_ISFIFO(s.st_mode);
	case FILSOCK:
		return S_ISSOCK(s.st_mode);
	case FILSYM:
		return S_ISLNK(s.st_mode);
	case FILSUID:
		return (s.st_mode & S_ISUID) != 0;
	case FILSGID:
		return (s.st_mode & S_ISGID) != 0;
	case FILSTCK:
		return (s.st_mode & S_ISVTX) != 0;
	case FILGZ:
		return s.st_size > (off_t)0;
	case FILUID:
		return s.st_uid == geteuid();
	case FILGID:
		return s.st_gid == getegid();
	default:
		return 1;
	}
}

static enum token
t_lex(char *s)
{
	struct t_op const *op;

	op = ops;

	if (s == 0) {
		t_wp_op = (struct t_op *)0;
		return EOI;
	}
	while (op->op_text) {
		if (strcmp(s, op->op_text) == 0) {
			if ((op->op_type == UNOP && isoperand()) ||
			    (op->op_num == LPAREN && *(t_wp+1) == 0))
				break;
			t_wp_op = op;
			return op->op_num;
		}
		op++;
	}
	t_wp_op = (struct t_op *)0;
	return OPERAND;
}

static int
isoperand(void)
{
	struct t_op const *op;
	char *s, *t;

	op = ops;
	if ((s  = *(t_wp+1)) == 0)
		return 1;
	if ((t = *(t_wp+2)) == 0)
		return 0;
	while (op->op_text) {
		if (strcmp(s, op->op_text) == 0)
	    		return op->op_type == BINOP &&
	    		    (t[0] != ')' || t[1] != '\0'); 
		op++;
	}
	return 0;
}

/* atoi with error detection */
static int
getn(const char *s)
{
	char *p;
	long r;

	errno = 0;
	r = strtol(s, &p, 10);

	if (errno != 0)
	      error("%s: out of range", s);

	while (isspace((unsigned char)*p))
	      p++;
	
	if (*p)
	      error("%s: bad number", s);

	return (int) r;
}

static int
newerf (const char *f1, const char *f2)
{
	struct stat b1, b2;

	return (stat (f1, &b1) == 0 &&
		stat (f2, &b2) == 0 &&
		b1.st_mtime > b2.st_mtime);
}

static int
olderf (const char *f1, const char *f2)
{
	struct stat b1, b2;

	return (stat (f1, &b1) == 0 &&
		stat (f2, &b2) == 0 &&
		b1.st_mtime < b2.st_mtime);
}

static int
equalf (const char *f1, const char *f2)
{
	struct stat b1, b2;

	return (stat (f1, &b1) == 0 &&
		stat (f2, &b2) == 0 &&
		b1.st_dev == b2.st_dev &&
		b1.st_ino == b2.st_ino);
}

/* Do the same thing access(2) does, but use the effective uid and gid,
   and don't make the mistake of telling root that any file is
   executable. */
static int
test_eaccess(const char *path, int mode)
{
	struct stat64 st;
	int euid = geteuid();

	if (stat64(path, &st) < 0)
		return (-1);

	if (euid == 0) {
		/* Root can read or write any file. */
		if (mode != X_OK)
		return (0);

		/* Root can execute any file that has any one of the execute
		   bits set. */
		if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
			return (0);
	}

	if (st.st_uid == euid)		/* owner */
		mode <<= 6;
	else if (bash_group_member(st.st_gid))
		mode <<= 3;

	if (st.st_mode & mode)
		return (0);

	return (-1);
}

/* Return non-zero if GID is one that we have in our groups list. */
static int
bash_group_member(gid_t gid)
{
	register int i;
	gid_t *group_array;
	int ngroups;

	/* Short-circuit if possible, maybe saving a call to getgroups(). */
	if (gid == getgid() || gid == getegid())
		return (1);

	ngroups = getgroups(0, NULL);
#ifdef SHELL
	group_array = stalloc(ngroups * sizeof(gid_t));
#else
	group_array = alloca(ngroups * sizeof(gid_t));
#endif
	getgroups(ngroups, group_array);

	/* Search through the list looking for GID. */
	for (i = 0; i < ngroups; i++)
		if (gid == group_array[i])
			return (1);

	return (0);
}




/*
 * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
 * This file contains code for the times builtin.
 * $Id: times.c,v 1.6 2001/12/12 20:35:08 herbert Exp $
 */

#include <sys/times.h>
#include <unistd.h>
#ifdef USE_GLIBC_STDIO
#include <stdio.h>
#else
#include "bltin.h"
#endif

#define main timescmd

int main() {
	struct tms buf;
	long int clk_tck = sysconf(_SC_CLK_TCK);

	times(&buf);
	printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
	       (int) (buf.tms_utime / clk_tck / 60),
	       ((double) buf.tms_utime) / clk_tck,
	       (int) (buf.tms_stime / clk_tck / 60),
	       ((double) buf.tms_stime) / clk_tck,
	       (int) (buf.tms_cutime / clk_tck / 60),
	       ((double) buf.tms_cutime) / clk_tck,
	       (int) (buf.tms_cstime / clk_tck / 60),
	       ((double) buf.tms_cstime) / clk_tck);
	return 0;
}




#
# NOTE: bltincmd must come first!

bltincmd	builtin
#alloccmd	alloc
bgcmd -j	bg
breakcmd	break continue
#catfcmd	catf
cdcmd		cd chdir
commandcmd	command
dotcmd		.
echocmd		echo
evalcmd		eval

fgcmd -j	fg
getoptscmd	getopts
hashcmd		hash
#jobidcmd	jobid
jobscmd		jobs
killcmd -j	kill
#linecmd		line
localcmd	local
#nlechocmd	nlecho
printfcmd	printf
pwdcmd		pwd
readcmd		read
returncmd	return

aliascmd	alias
ulimitcmd	ulimit
testcmd		test [
timescmd	times




#include "show.h"
#include "cd.h"

#define CD_PHYSICAL 1
#define CD_PRINT 2
STATIC void updatepwd __P((char *));

STATIC int docd __P((const char *, int));
STATIC const char *updatepwd __P((const char *));
STATIC char *getpwd __P((void));
STATIC int cdopt __P((void));

STATIC char *curdir = nullstr;		/* current working directory */
STATIC char *physdir = nullstr;		/* physical working directory */

STATIC int
cdopt()
{
	int flags = 0;
	int i, j;

	j = 'L';
	while ((i = nextopt("LP"))) {
		if (i != j) {
			flags ^= CD_PHYSICAL;
			j = i;
		}
	}

	return flags;
}

int
cdcmd(argc, argv)

{
	const char *dest;
	const char *path;
	const char *p;
	char c;
	struct stat statb;
	int flags;

	flags = cdopt();
	dest = *argptr;
	if (!dest)
		dest = bltinlookup(homestr);
	else if (dest[0] == '-' && dest[1] == '\0') {
		dest = bltinlookup("OLDPWD");
		flags |= CD_PRINT;
		goto step7;
		if (dest)
		        print = 1;
		else
		        dest = ".";
	}
	if (!dest)
		dest = nullstr;
	if (*dest == '/')
		goto step7;
	if (*dest == '.') {
		c = dest[1];
dotdot:
		switch (c) {
		case '\0':
		case '/':
			goto step6;
		case '.':
			c = dest[2];
			if (c != '.')
				goto dotdot;
			}
			if (docd(p, print) >= 0)
				return 0;

		}
	if (!*dest)
		dest = ".";
	if (!(path = bltinlookup("CDPATH"))) {
step6:
step7:
		p = dest;
		goto docd;
	}
	do {
		c = *path;
		p = padvance(&path, dest);
		if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
			if (c && c != ':')
				flags |= CD_PRINT;
docd:
			if (!docd(p, flags))
				goto out;
			break;
	}
	} while (path);
	error("can't cd to %s", dest);
	/* NOTREACHED */
out:
	if (flags & CD_PRINT)
		out1fmt(snlfmt, curdir);
	return 0;
}


/*
 * Actually do the chdir.  We also call hashcd to let the routines in exec.c
 * know that the current directory has changed.
 */

STATIC int
docd(const char *dest, int flags)
	char *dest;
	int print;
{
	const char *dir = 0;
	int err;
	char *component;
	struct stat statb;
	int first;
	int badstat;

	TRACE(("docd(\"%s\", %d) called\n", dest, print));

	TRACE(("docd(\"%s\", %d) called\n", dest, flags));
	 *  Check each component of the path. If we find a symlink or
	 *  something we can't stat, clear curdir to force a getcwd()
	 *  next time we get the value of the current directory.
	 */
	badstat = 0;
	cdcomppath = stalloc(strlen(dest) + 1);
	scopy(dest, cdcomppath);
	STARTSTACKSTR(p);
	if (*dest == '/') {
		STPUTC('/', p);
		cdcomppath++;
	}
	first = 1;
	while ((q = getcomponent()) != NULL) {
		if (q[0] == '\0' || (q[0] == '.' && q[1] == '\0'))
			continue;
		if (! first)
			STPUTC('/', p);
		first = 0;
		component = q;
		while (*q)
			STPUTC(*q++, p);
		if (equal(component, ".."))
			continue;
		STACKSTRNUL(p);
		if ((lstat(stackblock(), &statb) < 0)
		    || (S_ISLNK(statb.st_mode)))  {
			/* print = 1; */
			badstat = 1;
			break;
		}
	}

	INTOFF;
	if (!(flags & CD_PHYSICAL)) {
		dir = updatepwd(dest);
		if (dir)
			dest = dir;
	}
	err = chdir(dest);
	if (err)
		goto out;
	setpwd(dir, 1);
	hashcd();
out:
	INTON;
	return err;
		out1fmt("%s\n", curdir);
	return 0;
}


/*
 * Get the next component of the path name pointed to by cdcomppath.
 * This routine overwrites the string pointed to by cdcomppath.
 */

STATIC char *
getcomponent() {
	char *p;
	char *start;

	if ((p = cdcomppath) == NULL)
		return NULL;
	start = cdcomppath;
	while (*p != '/' && *p != '\0')
		p++;
	if (*p == '\0') {
		cdcomppath = NULL;
	} else {
		*p++ = '\0';
		cdcomppath = p;
	}
	return start;
}



/*
 * Update curdir (the name of the current directory) in response to a
 * cd command.
 * that the current directory has changed.
 */

STATIC const char *
updatepwd(const char *dir)
{
	{
	char *new;
	char *p;
	char *cdcomppath;
	const char *lim;

	cdcomppath = sstrdup(dir);

	/*
	 * If our argument is NULL, we don't know the current directory
	 * any more because we traversed a symbolic link or something
	 * we couldn't stat().
	 */
	if (dir == NULL || curdir == NULL)  {
		if (prevdir)
			ckfree(prevdir);
		INTOFF;
		prevdir = curdir;
		curdir = NULL;
		getpwd();
		setvar("PWD", curdir, VEXPORT);
		INTON;
		return;
	}
	cdcomppath = stalloc(strlen(dir) + 1);
	scopy(dir, cdcomppath);
	STARTSTACKSTR(new);
	if (*dir != '/') {
		if (curdir == nullstr)
			return 0;
		new = stputs(curdir, new);
	}
	new = makestrspace(strlen(dir) + 2, new);
	lim = stackblock() + 1;
	if (*dir != '/') {
		if (new[-1] != '/')
			USTPUTC('/', new);
		if (new > lim && *lim == '/')
			lim++;
	} else {
		USTPUTC('/', new);
		cdcomppath++;
		if (dir[1] == '/' && dir[2] != '/') {
			USTPUTC('/', new);
			cdcomppath++;
			lim++;
		}
	}
	p = strtok(cdcomppath, "/");
	while (p) {
		switch(*p) {
		case '.':
			if (p[1] == '.' && p[2] == '\0') {
				while (new > lim) {
			STUNPUTC(new);
					if (new[-1] == '/')
						break;
	}
				break;
			} else if (p[1] == '\0')
				break;
			/* fall through */
		default:
			new = stputs(p, new);
			USTPUTC('/', new);
		}
		p = strtok(0, "/");
	}
	if (new > lim)
		STUNPUTC(new);
	*new = 0;
	return stackblock();
	if (prevdir)
		ckfree(prevdir);
	prevdir = curdir;
	curdir = savestr(stackblock());
	setvar("PWD", curdir, VEXPORT);
	INTON;
}


#define MAXPWD 256

/*
 * Find out what the current directory is. If we already know the current
 * directory, this routine returns immediately.
 */
inline
STATIC char *
getpwd()
{
	char *dir = getcwd(0, 0);
	return dir ? dir : nullstr;
}

int
pwdcmd(argc, argv)
	int argc;
	char **argv;
{
	int flags;
	const char *dir = curdir;

	flags = cdopt();
	if (flags) {
		if (physdir == nullstr)
			setpwd(dir, 0);
		dir = physdir;
	}
	out1fmt(snlfmt, dir);
	return 0;
}




#define MAXPWD 256

/*
 * Find out what the current directory is. If we already know the current
 * directory, this routine returns immediately.
 */
void
setpwd(const char *val, int setold)
{
	char *oldcur, *dir;

	if (curdir)
		return;
	/*
	 * Things are a bit complicated here; we could have just used
	 * getcwd, but traditionally getcwd is implemented using popen
	 * to /bin/pwd. This creates a problem for us, since we cannot
	 * keep track of the job if it is being ran behind our backs.
	 * So we re-implement getcwd(), and we suppress interrupts
	 * throughout the process. This is not completely safe, since
	 * the user can still break out of it by killing the pwd program.
	 * We still try to use getcwd for systems that we know have a
	 * c implementation of getcwd, that does not open a pipe to
	 * /bin/pwd.
	 */
#if defined(__NetBSD__) || defined(__SVR4)
		
	oldcur = dir = curdir;
		char *pwd = getenv("PWD");
		struct stat stdot, stpwd;

	if (setold) {
		setvar("OLDPWD", oldcur, VEXPORT);
		    stdot.st_dev == stpwd.st_dev &&
		    stdot.st_ino == stpwd.st_ino) {
			curdir = savestr(pwd);
			return;
		}
		error("getcwd() failed: %s", strerror(errno));
	}
	curdir = savestr(buf);
#else
	{
		char *p;
		int i;
		int status;
		struct job *jp;
		int pip[2];

		INTOFF;
	if (physdir != nullstr) {
		if (physdir != oldcur)
			free(physdir);
		physdir = nullstr;
			(void) close(pip[0]);
			if (pip[1] != 1) {
				close(1);
				copyfd(pip[1], 1);
				close(pip[1]);
			}
			(void) execl("/bin/pwd", "pwd", (char *)0);
			error("Cannot exec /bin/pwd");
		}
		(void) close(pip[1]);
		pip[1] = -1;
		p = buf;
		while ((i = read(pip[0], p, buf + MAXPWD - p)) > 0
		     || (i == -1 && errno == EINTR)) {
			if (i > 0)
				p += i;
		}
	if (oldcur == val || !val) {
		char *s = getpwd();
		physdir = s;
		if (!val)
			dir = s;
	} else
		dir = savestr(val);
	if (oldcur != dir && oldcur != nullstr) {
		free(oldcur);
	}
	curdir = dir;
	INTON;
	setvar("PWD", dir, VEXPORT);
}

Lines 34-39 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/cd.h (-1 / +1 lines)
34	*	34	*
35	*/	35	*/
36		36
37	void getpwd __P((void));
38	int cdcmd __P((int, char **));	37	int cdcmd __P((int, char **));
39	int pwdcmd __P((int, char **));	38	int pwdcmd __P((int, char **));
		39	void setpwd __P((const char *, int));

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/ash.dirs (+2 lines)
	1	bin
	2	usr/share/man/man1




#!/bin/sh
#
# post-install script for the Debian GNU/Linux ash package
#
# $Id: ash.postinst,v 1.9 2002/10/26 11:27:48 herbert Exp $

set -e

check_divert() {
	div=$(dpkg-divert --list $1)
	distrib=${3:-$1.distrib}
	case $div in
	'' | *by\ dash)
		;;
	*by\ ash)
		dst=${div% by ash}
		dst=${dst##* to }

		# Work around dpkg-divert bug.
		if [ -e "$dst" ]; then
			mv "$dst" "$dst.ash-tmp"
		fi
		dpkg-divert --remove $1
		if [ -e "$dst.ash-tmp" ]; then
			mv "$dst.ash-tmp" "$dst"
		fi

		dpkg-divert --package dash --divert $distrib --add $1
		if [ "$dst" != $distrib ] && [ -e "$dst" ]; then
			mv "$dst" $distrib
		fi
		ln -sf $2 $1
		;;
	*)
		d=${1%/*}
		if
			[ -h $1 ] && [ -f $1 ] && [ -f $d/$4 ] &&
			cmp $1 $d/$4
		then
			ln -sf $2 $1
		fi
		;;
	esac
}

dcv='dpkg --compare-versions'

if [ "$1" = configure ] && [ -n "$2" ] && $dcv "$2" lt 0.4.3; then
	check_divert /bin/sh dash '' ash
	check_divert /usr/share/man/man1/sh.1.gz dash.1.gz \
		/usr/share/man/man1/sh.distrib.1.gz ash.1.gz
fi

#DEBHELPER#

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/bsdyacc (+20 lines)
	1	#!/bin/sh -e
	2
	3	if echo "$@" \| grep -q -- -o; then
	4	OUTPUT=$(echo "$@" \|
	5	sed 's/.-o[[:blank:]]\+$[^[:blank:]]\+$\.c./\1/')
	6	OPTIONS=$(echo "$@" \|
	7	sed 's/$.$-o[[:blank:]]\+[^[:blank:]]\+$.$/\1\2/')
	8	NEW=1
	9	else
	10	OUTPUT=$(echo "$@" \|
	11	sed -e 's/.[[:blank:]]\+$[^[:blank:]]\+$\.y./\1/')
	12	OPTIONS="$@"
	13	NEW=0
	14	fi
	15
	16	byacc $OPTIONS
	17	if [ $NEW = 1 ]; then
	18	mv y.tab.c $OUTPUT.c
	19	fi
	20	mv y.tab.h $OUTPUT.h




dash (0.4.10) unstable; urgency=low

  * Fixed redirection fd leak when execing.

 -- Herbert Xu <herbert@debian.org>  Sun, 19 Jan 2003 13:25:41 +1100

dash (0.4.9) unstable; urgency=low

  * Reset exitstatus in evalsubshell if backgnd is true.
  * Fixed glibc glob syntax error in expand.c.

 -- Herbert Xu <herbert@debian.org>  Sat, 11 Jan 2003 16:04:02 +1100

dash (0.4.8) unstable; urgency=low

  * Removed backgnd flag from ncmd due to previous redirection change.
  * Set lim after the stack stablises in updatepwd (closes: #173884).
  * Do not clobber the exitstatus after redirection.

 -- Herbert Xu <herbert@debian.org>  Mon, 23 Dec 2002 19:50:06 +1100

dash (0.4.7) unstable; urgency=low

  * Merged clearredir with reset code in redir.c.
  * Redirect before command search in evalcommand (closes: #168862).
  * Build binary-all packages in binary-indep (closes: #173191).

 -- Herbert Xu <herbert@debian.org>  Sat, 21 Dec 2002 13:52:37 +1100

dash (0.4.6) unstable; urgency=low

  * Restored code for leaving job control.

 -- Herbert Xu <herbert@debian.org>  Sun,  8 Dec 2002 15:21:58 +1100

dash (0.4.5) unstable; urgency=low

  * Optimised doformat so that vsnprintf is usually called only once.
  * Reset redirlist in clearredir so that popredir can work (closes: #170247).

 -- Herbert Xu <herbert@debian.org>  Sat, 23 Nov 2002 22:09:59 +1100

dash (0.4.4) unstable; urgency=low

  * Fixed duplicate define warnings in init.c.
  * Set debhelper compat to 4.
  * Vanishing mail boxes no longer elicit "you have mail" messages.
  * Function redirection errors no longer abort the shell.
  * Fixed potential memory leak in redirect.
  * Only allocate memory if necessary in redirect.
  * Reap dead here documents.
  * Do not strdup default values of static shell variables.
  * Removed unnecessary setprompt(0) calls.
  * Read in BUFSIZ chunks rather than BUFSIZ - 1.
  * Documented undefined escape behaviour for echo(1) (closes: #167893).
  * Do va_copy when we use a va_list twice (closes: #169503).

 -- Herbert Xu <herbert@debian.org>  Wed, 20 Nov 2002 19:48:31 +1100

dash (0.4.3) unstable; urgency=low

  * Added manual entry for PPID.
  * Exporting an unset variable no longer causes it to be set.
  * Fixed fd0 redirection in asynchronous lists.
  * Only stat if necessary in cdcmd (see #42880).
  * Removed extra newline in error message in arith lexer.
  * Set heredoclist to 0 ASAP in parseheredoc.
  * Removed BSD advertising clause from copyright file.
  * Check non-ash diversions as well in dash.postinst.
  * Duplicated diversion checking in ash.postinst (closes: #166441).

 -- Herbert Xu <herbert@debian.org>  Sat, 26 Oct 2002 21:28:33 +1000

dash (0.4.2) unstable; urgency=low

  * Give benefits of dash in templates (closes: #161527).
  * Fixed signed/unsigned on result of xwrite (closes: #161606).
  * Removed support for SIG prefixes in kill and trap.
  * Added -- processing in trap.
  * Dropped use of unset in postinst (closes: 161868).
  * Fixed printf(1) %* processing on bad integers and zero.
  * Use stat64 in test(1).
  * Allocate group_array with stalloc in test(1).
  * Disabled alias checking after a pattern in a case statement.
  * Wait now returns 128 + last trapped signal.
  * Printf now keeps going after errors.
  * Empty non-trivial parameter expansions are now removed correctly.
  * Call reset() before exitshell() is called.  This fixes the bug where
    returning an error from a function running under set -e caused the exit
    trap to be taken with evalskip set.
  * Fixed quoting of empty strings in single_quote().
  * Show line numbers on all errors.
  * Function names must be valid identifiers.
  * Removed unused dependency on groff.
  * Fixed race condition before entering a function.
  * Fixed getopts initialisation for functions.
  * Added memory barriers in INT macros.
  * Banned empty compound lists in most places.
  * Keep usage counters on functions (closes: #164234).
  * Updated copyright file.
  * Check evalskip in evalstring (closes: #165056).
  * Merged changes from NetBSD 1.6:
   . Added intmax support in printf(1).
   . Implemented set -u.

 -- Herbert Xu <herbert@debian.org>  Sat, 19 Oct 2002 14:23:11 +1000

dash (0.4.1) unstable; urgency=low

  * Removed extra new line in command -v output for aliases.
  * Removed alais prefix in the output of alias.
  * Recognise octal and hex numbers in arith expansion (closes: #151449).
  * Added sh(1) entries for echo, printf and test (closes: #156446).
  * Renamed to dash --- the Debian Almquist Shell.
  * Cleaned up rules file (Matej Vela).
  * Check mtime instead of size in chkmail per POSIX.
  * Added support for LFS (closes: #157884).
  * Added SuS options to cd and pwd (closes: #145828).

 -- Herbert Xu <herbert@debian.org>  Fri, 13 Sep 2002 20:35:06 +1000

ash (0.3.8-38) unstable; urgency=low

  * Turned pre-dependency to dependency in udeb since the former is not allowed
    (closes: #143749).

 -- Herbert Xu <herbert@debian.org>  Sun, 28 Apr 2002 11:59:05 +1000

ash (0.3.8-37) unstable; urgency=low

  * Added Japanese debconf translation (Tomohiro KUBOTA, closes: #137431).
  * Added missing escapes in manual page (Aaron Schrab, closes: #137966).
  * Added Russian debconf translation (Ilgiz Kalmetev, closes: #137618).
  * Fixed trap(1) documentation (closes: #140973).
  * Do not abort if getcwd fails.

 -- Herbert Xu <herbert@debian.org>  Wed,  3 Apr 2002 20:58:09 +1000

ash (0.3.8-36) unstable; urgency=low

  * Added library dependency for ash-udeb.
  * Handle null case statements correctly.
  * Fixed alias expansions in case statements (NetBSD).
  * Disabled unused jobid command.
  * Corrected documentation about shifting too much.
  * Added French debconf translation (Denis Barbier, closes: #134625).
  * Updated Spanish debconf translation (Carlos Valdivia, closes: #136366).

 -- Herbert Xu <herbert@debian.org>  Sat,  2 Mar 2002 18:31:22 +1100

ash (0.3.8-35) unstable; urgency=low

  * Moved PWD initialisation into var.c (closes: #124032).

 -- Herbert Xu <herbert@debian.org>  Mon, 24 Dec 2001 09:34:55 +1100

ash (0.3.8-34) unstable; urgency=low

  * NSEMI must be NOR + 1.
  * Set exitstatus to zero before evaluating cases (closes: #124066).
  * Explicitly set default answer of the ash/sh question to false so that
    people whose debconf priority is set to low and who keeps banging on their
    keyboards don't accidently end up with ash as /bin/sh.

 -- Herbert Xu <herbert@debian.org>  Fri, 21 Dec 2001 20:30:49 +1100

ash (0.3.8-33) unstable; urgency=low

  * Added missing inclusion of bltin.h in bltin/times.c.

 -- Herbert Xu <herbert@debian.org>  Thu, 13 Dec 2001 18:46:07 +1100

ash (0.3.8-32) unstable; urgency=low

  * Back slashes in expansions are now escaped (closes: #121516).

 -- Herbert Xu <herbert@debian.org>  Wed, 28 Nov 2001 20:15:01 +1100

ash (0.3.8-31) unstable; urgency=low

  * Made sure all back slashes are escaped.

 -- Herbert Xu <herbert@debian.org>  Mon, 26 Nov 2001 19:10:27 +1100

ash (0.3.8-30) unstable; urgency=low

  * Restored fnmatch(3) code.
  * Treat escaped slashes correctly while globbing.
  * Restored missing EV_EXIT check in evalcommand (closes: #120364).
  * Fixed stack corruption in _rmescapes.

 -- Herbert Xu <herbert@debian.org>  Sun, 25 Nov 2001 17:51:19 +1100

ash (0.3.8-29) unstable; urgency=low

  * Added missing va_end in fmtstr (NetBSD).
  * Removed shellproc crap.
  * Updated Swedish debconf translation (Mikael Hedin, closes: #116097).
  * Updated German debconf translation (Andreas Metzler, closes: #117160).
  * Break now treats illegal numbers according to SuS.
  * Errors in special builtins now rise to the top.
  * Normal redirection errors no longer abort the shell.
  * Functions now have the same variable assignment properties as special
    builtins.

 -- Herbert Xu <herbert@debian.org>  Sat,  3 Nov 2001 11:36:36 +1100

ash (0.3.8-28) unstable; urgency=low

  * Local variables are now unset properly in shprocvar() (closes: #114917).

 -- Herbert Xu <herbert@debian.org>  Sat, 13 Oct 2001 14:07:21 +1000

ash (0.3.8-27) unstable; urgency=low

  * Kill no longer aborts if it fails to kill someone.

 -- Herbert Xu <herbert@debian.org>  Sun, 30 Sep 2001 22:20:36 +1000

ash (0.3.8-26) unstable; urgency=low

  * The sh.1.gz diversion now agrees with reality (closes: #113831).

 -- Herbert Xu <herbert@debian.org>  Sat, 29 Sep 2001 08:43:27 +1000

ash (0.3.8-25) unstable; urgency=low

  * Only read ENV if the shell is interactive (closes: #110421).

 -- Herbert Xu <herbert@debian.org>  Wed, 29 Aug 2001 19:18:53 +1000

ash (0.3.8-24) unstable; urgency=low

  * Handle SIGINT when waiting even if there is no trap (closes: #107699).
  * Protect all makejob/forkshell/waitforjobs sequences from SIGINT.
  * Work around gcc bug that generates bad ..ng references (closes: #107994).

 -- Herbert Xu <herbert@debian.org>  Wed,  8 Aug 2001 20:28:28 +1000

ash (0.3.8-23) unstable; urgency=low

  * Fixed fence post error in scanleft (closes: #107229).
  * Removed stunalloc in expname as it interferes with addfname.
  * Fixed CTLESC skipping in scanright.

 -- Herbert Xu <herbert@debian.org>  Thu,  2 Aug 2001 20:06:00 +1000

ash (0.3.8-22) unstable; urgency=low

  * Fixed trailing back slash bug in echo/printf (closes: #106693).
  * Some quoted's are meant to be quotes.
  * Added Brazilian translation (Andre Luis Lopes, closes: #107041).

 -- Herbert Xu <herbert@debian.org>  Mon, 30 Jul 2001 20:21:52 +1000

ash (0.3.8-21) unstable; urgency=low

  * Fixed EV_EXIT/redirection bugs that caused core dumps.

 -- Herbert Xu <herbert@debian.org>  Sat, 28 Jul 2001 17:03:28 +1000

ash (0.3.8-20) unstable; urgency=low

  * Don't save fd2 if job control is turned off.
  * Don't push redirections when EV_EXIT is set.
  * Fixed assignment recognition in the presence of back ticks.
  * Combined checkkwd and checkalias.

 -- Herbert Xu <herbert@debian.org>  Fri, 27 Jul 2001 22:29:41 +1000

ash (0.3.8-19) unstable; urgency=low

  * Recompute strings after growing in subevalvar (closes: #106050).

 -- Herbert Xu <herbert@debian.org>  Mon, 23 Jul 2001 21:16:50 +1000

ash (0.3.8-18) unstable; urgency=low

  * Added more space optimisations for udeb on i386.
  * Set stack mark in patmatch (closes: #106050).
  * Fixed theoretical bug in expari.

 -- Herbert Xu <herbert@debian.org>  Sat, 21 Jul 2001 20:08:15 +1000

ash (0.3.8-17) unstable; urgency=low

  * Don't complain about unknown escape codes in echo and printf
    (closes: #105659).
  * Updated build-time dependency on groff-base (closes: #105612).

 -- Herbert Xu <herbert@debian.org>  Wed, 18 Jul 2001 19:33:20 +1000

ash (0.3.8-16) unstable; urgency=low

  * Fixed backslash bug in new pattern matching code.

 -- Herbert Xu <herbert@debian.org>  Mon, 16 Jul 2001 21:47:39 +1000

ash (0.3.8-15) unstable; urgency=low

  * Added Swedish translation of templates (Martin Sjögren, closes: #103158).
  * Restored escape code support in echo.
  * Removed assignment builtins since it is at best undefined by the SuS and
    also can't be implemented consistently.
  * Removed extraneous volatile modifier (closes: #104518).
  * General overhaul of word expansion (closes: #96588).
  * Redirection prefixes no longer stop assignments from being recognised.

 -- Herbert Xu <herbert@debian.org>  Sun, 15 Jul 2001 17:27:03 +1000

ash (0.3.8-14) unstable; urgency=low

  * Divert sh.1.gz to sh.distrib.1.gz (closes: #102251).
  * Added HETIO support for ^D and ^U (Aaron Lehmann, closes: #102215).
  * Added Spaniash translation of debconf templates (Carlos Valdivia Yagüe,
    closes: #103040).
  * Added versioned build-time dependency on groff.

 -- Herbert Xu <herbert@debian.org>  Mon,  2 Jul 2001 19:32:03 +1000

ash (0.3.8-13) unstable; urgency=low

  * Fixed a bug where errors in pipelines which are part of andor lists were
    not ignored when -e is in effect.

 -- Herbert Xu <herbert@debian.org>  Mon, 25 Jun 2001 19:40:27 +1000

ash (0.3.8-12) unstable; urgency=low

  * Rewrote arith_lex.l in C (Aaron Lehmann, closes: #101741).
  * && and || in arithmetic expansions now return either 0 or 1.

 -- Herbert Xu <herbert@debian.org>  Sun, 24 Jun 2001 20:14:29 +1000

ash (0.3.8-11) unstable; urgency=low

  * Check for NULL argument in evaltree() (closes: #98865, #98867).

 -- Herbert Xu <herbert@debian.org>  Sun, 27 May 2001 17:53:14 +1000

ash (0.3.8-10) unstable; urgency=low

  * Use /bin/ash in postinst to sidestep bugs in other shells (closes: #98739).
  * Exit status is now tested on non-negated pipelines (closes: #98736).

 -- Herbert Xu <herbert@debian.org>  Sat, 26 May 2001 23:56:07 +1000

ash (0.3.8-9) unstable; urgency=medium

  * IFS is now fetched using bltinlookup() again in read (closes: #98343).
  * Divert sh(1) man page as well as /bin/sh (closes: #98525).

 -- Herbert Xu <herbert@debian.org>  Fri, 25 May 2001 20:30:06 +1000

ash (0.3.8-8) unstable; urgency=low

  * Fixed diversion removal in prerm (duh, closes: #98031).

 -- Herbert Xu <herbert@debian.org>  Mon, 21 May 2001 20:52:48 +1000

ash (0.3.8-7) unstable; urgency=low

  * Fixed diversion test in prerm (closes: #98031).

 -- Herbert Xu <herbert@debian.org>  Sun, 20 May 2001 12:30:53 +1000

ash (0.3.8-6) unstable; urgency=low

  * Make sure that fd2 is closed when clearing redirects (closes: #96619).
  * Fixed memory corruption in stunalloc().
  * The output of export/readonly/set is now correctly quoted.
  * Fixed newline eating bug in expbackq().
  * Set OLDPWD.
  * Removed ash-medium as neither bf or di uses it.
  * Wait now waits for all its argument rather than the first one.
  * Wait will exit with 129 when interrupted by a signal for a which a trap has
    been set.

 -- Herbert Xu <herbert@debian.org>  Fri, 18 May 2001 21:51:41 +1000

ash (0.3.8-5) unstable; urgency=low

  * Added German translation to template file (Sebastian Feltel,
    closes: #96203).
  * Added missing initialisation in setalias() (closes: #95433).

 -- Herbert Xu <herbert@debian.org>  Fri,  4 May 2001 20:54:31 +1000

ash (0.3.8-4) unstable; urgency=low

  * Disabled fnmatch code as fnmatch(3) in glibc is broken.
  * Fixed echo example in man page (Kalle Olavi Niemitalo, closes: #96014).
  * Fixed trailing semicolon bug with eval (NetBSD).
  * Fixed globbing inconsistency with broken symlinks (NetBSD).

 -- Herbert Xu <herbert@debian.org>  Wed,  2 May 2001 22:57:16 +1000

ash (0.3.8-3) unstable; urgency=low

  * Work around broken autoconf scripts (closes: #95430).

 -- Herbert Xu <herbert@debian.org>  Tue,  1 May 2001 18:27:50 +1000

ash (0.3.8-2) unstable; urgency=low

  * Save checkalias before calling xxreadtoken() (closes: #95628).

 -- Herbert Xu <herbert@debian.org>  Sun, 29 Apr 2001 17:36:01 +1000

ash (0.3.8-1) unstable; urgency=low

  * NetBSD-current version as of 20010316.
  * Removed code that sets IFS.
  * Fixed memory leak with PWD.
  * Set PPID.
  * Fixed inconsistencies in alias expansion.
  * Restored original output code.
  * Enabled fnmatch code again.
  * Added builtin printf.
  * Offer to divert /bin/sh (closes: #70462).

 -- Herbert Xu <herbert@debian.org>  Wed, 25 Apr 2001 22:32:39 +1000

ash (0.3.7-16) unstable; urgency=low

  * Fixed incorrect default IFS in readcmd (closes: #88950).
  * Added missing return in hashcmd.

 -- Herbert Xu <herbert@debian.org>  Fri,  9 Mar 2001 20:44:40 +1100

ash (0.3.7-15) unstable; urgency=low

  * Unknown escape codes are now prnted literally by echo (closes: #82869).
  * Made hetio_read_input() fail if fd is not stdin.
  * Some uses of VSQUOTE were really meant to be quotes (closes: #88777).
  * Build different ashes in different subdirectories.

 -- Herbert Xu <herbert@debian.org>  Thu,  8 Mar 2001 21:32:28 +1100
 
ash (0.3.7-14) unstable; urgency=low

  * Removed predependency from udeb (closes: #81995).
  * Added /bin/sh symlink to udeb (closes: #81967).

 -- Herbert Xu <herbert@debian.org>  Sat, 13 Jan 2001 15:23:21 +1100

ash (0.3.7-13) unstable; urgency=low

  * Renamed the udeb to ash-udeb.

 -- Herbert Xu <herbert@debian.org>  Wed, 20 Dec 2000 19:32:34 +1100

ash (0.3.7-12) unstable; urgency=low

  * Added support for udebs (Randolph Chung, closes: #79237).

 -- Herbert Xu <herbert@debian.org>  Sat, 16 Dec 2000 13:53:28 +1100

ash (0.3.7-11) unstable; urgency=low

  * Preserve the previous exit status upon entering a function
    (closes: #78374).

 -- Herbert Xu <herbert@debian.org>  Sun,  3 Dec 2000 13:34:27 +1100

ash (0.3.7-10) unstable; urgency=low

  * Merged changes for GNU from Igor Khavkine.
  * Minimise the number of sigactions.

 -- Herbert Xu <herbert@debian.org>  Fri,  3 Nov 2000 20:31:52 +1100

ash (0.3.7-9) unstable; urgency=low

  * Predepend on the libraries.
  * Always save fd 2 when it is redirected (closes: #75302).

 -- Herbert Xu <herbert@debian.org>  Sun, 22 Oct 2000 08:40:40 +1100

ash (0.3.7-8) unstable; urgency=high

  * More redirection fixes (closes: #73613).

 -- Herbert Xu <herbert@debian.org>  Thu,  5 Oct 2000 18:22:17 +1100

ash (0.3.7-7) unstable; urgency=high

  * Added missing break in redirection code (closes: #72956).

 -- Herbert Xu <herbert@debian.org>  Tue,  3 Oct 2000 07:58:04 +1100

ash (0.3.7-6) unstable; urgency=low

  * command -[vV] no longer displays an error message on stdout.
  * Redirecting to /proc/self/fd/* now works (closes: #72852).

 -- Herbert Xu <herbert@debian.org>  Sun,  1 Oct 2000 12:56:39 +1100

ash (0.3.7-5) unstable; urgency=low

  * Implemented set -a.

 -- Herbert Xu <herbert@debian.org>  Sat, 30 Sep 2000 16:00:33 +1100

ash (0.3.7-4) unstable; urgency=low

  * Added build-time dependency on debhelper (closes: #69920).
  * Extended maximum length of arithmetic expansions to match 32-bit integers.

 -- Herbert Xu <herbert@debian.org>  Wed, 20 Sep 2000 14:28:16 +1100

ash (0.3.7-3) unstable; urgency=low

  * Switch to the old globbing code since glob(3) is hopelessly broken
    (closes: #69455).

 -- Herbert Xu <herbert@debian.org>  Mon, 21 Aug 2000 20:37:15 +1000

ash (0.3.7-2) unstable; urgency=low

  * Call glob(3) with GLOB_NOMAGIC (ouch).

 -- Herbert Xu <herbert@debian.org>  Sun,  6 Aug 2000 17:47:08 +1000

ash (0.3.7-1) unstable; urgency=low

  * NetBSD-current version as of 20000729.
  * Use fnmatch(3) and glob(3).
  * Fixed the use of backslashes in the pattern in parameter substitutions,
    hopefully for the last time.
  * Applied HETIO patch and built ash.medium (closes: #50788).  Will do ash.big
    when readline is fixed so that it doesn't leak anymore.

 -- Herbert Xu <herbert@debian.org>  Fri,  4 Aug 2000 21:36:44 +1000

ash (0.3.6-5) unstable; urgency=low

  * Fixed manpage entry for read with patch from Kevin Ryde (closes: #62500).
  * Fixed a file descriptor leak for pipelines.

 -- Herbert Xu <herbert@debian.org>  Wed, 19 Apr 2000 18:56:20 +1000

ash (0.3.6-4) unstable; urgency=low

  * Fixed the case of an empty command with redirections.

 -- Herbert Xu <herbert@debian.org>  Fri,  7 Apr 2000 12:07:18 +1000

ash (0.3.6-3) unstable; urgency=low

  * ! is now recognised correctly.
  * Ash is now more strict on the syntax, e.g., a lone ! is no longer accepted
    as an alternative to ! true.

 -- Herbert Xu <herbert@debian.org>  Fri,  7 Apr 2000 10:46:06 +1000

ash (0.3.6-2) unstable; urgency=low

  * Fixed a problem with fmtstr() which broke getopts.

 -- Herbert Xu <herbert@debian.org>  Sun,  2 Apr 2000 10:49:26 +1000

ash (0.3.6-1) unstable; urgency=low

  * NetBSD-current version as of 20000326.
  * Added a Build-Depends on groff (closes: #61041).
  * Implemented noclobber (closes: #59028).
  * Rewrote output.c to use stream IO.

 -- Herbert Xu <herbert@debian.org>  Sat,  1 Apr 2000 19:24:31 +1000

ash (0.3.5-10) frozen unstable; urgency=low

  * Don't stat mail boxes in non-interactive mode (closes: #59213).
  * Added an fflush(stdout) to the times builtin (closes: #59027).
  * Documented the times builtin.
  * Added source depends.

 -- Herbert Xu <herbert@debian.org>  Sat, 18 Mar 2000 18:58:44 +1100

ash (0.3.5-9) unstable; urgency=low

  * Double quotes inside paramater substitutions inside double quotes are now
    ignored as in bash (the originial behaviour was POSIX compliant too but
    IMHO this one makes a little bit more sense).
    This one broke mwm (but it was actually mwm's fault).
  * Corrected backslash/CTLESC treatment for patterns in parameter
    substitutions.

 -- Herbert Xu <herbert@debian.org>  Sat,  6 Nov 1999 18:13:19 +1100

ash (0.3.5-8) unstable; urgency=low

  * Replaced use of echo -n in manual page with escape codes.
  * Made FHS compliant (closes: #47978).
  * Restored echo's option processing ability.

 -- Herbert Xu <herbert@debian.org>  Fri, 22 Oct 1999 10:20:58 +1000

ash (0.3.5-7) unstable; urgency=low

  * echo no longer supports options.
  * Don't quote patterns inside parameter substitutions enclosed by double
    quotes (closes: #47842).

 -- Herbert Xu <herbert@debian.org>  Wed, 20 Oct 1999 20:28:14 +1000

ash (0.3.5-6) unstable; urgency=low

  * Use getcwd() instead of /bin/pwd -- Zack Weinberg (closes: #46981).

 -- Herbert Xu <herbert@debian.org>  Sun, 10 Oct 1999 16:31:49 +1000

ash (0.3.5-5) unstable; urgency=low

  * Only test for -e on simple commands (fixes #44559).

 -- Herbert Xu <herbert@debian.org>  Wed,  8 Sep 1999 22:18:27 +1000

ash (0.3.5-4) unstable; urgency=low

  * Don't wait for stopped children if job control is disabled (fixes #42814).
  * Allow an option '(' in a case statement (fixes #42364).

 -- Herbert Xu <herbert@debian.org>  Thu, 12 Aug 1999 23:30:30 +1000

ash (0.3.5-3) unstable; urgency=low

  * OK, the fix to the esoteric problem in 0.3.5-1 actually breaks VSASSIGN
    and VSQUESTION, they should work properly now (fixes #41327).

 -- Herbert Xu <herbert@debian.org>  Thu, 15 Jul 1999 22:47:13 +1000

ash (0.3.5-2) unstable; urgency=low

  * PATH search and execution is now correct.
  * hash no longer shows builtins.
  * Added kill builtin.
  * New description from James R. van Zandt reformatted by Josip Rodin.

 -- Herbert Xu <herbert@debian.org>  Mon, 12 Jul 1999 18:51:42 +1000

ash (0.3.5-1) unstable; urgency=low

  * New upstream release.
  * Adapted to new pmake (fixes #38737).
  * Fixed behvaiour of backslashes preceding a closing brace for a parameter
    substituion inside double quotes (even bash messes this one up :).
  * Fixed command (fixes #34639).
  * Fixed a pipe bug where stdin may be wrongly closed (fixes #35452).
  * Revamped getopts (fixes #39694).

 -- Herbert Xu <herbert@debian.org>  Sun,  4 Jul 1999 12:19:01 +1000

ash (0.3.4-7) unstable; urgency=low

  * Fixed a glibc 2.1 compatitibility problem.
  * Fixed a PWD inconsistency that stuffed up the kernel compilation.

 -- Herbert Xu <herbert@debian.org>  Mon, 17 May 1999 23:14:57 +1000

ash (0.3.4-6) unstable; urgency=low

  * Fixed incorrect -e test due to the last bug fix (fixes #26509).

 -- Herbert Xu <herbert@debian.org>  Tue,  8 Sep 1998 10:02:46 +1000

ash (0.3.4-5) unstable; urgency=low

  * Use test_eaccess from bash instead of access(2) (fixes #26110).

 -- Herbert Xu <herbert@debian.org>  Wed, 26 Aug 1998 21:22:49 +1000

ash (0.3.4-4) unstable; urgency=low

  * Only upload to unstable.

 -- Herbert Xu <herbert@debian.org>  Tue,  5 May 1998 18:01:02 +1000

ash (0.3.4-3) frozen unstable; urgency=low

  * Applied sparc patch (fixes #21562).

 -- Herbert Xu <herbert@debian.org>  Fri,  1 May 1998 19:48:13 +1000

ash (0.3.4-2) frozen unstable; urgency=low

  * Fixed the incorrect trap fixes (fixes #20363).

 -- Herbert Xu <herbert@debian.org>  Thu, 16 Apr 1998 21:07:10 +1000

ash (0.3.4-1) unstable; urgency=low

  * New upstream release.
  * Reverted word splitting change in 0.3.2-1 since the fix was broken and
    major work (the quote removal is done too quickly at the moment) is needed
    to fix it properly.
  * Fixed more trap noncompliance.

 -- Herbert Xu <herbert@debian.org>  Thu, 19 Mar 1998 22:59:12 +1100

ash (0.3.2-5) unstable; urgency=low

  * Fixed a bug when doing pattern matching in parameter expansions.

 -- Herbert Xu <herbert@debian.org>  Tue, 10 Mar 1998 21:25:40 +1100

ash (0.3.2-4) unstable; urgency=low

  * Allow ] to be quoted in bracket expressions (fixes #17533).
  * Move dh_fixperms to second last spot (fixes #18267).
  * Don't do field splitting in evalfor.

 -- Herbert Xu <herbert@debian.org>  Tue, 17 Feb 1998 13:32:09 +1100

ash (0.3.2-3) unstable; urgency=low

  * Fixed stupid core dump.

 -- Herbert Xu <herbert@debian.org>  Wed, 11 Feb 1998 21:33:55 +1100

ash (0.3.2-2) unstable; urgency=low

  * Hack for special builtins (fixes #18055).
  * Hack for command.

 -- Herbert Xu <herbert@debian.org>  Wed, 11 Feb 1998 21:19:46 +1100

ash (0.3.2-1) unstable; urgency=low

  * NetBSD-current version as of 19980209.
  * Fixed a word splitting problem after parameter expansion thanks to Alexey
    Marinichev.
  * Converted to debhelper (fixes #14612, #15005).

 -- Herbert Xu <herbert@debian.org>  Mon,  9 Feb 1998 16:53:48 +1100

ash (0.3.1-20) unstable; urgency=low

  * Fixed -e problem with eval.

 -- Herbert Xu <herbert@debian.org>  Sun,  7 Dec 1997 20:19:00 +1100

ash (0.3.1-19) unstable; urgency=low

  * Fixed -e problem with command substitution.

 -- Herbert Xu <herbert@debian.org>  Sun,  7 Dec 1997 19:44:49 +1100

ash (0.3.1-18) unstable; urgency=low

  * Do not link with ncurses (#15485).

 -- Herbert Xu <herbert@debian.org>  Sun, 30 Nov 1997 12:00:11 +1100

ash (0.3.1-17) unstable; urgency=low

  * Set PATH like bash (#15238).

 -- Herbert Xu <herbert@debian.org>  Wed, 26 Nov 1997 16:17:27 +1100

ash (0.3.1-16) unstable; urgency=low

  * Fixed incorrect assignment builtin code.

 -- Herbert Xu <herbert@debian.org>  Mon, 24 Nov 1997 16:19:10 +1100

ash (0.3.1-15) unstable; urgency=low

  * hash now returns error codes (needed by the Linux kernel).

 -- Herbert Xu <herbert@debian.org>  Sun, 23 Nov 1997 21:37:08 +1100

ash (0.3.1-14) unstable; urgency=low

  * Disabled word-splitting for assignment builtins.

 -- Herbert Xu <herbert@debian.org>  Sun, 23 Nov 1997 12:45:15 +1100

ash (0.3.1-13) unstable; urgency=low

  * ! is now recognised even after &&/||.

 -- Herbert Xu <herbert@debian.org>  Fri, 21 Nov 1997 22:09:05 +1100

ash (0.3.1-12) unstable; urgency=low

  * More fixes to the handling of SIGINT when forking.

 -- Herbert Xu <herbert@debian.org>  Fri, 14 Nov 1997 15:14:32 +1100

ash (0.3.1-11) unstable; urgency=low

  * Ignore SIGINT when forking non-interactively.

 -- Herbert Xu <herbert@debian.org>  Mon,  3 Nov 1997 12:00:02 +1100

ash (0.3.1-10) unstable; urgency=low

  * echo now handles options correctly.
  * echo nolonger returns 0 if erorrs occured while writing to stdout.
  * New code from GNU echo merged.
  * Error messages from test now work.

 -- Herbert Xu <herbert@debian.org>  Wed,  8 Oct 1997 21:47:13 +1000

ash (0.3.1-9) unstable; urgency=low

  * ! is recognised at pipeline level like bash.

 -- Herbert Xu <herbert@debian.org>  Mon, 15 Sep 1997 23:13:45 +1000

ash (0.3.1-8) unstable; urgency=medium

  * Old patch regarding SIGCHLD in again.

 -- Herbert Xu <herbert@debian.org>  Sun, 31 Aug 1997 11:20:27 +1000

ash (0.3.1-7) unstable; urgency=low

  * /bin/sh -e is behaving even better now (for loops within conditionals).

 -- Herbert Xu <herbert@debian.org>  Sat, 23 Aug 1997 22:08:19 +1000

ash (0.3.1-6) unstable; urgency=low

  * /bin/sh -e is behaving better now.

 -- Herbert Xu <herbert@debian.org>  Sat, 23 Aug 1997 13:16:26 +1000

ash (0.3.1-5) unstable; urgency=low

  * hash -v /dir/command doesn't coredump anymore.
  * type /dir/command now works correctly.

 -- Herbert Xu <herbert@debian.org>  Fri,  1 Aug 1997 20:48:19 +1000

ash (0.3.1-4) unstable; urgency=low

  * trap now understands symbolic signal names.

 -- Herbert Xu <herbert@debian.org>  Sat, 26 Jul 1997 14:04:46 +1000

ash (0.3.1-3) unstable; urgency=low

  * Added the builtin test command.

 -- Herbert Xu <herbert@debian.org>  Sun, 20 Jul 1997 15:00:14 +1000

ash (0.3.1-2) unstable; urgency=medium

  * Fixed a coredump involving $*.

 -- Herbert Xu <herbert@debian.org>  Sat, 19 Jul 1997 12:03:02 +1000

ash (0.3.1-1) unstable; urgency=medium

  * NetBSD-current version as of 19970715.
  * Fixed a "use after free" bug (#11294).

 -- Herbert Xu <herbert@debian.org>  Fri, 18 Jul 1997 13:48:09 +1000

ash (0.3-1) unstable; urgency=low

  * Initial Release.

 -- Herbert Xu <herbert@debian.org>  Thu, 19 Jun 1997 19:29:16 +1000


Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/compat (+1 lines)
	1	4




Source: dash
Section: shells
Priority: optional
Maintainer: Herbert Xu <herbert@debian.org>
Build-Depends: byacc, debhelper (>= 4), pmake
Standards-Version: 3.5.8

Package: dash
Architecture: any
Pre-Depends: ${shlibs:Depends}
Description: The Debian Almquist Shell
 "dash" is a POSIX compliant shell that is much smaller than "bash".
 We take advantage of that by making it the shell on the installation
 root floppy, where space is at a premium.
 .
 It can be usefully installed as /bin/sh (because it executes scripts
 somewhat faster than "bash"), or as the default shell either of root
 or of a second user with a userid of 0 (because it depends on fewer
 libraries, and is therefore less likely to be affected by an upgrade
 problem or a disk failure).  It is also useful for checking that a
 script uses only POSIX syntax.
 .
 "bash" is a better shell for most users, since it has some nice
 features absent from "dash", and is a required part of the system.

Package: dash-udeb
Architecture: any
Depends: ${shlibs:Depends}
Section: debian-installer
Priority: standard
Description: The Debian Almquist Shell for boot floppies
 "dash" is a POSIX compliant shell that is much smaller than "bash".
 We take advantage of that by making it the shell on the installation
 root floppy, where space is at a premium.
 .
 It can be usefully installed as /bin/sh (because it executes scripts
 somewhat faster than "bash"), or as the default shell either of root
 or of a second user with a userid of 0 (because it depends on fewer
 libraries, and is therefore less likely to be affected by an upgrade
 problem or a disk failure).  It is also useful for checking that a
 script uses only POSIX syntax.
 .
 "bash" is a better shell for most users, since it has some nice
 features absent from "dash", and is a required part of the system.

Package: ash
Architecture: all
Pre-Depends: dash
Description: Compatibility package for the Debian Almquist Shell
 This package exists so that users of the "ash" package can upgrade to the
 "dash" package which replaces the former.  It includes the /bin/ash symlink.
 You can remove this package if you do not use /bin/ash explicitly.





This package was debianized by Mark W. Eichin eichin@kitten.gen.ma.us on
Mon, 24 Feb 1997 16:00:16 -0500.

This package was re-ported from NetBSD and debianized by
Herbert Xu herbert@debian.org on Thu, 19 Jun 1997 19:29:16 +1000.

It was downloaded from ftp.netbsd.org.

Copyright:

Copyright (c) 1989-1994
	The Regents of the University of California.  All rights reserved.
Copyright (c) 1997-2002
	Herbert Xu <herbert@debian.org>

This code is derived from software contributed to Berkeley by Kenneth Almquist.

Please refer to /usr/share/common-licenses/BSD for details.

mksignames.c:

This file is not directly linked with dash.  However, its output is.

Copyright (C) 1992 Free Software Foundation, Inc.

This file is part of GNU Bash, the Bourne Again SHell.

Bash is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.

Bash is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License with
your Debian GNU/Linux system, in /usr/share/common-licenses/GPL, or with the
Debian GNU/Linux hello source package as the file COPYING.  If not,
write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111 USA.

$Id: copyright,v 1.6 2003/01/01 01:51:50 herbert Exp $




#!/bin/sh
#
# debconf script for the Debian GNU/Linux ash package
#
# $Id: dash.config,v 1.1 2002/09/14 06:17:50 herbert Exp $

set -e

. /usr/share/debconf/confmodule

db_version 2.0

if [ "$1" = configure ] && [ -z "$2" ]; then
	set +e
	db_fget ash/sh seen
	err=$?
	set -e

	case $err in
	0)
		if [ "$RET" = true ]; then
			db_fset dash/sh seen true
			db_get ash/sh
			db_set dash/sh "$RET"
			exit
		fi
		;;
	10)
		# ash/sh does not exist
		;;
	*)
		echo "db_fget exited with $err" >&2
		exit $err
		;;
	esac
fi

db_input low dash/sh || true
db_go

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/dash.dirs (+2 lines)
	1	bin
	2	usr/share/man/man1




#!/bin/sh
#
# post-install script for the Debian GNU/Linux dash package
#
# $Id: dash.postinst,v 1.3 2002/10/26 11:26:55 herbert Exp $

set -e

check_divert() {
	div=$(dpkg-divert --list $2)
	distrib=${4:-$2.distrib}
	case "$1" in
	true)
		if [ -z "$div" ]; then
			dpkg-divert --package dash --divert $distrib --add $2
			cp -dp $2 $distrib
			ln -sf $3 $2
		fi
		;;
	false)
		if [ -n "$div" ] && [ -z "${div%%*by dash}" ]; then
			mv $distrib $2
			dpkg-divert --remove $2
		fi
		;;
	ash)
		case $div in
		'')
			;;
		*by\ ash)
			dst=${div% by ash}
			dst=${dst##* to }

			# Work around dpkg-divert bug.
			if [ -e "$dst" ]; then
				mv "$dst" "$dst.dash-tmp"
			fi
			dpkg-divert --remove $2
			if [ -e "$dst.dash-tmp" ]; then
				mv "$dst.dash-tmp" "$dst"
			fi

			dpkg-divert --package dash --divert $distrib --add $2
			if [ "$dst" != $distrib ] && [ -e "$dst" ]; then
				mv "$dst" $distrib
			fi
			ln -sf $3 $2
			;;
		*)
			d=${2%/*}
			if
				[ -h $2 ] && [ -f $2 ] && [ -f $d/$5 ] &&
				cmp $2 $d/$5
			then
				ln -sf $3 $2
			fi
			;;
		esac
	esac
}

debconf=
if [ -f /usr/share/debconf/confmodule ]; then
	. /usr/share/debconf/confmodule
	debconf=yes
fi

if [ "$1" = configure ] && [ -z "$2" ]; then
	check_divert ash /bin/sh dash '' ash
	check_divert ash /usr/share/man/man1/sh.1.gz dash.1.gz \
		/usr/share/man/man1/sh.distrib.1.gz ash.1.gz
fi

if [ $debconf ]; then
	db_get dash/sh
	check_divert "$RET" /bin/sh dash
	check_divert "$RET" /usr/share/man/man1/sh.1.gz dash.1.gz \
		/usr/share/man/man1/sh.distrib.1.gz
fi

#DEBHELPER#




#!/bin/sh
#
# pre-removal script for the Debian GNU/Linux ash package
#
# $Id: dash.prerm,v 1.1 2002/09/14 06:17:50 herbert Exp $

set -e

remove_divert() {
	div=$(dpkg-divert --list $1)
	if [ -n "$div" ] && [ -z "${div%%*by dash}" ]; then
		distrib=${div% by dash}
		distrib=${distrib##* to }
		mv $distrib $1
		dpkg-divert --remove $1
	fi
}

if [ "$1" = remove ] || [ "$1" = deconfigure ]; then
	remove_divert /bin/sh
	remove_divert /usr/share/man/man1/sh.1.gz
fi

#DEBHELPER#

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/dash.templates (+10 lines)
	1	Template: dash/sh
	2	Type: boolean
	3	Default: false
	4	Description: Install dash as /bin/sh?
	5	Bash is the default /bin/sh on a Debian system. However, since our policy
	6	requires all shell scripts using /bin/sh to be POSIX compliant, any shell
	7	that conforms to POSIX can serve as /bin/sh. Since dash is POSIX compliant,
	8	it can be used as /bin/sh. You may wish to do this because dash is faster
	9	and smaller than bash.
	10




Template: dash/sh
Description: Install dash as /bin/sh?
 Bash is the default /bin/sh on a Debian system.  However, since our policy
 requires all shell scripts using /bin/sh to be POSIX compliant, any shell
 that conforms to POSIX can serve as /bin/sh.  Since dash is POSIX compliant,
 it can be used as /bin/sh.
Description-de: dash als /bin/sh installieren?
 Bash ist die Standard-Shell (/bin/sh) auf einem Debian-System. Da die
 Debian-Policy von allen Shellscripts, die /bin/sh benutzen,
 POSIX-Kompatibilität verlangt, kann für /bin/sh jede POSIX-kompatible Shell
 benutzt werden. Dash ist POSIX-kompatibel und kann daher als /bin/sh verwendet
 werden.





Template: dash/sh
Description: Install dash as /bin/sh?
 Bash is the default /bin/sh on a Debian system.  However, since our policy
 requires all shell scripts using /bin/sh to be POSIX compliant, any shell
 that conforms to POSIX can serve as /bin/sh.  Since dash is POSIX compliant,
 it can be used as /bin/sh.
Description-es: ¿Instalar dash como /bin/sh?
 Bash es el intérprte de comandos /bin/sh por defecto de los sistemas Debian.
 Sin embargo, dado que nuestras normas obligan a que todos los scripts para el
 intérprete de comandos se atengan a las normas POSIX, cualquier intérprete
 compatible con POSIX puede servir como /bin/sh.  Puesto que dash lo es, puede
 usarse como /bin/sh.





Template: dash/sh
Description: Install dash as /bin/sh?
 Bash is the default /bin/sh on a Debian system.  However, since our policy
 requires all shell scripts using /bin/sh to be POSIX compliant, any shell
 that conforms to POSIX can serve as /bin/sh.  Since dash is POSIX compliant,
 it can be used as /bin/sh.
Description-fr: Mettre un lien de /bin/sh vers dash ?
 Sur un système Debian, /bin/sh est bash par défaut. Cependant, comme notre
 charte impose que tous les scripts shells utilisant /bin/sh soient conformes
 à la norme POSIX, /bin/sh peut être n'importe quel shell conforme à cette
 norme. Et comme dash l'est, il peut servir de /bin/sh.


Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/dash.templates.ja (+13 lines)
	1	Template: dash/sh
	2	Description: Install dash as /bin/sh?
	3	Bash is the default /bin/sh on a Debian system. However, since our policy
	4	requires all shell scripts using /bin/sh to be POSIX compliant, any shell
	5	that conforms to POSIX can serve as /bin/sh. Since dash is POSIX compliant,
	6	it can be used as /bin/sh.
	7	Description-ja: dash ¤ò /bin/sh ¤È¤·¤Æ¥¤¥ó¥¹¥È¡¼¥ë¤·¤Þ¤¹¤«?
	8	Debian ¥·¥¹¥Æ¥à¤Ç¤Ï bash ¤¬¥Ç¥Õ¥©¥ë¥È¤Î /bin/sh ¤Ç¤¹¡£¤·¤«¤·¡¢Debian
	9	¤Î¥Ý¥ê¥·¡¼¤Ë¤è¤Ã¤Æ¡¢/bin/sh ¤òÍÑ¤¤¤ëÁ´¤Æ¤Î¥·¥§¥ë¥¹¥¯¥ê¥×¥È¤Ï POSIX
	10	½àµò¤Ç¤Ê¤±¤ì¤Ð¤Ê¤é¤Ê¤¤¤¿¤á¡¢POSIX ¤òËþ¤¿¤¹¥·¥§¥ë¤Ï¤É¤ì¤Ç¤â /bin/sh
	11	¤È¤Ê¤ë¤³¤È¤¬¤Ç¤¤Þ¤¹¡£dash ¤Ï POSIX ½àµò¤Ç¤¹¤Î¤Ç¡¢/bin/sh ¤È¤·¤Æ»È¤¦
	12	¤³¤È¤¬¤Ç¤¤Þ¤¹¡£
	13




Template: dash/sh
Description: Install dash as /bin/sh?
 Bash is the default /bin/sh on a Debian system.  However, since our policy
 requires all shell scripts using /bin/sh to be POSIX compliant, any shell
 that conforms to POSIX can serve as /bin/sh.  Since dash is POSIX compliant,
 it can be used as /bin/sh.
Description-pt_BR: Instalar dash como /bin/sh ?
 Bash é o /bin/sh padrão em um sistema Debian. Porém, uma vez que nossa
 política requer que todos os shell scripts usando /bin/sh sejam compatíveis
 POSIX, qualquer shell que esteja em conformidade POSIX pode servir como
 /bin/sh. Uma vez que dash é compatível POSIX, pode ser usado como /bin/sh.


Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/dash.templates.ru (+13 lines)
	1	Template: dash/sh
	2	Description: Install dash as /bin/sh?
	3	Bash is the default /bin/sh on a Debian system. However, since our policy
	4	requires all shell scripts using /bin/sh to be POSIX compliant, any shell
	5	that conforms to POSIX can serve as /bin/sh. Since dash is POSIX compliant,
	6	it can be used as /bin/sh.
	7	Description-ru: õÓÔÁÎÏ×ÉÔØ dash ËÁË /bin/sh?
	8	Bash - ÜÔÏ /bin/sh ÐÏ ÕÍÏÌÞÁÎÉÀ × ÓÉÓÔÅÍÅ Debian. ïÄÎÁËÏ, ÔÁË ËÁË ÎÁÛÁ
	9	ÐÏÌÉÔÉËÁ ÔÒÅÂÕÅÔ, ÞÔÏÂÙ ×ÓÅ ÓÃÅÎÁÒÉÉ ÏÂÏÌÏÞËÉ, ÉÓÐÏÌØÚÕÀÝÉÅ /bin/sh,
	10	ÂÙÌÉ ÓÏ×ÍÅÓÔÉÍÙÍÉ Ó POSIX, ÔÏ ÒÁÂÏÔÁÔØ ËÁË /bin/sh ÍÏÖÅÔ ÌÀÂÁÑ
	11	ÏÂÏÌÏÞËÁ, ÓÏ×ÍÅÓÔÉÍÁÑ Ó POSIX. ôÁË ËÁË dash ÓÏ×ÍÅÓÔÉÍ Ó POSIX, ÔÏ ÏÎ
	12	ÍÏÖÅÔ ÉÓÐÏÌØÚÏ×ÁÔØÓÑ ËÁË /bin/sh.
	13




Template: dash/sh
Type: boolean
Description: Install dash as /bin/sh?
 Bash is the default /bin/sh on a Debian system.  However, since our policy
 requires all shell scripts using /bin/sh to be POSIX compliant, any shell
 that conforms to POSIX can serve as /bin/sh.  Since dash is POSIX compliant,
 it can be used as /bin/sh.
Description-sv: Installera dash som /bin/sh?
 Bash är standardinställningen för /bin/sh på Debiansystem.  Eftersom vår
 policy kräver att alla script som använder /bin/sh måste vara
 POSIX-kompatibla, kan vilket POSIX-kompatibelt skal som helst vara /bi/sh.  Då
 dash är POSIX-kompatibelt kan det användas som /bin/sh.


Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/dash-udeb.dirs (+1 lines)
	1	bin




#!/usr/bin/make -f
# $Id: rules,v 1.38 2002/12/16 08:07:10 herbert Exp $

# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1

# This has to be exported to make some magic below work.
export DH_OPTIONS

DEB_HOST_ARCH := $(shell dpkg-architecture -qDEB_HOST_ARCH)

CDEF := \
	-Wall -DBSD=1 -DSMALL -D_GNU_SOURCE -DGLOB_BROKEN -DHAVE_VASPRINTF=1 \
	-DIFS_BROKEN -DGCC_BROKEN_NG \
	-D__COPYRIGHT\(x\)= -D__RCSID\(x\)= -D_DIAGASSERT\(x\)=

OPT := -g -O2 -fstrict-aliasing
OPTSM := -g -Os -fstrict-aliasing -fomit-frame-pointer -DREALLY_SMALL

ifeq ($(DEB_HOST_ARCH),i386)
OPTSM += \
	-malign-loops=0 -malign-jumps=0 -malign-functions=0 \
	-mpreferred-stack-boundary=2 -DUSE_NORETURN
endif

setup: setup-stamp
setup-stamp:
	rm -rf obj obj-udeb
	mkdir obj obj-udeb
	chmod u+x debian/bsdyacc
	touch setup-stamp

build: setup-stamp
	dh_testdir

	pmake CFLAGS:='$(CDEF) $(OPT)' \
		YACC:='$${.CURDIR}/debian/bsdyacc'
	MAKEOBJDIR=obj-udeb pmake CFLAGS:='$(CDEF) $(OPTSM)' \
		YACC:='$${.CURDIR}/debian/bsdyacc'

clean:
	dh_testdir
	dh_testroot
	rm -f setup-stamp

	rm -rf obj obj-udeb

	dh_clean

install: build
	dh_testdir
	dh_testroot
	dh_clean -k
	dh_installdirs

	install obj/sh debian/dash/bin/dash
	install -m 644 sh.1 debian/dash/usr/share/man/man1/dash.1
	install obj-udeb/sh debian/dash-udeb/bin/dash
	ln -s dash debian/dash-udeb/bin/sh
	ln -s dash debian/ash/bin/ash
	ln -s dash.1.gz debian/ash/usr/share/man/man1/ash.1.gz

# This single target is used to build all the packages, all at once, or
# one at a time. So keep in mind: any options passed to commands here will
# affect _all_ packages. Anything you want to only affect one package
# should be put in another target, such as the install target.
binary-common:
	dh_testdir
	dh_testroot
	dh_installdebconf
	dh_installdocs -Ndash-udeb
	dh_installexamples
	dh_installmenu
	dh_installcron
	dh_installchangelogs -Ndash-udeb
ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))
	dh_strip
endif
	dh_compress
	dh_fixperms
	dh_installdeb -Ndash-udeb
	dh_shlibdeps
	dh_gencontrol
	dh_md5sums
	dh_builddeb

# Build architecture-independent files here.
binary-indep: install
	$(MAKE) -f debian/rules DH_OPTIONS=-i binary-common

# Build architecture-dependent files here.
binary-arch: install
	$(MAKE) -f debian/rules DH_OPTIONS=-a binary-common

	for i in ../dash-udeb_*.deb; do mv $$i $${i%deb}udeb; done
	sed '/^[^ ]*\.udeb/d; s/^\(dash-udeb_[^ ]*\.\)deb/\1udeb/' \
		debian/files > debian/files.new
	mv debian/files.new debian/files

binary: binary-indep binary-arch
.PHONY: build clean binary-indep binary-arch binary binary-common install setup

Lines 1-4 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/error.c (-111 / +71 lines)
1	/* $NetBSD: error.c,v 1.24 2002/05/15 16:33:35 christos Exp $ */	1	/* $NetBSD: error.c,v 1.25 2002/05/25 23:09:06 wiz Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 1991, 1993	4	* Copyright (c) 1991, 1993
Lines 41-47 Link Here
41	#if 0	41	#if 0
42	static char sccsid[] = "@(#)error.c 8.2 (Berkeley) 5/4/95";	42	static char sccsid[] = "@(#)error.c 8.2 (Berkeley) 5/4/95";
43	#else	43	#else
44	__RCSID("$NetBSD: error.c,v 1.24 2002/05/15 16:33:35 christos Exp $");	44	__RCSID("$NetBSD: error.c,v 1.25 2002/05/25 23:09:06 wiz Exp $");
45	#endif	45	#endif
46	#endif /* not lint */	46	#endif /* not lint */
47		47
Lines 51-56 Link Here
51		51
52	#include <signal.h>	52	#include <signal.h>
53	#include <stdlib.h>	53	#include <stdlib.h>
		54	#include <string.h>
54	#include <unistd.h>	55	#include <unistd.h>
55	#include <errno.h>	56	#include <errno.h>
56		57
Lines 60-65 Link Here
60	#include "output.h"	61	#include "output.h"
61	#include "error.h"	62	#include "error.h"
62	#include "show.h"	63	#include "show.h"
		64	#include "eval.h"
		65	#include "parser.h"
63		66
64		67
65	/*	68	/*
Lines 68-80 Link Here
68		71
69	struct jmploc *handler;	72	struct jmploc *handler;
70	int exception;	73	int exception;
71	volatile int suppressint;	74	int suppressint;
72	volatile int intpending;	75	volatile sig_atomic_t intpending;
73	char *commandname;
74		76
75		77
76	static void exverror __P((int, const char *, va_list))	78	static void exverror(int, const char *, va_list) __attribute__((__noreturn__));
77	__attribute__((__noreturn__));	79	static void vwarn(const char *, va_list);
78		80
79	/*	81	/*
80	* Called to raise an exception. Since C doesn't include exceptions, we	82	* Called to raise an exception. Since C doesn't include exceptions, we
Lines 86-93 Link Here
86	exraise(e)	88	exraise(e)
87	int e;	89	int e;
88	{	90	{
		91	#ifdef DEBUG
89	if (handler == NULL)	92	if (handler == NULL)
90	abort();	93	abort();
		94	#endif
		95	INTOFF;
		96
91	exception = e;	97	exception = e;
92	longjmp(handler->loc, 1);	98	longjmp(handler->loc, 1);
93	}	99	}
Lines 97-125 Link Here
97	* Called from trap.c when a SIGINT is received. (If the user specifies	103	* Called from trap.c when a SIGINT is received. (If the user specifies
98	* that SIGINT is to be trapped or ignored using the trap builtin, then	104	* that SIGINT is to be trapped or ignored using the trap builtin, then
99	* this routine is not called.) Suppressint is nonzero when interrupts	105	* this routine is not called.) Suppressint is nonzero when interrupts
100	* are held using the INTOFF macro. The call to _exit is necessary because	106	* are held using the INTOFF macro. (The test for iflag is just
101	* there is a short period after a fork before the signal handlers are	107	* defensive programming.)
102	* set to the appropriate value for the child. (The test for iflag is
103	* just defensive programming.)
104	*/	108	*/
105		109
106	void	110	void
107	onint() {	111	onint() {
108	sigset_t sigset;
109
110	if (suppressint) {
111	intpending++;
112	return;
113	}
114	intpending = 0;	112	intpending = 0;
115	sigemptyset(&sigset);	113	if (!(rootshell && iflag)) {
116	sigprocmask(SIG_SETMASK, &sigset, NULL);
117	if (rootshell && iflag)
118	exraise(EXINT);
119	else {
120	signal(SIGINT, SIG_DFL);	114	signal(SIGINT, SIG_DFL);
121	raise(SIGINT);	115	raise(SIGINT);
122	}	116	}
		117	exraise(EXINT);
123	/* NOTREACHED */	118	/* NOTREACHED */
124	}	119	}
125		120
Lines 135-207 Link Here
135	const char *msg;	130	const char *msg;
136	va_list ap;	131	va_list ap;
137	{	132	{
138	CLEAR_PENDING_INT;
139	INTOFF;
140
141	#ifdef DEBUG	133	#ifdef DEBUG
142	if (msg)	134	if (msg)
143	TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid()));	135	TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid()));
144	else	136	else
145	TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));	137	TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
146	#endif	138	#endif
147	if (msg) {	139	vwarn(msg, ap);
148	if (commandname)
149	outfmt(&errout, "%s: ", commandname);
150	doformat(&errout, msg, ap);
151	out2c('\n');
152	}
153	flushall();	140	flushall();
154	exraise(cond);	141	exraise(cond);
155	/* NOTREACHED */	142	/* NOTREACHED */
156	}	143	}
157		144
158		145
159	#ifdef __STDC__
160	void	146	void
161	error(const char *msg, ...)	147	error(const char *msg, ...)
162	#else
163	void
164	error(va_alist)
165	va_dcl
166	#endif
167	{	148	{
168	#ifndef __STDC__
169	const char *msg;
170	#endif
171	va_list ap;	149	va_list ap;
172	#ifdef __STDC__	150
173	va_start(ap, msg);	151	va_start(ap, msg);
174	#else
175	va_start(ap);
176	msg = va_arg(ap, const char *);
177	#endif
178	exverror(EXERROR, msg, ap);	152	exverror(EXERROR, msg, ap);
179	/* NOTREACHED */	153	/* NOTREACHED */
180	va_end(ap);	154	va_end(ap);
181	}	155	}
182		156
183		157
184	#ifdef __STDC__
185	void	158	void
186	exerror(int cond, const char *msg, ...)	159	exerror(int cond, const char *msg, ...)
187	#else
188	void
189	exerror(va_alist)
190	va_dcl
191	#endif
192	{	160	{
193	#ifndef __STDC__
194	int cond;
195	const char *msg;
196	#endif
197	va_list ap;	161	va_list ap;
198	#ifdef __STDC__	162
199	va_start(ap, msg);	163	va_start(ap, msg);
200	#else
201	va_start(ap);
202	cond = va_arg(ap, int);
203	msg = va_arg(ap, const char *);
204	#endif
205	exverror(cond, msg, ap);	164	exverror(cond, msg, ap);
206	/* NOTREACHED */	165	/* NOTREACHED */
207	va_end(ap);	166	va_end(ap);
Lines 223-278 Link Here
223	#define ALL (E_OPEN\|E_CREAT\|E_EXEC)	182	#define ALL (E_OPEN\|E_CREAT\|E_EXEC)
224		183
225	STATIC const struct errname errormsg[] = {	184	STATIC const struct errname errormsg[] = {
226	{ EINTR, ALL, "interrupted" },	185	{ ENOENT, E_OPEN, "No such file" },
227	{ EACCES, ALL, "permission denied" },	186	{ ENOENT, E_CREAT,"Directory nonexistent" },
228	{ EIO, ALL, "I/O error" },
229	{ EEXIST, ALL, "file exists" },
230	{ ENOENT, E_OPEN, "no such file" },
231	{ ENOENT, E_CREAT,"directory nonexistent" },
232	{ ENOENT, E_EXEC, "not found" },	187	{ ENOENT, E_EXEC, "not found" },
233	{ ENOTDIR, E_OPEN, "no such file" },	188	{ ENOTDIR, E_OPEN, "No such file" },
234	{ ENOTDIR, E_CREAT,"directory nonexistent" },	189	{ ENOTDIR, E_CREAT,"Directory nonexistent" },
235	{ ENOTDIR, E_EXEC, "not found" },	190	{ ENOTDIR, E_EXEC, "not found" },
236	{ EISDIR, ALL, "is a directory" },
237	#ifdef notdef
238	{ EMFILE, ALL, "too many open files" },
239	#endif
240	{ ENFILE, ALL, "file table overflow" },
241	{ ENOSPC, ALL, "file system full" },
242	#ifdef EDQUOT
243	{ EDQUOT, ALL, "disk quota exceeded" },
244	#endif
245	#ifdef ENOSR
246	{ ENOSR, ALL, "no streams resources" },
247	#endif
248	{ ENXIO, ALL, "no such device or address" },
249	{ EROFS, ALL, "read-only file system" },
250	{ ETXTBSY, ALL, "text busy" },
251	#ifdef SYSV	191	#ifdef SYSV
252	{ EAGAIN, E_EXEC, "not enough memory" },	192	{ EAGAIN, E_EXEC, "Not enough memory" },
253	#endif
254	{ ENOMEM, ALL, "not enough memory" },
255	#ifdef ENOLINK
256	{ ENOLINK, ALL, "remote access failed" },
257	#endif
258	#ifdef EMULTIHOP
259	{ EMULTIHOP, ALL, "remote access failed" },
260	#endif
261	#ifdef ECOMM
262	{ ECOMM, ALL, "remote access failed" },
263	#endif
264	#ifdef ESTALE
265	{ ESTALE, ALL, "remote access failed" },
266	#endif
267	#ifdef ETIMEDOUT
268	{ ETIMEDOUT, ALL, "remote access failed" },
269	#endif
270	#ifdef ELOOP
271	{ ELOOP, ALL, "symbolic link loop" },
272	#endif
273	{ E2BIG, E_EXEC, "argument list too long" },
274	#ifdef ELIBACC
275	{ ELIBACC, E_EXEC, "shared library missing" },
276	#endif	193	#endif
277	{ 0, 0, NULL },	194	{ 0, 0, NULL },
278	};	195	};
Lines 290-301 Link Here
290	int action;	207	int action;
291	{	208	{
292	struct errname const *ep;	209	struct errname const *ep;
293	static char buf[12];
294		210
295	for (ep = errormsg ; ep->errcode ; ep++) {	211	for (ep = errormsg ; ep->errcode ; ep++) {
296	if (ep->errcode == e && (ep->action & action) != 0)	212	if (ep->errcode == e && (ep->action & action) != 0)
297	return ep->msg;	213	return ep->msg;
298	}	214	}
299	fmtstr(buf, sizeof buf, "error %d", e);	215	return strerror(e);
300	return buf;	216	}
		217
		218
		219	#ifdef REALLY_SMALL
		220	void
		221	__inton() {
		222	if (--suppressint == 0 && intpending) {
		223	onint();
		224	}
		225	}
		226	#endif
		227
		228
		229
		230	/*
		231	* Print an error message for the current command.
		232	*/
		233	static void vwarn(const char *const msg, va_list ap) {
		234	struct output *errs;
		235	const char *name;
		236	const char *fmt;
		237
		238	errs = out2;
		239	name = arg0;
		240	fmt = "%s: ";
		241	if (commandname) {
		242	name = commandname;
		243	fmt = "%s: %d: ";
		244	}
		245	outfmt(errs, fmt, name, startlinno);
		246	doformat(errs, msg, ap);
		247	#if FLUSHERR
		248	outc('\n', errs);
		249	#else
		250	outcslow('\n', errs);
		251	#endif
		252	}
		253
		254
		255	void warnx(const char *msg, ...) {
		256	va_list ap;
		257
		258	va_start(ap, msg);
		259	vwarn(msg, ap);
		260	va_end(ap);
301	}	261	}

Lines 38-43 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/error.h (-8 / +43 lines)
38	* @(#)error.h 8.2 (Berkeley) 5/4/95	38	* @(#)error.h 8.2 (Berkeley) 5/4/95
39	*/	39	*/
40		40
		41	#include <setjmp.h>
		42	#include <signal.h>
		43
41	/*	44	/*
42	* Types of operations (passed to the errmsg routine).	45	* Types of operations (passed to the errmsg routine).
43	*/	46	*/
Lines 57-64 Link Here
57	* inner scope, and restore handler on exit from the scope.	60	* inner scope, and restore handler on exit from the scope.
58	*/	61	*/
59		62
60	#include <setjmp.h>
61
62	struct jmploc {	63	struct jmploc {
63	jmp_buf loc;	64	jmp_buf loc;
64	};	65	};
Lines 71-76 Link Here
71	#define EXERROR 1 /* a generic error */	72	#define EXERROR 1 /* a generic error */
72	#define EXSHELLPROC 2 /* execute a shell procedure */	73	#define EXSHELLPROC 2 /* execute a shell procedure */
73	#define EXEXEC 3 /* command execution failed */	74	#define EXEXEC 3 /* command execution failed */
		75	#define EXEXIT 4 /* exit the shell */
74		76
75		77
76	/*	78	/*
Lines 80-99 Link Here
80	* more fun than worrying about efficiency and portability. :-))	82	* more fun than worrying about efficiency and portability. :-))
81	*/	83	*/
82		84
83	extern volatile int suppressint;	85	extern int suppressint;
84	extern volatile int intpending;	86	extern volatile sig_atomic_t intpending;
85		87
86	#define INTOFF suppressint++	88	#define barrier() ({ __asm__ __volatile__ ("": : :"memory"); })
87	#define INTON { if (--suppressint == 0 && intpending) onint(); }	89	#define INTOFF \
88	#define FORCEINTON {suppressint = 0; if (intpending) onint();}	90	({ \
		91	suppressint++; \
		92	barrier(); \
		93	0; \
		94	})
		95	#ifdef REALLY_SMALL
		96	void __inton __P((void));
		97	#define INTON __inton()
		98	#else
		99	#define INTON \
		100	({ \
		101	barrier(); \
		102	if (--suppressint == 0 && intpending) onint(); \
		103	0; \
		104	})
		105	#endif
		106	#define FORCEINTON \
		107	({ \
		108	barrier(); \
		109	suppressint = 0; \
		110	if (intpending) onint(); \
		111	0; \
		112	})
		113	#define SAVEINT(v) ((v) = suppressint)
		114	#define RESTOREINT(v) \
		115	({ \
		116	barrier(); \
		117	if ((suppressint = (v)) == 0 && intpending) onint(); \
		118	})
89	#define CLEAR_PENDING_INT intpending = 0	119	#define CLEAR_PENDING_INT intpending = 0
90	#define int_pending() intpending	120	#define int_pending() intpending
91		121
92	void exraise __P((int)) __attribute__((__noreturn__));	122	void exraise __P((int)) __attribute__((__noreturn__));
		123	#ifdef USE_NORETURN
		124	void onint __P((void)) __attribute__((__noreturn__));
		125	#else
93	void onint __P((void));	126	void onint __P((void));
		127	#endif
94	void error __P((const char *, ...)) __attribute__((__noreturn__));	128	void error __P((const char *, ...)) __attribute__((__noreturn__));
95	void exerror __P((int, const char *, ...)) __attribute__((__noreturn__));	129	void exerror __P((int, const char *, ...)) __attribute__((__noreturn__));
96	const char *errmsg __P((int, int));	130	const char *errmsg __P((int, int));
		131	void warnx __P((const char *, ...));
97		132
98		133
99	/*	134	/*
Lines 101-107 Link Here
101	* so we use _setjmp instead.	136	* so we use _setjmp instead.
102	*/	137	*/
103		138
104	#if defined(BSD) && !defined(__SVR4)	139	#if defined(BSD) && !defined(__SVR4) && !defined(__GLIBC__)
105	#define setjmp(jmploc) _setjmp(jmploc)	140	#define setjmp(jmploc) _setjmp(jmploc)
106	#define longjmp(jmploc, val) _longjmp(jmploc, val)	141	#define longjmp(jmploc, val) _longjmp(jmploc, val)
107	#endif	142	#endif

Lines 45-52 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/eval.c (-211 / +354 lines)
45	#endif	45	#endif
46	#endif /* not lint */	46	#endif /* not lint */
47		47
		48	#include <sys/types.h>
48	#include <signal.h>	49	#include <signal.h>
		50	#include <malloc.h>
49	#include <unistd.h>	51	#include <unistd.h>
		52	#include <errno.h>
50		53
51	/*	54	/*
52	* Evaluate a command.	55	* Evaluate a command.
Lines 98-106 Link Here
98	STATIC void evalcase __P((union node *, int));	101	STATIC void evalcase __P((union node *, int));
99	STATIC void evalsubshell __P((union node *, int));	102	STATIC void evalsubshell __P((union node *, int));
100	STATIC void expredir __P((union node *));	103	STATIC void expredir __P((union node *));
101	STATIC void evalpipe __P((union node *));	104	STATIC void evalpipe __P((union node *, int));
		105	#ifdef notyet
102	STATIC void evalcommand __P((union node , int, struct backcmd ));	106	STATIC void evalcommand __P((union node , int, struct backcmd ));
		107	#else
		108	STATIC void evalcommand __P((union node *, int));
		109	#endif
103	STATIC void prehash __P((union node *));	110	STATIC void prehash __P((union node *));
		111	STATIC void eprintlist __P((struct strlist *));
		112	#if !defined(__alpha__) \|\| !defined(GCC_BROKEN_NG)
		113	STATIC
		114	#endif
		115	void evaltreenr __P((union node *, int)) __attribute__ ((noreturn));
104		116
105		117
106	/*	118	/*
Lines 115-124 Link Here
115	loopnest = 0;	127	loopnest = 0;
116	funcnest = 0;	128	funcnest = 0;
117	}	129	}
118
119	SHELLPROC {
120	exitstatus = 0;
121	}
122	#endif	130	#endif
123		131
124		132
Lines 142-149 Link Here
142	STARTSTACKSTR(concat);	150	STARTSTACKSTR(concat);
143	ap = argv + 2;	151	ap = argv + 2;
144	for (;;) {	152	for (;;) {
145	while (*p)	153	concat = stputs(p, concat);
146	STPUTC(*p++, concat);
147	if ((p = *ap++) == NULL)	154	if ((p = *ap++) == NULL)
148	break;	155	break;
149	STPUTC(' ', concat);	156	STPUTC(' ', concat);
Lines 170-179 Link Here
170	struct stackmark smark;	177	struct stackmark smark;
171		178
172	setstackmark(&smark);	179	setstackmark(&smark);
173	setinputstring(s, 1);	180	setinputstring(s);
174	while ((n = parsecmd(0)) != NEOF) {	181	while ((n = parsecmd(0)) != NEOF) {
175	evaltree(n, flag);	182	evaltree(n, flag);
176	popstackmark(&smark);	183	popstackmark(&smark);
		184	if (evalskip)
		185	break;
177	}	186	}
178	popfile();	187	popfile();
179	popstackmark(&smark);	188	popstackmark(&smark);
Lines 191-199 Link Here
191	union node *n;	200	union node *n;
192	int flags;	201	int flags;
193	{	202	{
		203	int checkexit = 0;
		204	void (evalfn)(union node , int);
		205	unsigned isor;
		206	int status;
194	if (n == NULL) {	207	if (n == NULL) {
195	TRACE(("evaltree(NULL) called\n"));	208	TRACE(("evaltree(NULL) called\n"));
196	exitstatus = 0;
197	goto out;	209	goto out;
198	}	210	}
199	#ifndef SMALL	211	#ifndef SMALL
Lines 201-289 Link Here
201	#endif	213	#endif
202	TRACE(("evaltree(0x%lx: %d) called\n", (long)n, n->type));	214	TRACE(("evaltree(0x%lx: %d) called\n", (long)n, n->type));
203	switch (n->type) {	215	switch (n->type) {
204	case NSEMI:	216	default:
205	evaltree(n->nbinary.ch1, flags & EV_TESTED);	217	#ifdef DEBUG
206	if (evalskip)	218	out1fmt("Node type = %d\n", n->type);
207	goto out;	219	#ifndef USE_GLIBC_STDIO
208	evaltree(n->nbinary.ch2, flags);	220	flushout(out1);
209	break;	221	#endif
210	case NAND:
211	evaltree(n->nbinary.ch1, EV_TESTED);
212	if (evalskip \|\| exitstatus != 0) {
213	/* don't bomb out on "set -e; false && true" */
214	flags \|= EV_TESTED;
215	goto out;
216	}
217	evaltree(n->nbinary.ch2, flags \| EV_TESTED);
218	break;
219	case NOR:
220	evaltree(n->nbinary.ch1, EV_TESTED);
221	if (evalskip \|\| exitstatus == 0)
222	goto out;
223	evaltree(n->nbinary.ch2, flags \| EV_TESTED);
224	break;	222	break;
		223	#endif
		224	case NNOT:
		225	evaltree(n->nnot.com, EV_TESTED);
		226	status = !exitstatus;
		227	goto setstatus;
225	case NREDIR:	228	case NREDIR:
226	expredir(n->nredir.redirect);	229	expredir(n->nredir.redirect);
227	redirect(n->nredir.redirect, REDIR_PUSH);	230	status = redirectsafe(n->nredir.redirect, REDIR_PUSH);
228	evaltree(n->nredir.n, flags);	231	if (!status) {
229	popredir();	232	evaltree(n->nredir.n, flags & EV_TESTED);
		233	status = exitstatus;
		234	}
		235	popredir(0);
		236	goto setstatus;
		237	case NCMD:
		238	#ifdef notyet
		239	if (eflag && !(flags & EV_TESTED))
		240	checkexit = ~0;
		241	evalcommand(n, flags, (struct backcmd *)NULL);
230	break;	242	break;
		243	#else
		244	evalfn = evalcommand;
		245	checkexit:
		246	if (eflag && !(flags & EV_TESTED))
		247	checkexit = ~0;
		248	goto calleval;
		249	#endif
		250	case NFOR:
		251	evalfn = evalfor;
		252	goto calleval;
		253	case NWHILE:
		254	case NUNTIL:
		255	evalfn = evalloop;
		256	goto calleval;
231	case NSUBSHELL:	257	case NSUBSHELL:
232	evalsubshell(n, flags);
233	break;
234	case NBACKGND:	258	case NBACKGND:
235	evalsubshell(n, flags);	259	evalfn = evalsubshell;
		260	goto calleval;
		261	case NPIPE:
		262	evalfn = evalpipe;
		263	#ifdef notyet
		264	if (eflag && !(flags & EV_TESTED))
		265	checkexit = ~0;
		266	goto calleval;
		267	#else
		268	goto checkexit;
		269	#endif
		270	case NCASE:
		271	evalfn = evalcase;
		272	goto calleval;
		273	case NAND:
		274	case NOR:
		275	case NSEMI:
		276	#if NAND + 1 != NOR
		277	#error NAND + 1 != NOR
		278	#endif
		279	#if NOR + 1 != NSEMI
		280	#error NOR + 1 != NSEMI
		281	#endif
		282	isor = n->type - NAND;
		283	evaltree(
		284	n->nbinary.ch1,
		285	(flags \| ((isor >> 1) - 1)) & EV_TESTED
		286	);
		287	if (!exitstatus == isor)
236	break;	288	break;
237	case NIF: {	289	if (!evalskip) {
238	evaltree(n->nif.test, EV_TESTED);	290	n = n->nbinary.ch2;
239	if (evalskip)	291	evaln:
240	goto out;	292	evalfn = evaltree;
241	if (exitstatus == 0)	293	calleval:
242	evaltree(n->nif.ifpart, flags);	294	evalfn(n, flags);
243	else if (n->nif.elsepart)
244	evaltree(n->nif.elsepart, flags);
245	else
246	exitstatus = 0;
247	break;	295	break;
248	}	296	}
249	case NWHILE:
250	case NUNTIL:
251	evalloop(n, flags);
252	break;	297	break;
253	case NFOR:	298	case NIF:
254	evalfor(n, flags);	299	evaltree(n->nif.test, EV_TESTED);
255	break;	300	if (evalskip)
256	case NCASE:
257	evalcase(n, flags);
258	break;	301	break;
		302	if (exitstatus == 0) {
		303	n = n->nif.ifpart;
		304	goto evaln;
		305	} else if (n->nif.elsepart) {
		306	n = n->nif.elsepart;
		307	goto evaln;
		308	}
		309	goto success;
259	case NDEFUN:	310	case NDEFUN:
260	defun(n->narg.text, n->narg.next);	311	defun(n->narg.text, n->narg.next);
261	exitstatus = 0;	312	success:
262	break;	313	status = 0;
263	case NNOT:	314	setstatus:
264	evaltree(n->nnot.com, EV_TESTED);	315	exitstatus = status;
265	exitstatus = !exitstatus;
266	break;
267
268	case NPIPE:
269	evalpipe(n);
270	break;
271	case NCMD:
272	evalcommand(n, flags, (struct backcmd *)NULL);
273	break;
274	default:
275	out1fmt("Node type = %d\n", n->type);
276	flushout(&output);
277	break;	316	break;
278	}	317	}
279	out:	318	out:
280	if (pendingsigs)	319	if (pendingsigs)
281	dotrap();	320	dotrap();
282	if ((flags & EV_EXIT) != 0)	321	if (flags & EV_EXIT \|\| checkexit & exitstatus)
283	exitshell(exitstatus);	322	exraise(EXEXIT);
284	}	323	}
285		324
286		325
		326	#if !defined(__alpha__) \|\| !defined(GCC_BROKEN_NG)
		327	STATIC
		328	#endif
		329	void evaltreenr(union node *, int) __attribute__ ((alias("evaltree")));
		330
		331
287	STATIC void	332	STATIC void
288	evalloop(n, flags)	333	evalloop(n, flags)
289	union node *n;	334	union node *n;
Lines 293-298 Link Here
293		338
294	loopnest++;	339	loopnest++;
295	status = 0;	340	status = 0;
		341	flags &= EV_TESTED;
296	for (;;) {	342	for (;;) {
297	evaltree(n->nbinary.ch1, EV_TESTED);	343	evaltree(n->nbinary.ch1, EV_TESTED);
298	if (evalskip) {	344	if (evalskip) {
Lines 311-317 Link Here
311	if (exitstatus == 0)	357	if (exitstatus == 0)
312	break;	358	break;
313	}	359	}
314	evaltree(n->nbinary.ch2, flags & EV_TESTED);	360	evaltree(n->nbinary.ch2, flags);
315	status = exitstatus;	361	status = exitstatus;
316	if (evalskip)	362	if (evalskip)
317	goto skipping;	363	goto skipping;
Lines 344-352 Link Here
344		390
345	exitstatus = 0;	391	exitstatus = 0;
346	loopnest++;	392	loopnest++;
		393	flags &= EV_TESTED;
347	for (sp = arglist.list ; sp ; sp = sp->next) {	394	for (sp = arglist.list ; sp ; sp = sp->next) {
348	setvar(n->nfor.var, sp->text, 0);	395	setvar(n->nfor.var, sp->text, 0);
349	evaltree(n->nfor.body, flags & EV_TESTED);	396	evaltree(n->nfor.body, flags);
350	if (evalskip) {	397	if (evalskip) {
351	if (evalskip == SKIPCONT && --skipcount <= 0) {	398	if (evalskip == SKIPCONT && --skipcount <= 0) {
352	evalskip = 0;	399	evalskip = 0;
Lines 377-382 Link Here
377	setstackmark(&smark);	424	setstackmark(&smark);
378	arglist.lastp = &arglist.list;	425	arglist.lastp = &arglist.list;
379	oexitstatus = exitstatus;	426	oexitstatus = exitstatus;
		427	exitstatus = 0;
380	expandarg(n->ncase.expr, &arglist, EXP_TILDE);	428	expandarg(n->ncase.expr, &arglist, EXP_TILDE);
381	for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {	429	for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
382	for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {	430	for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
Lines 405-424 Link Here
405	{	453	{
406	struct job *jp;	454	struct job *jp;
407	int backgnd = (n->type == NBACKGND);	455	int backgnd = (n->type == NBACKGND);
		456	int status;
408		457
409	expredir(n->nredir.redirect);	458	expredir(n->nredir.redirect);
		459	if (!backgnd && flags & EV_EXIT && !trap[0])
		460	goto nofork;
		461	INTOFF;
410	jp = makejob(n, 1);	462	jp = makejob(n, 1);
411	if (forkshell(jp, n, backgnd) == 0) {	463	if (forkshell(jp, n, backgnd) == 0) {
		464	INTON;
		465	flags \|= EV_EXIT;
412	if (backgnd)	466	if (backgnd)
413	flags &=~ EV_TESTED;	467	flags &=~ EV_TESTED;
		468	nofork:
414	redirect(n->nredir.redirect, 0);	469	redirect(n->nredir.redirect, 0);
415	evaltree(n->nredir.n, flags \| EV_EXIT); /* never returns */	470	evaltreenr(n->nredir.n, flags);
		471	/* never returns */
416	}	472	}
417	if (! backgnd) {	473	status = 0;
418	INTOFF;	474	if (!backgnd)
419	exitstatus = waitforjob(jp);	475	status = waitforjob(jp);
		476	exitstatus = status;
420	INTON;	477	INTON;
421	}
422	}	478	}
423		479
424		480
Lines 467-474 Link Here
467	*/	523	*/
468		524
469	STATIC void	525	STATIC void
470	evalpipe(n)	526	evalpipe(n, flags)
471	union node *n;	527	union node *n;
		528	int flags;
472	{	529	{
473	struct job *jp;	530	struct job *jp;
474	struct nodelist *lp;	531	struct nodelist *lp;
Lines 480-485 Link Here
480	pipelen = 0;	537	pipelen = 0;
481	for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)	538	for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
482	pipelen++;	539	pipelen++;
		540	flags \|= EV_EXIT;
483	INTOFF;	541	INTOFF;
484	jp = makejob(n, pipelen);	542	jp = makejob(n, pipelen);
485	prevfd = -1;	543	prevfd = -1;
Lines 494-526 Link Here
494	}	552	}
495	if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {	553	if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
496	INTON;	554	INTON;
		555	if (pip[1] >= 0) {
		556	close(pip[0]);
		557	}
497	if (prevfd > 0) {	558	if (prevfd > 0) {
498	close(0);	559	dup2(prevfd, 0);
499	copyfd(prevfd, 0);
500	close(prevfd);	560	close(prevfd);
501	}	561	}
502	if (pip[1] >= 0) {	562	if (pip[1] > 1) {
503	close(pip[0]);	563	dup2(pip[1], 1);
504	if (pip[1] != 1) {
505	close(1);
506	copyfd(pip[1], 1);
507	close(pip[1]);	564	close(pip[1]);
508	}	565	}
509	}	566	evaltree(lp->n, flags);
510	evaltree(lp->n, EV_EXIT);
511	}	567	}
512	if (prevfd >= 0)	568	if (prevfd >= 0)
513	close(prevfd);	569	close(prevfd);
514	prevfd = pip[0];	570	prevfd = pip[0];
515	close(pip[1]);	571	close(pip[1]);
516	}	572	}
517	INTON;
518	if (n->npipe.backgnd == 0) {	573	if (n->npipe.backgnd == 0) {
519	INTOFF;
520	exitstatus = waitforjob(jp);	574	exitstatus = waitforjob(jp);
521	TRACE(("evalpipe: job done exit status %d\n", exitstatus));	575	TRACE(("evalpipe: job done exit status %d\n", exitstatus));
522	INTON;
523	}	576	}
		577	INTON;
524	}	578	}
525		579
526		580
Lines 595-604 Link Here
595	*/	649	*/
596		650
597	STATIC void	651	STATIC void
		652	#ifdef notyet
598	evalcommand(cmd, flags, backcmd)	653	evalcommand(cmd, flags, backcmd)
599	union node *cmd;	654	union node *cmd;
600	int flags;	655	int flags;
601	struct backcmd *backcmd;	656	struct backcmd *backcmd;
		657	#else
		658	evalcommand(cmd, flags)
		659	union node *cmd;
		660	int flags;
		661	#endif
602	{	662	{
603	struct stackmark smark;	663	struct stackmark smark;
604	union node *argp;	664	union node *argp;
Lines 607-631 Link Here
607	char **argv;	667	char **argv;
608	int argc;	668	int argc;
609	char **envp;	669	char **envp;
610	int varflag;
611	struct strlist *sp;	670	struct strlist *sp;
612	int mode;	671	int mode;
		672	#ifdef notyet
613	int pip[2];	673	int pip[2];
		674	#endif
614	struct cmdentry cmdentry;	675	struct cmdentry cmdentry;
615	struct job *jp;	676	struct job *jp;
616	struct jmploc jmploc;
617	struct jmploc *volatile savehandler;
618	char *volatile savecmdname;	677	char *volatile savecmdname;
619	volatile struct shparam saveparam;	678	volatile struct shparam saveparam;
620	struct localvar *volatile savelocalvars;	679	struct localvar *volatile savelocalvars;
621	volatile int e;
622	char *lastarg;	680	char *lastarg;
		681	const char *path;
		682	int spclbltin;
		683	int redir;
		684	struct jmploc *volatile savehandler;
		685	struct jmploc jmploc;
623	#if __GNUC__	686	#if __GNUC__
624	/* Avoid longjmp clobbering */	687	/* Avoid longjmp clobbering */
625	(void) &argv;	688	(void) &argv;
626	(void) &argc;	689	(void) &argc;
627	(void) &lastarg;	690	(void) &lastarg;
628	(void) &flags;	691	(void) &flags;
		692	(void) &spclbltin;
		693	(void) &redir;
629	#endif	694	#endif
630		695
631	/* First expand the arguments. */	696	/* First expand the arguments. */
Lines 633-654 Link Here
633	setstackmark(&smark);	698	setstackmark(&smark);
634	arglist.lastp = &arglist.list;	699	arglist.lastp = &arglist.list;
635	varlist.lastp = &varlist.list;	700	varlist.lastp = &varlist.list;
636	varflag = 1;	701	arglist.list = 0;
637	oexitstatus = exitstatus;	702	oexitstatus = exitstatus;
638	exitstatus = 0;	703	exitstatus = 0;
639	for (argp = cmd->ncmd.args ; argp ; argp = argp->narg.next) {	704	path = pathval();
640	char *p = argp->narg.text;	705	for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
641	if (varflag && is_name(*p)) {
642	do {
643	p++;
644	} while (is_in_name(*p));
645	if (*p == '=') {
646	expandarg(argp, &varlist, EXP_VARTILDE);	706	expandarg(argp, &varlist, EXP_VARTILDE);
647	continue;
648	}
649	}	707	}
		708	for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
650	expandarg(argp, &arglist, EXP_FULL \| EXP_TILDE);	709	expandarg(argp, &arglist, EXP_FULL \| EXP_TILDE);
651	varflag = 0;
652	}	710	}
653	*arglist.lastp = NULL;	711	*arglist.lastp = NULL;
654	*varlist.lastp = NULL;	712	*varlist.lastp = NULL;
Lines 670-746 Link Here
670		728
671	/* Print the command if xflag is set. */	729	/* Print the command if xflag is set. */
672	if (xflag) {	730	if (xflag) {
		731	#ifdef FLUSHERR
673	outc('+', &errout);	732	outc('+', &errout);
674	for (sp = varlist.list ; sp ; sp = sp->next) {	733	#else
675	outc(' ', &errout);	734	outcslow('+', &errout);
676	out2str(sp->text);	735	#endif
677	}	736	eprintlist(varlist.list);
678	for (sp = arglist.list ; sp ; sp = sp->next) {	737	eprintlist(arglist.list);
679	outc(' ', &errout);	738	#ifdef FLUSHERR
680	out2str(sp->text);
681	}
682	outc('\n', &errout);	739	outc('\n', &errout);
683	flushout(&errout);	740	flushout(&errout);
		741	#else
		742	outcslow('\n', &errout);
		743	#endif
684	}	744	}
685		745
		746	redir = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH);
		747
686	/* Now locate the command. */	748	/* Now locate the command. */
687	if (argc == 0) {	749	if (argc == 0) {
688	cmdentry.cmdtype = CMDBUILTIN;	750	cmdentry.cmdtype = CMDBUILTIN;
689	cmdentry.u.index = BLTINCMD;	751	cmdentry.u.cmd = BLTINCMD;
		752	spclbltin = 1;
690	} else {	753	} else {
691	static const char PATH[] = "PATH=";	754	const char *oldpath;
692	const char *path = pathval();	755	int findflag = DO_ERR;
		756	int oldfindflag;
693		757
694	/*	758	/*
695	* Modify the command lookup path, if a PATH= assignment	759	* Modify the command lookup path, if a PATH= assignment
696	* is present	760	* is present
697	*/	761	*/
698	for (sp = varlist.list ; sp ; sp = sp->next)	762	for (sp = varlist.list ; sp ; sp = sp->next)
699	if (strncmp(sp->text, PATH, sizeof(PATH) - 1) == 0)	763	if (varequal(sp->text, defpathvar)) {
700	path = sp->text + sizeof(PATH) - 1;	764	path = sp->text + 5;
701		765	findflag \|= DO_BRUTE;
702	find_command(argv[0], &cmdentry, DO_ERR, path);	766	}
		767	oldpath = path;
		768	oldfindflag = findflag;
		769	spclbltin = -1;
		770	for(;;) {
		771	find_command(argv[0], &cmdentry, findflag, path);
703	if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */	772	if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
704	exitstatus = 127;	773	goto notfound;
705	flushout(&errout);
706	return;
707	}	774	}
708	/* implement the bltin builtin here */	775	/* implement bltin and command here */
709	if (cmdentry.cmdtype == CMDBUILTIN && cmdentry.u.index == BLTINCMD) {	776	if (cmdentry.cmdtype != CMDBUILTIN) {
710	for (;;) {	777	break;
		778	}
		779	if (spclbltin < 0) {
		780	spclbltin =
		781	!!(
		782	cmdentry.u.cmd->flags &
		783	BUILTIN_SPECIAL
		784	) * 2
		785	;
		786	}
		787	if (cmdentry.u.cmd == BLTINCMD) {
		788	for(;;) {
		789	struct builtincmd *bcmd;
		790
711	argv++;	791	argv++;
712	if (--argc == 0)	792	if (--argc == 0)
713	break;	793	goto found;
714	if ((cmdentry.u.index = find_builtin(*argv)) < 0) {	794	if (!(bcmd = find_builtin(*argv))) {
715	outfmt(&errout, "%s: not found\n", *argv);	795	outfmt(&errout, "%s: not found\n", *argv);
		796	notfound:
716	exitstatus = 127;	797	exitstatus = 127;
		798	#ifdef FLUSHERR
717	flushout(&errout);	799	flushout(&errout);
718	return;	800	#endif
		801	goto out;
719	}	802	}
720	if (cmdentry.u.index != BLTINCMD)	803	cmdentry.u.cmd = bcmd;
		804	if (bcmd != BLTINCMD)
721	break;	805	break;
722	}	806	}
723	}	807	}
		808	if (cmdentry.u.cmd == COMMANDCMD) {
		809	argv++;
		810	if (--argc == 0) {
		811	goto found;
		812	}
		813	if (*argv[0] == '-') {
		814	if (!equal(argv[0], "-p")) {
		815	argv--;
		816	argc++;
		817	break;
		818	}
		819	argv++;
		820	if (--argc == 0) {
		821	goto found;
		822	}
		823	path = defpath;
		824	findflag \|= DO_BRUTE;
		825	} else {
		826	path = oldpath;
		827	findflag = oldfindflag;
		828	}
		829	findflag \|= DO_NOFUN;
		830	continue;
		831	}
		832	found:
		833	break;
		834	}
724	}	835	}
725		836
726	/* Fork off a child process if necessary. */	837	/* Fork off a child process if necessary. */
727	if (cmd->ncmd.backgnd	838	if (
728	\|\| (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)	839	(
		840	cmdentry.cmdtype == CMDNORMAL &&
		841	(!(flags & EV_EXIT) \|\| trap[0])
		842	)
		843	#ifdef notyet
729	\|\| ((flags & EV_BACKCMD) != 0	844	\|\| ((flags & EV_BACKCMD) != 0
730	&& (cmdentry.cmdtype != CMDBUILTIN	845	&& (cmdentry.cmdtype != CMDBUILTIN
731	\|\| cmdentry.u.index == DOTCMD	846	\|\| cmdentry.u.bcmd == DOTCMD
732	\|\| cmdentry.u.index == EVALCMD))) {	847	\|\| cmdentry.u.bcmd == EVALCMD))
		848	#endif
		849	) {
		850	INTOFF;
733	jp = makejob(cmd, 1);	851	jp = makejob(cmd, 1);
734	mode = cmd->ncmd.backgnd;	852	mode = FORK_FG;
		853	#ifdef notyet
735	if (flags & EV_BACKCMD) {	854	if (flags & EV_BACKCMD) {
736	mode = FORK_NOJOB;	855	mode = FORK_NOJOB;
737	if (pipe(pip) < 0)	856	if (pipe(pip) < 0)
738	error("Pipe call failed");	857	error("Pipe call failed");
739	}	858	}
		859	#endif
740	if (forkshell(jp, cmd, mode) != 0)	860	if (forkshell(jp, cmd, mode) != 0)
741	goto parent; /* at end of routine */	861	goto parent; /* at end of routine */
742	if (flags & EV_BACKCMD) {
743	FORCEINTON;	862	FORCEINTON;
		863	#ifdef notyet
		864	if (flags & EV_BACKCMD) {
744	close(pip[0]);	865	close(pip[0]);
745	if (pip[1] != 1) {	866	if (pip[1] != 1) {
746	close(1);	867	close(1);
Lines 748-895 Link Here
748	close(pip[1]);	869	close(pip[1]);
749	}	870	}
750	}	871	}
		872	#endif
751	flags \|= EV_EXIT;	873	flags \|= EV_EXIT;
		874	} else {
		875	flags &= ~EV_EXIT;
752	}	876	}
753		877
754	/* This is the child process if a fork occurred. */	878	/* This is the child process if a fork occurred. */
755	/* Execute the command. */	879	/* Execute the command. */
756	if (cmdentry.cmdtype == CMDFUNCTION) {	880	if (redir) {
		881	/* We have a redirection error. */
		882	exitstatus = redir;
		883	if (spclbltin == 2)
		884	exraise(EXERROR);
		885	} else if (cmdentry.cmdtype == CMDFUNCTION) {
757	#ifdef DEBUG	886	#ifdef DEBUG
758	trputs("Shell function: "); trargs(argv);	887	trputs("Shell function: "); trargs(argv);
759	#endif	888	#endif
760	redirect(cmd->ncmd.redirect, REDIR_PUSH);	889	exitstatus = oexitstatus;
761	saveparam = shellparam;	890	saveparam = shellparam;
762	shellparam.malloc = 0;
763	shellparam.reset = 1;
764	shellparam.nparam = argc - 1;
765	shellparam.p = argv + 1;
766	shellparam.optnext = NULL;
767	INTOFF;
768	savelocalvars = localvars;	891	savelocalvars = localvars;
769	localvars = NULL;	892	exception = -1;
770	INTON;
771	if (setjmp(jmploc.loc)) {	893	if (setjmp(jmploc.loc)) {
772	if (exception == EXSHELLPROC) {	894	goto funcdone;
773	freeparam((volatile struct shparam *)
774	&saveparam);
775	} else {
776	freeparam(&shellparam);
777	shellparam = saveparam;
778	}
779	poplocalvars();
780	localvars = savelocalvars;
781	handler = savehandler;
782	longjmp(handler->loc, 1);
783	}	895	}
		896	INTOFF;
784	savehandler = handler;	897	savehandler = handler;
785	handler = &jmploc;	898	handler = &jmploc;
786	for (sp = varlist.list ; sp ; sp = sp->next)	899	localvars = NULL;
787	mklocal(sp->text);	900	shellparam.malloc = 0;
		901	cmdentry.u.func->count++;
		902	INTON;
		903	shellparam.nparam = argc - 1;
		904	shellparam.p = argv + 1;
		905	shellparam.optind = 1;
		906	shellparam.optoff = -1;
		907	listsetvar(varlist.list, 0);
788	funcnest++;	908	funcnest++;
789	evaltree(cmdentry.u.func, flags & EV_TESTED);	909	evaltree(&cmdentry.u.func->n, flags & EV_TESTED);
790	funcnest--;	910	funcnest--;
		911	funcdone:
791	INTOFF;	912	INTOFF;
		913	freefunc(cmdentry.u.func);
792	poplocalvars();	914	poplocalvars();
793	localvars = savelocalvars;	915	localvars = savelocalvars;
794	freeparam(&shellparam);	916	freeparam(&shellparam);
795	shellparam = saveparam;	917	shellparam = saveparam;
796	handler = savehandler;	918	handler = savehandler;
797	popredir();
798	INTON;	919	INTON;
		920	if (exception >= 0) {
		921	longjmp(handler->loc, 1);
		922	}
799	if (evalskip == SKIPFUNC) {	923	if (evalskip == SKIPFUNC) {
800	evalskip = 0;	924	evalskip = 0;
801	skipcount = 0;	925	skipcount = 0;
802	}	926	}
803	if (flags & EV_EXIT)
804	exitshell(exitstatus);
805	} else if (cmdentry.cmdtype == CMDBUILTIN) {	927	} else if (cmdentry.cmdtype == CMDBUILTIN) {
806	#ifdef DEBUG	928	#ifdef DEBUG
807	trputs("builtin command: "); trargs(argv);	929	trputs("builtin command: "); trargs(argv);
808	#endif	930	#endif
809	mode = (cmdentry.u.index == EXECCMD)? 0 : REDIR_PUSH;	931	if (spclbltin) {
810	if (flags == EV_BACKCMD) {	932	int f = 0;
811	memout.nleft = 0;	933	if (cmdentry.u.cmd == EXECCMD) {
812	memout.nextc = memout.buf;	934	redir++;
813	memout.bufsize = 64;	935	if (argc > 1)
814	mode \|= REDIR_BACKQ;	936	f = VEXPORT;
		937	}
		938	listsetvar(varlist.list, f);
815	}	939	}
816	redirect(cmd->ncmd.redirect, mode);
817	savecmdname = commandname;	940	savecmdname = commandname;
818	cmdenviron = varlist.list;	941	cmdenviron = varlist.list;
819	e = -1;	942	exception = -1;
820	if (setjmp(jmploc.loc)) {	943	if (setjmp(jmploc.loc)) {
821	e = exception;
822	exitstatus = (e == EXINT)? SIGINT+128 : 2;
823	goto cmddone;	944	goto cmddone;
824	}	945	}
825	savehandler = handler;	946	savehandler = handler;
826	handler = &jmploc;	947	handler = &jmploc;
		948	#ifdef notyet
		949	if (flags == EV_BACKCMD) {
		950	#ifdef USE_GLIBC_STDIO
		951	openmemout();
		952	#else
		953	memout.nleft = 0;
		954	memout.nextc = memout.buf;
		955	memout.bufsize = 64;
		956	#endif
		957	}
		958	#endif
827	commandname = argv[0];	959	commandname = argv[0];
828	argptr = argv + 1;	960	argptr = argv + 1;
829	optptr = NULL; /* initialize nextopt */	961	optptr = NULL; /* initialize nextopt */
830	exitstatus = (*builtinfunc[cmdentry.u.index])(argc, argv);	962	exitstatus = (*cmdentry.u.cmd->builtinfunc)(argc, argv);
831	flushall();	963	flushall();
832	cmddone:	964	cmddone:
		965	exitstatus \|= outerr(out1);
		966	#ifdef notyet
833	out1 = &output;	967	out1 = &output;
834	out2 = &errout;	968	out2 = &errout;
		969	#endif
835	freestdout();	970	freestdout();
836	cmdenviron = NULL;	971	cmdenviron = NULL;
837	if (e != EXSHELLPROC) {
838	commandname = savecmdname;	972	commandname = savecmdname;
839	if (flags & EV_EXIT)
840	exitshell(exitstatus);
841	}
842	handler = savehandler;	973	handler = savehandler;
843	if (e != -1) {	974	if (exception >= 0) {
844	if ((e != EXERROR && e != EXEXEC)	975	int f = exception;
845	\|\| cmdentry.u.index == BLTINCMD	976	if (f != EXEXIT) {
846	\|\| cmdentry.u.index == DOTCMD	977	int status = (f == EXINT) ? SIGINT + 128 : 2;
847	\|\| cmdentry.u.index == EVALCMD	978	exitstatus = status;
848	#ifndef SMALL	979	}
849	\|\| cmdentry.u.index == HISTCMD	980	if (f == EXINT \|\| spclbltin & 2) {
850	#endif	981	exraise(f);
851	\|\| cmdentry.u.index == EXECCMD)	982	}
852	exraise(e);
853	FORCEINTON;	983	FORCEINTON;
854	}	984	}
855	if (cmdentry.u.index != EXECCMD)	985	#ifdef notyet
856	popredir();
857	if (flags == EV_BACKCMD) {	986	if (flags == EV_BACKCMD) {
		987	#ifdef USE_GLIBC_STDIO
		988	if (__closememout()) {
		989	error(
		990	"__closememout() failed: %s",
		991	strerror(errno)
		992	);
		993	}
		994	#endif
858	backcmd->buf = memout.buf;	995	backcmd->buf = memout.buf;
		996	#ifdef USE_GLIBC_STDIO
		997	backcmd->nleft = memout.bufsize;
		998	#else
859	backcmd->nleft = memout.nextc - memout.buf;	999	backcmd->nleft = memout.nextc - memout.buf;
		1000	#endif
860	memout.buf = NULL;	1001	memout.buf = NULL;
861	}	1002	}
		1003	#endif
862	} else {	1004	} else {
863	#ifdef DEBUG	1005	#ifdef DEBUG
864	trputs("normal command: "); trargs(argv);	1006	trputs("normal command: "); trargs(argv);
865	#endif	1007	#endif
866	clearredir();
867	redirect(cmd->ncmd.redirect, 0);
868	for (sp = varlist.list ; sp ; sp = sp->next)	1008	for (sp = varlist.list ; sp ; sp = sp->next)
869	setvareq(sp->text, VEXPORT\|VSTACK);	1009	setvareq(sp->text, VEXPORT\|VSTACK);
870	envp = environment();	1010	envp = environment();
871	shellexec(argv, envp, pathval(), cmdentry.u.index);	1011	shellexec(argv, envp, path, cmdentry.u.index);
872	}	1012	}
		1013	if (flags & EV_EXIT)
		1014	exraise(EXEXIT);
873	goto out;	1015	goto out;
874		1016
875	parent: /* parent process gets here (if we forked) */	1017	parent: /* parent process gets here (if we forked) */
876	if (mode == 0) { /* argument to fork */	1018	if (mode == FORK_FG) { /* argument to fork */
877	INTOFF;
878	exitstatus = waitforjob(jp);	1019	exitstatus = waitforjob(jp);
879	INTON;	1020	#ifdef notyet
880	} else if (mode == 2) {	1021	} else if (mode == FORK_NOJOB) {
881	backcmd->fd = pip[0];	1022	backcmd->fd = pip[0];
882	close(pip[1]);	1023	close(pip[1]);
883	backcmd->jp = jp;	1024	backcmd->jp = jp;
		1025	#endif
884	}	1026	}
		1027	INTON;
885		1028
886	out:	1029	out:
		1030	popredir(redir);
887	if (lastarg)	1031	if (lastarg)
888	setvar("_", lastarg, 0);	1032	setvar("_", lastarg, 0);
889	popstackmark(&smark);	1033	popstackmark(&smark);
890
891	if (eflag && exitstatus && !(flags & EV_TESTED))
892	exitshell(exitstatus);
893	}	1034	}
894		1035
895		1036
Lines 897-904 Link Here
897	/*	1038	/*
898	* Search for a command. This is called before we fork so that the	1039	* Search for a command. This is called before we fork so that the
899	* location of the command will be available in the parent as well as	1040	* location of the command will be available in the parent as well as
900	* the child. The check for "goodname" is an overly conservative	1041	* the child.
901	* check that the name will not be subject to expansion.
902	*/	1042	*/
903		1043
904	STATIC void	1044	STATIC void
Lines 908-916 Link Here
908	struct cmdentry entry;	1048	struct cmdentry entry;
909		1049
910	if (n->type == NCMD && n->ncmd.args)	1050	if (n->type == NCMD && n->ncmd.args)
911	if (goodname(n->ncmd.args->narg.text))	1051	find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
912	find_command(n->ncmd.args->narg.text, &entry, 0,
913	pathval());
914	}	1052	}
915		1053
916		1054
Lines 930-936 Link Here
930	int argc;	1068	int argc;
931	char **argv;	1069	char **argv;
932	{	1070	{
933	listsetvar(cmdenviron);
934	/*	1071	/*
935	* Preserve exitstatus of a previous possible redirection	1072	* Preserve exitstatus of a previous possible redirection
936	* as POSIX mandates	1073	* as POSIX mandates
Lines 957-962 Link Here
957	{	1094	{
958	int n = argc > 1 ? number(argv[1]) : 1;	1095	int n = argc > 1 ? number(argv[1]) : 1;
959		1096
		1097	if (n <= 0)
		1098	error(illnum, argv[1]);
960	if (n > loopnest)	1099	if (n > loopnest)
961	n = loopnest;	1100	n = loopnest;
962	if (n > 0) {	1101	if (n > 0) {
Lines 1016-1029 Link Here
1016	char **argv;	1155	char **argv;
1017	{	1156	{
1018	if (argc > 1) {	1157	if (argc > 1) {
1019	struct strlist *sp;
1020
1021	iflag = 0; /* exit on error */	1158	iflag = 0; /* exit on error */
1022	mflag = 0;	1159	mflag = 0;
1023	optschanged();	1160	optschanged();
1024	for (sp = cmdenviron; sp ; sp = sp->next)
1025	setvareq(sp->text, VEXPORT\|VSTACK);
1026	shellexec(argv + 1, environment(), pathval(), 0);	1161	shellexec(argv + 1, environment(), pathval(), 0);
1027	}	1162	}
1028	return 0;	1163	return 0;
1029	}	1164	}
		1165
		1166	STATIC void
		1167	eprintlist(struct strlist *sp)
		1168	{
		1169	for (; sp; sp = sp->next) {
		1170	outfmt(&errout, " %s",sp->text);
		1171	}
		1172	}

Lines 51-56 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/exec.c (-243 / +277 lines)
51	#include <fcntl.h>	51	#include <fcntl.h>
52	#include <errno.h>	52	#include <errno.h>
53	#include <stdlib.h>	53	#include <stdlib.h>
		54	#include <sysexits.h>
		55	#include <stdbool.h>
		56	#include <paths.h>
54		57
55	/*	58	/*
56	* When commands are first encountered, they are entered in a hash table.	59	* When commands are first encountered, they are entered in a hash table.
Lines 99-117 Link Here
99		102
100	STATIC struct tblentry *cmdtable[CMDTABLESIZE];	103	STATIC struct tblentry *cmdtable[CMDTABLESIZE];
101	STATIC int builtinloc = -1; /* index in path of %builtin, or -1 */	104	STATIC int builtinloc = -1; /* index in path of %builtin, or -1 */
102	int exerrno = 0; /* Last exec error */	105	int exerrno; /* Last exec error */
103		106
104		107
105	STATIC void tryexec __P((char , char , char *));	108	STATIC void tryexec __P((char , char , char *));
		109	#if !defined(BSD) && !defined(linux)
106	STATIC void execinterp __P((char , char ));	110	STATIC void execinterp __P((char , char ));
		111	#endif
107	STATIC void printentry __P((struct tblentry *, int));	112	STATIC void printentry __P((struct tblentry *, int));
108	STATIC void clearcmdentry __P((int));	113	STATIC void clearcmdentry __P((int));
109	STATIC struct tblentry cmdlookup __P((char , int));	114	STATIC struct tblentry cmdlookup __P((char , int));
110	STATIC void delete_cmd_entry __P((void));	115	STATIC void delete_cmd_entry __P((void));
		116	STATIC int describe_command __P((struct output , char , int));
		117	STATIC int path_change __P((const char , int ));
111		118
112		119
113	extern char *const parsekwd[];
114
115	/*	120	/*
116	* Exec a program. Never returns. If you change this routine, you may	121	* Exec a program. Never returns. If you change this routine, you may
117	* have to change the find_command routine as well.	122	* have to change the find_command routine as well.
Lines 126-131 Link Here
126	char *cmdname;	131	char *cmdname;
127	int e;	132	int e;
128		133
		134	clearredir(1);
129	if (strchr(argv[0], '/') != NULL) {	135	if (strchr(argv[0], '/') != NULL) {
130	tryexec(argv[0], argv, envp);	136	tryexec(argv[0], argv, envp);
131	e = errno;	137	e = errno;
Lines 164-174 Link Here
164	char **argv;	170	char **argv;
165	char **envp;	171	char **envp;
166	{	172	{
167	int e;	173	int repeated = 0;
168	#ifndef BSD	174	#if !defined(BSD) && !defined(linux)
169	char *p;	175	char *p;
170	#endif	176	#endif
171		177
		178	repeat:
172	#ifdef SYSV	179	#ifdef SYSV
173	do {	180	do {
174	execve(cmd, argv, envp);	181	execve(cmd, argv, envp);
Lines 176-278 Link Here
176	#else	183	#else
177	execve(cmd, argv, envp);	184	execve(cmd, argv, envp);
178	#endif	185	#endif
179	e = errno;	186	if (repeated++) {
180	if (e == ENOEXEC) {	187	ckfree(argv);
181	initshellproc();	188	} else if (errno == ENOEXEC) {
182	setinputfile(cmd, 0);
183	commandname = arg0 = savestr(argv[0]);
184	#ifndef BSD
185	pgetc(); pungetc(); /* fill up input buffer */
186	p = parsenextc;
187	if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
188	argv[0] = cmd;
189	execinterp(argv, envp);
190	}
191	#endif
192	setparam(argv + 1);
193	exraise(EXSHELLPROC);
194	}
195	errno = e;
196	}
197
198
199	#ifndef BSD
200	/*
201	* Execute an interpreter introduced by "#!", for systems where this
202	* feature has not been built into the kernel. If the interpreter is
203	* the shell, return (effectively ignoring the "#!"). If the execution
204	* of the interpreter fails, exit.
205	*
206	* This code peeks inside the input buffer in order to avoid actually
207	* reading any input. It would benefit from a rewrite.
208	*/
209
210	#define NEWARGS 5
211
212	STATIC void
213	execinterp(argv, envp)
214	char argv, envp;
215	{
216	int n;
217	char *inp;
218	char *outp;
219	char c;
220	char *p;
221	char **ap;	189	char **ap;
222	char *newargs[NEWARGS];
223	int i;
224	char **ap2;
225	char **new;	190	char **new;
226		191
227	n = parsenleft - 2;	192	for (ap = argv; *ap; ap++)
228	inp = parsenextc + 2;	193	;
229	ap = newargs;	194	ap = new = ckmalloc((ap - argv + 2) * sizeof(char *));
230	for (;;) {	195	*ap++ = cmd = _PATH_BSHELL;
231	while (--n >= 0 && (inp == ' ' \|\| inp == '\t'))	196	while ((ap++ = argv++))
232	inp++;	197	;
233	if (n < 0)	198	argv = new;
234	goto bad;	199	goto repeat;
235	if ((c = *inp++) == '\n')
236	break;
237	if (ap == &newargs[NEWARGS])
238	bad: error("Bad #! line");
239	STARTSTACKSTR(outp);
240	do {
241	STPUTC(c, outp);
242	} while (--n >= 0 && (c = *inp++) != ' ' && c != '\t' && c != '\n');
243	STPUTC('\0', outp);
244	n++, inp--;
245	*ap++ = grabstackstr(outp);
246	}
247	if (ap == newargs + 1) { /* if no args, maybe no exec is needed */
248	p = newargs[0];
249	for (;;) {
250	if (equal(p, "sh") \|\| equal(p, "ash")) {
251	return;
252	}
253	while (*p != '/') {
254	if (*p == '\0')
255	goto break2;
256	p++;
257	}
258	p++;
259	}
260	break2:;
261	}	200	}
262	i = (char )ap - (char )newargs; /* size in bytes */
263	if (i == 0)
264	error("Bad #! line");
265	for (ap2 = argv ; *ap2++ != NULL ; );
266	new = ckmalloc(i + ((char )ap2 - (char )argv));
267	ap = newargs, ap2 = new;
268	while ((i -= sizeof (char **)) >= 0)
269	ap2++ = ap++;
270	ap = argv;
271	while (ap2++ = ap++);
272	shellexec(new, envp, pathval(), 0);
273	/* NOTREACHED */
274	}	201	}
275	#endif
276		202
277		203
278		204
Lines 296-302 Link Here
296	const char *p;	222	const char *p;
297	char *q;	223	char *q;
298	const char *start;	224	const char *start;
299	int len;	225	size_t len;
300		226
301	if (*path == NULL)	227	if (*path == NULL)
302	return NULL;	228	return NULL;
Lines 345-350 Link Here
345	while ((c = nextopt("rv")) != '\0') {	271	while ((c = nextopt("rv")) != '\0') {
346	if (c == 'r') {	272	if (c == 'r') {
347	clearcmdentry(0);	273	clearcmdentry(0);
		274	return 0;
348	} else if (c == 'v') {	275	} else if (c == 'v') {
349	verbose++;	276	verbose++;
350	}	277	}
Lines 352-378 Link Here
352	if (*argptr == NULL) {	279	if (*argptr == NULL) {
353	for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {	280	for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
354	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {	281	for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
		282	if (cmdp->cmdtype != CMDBUILTIN) {
355	printentry(cmdp, verbose);	283	printentry(cmdp, verbose);
356	}	284	}
357	}	285	}
		286	}
358	return 0;	287	return 0;
359	}	288	}
		289	c = 0;
360	while ((name = *argptr) != NULL) {	290	while ((name = *argptr) != NULL) {
361	if ((cmdp = cmdlookup(name, 0)) != NULL	291	if ((cmdp = cmdlookup(name, 0)) != NULL
362	&& (cmdp->cmdtype == CMDNORMAL	292	&& (cmdp->cmdtype == CMDNORMAL
363	\|\| (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))	293	\|\| (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
364	delete_cmd_entry();	294	delete_cmd_entry();
365	find_command(name, &entry, DO_ERR, pathval());	295	find_command(name, &entry, DO_ERR, pathval());
366	if (verbose) {	296	if (entry.cmdtype == CMDUNKNOWN) c = 1;
367	if (entry.cmdtype != CMDUNKNOWN) { /* if no error msg */	297	else if (verbose) {
368	cmdp = cmdlookup(name, 0);	298	cmdp = cmdlookup(name, 0);
369	printentry(cmdp, verbose);	299	if (cmdp) printentry(cmdp, verbose);
370	}
371	flushall();	300	flushall();
372	}	301	}
373	argptr++;	302	argptr++;
374	}	303	}
375	return 0;	304	return c;
376	}	305	}
377		306
378		307
Lines 399-407 Link Here
399	out1fmt("function %s", cmdp->cmdname);	328	out1fmt("function %s", cmdp->cmdname);
400	if (verbose) {	329	if (verbose) {
401	INTOFF;	330	INTOFF;
402	name = commandtext(cmdp->param.func);	331	name = commandtext(&cmdp->param.func->n);
403	out1c(' ');	332	out1fmt(" %s", name);
404	out1str(name);
405	ckfree(name);	333	ckfree(name);
406	INTON;	334	INTON;
407	}	335	}
Lines 410-418 Link Here
410	error("internal error: cmdtype %d", cmdp->cmdtype);	338	error("internal error: cmdtype %d", cmdp->cmdtype);
411	#endif	339	#endif
412	}	340	}
413	if (cmdp->rehash)	341	out1fmt(snlfmt, cmdp->rehash ? "*" : nullstr);
414	out1c('*');
415	out1c('\n');
416	}	342	}
417		343
418		344
Lines 433-446 Link Here
433	int idx;	359	int idx;
434	int prev;	360	int prev;
435	char *fullname;	361	char *fullname;
436	struct stat statb;	362	struct stat64 statb;
437	int e;	363	int e;
438	int i;	364	int bltin;
		365	int firstchange;
		366	int updatetbl;
		367	bool regular;
		368	struct builtincmd *bcmd;
439		369
440	/* If name contains a slash, don't use the hash table */	370	/* If name contains a slash, don't use the hash table */
441	if (strchr(name, '/') != NULL) {	371	if (strchr(name, '/') != NULL) {
442	if (act & DO_ABS) {	372	if (act & DO_ABS) {
443	while (stat(name, &statb) < 0) {	373	while (stat64(name, &statb) < 0) {
444	#ifdef SYSV	374	#ifdef SYSV
445	if (errno == EINTR)	375	if (errno == EINTR)
446	continue;	376	continue;
Lines 460-482 Link Here
460	return;	390	return;
461	}	391	}
462		392
		393	updatetbl = 1;
		394	if (act & DO_BRUTE) {
		395	firstchange = path_change(path, &bltin);
		396	} else {
		397	bltin = builtinloc;
		398	firstchange = 9999;
		399	}
		400
463	/* If name is in the table, and not invalidated by cd, we're done */	401	/* If name is in the table, and not invalidated by cd, we're done */
464	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0)	402	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
		403	if (cmdp->cmdtype == CMDFUNCTION) {
		404	if (act & DO_NOFUN) {
		405	updatetbl = 0;
		406	} else {
		407	goto success;
		408	}
		409	} else if (act & DO_BRUTE) {
		410	if ((cmdp->cmdtype == CMDNORMAL &&
		411	cmdp->param.index >= firstchange) \|\|
		412	(cmdp->cmdtype == CMDBUILTIN &&
		413	((builtinloc < 0 && bltin >= 0) ?
		414	bltin : builtinloc) >= firstchange)) {
		415	/* need to recompute the entry */
		416	} else {
		417	goto success;
		418	}
		419	} else {
		420	goto success;
		421	}
		422	}
		423
		424	bcmd = find_builtin(name);
		425	regular = bcmd && bcmd->flags & BUILTIN_REGULAR;
		426
		427	if (regular) {
		428	if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
465	goto success;	429	goto success;
		430	}
		431	} else if (act & DO_BRUTE) {
		432	if (firstchange == 0) {
		433	updatetbl = 0;
		434	}
		435	}
466		436
467	/* If %builtin not in path, check for builtin next */	437	/* If %builtin not in path, check for builtin next */
468	if (builtinloc < 0 && (i = find_builtin(name)) >= 0) {	438	if (regular \|\| (bltin < 0 && bcmd)) {
		439	builtin:
		440	if (!updatetbl) {
		441	entry->cmdtype = CMDBUILTIN;
		442	entry->u.cmd = bcmd;
		443	return;
		444	}
469	INTOFF;	445	INTOFF;
470	cmdp = cmdlookup(name, 1);	446	cmdp = cmdlookup(name, 1);
471	cmdp->cmdtype = CMDBUILTIN;	447	cmdp->cmdtype = CMDBUILTIN;
472	cmdp->param.index = i;	448	cmdp->param.cmd = bcmd;
473	INTON;	449	INTON;
474	goto success;	450	goto success;
475	}	451	}
476		452
477	/* We have to search path. */	453	/* We have to search path. */
478	prev = -1; /* where to start */	454	prev = -1; /* where to start */
479	if (cmdp) { /* doing a rehash */	455	if (cmdp && cmdp->rehash) { /* doing a rehash */
480	if (cmdp->cmdtype == CMDBUILTIN)	456	if (cmdp->cmdtype == CMDBUILTIN)
481	prev = builtinloc;	457	prev = builtinloc;
482	else	458	else
Lines 489-518 Link Here
489	while ((fullname = padvance(&path, name)) != NULL) {	465	while ((fullname = padvance(&path, name)) != NULL) {
490	stunalloc(fullname);	466	stunalloc(fullname);
491	idx++;	467	idx++;
		468	if (idx >= firstchange) {
		469	updatetbl = 0;
		470	}
492	if (pathopt) {	471	if (pathopt) {
493	if (prefix("builtin", pathopt)) {	472	if (prefix("builtin", pathopt)) {
494	if ((i = find_builtin(name)) < 0)	473	if ((bcmd = find_builtin(name))) {
495	goto loop;	474	goto builtin;
496	INTOFF;	475	}
497	cmdp = cmdlookup(name, 1);	476	continue;
498	cmdp->cmdtype = CMDBUILTIN;	477	} else if (!(act & DO_NOFUN) &&
499	cmdp->param.index = i;	478	prefix("func", pathopt)) {
500	INTON;
501	goto success;
502	} else if (prefix("func", pathopt)) {
503	/* handled below */	479	/* handled below */
504	} else {	480	} else {
505	goto loop; /* ignore unimplemented options */	481	continue; /* ignore unimplemented options */
506	}	482	}
507	}	483	}
508	/* if rehash, don't redo absolute path names */	484	/* if rehash, don't redo absolute path names */
509	if (fullname[0] == '/' && idx <= prev) {	485	if (fullname[0] == '/' && idx <= prev &&
		486	idx < firstchange) {
510	if (idx < prev)	487	if (idx < prev)
511	goto loop;	488	continue;
512	TRACE(("searchexec \"%s\": no change\n", name));	489	TRACE(("searchexec \"%s\": no change\n", name));
513	goto success;	490	goto success;
514	}	491	}
515	while (stat(fullname, &statb) < 0) {	492	while (stat64(fullname, &statb) < 0) {
516	#ifdef SYSV	493	#ifdef SYSV
517	if (errno == EINTR)	494	if (errno == EINTR)
518	continue;	495	continue;
Lines 523-529 Link Here
523	}	500	}
524	e = EACCES; /* if we fail, this will be the error */	501	e = EACCES; /* if we fail, this will be the error */
525	if (!S_ISREG(statb.st_mode))	502	if (!S_ISREG(statb.st_mode))
526	goto loop;	503	continue;
527	if (pathopt) { /* this is a %func directory */	504	if (pathopt) { /* this is a %func directory */
528	stalloc(strlen(fullname) + 1);	505	stalloc(strlen(fullname) + 1);
529	readcmdfile(fullname);	506	readcmdfile(fullname);
Lines 545-550 Link Here
545	}	522	}
546	#endif	523	#endif
547	TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));	524	TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
		525	/* If we aren't called with DO_BRUTE and cmdp is set, it must
		526	be a function and we're being called with DO_NOFUN */
		527	if (!updatetbl) {
		528	entry->cmdtype = CMDNORMAL;
		529	entry->u.index = idx;
		530	return;
		531	}
548	INTOFF;	532	INTOFF;
549	cmdp = cmdlookup(name, 1);	533	cmdp = cmdlookup(name, 1);
550	cmdp->cmdtype = CMDNORMAL;	534	cmdp->cmdtype = CMDNORMAL;
Lines 554-563 Link Here
554	}	538	}
555		539
556	/* We failed. If there was an entry for this command, delete it */	540	/* We failed. If there was an entry for this command, delete it */
557	if (cmdp)	541	if (cmdp && updatetbl)
558	delete_cmd_entry();	542	delete_cmd_entry();
559	if (act & DO_ERR)	543	if (act & DO_ERR)
560	outfmt(out2, "%s: %s\n", name, errmsg(e, E_EXEC));	544	warnx("%s: %s", name, errmsg(e, E_EXEC));
561	entry->cmdtype = CMDUNKNOWN;	545	entry->cmdtype = CMDUNKNOWN;
562	return;	546	return;
563		547
Lines 573-589 Link Here
573	* Search the table of builtin commands.	557	* Search the table of builtin commands.
574	*/	558	*/
575		559
576	int	560	struct builtincmd *
577	find_builtin(name)	561	find_builtin(const char *name)
578	char *name;
579	{	562	{
580	const struct builtincmd *bp;	563	struct builtincmd *bp;
581		564
582	for (bp = builtincmd ; bp->name ; bp++) {	565	bp = bsearch(
583	if (bp->name == name && equal(bp->name, name))	566	&name, builtincmd, NUMBUILTINS, sizeof(struct builtincmd),
584	return bp->code;	567	pstrcmp
585	}	568	);
586	return -1;	569	return bp;
587	}	570	}
588		571
589		572
Lines 619-655 Link Here
619	changepath(newval)	602	changepath(newval)
620	const char *newval;	603	const char *newval;
621	{	604	{
622	const char old, new;
623	int idx;
624	int firstchange;	605	int firstchange;
625	int bltin;	606	int bltin;
626		607
627	old = pathval();	608	firstchange = path_change(newval, &bltin);
628	new = newval;
629	firstchange = 9999; /* assume no change */
630	idx = 0;
631	bltin = -1;
632	for (;;) {
633	if (old != new) {
634	firstchange = idx;
635	if ((old == '\0' && new == ':')
636	\|\| (old == ':' && new == '\0'))
637	firstchange++;
638	old = new; /* ignore subsequent differences */
639	}
640	if (*new == '\0')
641	break;
642	if (*new == '%' && bltin < 0 && prefix("builtin", new + 1))
643	bltin = idx;
644	if (*new == ':') {
645	idx++;
646	}
647	new++, old++;
648	}
649	if (builtinloc < 0 && bltin >= 0)	609	if (builtinloc < 0 && bltin >= 0)
650	builtinloc = bltin; /* zap builtins */	610	builtinloc = bltin; /* zap builtins */
651	if (builtinloc >= 0 && bltin < 0)
652	firstchange = 0;
653	clearcmdentry(firstchange);	611	clearcmdentry(firstchange);
654	builtinloc = bltin;	612	builtinloc = bltin;
655	}	613	}
Lines 687-727 Link Here
687	}	645	}
688		646
689		647
690	/*
691	* Delete all functions.
692	*/
693
694	#ifdef mkinit
695	MKINIT void deletefuncs __P((void));
696
697	SHELLPROC {
698	deletefuncs();
699	}
700	#endif
701
702	void
703	deletefuncs() {
704	struct tblentry **tblp;
705	struct tblentry **pp;
706	struct tblentry *cmdp;
707
708	INTOFF;
709	for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
710	pp = tblp;
711	while ((cmdp = *pp) != NULL) {
712	if (cmdp->cmdtype == CMDFUNCTION) {
713	*pp = cmdp->next;
714	freefunc(cmdp->param.func);
715	ckfree(cmdp);
716	} else {
717	pp = &cmdp->next;
718	}
719	}
720	}
721	INTON;
722	}
723
724
725		648
726	/*	649	/*
727	* Locate a command in the command hash table. If "add" is nonzero,	650	* Locate a command in the command hash table. If "add" is nonzero,
Lines 780-785 Link Here
780	INTOFF;	703	INTOFF;
781	cmdp = *lastcmdentry;	704	cmdp = *lastcmdentry;
782	*lastcmdentry = cmdp->next;	705	*lastcmdentry = cmdp->next;
		706	if (cmdp->cmdtype == CMDFUNCTION)
		707	freefunc(cmdp->param.func);
783	ckfree(cmdp);	708	ckfree(cmdp);
784	INTON;	709	INTON;
785	}	710	}
Lines 851-868 Link Here
851	* Delete a function if it exists.	776	* Delete a function if it exists.
852	*/	777	*/
853		778
854	int	779	void
855	unsetfunc(name)	780	unsetfunc(name)
856	char *name;	781	char *name;
857	{	782	{
858	struct tblentry *cmdp;	783	struct tblentry *cmdp;
859		784
860	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {	785	if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION)
861	freefunc(cmdp->param.func);
862	delete_cmd_entry();	786	delete_cmd_entry();
863	return (0);
864	}
865	return (1);
866	}	787	}
867		788
868	/*	789	/*
Lines 874-947 Link Here
874	int argc;	795	int argc;
875	char **argv;	796	char **argv;
876	{	797	{
877	struct cmdentry entry;
878	struct tblentry *cmdp;
879	char * const *pp;
880	struct alias *ap;
881	int i;	798	int i;
882	int err = 0;	799	int err = 0;
883		800
884	for (i = 1; i < argc; i++) {	801	for (i = 1; i < argc; i++) {
885	out1str(argv[i]);	802	err \|= describe_command(out1, argv[i], 1);
886	/* First look at the keywords */	803	}
887	for (pp = parsekwd; *pp; pp++)	804	return err;
888	if (*pp == argv[i] && equal(*pp, argv[i]))	805	}
889	break;
890		806
891	if (*pp) {	807	STATIC int
892	out1str(" is a shell keyword\n");	808	describe_command(out, command, verbose)
893	continue;	809	struct output *out;
		810	char *command;
		811	int verbose;
		812	{
		813	struct cmdentry entry;
		814	struct tblentry *cmdp;
		815	const struct alias *ap;
		816	const char *path = pathval();
		817
		818	if (verbose) {
		819	outstr(command, out);
		820	}
		821
		822	/* First look at the keywords */
		823	if (findkwd(command)) {
		824	outstr(verbose ? " is a shell keyword" : command, out);
		825	goto out;
894	}	826	}
895		827
896	/* Then look at the aliases */	828	/* Then look at the aliases */
897	if ((ap = lookupalias(argv[i], 1)) != NULL) {	829	if ((ap = lookupalias(command, 0)) != NULL) {
898	out1fmt(" is an alias for %s\n", ap->val);	830	if (verbose) {
899	continue;	831	outfmt(out, " is an alias for %s", ap->val);
		832	} else {
		833	outstr("alias ", out);
		834	printalias(ap);
		835	return 0;
		836	}
		837	goto out;
900	}	838	}
901		839
902	/* Then check if it is a tracked alias */	840	/* Then check if it is a tracked alias */
903	if ((cmdp = cmdlookup(argv[i], 0)) != NULL) {	841	if ((cmdp = cmdlookup(command, 0)) != NULL) {
904	entry.cmdtype = cmdp->cmdtype;	842	entry.cmdtype = cmdp->cmdtype;
905	entry.u = cmdp->param;	843	entry.u = cmdp->param;
906	}	844	} else {
907	else {
908	/* Finally use brute force */	845	/* Finally use brute force */
909	find_command(argv[i], &entry, DO_ABS, pathval());	846	find_command(command, &entry, DO_ABS, path);
910	}	847	}
911		848
912	switch (entry.cmdtype) {	849	switch (entry.cmdtype) {
913	case CMDNORMAL: {	850	case CMDNORMAL: {
914	if (strchr(argv[i], '/') == NULL) {
915	const char *path = pathval();
916	char *name;
917	int j = entry.u.index;	851	int j = entry.u.index;
		852	char *p;
		853	if (j == -1) {
		854	p = command;
		855	} else {
918	do {	856	do {
919	name = padvance(&path, argv[i]);	857	p = padvance(&path, command);
920	stunalloc(name);	858	stunalloc(p);
921	} while (--j >= 0);	859	} while (--j >= 0);
922	out1fmt(" is%s %s\n",	860	}
923	cmdp ? " a tracked alias for" : "", name);	861	if (verbose) {
		862	outfmt(
		863	out, " is%s %s",
		864	cmdp ? " a tracked alias for" : nullstr, p
		865	);
924	} else {	866	} else {
925	if (access(argv[i], X_OK) == 0)	867	outstr(p, out);
926	out1fmt(" is %s\n", argv[i]);
927	else
928	out1fmt(": %s\n", strerror(errno));
929	}	868	}
930	break;	869	break;
931	}	870	}
		871
932	case CMDFUNCTION:	872	case CMDFUNCTION:
933	out1str(" is a shell function\n");	873	if (verbose) {
		874	outstr(" is a shell function", out);
		875	} else {
		876	outstr(command, out);
		877	}
934	break;	878	break;
935		879
936	case CMDBUILTIN:	880	case CMDBUILTIN:
937	out1str(" is a shell builtin\n");	881	if (verbose) {
		882	outfmt(
		883	out, " is a %sshell builtin",
		884	entry.u.cmd->flags & BUILTIN_SPECIAL ?
		885	"special " : nullstr
		886	);
		887	} else {
		888	outstr(command, out);
		889	}
938	break;	890	break;
939		891
940	default:	892	default:
941	out1str(": not found\n");	893	if (verbose) {
942	err \|= 127;	894	outstr(": not found\n", out);
		895	}
		896	return 127;
		897	}
		898
		899	out:
		900	outc('\n', out);
		901	return 0;
		902	}
		903
		904	int
		905	commandcmd(argc, argv)
		906	int argc;
		907	char **argv;
		908	{
		909	int c;
		910	int default_path = 0;
		911	int verify_only = 0;
		912	int verbose_verify_only = 0;
		913
		914	while ((c = nextopt("pvV")) != '\0')
		915	switch (c) {
		916	case 'p':
		917	default_path = 1;
943	break;	918	break;
		919	case 'v':
		920	verify_only = 1;
		921	break;
		922	case 'V':
		923	verbose_verify_only = 1;
		924	break;
		925	default:
		926	outfmt(out2,
		927	"command: nextopt returned character code 0%o\n", c);
		928	return EX_SOFTWARE;
944	}	929	}
		930
		931	if (default_path + verify_only + verbose_verify_only > 1 \|\|
		932	!*argptr) {
		933	outfmt(out2,
		934	"command [-p] command [arg ...]\n");
		935	outfmt(out2,
		936	"command {-v\|-V} command\n");
		937	return EX_USAGE;
945	}	938	}
946	return err;	939
		940	if (verify_only \|\| verbose_verify_only) {
		941	return describe_command(out1, *argptr, verbose_verify_only);
		942	}
		943
		944	return 0;
		945	}
		946
		947	STATIC int
		948	path_change(newval, bltin)
		949	const char *newval;
		950	int *bltin;
		951	{
		952	const char old, new;
		953	int idx;
		954	int firstchange;
		955
		956	old = pathval();
		957	new = newval;
		958	firstchange = 9999; /* assume no change */
		959	idx = 0;
		960	*bltin = -1;
		961	for (;;) {
		962	if (old != new) {
		963	firstchange = idx;
		964	if ((old == '\0' && new == ':')
		965	\|\| (old == ':' && new == '\0'))
		966	firstchange++;
		967	old = new; /* ignore subsequent differences */
		968	}
		969	if (*new == '\0')
		970	break;
		971	if (new == '%' && bltin < 0 && prefix("builtin", new + 1))
		972	*bltin = idx;
		973	if (*new == ':') {
		974	idx++;
		975	}
		976	new++, old++;
		977	}
		978	if (builtinloc >= 0 && *bltin < 0)
		979	firstchange = 0;
		980	return firstchange;
947	}	981	}




	int cmdtype;
	union param {
		int index;
		struct funcnode *func;
		const struct builtincmd *cmd;
	} u;
};


#define DO_ERR	1		/* find_command prints errors */
#define DO_ABS	2		/* find_command checks absolute paths */
#define DO_NOFUN	4	/* find_command ignores functions */
#define DO_BRUTE	8	/* find_command ignores hash table */

extern const char *pathopt;	/* set by padvance */
extern int exerrno;		/* last exec error */

char *padvance __P((const char **, const char *));
int hashcmd __P((int, char **));
void find_command __P((char *, struct cmdentry *, int, const char *));
struct builtincmd *find_builtin __P((const char *));
void hashcd __P((void));
void changepath __P((const char *));
void deletefuncs __P((void));
void getcmdentry __P((char *, struct cmdentry *));
void addcmdentry __P((char *, struct cmdentry *));
void defun __P((char *, union node *));
void unsetfunc __P((char *));
int typecmd __P((int, char **));
int commandcmd __P((int, char **));

Lines 54-59 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/expand.c (-484 / +718 lines)
54	#include <pwd.h>	54	#include <pwd.h>
55	#include <stdlib.h>	55	#include <stdlib.h>
56	#include <stdio.h>	56	#include <stdio.h>
		57	#include <limits.h>
		58	#if defined(__GLIBC__)
		59	#if !defined(FNMATCH_BROKEN)
		60	#include <fnmatch.h>
		61	#if !defined(GLOB_BROKEN)
		62	#include <glob.h>
		63	#endif
		64	#endif
		65	#endif
57		66
58	/*	67	/*
59	* Routines to expand arguments to commands. We have to deal with	68	* Routines to expand arguments to commands. We have to deal with
Lines 78-83 Link Here
78	#include "show.h"	87	#include "show.h"
79		88
80	/*	89	/*
		90	* _rmescape() flags
		91	*/
		92	#define RMESCAPE_ALLOC 0x1 /* Allocate a new string */
		93	#define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
		94	#define RMESCAPE_QUOTED 0x4 /* Remove CTLESC unless in quotes */
		95	#define RMESCAPE_GROW 0x8 /* Grow strings instead of stalloc */
		96	#define RMESCAPE_HEAP 0x10 /* Malloc strings instead of stalloc */
		97
		98	/*
81	* Structure specifying which parts of the string should be searched	99	* Structure specifying which parts of the string should be searched
82	* for IFS characters.	100	* for IFS characters.
83	*/	101	*/
Lines 89-122 Link Here
89	int nulonly; /* search for nul bytes only */	107	int nulonly; /* search for nul bytes only */
90	};	108	};
91		109
92		110	/* output of current string */
93	char expdest; / output of current string */	111	static char *expdest;
94	struct nodelist argbackq; / list of back quote expressions */	112	/* list of back quote expressions */
95	struct ifsregion ifsfirst; /* first struct in list of ifs regions */	113	static struct nodelist *argbackq;
96	struct ifsregion ifslastp; / last struct in list */	114	/* first struct in list of ifs regions */
97	struct arglist exparg; /* holds expanded arg list */	115	static struct ifsregion ifsfirst;
		116	/* last struct in list */
		117	static struct ifsregion *ifslastp;
		118	/* holds expanded arg list */
		119	static struct arglist exparg;
98		120
99	STATIC void argstr __P((char *, int));	121	STATIC void argstr __P((char *, int));
100	STATIC char exptilde __P((char , int));	122	STATIC char exptilde __P((char , int));
101	STATIC void expbackq __P((union node *, int, int));	123	STATIC void expbackq __P((union node *, int, int));
102	STATIC int subevalvar __P((char , char , int, int, int, int));	124	STATIC const char subevalvar __P((char , char *, int, int, int, int, int));
103	STATIC char evalvar __P((char , int));	125	STATIC char evalvar __P((char , int));
104	STATIC int varisset __P((char *, int));	126	STATIC int varisset __P((char *, int));
		127	STATIC void strtodest __P((const char , const char , int));
		128	STATIC void memtodest __P((const char , size_t, const char , int));
105	STATIC void varvalue __P((char *, int, int));	129	STATIC void varvalue __P((char *, int, int));
106	STATIC void recordregion __P((int, int, int));	130	STATIC void recordregion __P((int, int, int));
107	STATIC void removerecordregions __P((int));	131	STATIC void removerecordregions __P((int));
108	STATIC void ifsbreakup __P((char , struct arglist ));	132	STATIC void ifsbreakup __P((char , struct arglist ));
109	STATIC void ifsfree __P((void));	133	STATIC void ifsfree __P((void));
110	STATIC void expandmeta __P((struct strlist *, int));	134	STATIC void expandmeta __P((struct strlist *, int));
		135	#if defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
		136	STATIC void addglob __P((const glob_t *));
		137	#else
111	STATIC void expmeta __P((char , char ));	138	STATIC void expmeta __P((char , char ));
		139	#endif
112	STATIC void addfname __P((char *));	140	STATIC void addfname __P((char *));
		141	#if !(defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
113	STATIC struct strlist expsort __P((struct strlist ));	142	STATIC struct strlist expsort __P((struct strlist ));
114	STATIC struct strlist msort __P((struct strlist , int));	143	STATIC struct strlist msort __P((struct strlist , int));
115	STATIC int pmatch __P((char , char , int));	144	#endif
116	STATIC char cvtnum __P((int, char ));	145	STATIC int patmatch __P((char , const char ));
		146	#if !defined(__GLIBC__) \|\| defined(FNMATCH_BROKEN)
		147	STATIC int pmatch __P((const char , const char ));
		148	#else
		149	#define pmatch(a, b) !fnmatch((a), (b), 0)
		150	#endif
		151	STATIC int cvtnum __P((long));
		152	STATIC size_t esclen __P((const char , const char ));
		153	STATIC char scanleft __P((char , char , char , char *, int, int));
		154	STATIC char scanright __P((char , char , char , char *, int, int));
		155	static void varunset(const char , const char , const char *, int)
		156	__attribute__((__noreturn__));
117		157
118	extern int oexitstatus;	158	extern int oexitstatus;
119		159
		160
		161	/*
		162	* Prepare a pattern for a glob(3) call.
		163	*
		164	* Returns an stalloced string.
		165	*/
		166
		167	STATIC inline char *
		168	preglob(const char *pattern, int quoted, int flag) {
		169	flag \|= RMESCAPE_GLOB;
		170	if (quoted) {
		171	flag \|= RMESCAPE_QUOTED;
		172	}
		173	return _rmescapes((char *)pattern, flag);
		174	}
		175
		176
		177	STATIC size_t
		178	esclen(const char start, const char p) {
		179	size_t esc = 0;
		180
		181	while (p > start && *--p == CTLESC) {
		182	esc++;
		183	}
		184	return esc;
		185	}
		186
		187
120	/*	188	/*
121	* Expand shell variables and backquotes inside a here document.	189	* Expand shell variables and backquotes inside a here document.
122	*/	190	*/
Lines 196-259 Link Here
196	char *p;	264	char *p;
197	int flag;	265	int flag;
198	{	266	{
199	char c;	267	static const char spclchars[] = {
		268	'=',
		269	':',
		270	CTLQUOTEMARK,
		271	CTLENDVAR,
		272	CTLESC,
		273	CTLVAR,
		274	CTLBACKQ,
		275	CTLBACKQ \| CTLQUOTE,
		276	CTLENDARI,
		277	0
		278	};
		279	const char *reject = spclchars;
		280	int c;
200	int quotes = flag & (EXP_FULL \| EXP_CASE); /* do CTLESC */	281	int quotes = flag & (EXP_FULL \| EXP_CASE); /* do CTLESC */
201	int firsteq = 1;	282	int breakall = flag & EXP_WORD;
		283	int inquotes;
		284	size_t length;
		285	int startloc;
202		286
203	if (*p == '~' && (flag & (EXP_TILDE \| EXP_VARTILDE)))	287	if (!(flag & EXP_VARTILDE)) {
		288	reject += 2;
		289	} else if (flag & EXP_VARTILDE2) {
		290	reject++;
		291	}
		292	inquotes = 0;
		293	length = 0;
		294	if (flag & EXP_TILDE) {
		295	flag &= ~EXP_TILDE;
		296	tilde:
204	p = exptilde(p, flag);	297	p = exptilde(p, flag);
		298	}
		299	start:
		300	startloc = expdest - stackblock();
205	for (;;) {	301	for (;;) {
206	switch (c = *p++) {	302	length += strcspn(p + length, reject);
		303	c = p[length];
		304	if ((c && !(c & 0x80)) \|\| c == CTLENDARI) {
		305	/* c == '=' \|\| c == ':' \|\| c == CTLENDARI */
		306	length++;
		307	}
		308	if (length > 0) {
		309	int newloc;
		310	expdest = stnputs(p, length, expdest);
		311	newloc = expdest - stackblock();
		312	if (breakall && !inquotes && newloc > startloc) {
		313	recordregion(startloc, newloc, 0);
		314	}
		315	startloc = newloc;
		316	}
		317	p += length + 1;
		318	length = 0;
		319
		320	switch (c) {
207	case '\0':	321	case '\0':
		322	goto breakloop;
		323	case '=':
		324	if (flag & EXP_VARTILDE2) {
		325	p--;
		326	continue;
		327	}
		328	flag \|= EXP_VARTILDE2;
		329	reject++;
		330	/* fall through */
		331	case ':':
		332	/*
		333	* sort of a hack - expand tildes in variable
		334	* assignments (after the first '=' and after ':'s).
		335	*/
		336	if (*--p == '~') {
		337	goto tilde;
		338	}
		339	continue;
		340	}
		341
		342	switch (c) {
208	case CTLENDVAR: /* ??? */	343	case CTLENDVAR: /* ??? */
209	goto breakloop;	344	goto breakloop;
210	case CTLQUOTEMARK:	345	case CTLQUOTEMARK:
211	/* "$@" syntax adherence hack */	346	/* "$@" syntax adherence hack */
212	if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=')	347	if (
213	break;	348	!inquotes &&
214	if ((flag & EXP_FULL) != 0)	349	!memcmp(p, dolatstr, DOLATSTRLEN) &&
215	STPUTC(c, expdest);	350	(p[4] == CTLQUOTEMARK \|\| (
		351	p[4] == CTLENDVAR &&
		352	p[5] == CTLQUOTEMARK
		353	))
		354	) {
		355	p = evalvar(p + 1, flag) + 1;
		356	goto start;
		357	}
		358	inquotes = !inquotes;
		359	addquote:
		360	if (quotes) {
		361	p--;
		362	length++;
		363	startloc++;
		364	}
216	break;	365	break;
217	case CTLESC:	366	case CTLESC:
218	if (quotes)	367	startloc++;
219	STPUTC(c, expdest);	368	length++;
220	c = *p++;	369	goto addquote;
221	STPUTC(c, expdest);
222	break;
223	case CTLVAR:	370	case CTLVAR:
224	p = evalvar(p, flag);	371	p = evalvar(p, flag);
225	break;	372	goto start;
226	case CTLBACKQ:	373	case CTLBACKQ:
		374	c = 0;
227	case CTLBACKQ\|CTLQUOTE:	375	case CTLBACKQ\|CTLQUOTE:
228	expbackq(argbackq->n, c & CTLQUOTE, flag);	376	expbackq(argbackq->n, c, quotes);
229	argbackq = argbackq->next;	377	argbackq = argbackq->next;
230	break;	378	goto start;
231	case CTLENDARI:	379	case CTLENDARI:
232	expari(flag);	380	p--;
233	break;	381	expari(quotes);
234	case ':':	382	goto start;
235	case '=':
236	/*
237	* sort of a hack - expand tildes in variable
238	* assignments (after the first '=' and after ':'s).
239	*/
240	STPUTC(c, expdest);
241	if (flag & EXP_VARTILDE && *p == '~') {
242	if (c == '=') {
243	if (firsteq)
244	firsteq = 0;
245	else
246	break;
247	}
248	p = exptilde(p, flag);
249	}
250	break;
251	default:
252	STPUTC(c, expdest);
253	}	383	}
254	}	384	}
255	breakloop:;	385	breakloop:
256	return;	386	;
257	}	387	}
258		388
259	STATIC char *	389	STATIC char *
Lines 262-272 Link Here
262	int flag;	392	int flag;
263	{	393	{
264	char c, *startp = p;	394	char c, *startp = p;
		395	char *name;
265	struct passwd *pw;	396	struct passwd *pw;
266	const char *home;	397	const char *home;
267	int quotes = flag & (EXP_FULL \| EXP_CASE);	398	int quotes = flag & (EXP_FULL \| EXP_CASE);
		399	int startloc;
268		400
269	while ((c = *p) != '\0') {	401	if (*p == CTLESC && (flag & EXP_QWORD)) {
		402	p++;
		403	}
		404	if (*p != '~') {
		405	return startp;
		406	}
		407	name = p + 1;
		408
		409	while ((c = *++p) != '\0') {
270	switch(c) {	410	switch(c) {
271	case CTLESC:	411	case CTLESC:
272	return (startp);	412	return (startp);
Lines 277-304 Link Here
277	goto done;	417	goto done;
278	break;	418	break;
279	case '/':	419	case '/':
		420	case CTLENDVAR:
280	goto done;	421	goto done;
281	}	422	}
282	p++;
283	}	423	}
284	done:	424	done:
285	*p = '\0';	425	*p = '\0';
286	if (*(startp+1) == '\0') {	426	if (*name == '\0') {
287	if ((home = lookupvar("HOME")) == NULL)	427	if ((home = lookupvar(homestr)) == NULL)
288	goto lose;	428	goto lose;
289	} else {	429	} else {
290	if ((pw = getpwnam(startp+1)) == NULL)	430	if ((pw = getpwnam(name)) == NULL)
291	goto lose;	431	goto lose;
292	home = pw->pw_dir;	432	home = pw->pw_dir;
293	}	433	}
294	if (*home == '\0')	434	if (*home == '\0')
295	goto lose;	435	goto lose;
296	*p = c;	436	*p = c;
297	while ((c = *home++) != '\0') {	437	startloc = expdest - stackblock();
298	if (quotes && SQSYNTAX[(int)c] == CCTL)	438	strtodest(home, SQSYNTAX, quotes);
299	STPUTC(CTLESC, expdest);	439	recordregion(startloc, expdest - stackblock(), 0);
300	STPUTC(c, expdest);
301	}
302	return (p);	440	return (p);
303	lose:	441	lose:
304	*p = c;	442	*p = c;
Lines 352-412 Link Here
352	* evaluate, place result in (backed up) result, adjust string position.	490	* evaluate, place result in (backed up) result, adjust string position.
353	*/	491	*/
354	void	492	void
355	expari(flag)	493	expari(quotes)
356	int flag;	494	int quotes;
357	{	495	{
358	char p, start;	496	char p, start;
359	int result;
360	int begoff;	497	int begoff;
361	int quotes = flag & (EXP_FULL \| EXP_CASE);	498	int flag;
362	int quoted;	499	int len;
363		500
364	/* ifsfree(); */	501	/* ifsfree(); */
365		502
366	/*	503	/*
367	* This routine is slightly over-complicated for	504	* This routine is slightly over-complicated for
368	* efficiency. First we make sure there is	505	* efficiency. Next we scan backwards looking for the
369	* enough space for the result, which may be bigger	506	* start of arithmetic.
370	* than the expression if we add exponentation. Next we
371	* scan backwards looking for the start of arithmetic. If the
372	* next previous character is a CTLESC character, then we
373	* have to rescan starting from the beginning since CTLESC
374	* characters have to be processed left to right.
375	*/	507	*/
376	#if INT_MAX / 1000000000 >= 10 \|\| INT_MIN / 1000000000 <= -10
377	#error "integers with more than 10 digits are not supported"
378	#endif
379	CHECKSTRSPACE(12 - 2, expdest);
380	USTPUTC('\0', expdest);
381	start = stackblock();	508	start = stackblock();
382	p = expdest - 1;	509	p = expdest - 1;
383	while (*p != CTLARI && p >= start)	510	*p = '\0';
384	--p;	511	p--;
385	if (*p != CTLARI)	512	do {
		513	int esc;
		514
		515	while (*p != CTLARI) {
		516	p--;
		517	#ifdef DEBUG
		518	if (p < start) {
386	error("missing CTLARI (shouldn't happen)");	519	error("missing CTLARI (shouldn't happen)");
387	if (p > start && *(p-1) == CTLESC)	520	}
388	for (p = start; *p != CTLARI; p++)	521	#endif
389	if (*p == CTLESC)	522	}
390	p++;	523
		524	esc = esclen(start, p);
		525	if (!(esc % 2)) {
		526	break;
		527	}
		528
		529	p -= esc + 1;
		530	} while (1);
391		531
392	if (p[1] == '"')
393	quoted=1;
394	else
395	quoted=0;
396	begoff = p - start;	532	begoff = p - start;
		533
397	removerecordregions(begoff);	534	removerecordregions(begoff);
		535
		536	flag = p[1];
		537
		538	expdest = p;
		539
398	if (quotes)	540	if (quotes)
399	rmescapes(p+2);	541	rmescapes(p + 2);
400	result = arith(p+2);
401	fmtstr(p, 12, "%d", result);
402		542
403	while (*p++)	543	len = cvtnum(arith(p + 2));
404	;
405		544
406	if (quoted == 0)	545	if (flag != '"')
407	recordregion(begoff, p - 1 - start, 0);	546	recordregion(begoff, begoff + len, 0);
408	result = expdest - p + 1;
409	STADJUST(-result, expdest);
410	}	547	}
411		548
412		549
Lines 415-456 Link Here
415	*/	552	*/
416		553
417	STATIC void	554	STATIC void
418	expbackq(cmd, quoted, flag)	555	expbackq(cmd, quoted, quotes)
419	union node *cmd;	556	union node *cmd;
420	int quoted;	557	int quoted;
421	int flag;	558	int quotes;
422	{	559	{
423	struct backcmd in;	560	struct backcmd in;
424	int i;	561	int i;
425	char buf[128];	562	char buf[128];
426	char *p;	563	char *p;
427	char *dest = expdest;	564	char *dest = expdest;
428	struct ifsregion saveifs, *savelastp;	565	struct ifsregion saveifs;
		566	struct ifsregion *savelastp;
429	struct nodelist *saveargbackq;	567	struct nodelist *saveargbackq;
430	char lastc;
431	int startloc = dest - stackblock();	568	int startloc = dest - stackblock();
432	char const *syntax = quoted? DQSYNTAX : BASESYNTAX;	569	char const *syntax = quoted? DQSYNTAX : BASESYNTAX;
433	int saveherefd;	570	int saveherefd;
434	int quotes = flag & (EXP_FULL \| EXP_CASE);
435		571
436	INTOFF;	572	in.fd = -1;
		573	in.buf = 0;
		574	in.jp = 0;
		575
437	saveifs = ifsfirst;	576	saveifs = ifsfirst;
438	savelastp = ifslastp;	577	savelastp = ifslastp;
439	saveargbackq = argbackq;	578	saveargbackq = argbackq;
440	saveherefd = herefd;	579	saveherefd = herefd;
441	herefd = -1;	580	herefd = -1;
442	p = grabstackstr(dest);	581
443	evalbackcmd(cmd, &in);	582	INTOFF;
444	ungrabstackstr(p, dest);	583	evalbackcmd(cmd, (struct backcmd *) &in);
445	ifsfirst = saveifs;	584	ifsfirst = saveifs;
446	ifslastp = savelastp;	585	ifslastp = savelastp;
447	argbackq = saveargbackq;	586	argbackq = saveargbackq;
448	herefd = saveherefd;	587	herefd = saveherefd;
449		588
450	p = in.buf;	589	p = in.buf;
451	lastc = '\0';	590	i = in.nleft;
		591	if (i == 0)
		592	goto read;
452	for (;;) {	593	for (;;) {
453	if (--in.nleft < 0) {	594	memtodest(p, i, syntax, quotes);
		595	read:
454	if (in.fd < 0)	596	if (in.fd < 0)
455	break;	597	break;
456	while ((i = read(in.fd, buf, sizeof buf)) < 0 && errno == EINTR);	598	while ((i = read(in.fd, buf, sizeof buf)) < 0 && errno == EINTR);
Lines 458-475 Link Here
458	if (i <= 0)	600	if (i <= 0)
459	break;	601	break;
460	p = buf;	602	p = buf;
461	in.nleft = i - 1;
462	}
463	lastc = *p++;
464	if (lastc != '\0') {
465	if (quotes && syntax[(int)lastc] == CCTL)
466	STPUTC(CTLESC, dest);
467	STPUTC(lastc, dest);
468	}
469	}	603	}
470		604
		605	dest = expdest;
		606
471	/* Eat all trailing newlines */	607	/* Eat all trailing newlines */
472	for (p--; lastc == '\n'; lastc = *--p)	608	for (; dest > stackblock() && dest[-1] == '\n';)
473	STUNPUTC(dest);	609	STUNPUTC(dest);
474		610
475	if (in.fd >= 0)	611	if (in.fd >= 0)
Lines 478-483 Link Here
478	ckfree(in.buf);	614	ckfree(in.buf);
479	if (in.jp)	615	if (in.jp)
480	exitstatus = waitforjob(in.jp);	616	exitstatus = waitforjob(in.jp);
		617	INTON;
481	if (quoted == 0)	618	if (quoted == 0)
482	recordregion(startloc, dest - stackblock(), 0);	619	recordregion(startloc, dest - stackblock(), 0);
483	TRACE(("evalbackq: size=%d: \"%.*s\"\n",	620	TRACE(("evalbackq: size=%d: \"%.*s\"\n",
Lines 485-615 Link Here
485	(dest - stackblock()) - startloc,	622	(dest - stackblock()) - startloc,
486	stackblock() + startloc));	623	stackblock() + startloc));
487	expdest = dest;	624	expdest = dest;
488	INTON;
489	}	625	}
490		626
491		627
		628	STATIC char *
		629	scanleft(
		630	char startp, char rmesc, char rmescend, char str, int quotes,
		631	int zero
		632	) {
		633	char *loc;
		634	char *loc2;
		635	char c;
		636
		637	loc = startp;
		638	loc2 = rmesc;
		639	do {
		640	int match;
		641	const char *s = loc2;
		642	c = *loc2;
		643	if (zero) {
		644	*loc2 = '\0';
		645	s = rmesc;
		646	}
		647	match = pmatch(str, s);
		648	*loc2 = c;
		649	if (match)
		650	return loc;
		651	if (quotes && *loc == CTLESC)
		652	loc++;
		653	loc++;
		654	loc2++;
		655	} while (c);
		656	return 0;
		657	}
		658
		659
		660	STATIC char *
		661	scanright(
		662	char startp, char rmesc, char rmescend, char str, int quotes,
		663	int zero
		664	) {
		665	int esc = 0;
		666	char *loc;
		667	char *loc2;
492		668
493	STATIC int	669	for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) {
494	subevalvar(p, str, strloc, subtype, startloc, varflags)	670	int match;
		671	char c = *loc2;
		672	const char *s = loc2;
		673	if (zero) {
		674	*loc2 = '\0';
		675	s = rmesc;
		676	}
		677	match = pmatch(str, s);
		678	*loc2 = c;
		679	if (match)
		680	return loc;
		681	loc--;
		682	if (quotes) {
		683	if (--esc < 0) {
		684	esc = esclen(startp, loc);
		685	}
		686	if (esc % 2) {
		687	esc--;
		688	loc--;
		689	}
		690	}
		691	}
		692	return 0;
		693	}
		694
		695	STATIC const char *
		696	subevalvar(p, str, strloc, subtype, startloc, varflags, quotes)
495	char *p;	697	char *p;
496	char *str;	698	char *str;
497	int strloc;	699	int strloc;
498	int subtype;	700	int subtype;
499	int startloc;	701	int startloc;
500	int varflags;	702	int varflags;
		703	int quotes;
501	{	704	{
502	char *startp;	705	char *startp;
503	char *loc = NULL;	706	char *loc;
504	char *q;
505	int c = 0;
506	int saveherefd = herefd;	707	int saveherefd = herefd;
507	struct nodelist *saveargbackq = argbackq;	708	struct nodelist *saveargbackq = argbackq;
508	int amount;	709	int amount;
		710	char rmesc, rmescend;
		711	int zero;
		712	char (scan)(char , char , char , char , int , int);
509		713
510	herefd = -1;	714	herefd = -1;
511	argstr(p, 0);	715	argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
512	STACKSTRNUL(expdest);	716	STPUTC('\0', expdest);
513	herefd = saveherefd;	717	herefd = saveherefd;
514	argbackq = saveargbackq;	718	argbackq = saveargbackq;
515	startp = stackblock() + startloc;	719	startp = stackblock() + startloc;
516	if (str == NULL)
517	str = stackblock() + strloc;
518		720
519	switch (subtype) {	721	switch (subtype) {
520	case VSASSIGN:	722	case VSASSIGN:
521	setvar(str, startp, 0);	723	setvar(str, startp, 0);
522	amount = startp - expdest;	724	amount = startp - expdest;
523	STADJUST(amount, expdest);	725	STADJUST(amount, expdest);
524	varflags &= ~VSNUL;	726	return startp;
525	if (c != 0)
526	*loc = c;
527	return 1;
528		727
529	case VSQUESTION:	728	case VSQUESTION:
530	if (*p != CTLENDVAR) {	729	varunset(p, str, startp, varflags);
531	outfmt(&errout, "%s\n", startp);
532	error((char *)NULL);
533	}
534	error("%.*s: parameter %snot set", p - str - 1,
535	str, (varflags & VSNUL) ? "null or "
536	: nullstr);
537	/* NOTREACHED */	730	/* NOTREACHED */
538
539	case VSTRIMLEFT:
540	for (loc = startp; loc < str; loc++) {
541	c = *loc;
542	*loc = '\0';
543	if (patmatch(str, startp, varflags & VSQUOTE))
544	goto recordleft;
545	*loc = c;
546	if ((varflags & VSQUOTE) && *loc == CTLESC)
547	loc++;
548	}	731	}
549	return 0;
550		732
551	case VSTRIMLEFTMAX:	733	subtype -= VSTRIMRIGHT;
552	for (loc = str - 1; loc >= startp;) {	734	#ifdef DEBUG
553	c = *loc;	735	if (subtype < 0 \|\| subtype > 3)
554	*loc = '\0';	736	abort();
555	if (patmatch(str, startp, varflags & VSQUOTE))	737	#endif
556	goto recordleft;
557	*loc = c;
558	loc--;
559	if ((varflags & VSQUOTE) && loc > startp &&
560	*(loc - 1) == CTLESC) {
561	for (q = startp; q < loc; q++)
562	if (*q == CTLESC)
563	q++;
564	if (q > loc)
565	loc--;
566	}
567	}
568	return 0;
569		738
570	case VSTRIMRIGHT:	739	rmesc = startp;
571	for (loc = str - 1; loc >= startp;) {	740	rmescend = stackblock() + strloc;
572	if (patmatch(str, loc, varflags & VSQUOTE))	741	if (quotes) {
573	goto recordright;	742	rmesc = _rmescapes(startp, RMESCAPE_ALLOC \| RMESCAPE_GROW);
574	loc--;	743	if (rmesc != startp) {
575	if ((varflags & VSQUOTE) && loc > startp &&	744	rmescend = expdest;
576	*(loc - 1) == CTLESC) {	745	startp = stackblock() + startloc;
577	for (q = startp; q < loc; q++)
578	if (*q == CTLESC)
579	q++;
580	if (q > loc)
581	loc--;
582	}	746	}
583	}	747	}
584	return 0;	748	rmescend--;
		749	str = stackblock() + strloc;
		750	preglob(str, varflags & VSQUOTE, 0);
585		751
586	case VSTRIMRIGHTMAX:	752	/* zero = subtype == VSTRIMLEFT \|\| subtype == VSTRIMLEFTMAX */
587	for (loc = startp; loc < str - 1; loc++) {	753	zero = subtype >> 1;
588	if (patmatch(str, loc, varflags & VSQUOTE))	754	/* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
589	goto recordright;	755	scan = (subtype & 1) ^ zero ? scanleft : scanright;
590	if ((varflags & VSQUOTE) && *loc == CTLESC)
591	loc++;
592	}
593	return 0;
594		756
595	default:	757	loc = scan(startp, rmesc, rmescend, str, quotes, zero);
596	abort();	758	if (loc) {
		759	if (zero) {
		760	memmove(startp, loc, str - loc);
		761	loc = startp + (str - loc) - 1;
597	}	762	}
598		763	*loc = '\0';
599	recordleft:
600	*loc = c;
601	amount = ((str - 1) - (loc - startp)) - expdest;
602	STADJUST(amount, expdest);
603	while (loc != str - 1)
604	startp++ = loc++;
605	return 1;
606
607	recordright:
608	amount = loc - expdest;	764	amount = loc - expdest;
609	STADJUST(amount, expdest);	765	STADJUST(amount, expdest);
610	STPUTC('\0', expdest);	766	}
611	STADJUST(-1, expdest);	767	return loc;
612	return 1;
613	}	768	}
614		769
615		770
Lines 617-736 Link Here
617	* Expand a variable, and return a pointer to the next character in the	772	* Expand a variable, and return a pointer to the next character in the
618	* input string.	773	* input string.
619	*/	774	*/
620
621	STATIC char *	775	STATIC char *
622	evalvar(p, flag)	776	evalvar(p, flag)
623	char *p;	777	char *p;
624	int flag;	778	const int flag;
625	{	779	{
626	int subtype;	780	int subtype;
627	int varflags;	781	int varflags;
628	char *var;	782	char *var;
629	char *val;
630	int patloc;	783	int patloc;
631	int c;	784	int c;
632	int set;	785	int set;
633	int special;
634	int startloc;	786	int startloc;
635	int varlen;	787	size_t varlen;
636	int easy;	788	int easy;
637	int quotes = flag & (EXP_FULL \| EXP_CASE);	789	int quotes;
		790	int quoted;
638		791
		792	quotes = flag & (EXP_FULL \| EXP_CASE);
639	varflags = *p++;	793	varflags = *p++;
640	subtype = varflags & VSTYPE;	794	subtype = varflags & VSTYPE;
		795	quoted = varflags & VSQUOTE;
641	var = p;	796	var = p;
642	special = 0;	797	easy = (!quoted \|\| (*var == '@' && shellparam.nparam));
643	if (! is_name(*p))
644	special = 1;
645	p = strchr(p, '=') + 1;
646	again: /* jump here after setting a variable with ${var=text} */
647	if (special) {
648	set = varisset(var, varflags & VSNUL);
649	val = NULL;
650	} else {
651	val = lookupvar(var);
652	if (val == NULL \|\| ((varflags & VSNUL) && val[0] == '\0')) {
653	val = NULL;
654	set = 0;
655	} else
656	set = 1;
657	}
658	varlen = 0;	798	varlen = 0;
659	startloc = expdest - stackblock();	799	startloc = expdest - stackblock();
660	if (!set && uflag)	800	p = strchr(p, '=') + 1;
661	switch (subtype) {	801
662	case VSNORMAL:	802	if (!is_name(*var)) {
663	case VSTRIMLEFT:	803	set = varisset(var, varflags & VSNUL);
664	case VSTRIMLEFTMAX:	804	set--;
665	case VSTRIMRIGHT:	805	if (subtype == VSPLUS)
666	case VSTRIMRIGHTMAX:	806	goto vsplus;
667	case VSLENGTH:	807	if (++set) {
668	error("%.*s: parameter not set", p - var - 1, var);	808	varvalue(var, quoted, flag);
669	/* NOTREACHED */
670	}
671	if (set && subtype != VSPLUS) {
672	/* insert the value of the variable */
673	if (special) {
674	varvalue(var, varflags & VSQUOTE, flag & EXP_FULL);
675	if (subtype == VSLENGTH) {	809	if (subtype == VSLENGTH) {
676	varlen = expdest - stackblock() - startloc;	810	varlen = expdest - stackblock() - startloc;
677	STADJUST(-varlen, expdest);	811	STADJUST(-varlen, expdest);
		812	goto vslen;
		813	}
678	}	814	}
679	} else {	815	} else {
680	char const *syntax = (varflags & VSQUOTE) ? DQSYNTAX	816	const char *val;
681	: BASESYNTAX;	817	again:
		818	/* jump here after setting a variable with ${var=text} */
		819	val = lookupvar(var);
		820	set = !val \|\| ((varflags & VSNUL) && !*val);
		821	if (subtype == VSPLUS)
		822	goto vsplus;
		823	if (--set) {
		824	varlen = strlen(val);
		825	if (subtype == VSLENGTH)
		826	goto vslen;
		827	memtodest(
		828	val, varlen, quoted ? DQSYNTAX : BASESYNTAX,
		829	quotes
		830	);
		831	}
		832	}
682		833
683	if (subtype == VSLENGTH) {	834
684	for (;*val; val++)	835	if (subtype == VSMINUS) {
685	varlen++;	836	vsplus:
		837	if (!set) {
		838	argstr(
		839	p, flag \| EXP_TILDE \|
		840	(quoted ? EXP_QWORD : EXP_WORD)
		841	);
		842	goto end;
686	}	843	}
687	else {	844	if (easy)
688	while (*val) {	845	goto record;
689	if (quotes && syntax[(int)*val] == CCTL)	846	goto end;
690	STPUTC(CTLESC, expdest);
691	STPUTC(*val++, expdest);
692	}	847	}
693		848
		849	if (subtype == VSASSIGN \|\| subtype == VSQUESTION) {
		850	if (!set) {
		851	if (subevalvar(p, var, 0, subtype, startloc,
		852	varflags, 0)) {
		853	varflags &= ~VSNUL;
		854	/*
		855	* Remove any recorded regions beyond
		856	* start of variable
		857	*/
		858	removerecordregions(startloc);
		859	goto again;
694	}	860	}
		861	goto end;
695	}	862	}
		863	if (easy)
		864	goto record;
		865	goto end;
696	}	866	}
697		867
698	if (subtype == VSPLUS)	868	if (!set && uflag)
699	set = ! set;	869	varunset(p, var, 0, 0);
700
701	easy = ((varflags & VSQUOTE) == 0 \|\|
702	(*var == '@' && shellparam.nparam != 1));
703
704		870
705	switch (subtype) {	871	if (subtype == VSLENGTH) {
706	case VSLENGTH:	872	vslen:
707	expdest = cvtnum(varlen, expdest);	873	cvtnum(varlen);
708	goto record;	874	goto record;
		875	}
709		876
710	case VSNORMAL:	877	if (subtype == VSNORMAL) {
711	if (!easy)	878	if (!easy)
712	break;	879	goto end;
713	record:	880	record:
714	recordregion(startloc, expdest - stackblock(),	881	recordregion(startloc, expdest - stackblock(), quoted);
715	varflags & VSQUOTE);	882	goto end;
716	break;
717
718	case VSPLUS:
719	case VSMINUS:
720	if (!set) {
721	argstr(p, flag);
722	break;
723	}	883	}
724	if (easy)
725	goto record;
726	break;
727		884
		885	#ifdef DEBUG
		886	switch (subtype) {
728	case VSTRIMLEFT:	887	case VSTRIMLEFT:
729	case VSTRIMLEFTMAX:	888	case VSTRIMLEFTMAX:
730	case VSTRIMRIGHT:	889	case VSTRIMRIGHT:
731	case VSTRIMRIGHTMAX:	890	case VSTRIMRIGHTMAX:
732	if (!set)
733	break;	891	break;
		892	default:
		893	abort();
		894	}
		895	#endif
		896
		897	if (set) {
734	/*	898	/*
735	* Terminate the string and start recording the pattern	899	* Terminate the string and start recording the pattern
736	* right after it	900	* right after it
Lines 738-774 Link Here
738	STPUTC('\0', expdest);	902	STPUTC('\0', expdest);
739	patloc = expdest - stackblock();	903	patloc = expdest - stackblock();
740	if (subevalvar(p, NULL, patloc, subtype,	904	if (subevalvar(p, NULL, patloc, subtype,
741	startloc, varflags) == 0) {	905	startloc, varflags, quotes) == 0) {
742	int amount = (expdest - stackblock() - patloc) + 1;	906	int amount = expdest - (stackblock() + patloc - 1);
743	STADJUST(-amount, expdest);	907	STADJUST(-amount, expdest);
744	}	908	}
745	/* Remove any recorded regions beyond start of variable */	909	/* Remove any recorded regions beyond start of variable */
746	removerecordregions(startloc);	910	removerecordregions(startloc);
747	goto record;	911	goto record;
748
749	case VSASSIGN:
750	case VSQUESTION:
751	if (!set) {
752	if (subevalvar(p, var, 0, subtype, startloc,
753	varflags)) {
754	varflags &= ~VSNUL;
755	/*
756	* Remove any recorded regions beyond
757	* start of variable
758	*/
759	removerecordregions(startloc);
760	goto again;
761	}
762	break;
763	}
764	if (easy)
765	goto record;
766	break;
767
768	default:
769	abort();
770	}	912	}
771		913
		914	end:
772	if (subtype != VSNORMAL) { /* skip to end of alternative */	915	if (subtype != VSNORMAL) { /* skip to end of alternative */
773	int nesting = 1;	916	int nesting = 1;
774	for (;;) {	917	for (;;) {
Lines 801-807 Link Here
801	int nulok;	944	int nulok;
802	{	945	{
803	if (*name == '!')	946	if (*name == '!')
804	return backgndpid != -1;	947	return backgndpid != 0;
805	else if (name == '@' \|\| name == '*') {	948	else if (name == '@' \|\| name == '*') {
806	if (*shellparam.p == NULL)	949	if (*shellparam.p == NULL)
807	return 0;	950	return 0;
Lines 835-871 Link Here
835		978
836		979
837	/*	980	/*
		981	* Put a string on the stack.
		982	*/
		983
		984	STATIC void
		985	memtodest(const char p, size_t len, const char syntax, int quotes) {
		986	char *q = expdest;
		987
		988	q = makestrspace(len * 2, q);
		989
		990	while (len--) {
		991	int c = *p++;
		992	if (!c)
		993	continue;
		994	if (quotes && (syntax[c] == CCTL \|\| syntax[c] == CBACK))
		995	USTPUTC(CTLESC, q);
		996	USTPUTC(c, q);
		997	}
		998
		999	expdest = q;
		1000	}
		1001
		1002
		1003	STATIC void
		1004	strtodest(p, syntax, quotes)
		1005	const char *p;
		1006	const char *syntax;
		1007	int quotes;
		1008	{
		1009	memtodest(p, strlen(p), syntax, quotes);
		1010	}
		1011
		1012
		1013
		1014	/*
838	* Add the value of a specialized variable to the stack string.	1015	* Add the value of a specialized variable to the stack string.
839	*/	1016	*/
840		1017
841	STATIC void	1018	STATIC void
842	varvalue(name, quoted, allow_split)	1019	varvalue(name, quoted, flags)
843	char *name;	1020	char *name;
844	int quoted;	1021	int quoted;
845	int allow_split;	1022	int flags;
846	{	1023	{
847	int num;	1024	int num;
848	char *p;	1025	char *p;
849	int i;	1026	int i;
850	char sep;	1027	int sep;
		1028	int sepq = 0;
851	char **ap;	1029	char **ap;
852	char const *syntax;	1030	char const *syntax;
		1031	int allow_split = flags & EXP_FULL;
		1032	int quotes = flags & (EXP_FULL \| EXP_CASE);
853		1033
854	#define STRTODEST(p) \	1034	syntax = quoted ? DQSYNTAX : BASESYNTAX;
855	do {\
856	if (allow_split) { \
857	syntax = quoted? DQSYNTAX : BASESYNTAX; \
858	while (*p) { \
859	if (syntax[(int)*p] == CCTL) \
860	STPUTC(CTLESC, expdest); \
861	STPUTC(*p++, expdest); \
862	} \
863	} else \
864	while (*p) \
865	STPUTC(*p++, expdest); \
866	} while (0)
867
868
869	switch (*name) {	1035	switch (*name) {
870	case '$':	1036	case '$':
871	num = rootpid;	1037	num = rootpid;
Lines 879-924 Link Here
879	case '!':	1045	case '!':
880	num = backgndpid;	1046	num = backgndpid;
881	numvar:	1047	numvar:
882	expdest = cvtnum(num, expdest);	1048	cvtnum(num);
883	break;	1049	break;
884	case '-':	1050	case '-':
885	for (i = 0 ; i < NOPTS ; i++) {	1051	for (i = 0 ; i < NOPTS ; i++) {
886	if (optlist[i].val)	1052	if (optlist[i])
887	STPUTC(optlist[i].letter, expdest);	1053	STPUTC(optletters[i], expdest);
888	}	1054	}
889	break;	1055	break;
890	case '@':	1056	case '@':
891	if (allow_split && quoted) {	1057	if (allow_split && quoted) {
892	for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {	1058	sep = 1 << CHAR_BIT;
893	STRTODEST(p);	1059	goto param;
894	if (*ap)
895	STPUTC('\0', expdest);
896	}
897	break;
898	}	1060	}
899	/* fall through */	1061	/* fall through */
900	case '*':	1062	case '*':
901	if (ifsset() != 0)	1063	sep = ifsset() ? ifsval()[0] : ' ';
902	sep = ifsval()[0];	1064	if (quotes) {
903	else	1065	sepq = (syntax[sep] == CCTL) \|\| (syntax[sep] == CBACK);
904	sep = ' ';	1066	}
		1067	param:
905	for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {	1068	for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
906	STRTODEST(p);	1069	strtodest(p, syntax, quotes);
907	if (*ap && sep)	1070	if (*ap && sep) {
908	STPUTC(sep, expdest);	1071	p = expdest;
		1072	if (sepq)
		1073	STPUTC(CTLESC, p);
		1074	STPUTC(sep, p);
		1075	expdest = p;
		1076	}
909	}	1077	}
910	break;	1078	break;
911	case '0':	1079	case '0':
912	p = arg0;	1080	strtodest(arg0, syntax, quotes);
913	STRTODEST(p);
914	break;	1081	break;
915	default:	1082	default:
916	if (is_digit(*name)) {
917	num = atoi(name);	1083	num = atoi(name);
918	if (num > 0 && num <= shellparam.nparam) {	1084	if (num > 0 && num <= shellparam.nparam) {
919	p = shellparam.p[num - 1];	1085	strtodest(shellparam.p[num - 1], syntax, quotes);
920	STRTODEST(p);
921	}
922	}	1086	}
923	break;	1087	break;
924	}	1088	}
Lines 942-952 Link Here
942	if (ifslastp == NULL) {	1106	if (ifslastp == NULL) {
943	ifsp = &ifsfirst;	1107	ifsp = &ifsfirst;
944	} else {	1108	} else {
		1109	INTOFF;
945	ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion));	1110	ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion));
		1111	ifsp->next = NULL;
946	ifslastp->next = ifsp;	1112	ifslastp->next = ifsp;
		1113	INTON;
947	}	1114	}
948	ifslastp = ifsp;	1115	ifslastp = ifsp;
949	ifslastp->next = NULL;
950	ifslastp->begoff = start;	1116	ifslastp->begoff = start;
951	ifslastp->endoff = end;	1117	ifslastp->endoff = end;
952	ifslastp->nulonly = nulonly;	1118	ifslastp->nulonly = nulonly;
Lines 969-975 Link Here
969	char *start;	1135	char *start;
970	char *p;	1136	char *p;
971	char *q;	1137	char *q;
972	const char *ifs;	1138	const char ifs, realifs;
973	int ifsspc;	1139	int ifsspc;
974	int nulonly;	1140	int nulonly;
975		1141
Lines 977-989 Link Here
977	start = string;	1143	start = string;
978	ifsspc = 0;	1144	ifsspc = 0;
979	nulonly = 0;	1145	nulonly = 0;
		1146	realifs = ifsset() ? ifsval() : defifs;
980	if (ifslastp != NULL) {	1147	if (ifslastp != NULL) {
981	ifsp = &ifsfirst;	1148	ifsp = &ifsfirst;
982	do {	1149	do {
983	p = string + ifsp->begoff;	1150	p = string + ifsp->begoff;
984	nulonly = ifsp->nulonly;	1151	nulonly = ifsp->nulonly;
985	ifs = nulonly ? nullstr :	1152	ifs = nulonly ? nullstr : realifs;
986	( ifsset() ? ifsval() : " \t\n" );
987	ifsspc = 0;	1153	ifsspc = 0;
988	while (p < string + ifsp->endoff) {	1154	while (p < string + ifsp->endoff) {
989	q = p;	1155	q = p;
Lines 991-997 Link Here
991	p++;	1157	p++;
992	if (strchr(ifs, *p)) {	1158	if (strchr(ifs, *p)) {
993	if (!nulonly)	1159	if (!nulonly)
994	ifsspc = (strchr(" \t\n", *p) != NULL);	1160	ifsspc = (strchr(defifs, *p) != NULL);
995	/* Ignore IFS whitespace at start */	1161	/* Ignore IFS whitespace at start */
996	if (q == start && ifsspc) {	1162	if (q == start && ifsspc) {
997	p++;	1163	p++;
Lines 1015-1021 Link Here
1015	if (strchr(ifs, *p) == NULL ) {	1181	if (strchr(ifs, *p) == NULL ) {
1016	p = q;	1182	p = q;
1017	break;	1183	break;
1018	} else if (strchr(" \t\n",*p) == NULL) {	1184	} else if (strchr(defifs, *p) == NULL) {
1019	if (ifsspc) {	1185	if (ifsspc) {
1020	p++;	1186	p++;
1021	ifsspc = 0;	1187	ifsspc = 0;
Lines 1032-1050 Link Here
1032	p++;	1198	p++;
1033	}	1199	}
1034	} while ((ifsp = ifsp->next) != NULL);	1200	} while ((ifsp = ifsp->next) != NULL);
1035	if (*start \|\| (!ifsspc && start > string &&	1201	if (nulonly)
1036	(nulonly \|\| 1))) {	1202	goto add;
1037	sp = (struct strlist )stalloc(sizeof sp);
1038	sp->text = start;
1039	*arglist->lastp = sp;
1040	arglist->lastp = &sp->next;
1041	}	1203	}
1042	} else {	1204
		1205	if (!*start)
		1206	return;
		1207
		1208	add:
1043	sp = (struct strlist )stalloc(sizeof sp);	1209	sp = (struct strlist )stalloc(sizeof sp);
1044	sp->text = start;	1210	sp->text = start;
1045	*arglist->lastp = sp;	1211	*arglist->lastp = sp;
1046	arglist->lastp = &sp->next;	1212	arglist->lastp = &sp->next;
1047	}
1048	}	1213	}
1049		1214
1050	STATIC void	1215	STATIC void
Lines 1069-1075 Link Here
1069	* should be escapes. The results are stored in the list exparg.	1234	* should be escapes. The results are stored in the list exparg.
1070	*/	1235	*/
1071		1236
1072	char *expdir;	1237	#if defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
		1238	STATIC void
		1239	expandmeta(str, flag)
		1240	struct strlist *str;
		1241	int flag;
		1242	{
		1243	/* TODO - EXP_REDIR */
		1244
		1245	while (str) {
		1246	const char *p;
		1247	glob_t pglob;
		1248	int i;
		1249
		1250	if (fflag)
		1251	goto nometa;
		1252	INTOFF;
		1253	p = preglob(str->text, 0, RMESCAPE_ALLOC \| RMESCAPE_HEAP);
		1254	i = glob(p, GLOB_NOMAGIC, 0, &pglob);
		1255	if (p != str->text)
		1256	ckfree(p);
		1257	switch (i) {
		1258	case 0:
		1259	if (!(pglob.gl_flags & GLOB_MAGCHAR))
		1260	goto nometa2;
		1261	addglob(&pglob);
		1262	globfree(&pglob);
		1263	INTON;
		1264	break;
		1265	case GLOB_NOMATCH:
		1266	nometa2:
		1267	globfree(&pglob);
		1268	INTON;
		1269	nometa:
		1270	*exparg.lastp = str;
		1271	rmescapes(str->text);
		1272	exparg.lastp = &str->next;
		1273	break;
		1274	default: /* GLOB_NOSPACE */
		1275	error("Out of space");
		1276	}
		1277	str = str->next;
		1278	}
		1279	}
		1280
		1281
		1282	/*
		1283	* Add the result of glob(3) to the list.
		1284	*/
		1285
		1286	STATIC void
		1287	addglob(pglob)
		1288	const glob_t *pglob;
		1289	{
		1290	char **p = pglob->gl_pathv;
		1291
		1292	do {
		1293	addfname(*p);
		1294	} while (*++p);
		1295	}
		1296
		1297
		1298	#else /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
		1299	STATIC char *expdir;
1073		1300
1074		1301
1075	STATIC void	1302	STATIC void
Lines 1077-1108 Link Here
1077	struct strlist *str;	1304	struct strlist *str;
1078	int flag;	1305	int flag;
1079	{	1306	{
1080	char *p;	1307	static const char metachars[] = {
1081	struct strlist **savelastp;	1308	'*', '?', '[', 0
1082	struct strlist *sp;	1309	};
1083	char c;
1084	/* TODO - EXP_REDIR */	1310	/* TODO - EXP_REDIR */
1085		1311
1086	while (str) {	1312	while (str) {
		1313	struct strlist **savelastp;
		1314	struct strlist *sp;
		1315	char *p;
		1316
1087	if (fflag)	1317	if (fflag)
1088	goto nometa;	1318	goto nometa;
1089	p = str->text;	1319	if (!strpbrk(str->text, metachars))
1090	for (;;) { /* fast check for meta chars */
1091	if ((c = *p++) == '\0')
1092	goto nometa;	1320	goto nometa;
1093	if (c == '*' \|\| c == '?' \|\| c == '[' \|\| c == '!')
1094	break;
1095	}
1096	savelastp = exparg.lastp;	1321	savelastp = exparg.lastp;
		1322
1097	INTOFF;	1323	INTOFF;
1098	if (expdir == NULL) {	1324	p = preglob(str->text, 0, RMESCAPE_ALLOC \| RMESCAPE_HEAP);
		1325	{
1099	int i = strlen(str->text);	1326	int i = strlen(str->text);
1100	expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */	1327	expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
1101	}	1328	}
1102		1329
1103	expmeta(expdir, str->text);	1330	expmeta(expdir, p);
1104	ckfree(expdir);	1331	ckfree(expdir);
1105	expdir = NULL;	1332	if (p != str->text)
		1333	ckfree(p);
1106	INTON;	1334	INTON;
1107	if (exparg.lastp == savelastp) {	1335	if (exparg.lastp == savelastp) {
1108	/*	1336	/*
Lines 1135-1145 Link Here
1135	{	1363	{
1136	char *p;	1364	char *p;
1137	const char *cp;	1365	const char *cp;
1138	char *q;
1139	char *start;	1366	char *start;
1140	char *endname;	1367	char *endname;
1141	int metaflag;	1368	int metaflag;
1142	struct stat statb;	1369	struct stat64 statb;
1143	DIR *dirp;	1370	DIR *dirp;
1144	struct dirent *dp;	1371	struct dirent *dp;
1145	int atend;	1372	int atend;
Lines 1147-1163 Link Here
1147		1374
1148	metaflag = 0;	1375	metaflag = 0;
1149	start = name;	1376	start = name;
1150	for (p = name ; ; p++) {	1377	for (p = name; *p; p++) {
1151	if (p == '' \|\| *p == '?')	1378	if (p == '' \|\| *p == '?')
1152	metaflag = 1;	1379	metaflag = 1;
1153	else if (*p == '[') {	1380	else if (*p == '[') {
1154	q = p + 1;	1381	char *q = p + 1;
1155	if (*q == '!')	1382	if (*q == '!')
1156	q++;	1383	q++;
1157	for (;;) {	1384	for (;;) {
1158	while (*q == CTLQUOTEMARK)	1385	if (*q == '\\')
1159	q++;
1160	if (*q == CTLESC)
1161	q++;	1386	q++;
1162	if (q == '/' \|\| q == '\0')	1387	if (q == '/' \|\| q == '\0')
1163	break;	1388	break;
Lines 1166-1211 Link Here
1166	break;	1391	break;
1167	}	1392	}
1168	}	1393	}
1169	} else if (*p == '!' && p[1] == '!' && (p == name \|\| p[-1] == '/')) {	1394	} else if (*p == '\\')
1170	metaflag = 1;
1171	} else if (*p == '\0')
1172	break;
1173	else if (*p == CTLQUOTEMARK)
1174	continue;
1175	else if (*p == CTLESC)
1176	p++;	1395	p++;
1177	if (*p == '/') {	1396	else if (*p == '/') {
1178	if (metaflag)	1397	if (metaflag)
1179	break;	1398	goto out;
1180	start = p + 1;	1399	start = p + 1;
1181	}	1400	}
1182	}	1401	}
		1402	out:
1183	if (metaflag == 0) { /* we've reached the end of the file name */	1403	if (metaflag == 0) { /* we've reached the end of the file name */
1184	if (enddir != expdir)	1404	if (enddir != expdir)
1185	metaflag++;	1405	metaflag++;
1186	for (p = name ; ; p++) {	1406	p = name;
1187	if (*p == CTLQUOTEMARK)	1407	do {
1188	continue;	1408	if (*p == '\\')
1189	if (*p == CTLESC)
1190	p++;	1409	p++;
1191	enddir++ = p;	1410	enddir++ = p;
1192	if (*p == '\0')	1411	} while (*p++);
1193	break;	1412	if (metaflag == 0 \|\| lstat64(expdir, &statb) >= 0)
1194	}
1195	if (metaflag == 0 \|\| lstat(expdir, &statb) >= 0)
1196	addfname(expdir);	1413	addfname(expdir);
1197	return;	1414	return;
1198	}	1415	}
1199	endname = p;	1416	endname = p;
1200	if (start != name) {	1417	if (name < start) {
1201	p = name;	1418	p = name;
1202	while (p < start) {	1419	do {
1203	while (*p == CTLQUOTEMARK)	1420	if (*p == '\\')
1204	p++;
1205	if (*p == CTLESC)
1206	p++;	1421	p++;
1207	enddir++ = p++;	1422	enddir++ = p++;
1208	}	1423	} while (p < start);
1209	}	1424	}
1210	if (enddir == expdir) {	1425	if (enddir == expdir) {
1211	cp = ".";	1426	cp = ".";
Lines 1227-1242 Link Here
1227	}	1442	}
1228	matchdot = 0;	1443	matchdot = 0;
1229	p = start;	1444	p = start;
1230	while (*p == CTLQUOTEMARK)	1445	if (*p == '\\')
1231	p++;
1232	if (*p == CTLESC)
1233	p++;	1446	p++;
1234	if (*p == '.')	1447	if (*p == '.')
1235	matchdot++;	1448	matchdot++;
1236	while (! int_pending() && (dp = readdir(dirp)) != NULL) {	1449	while (! int_pending() && (dp = readdir(dirp)) != NULL) {
1237	if (dp->d_name[0] == '.' && ! matchdot)	1450	if (dp->d_name[0] == '.' && ! matchdot)
1238	continue;	1451	continue;
1239	if (patmatch(start, dp->d_name, 0)) {	1452	if (pmatch(start, dp->d_name)) {
1240	if (atend) {	1453	if (atend) {
1241	scopy(dp->d_name, enddir);	1454	scopy(dp->d_name, enddir);
1242	addfname(expdir);	1455	addfname(expdir);
Lines 1253-1258 Link Here
1253	if (! atend)	1466	if (! atend)
1254	endname[-1] = '/';	1467	endname[-1] = '/';
1255	}	1468	}
		1469	#endif /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
1256		1470
1257		1471
1258	/*	1472	/*
Lines 1263-1280 Link Here
1263	addfname(name)	1477	addfname(name)
1264	char *name;	1478	char *name;
1265	{	1479	{
1266	char *p;
1267	struct strlist *sp;	1480	struct strlist *sp;
1268		1481
1269	p = stalloc(strlen(name) + 1);
1270	scopy(name, p);
1271	sp = (struct strlist )stalloc(sizeof sp);	1482	sp = (struct strlist )stalloc(sizeof sp);
1272	sp->text = p;	1483	sp->text = sstrdup(name);
1273	*exparg.lastp = sp;	1484	*exparg.lastp = sp;
1274	exparg.lastp = &sp->next;	1485	exparg.lastp = &sp->next;
1275	}	1486	}
1276		1487
1277		1488
		1489	#if !(defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
1278	/*	1490	/*
1279	* Sort the results of file name expansion. It calculates the number of	1491	* Sort the results of file name expansion. It calculates the number of
1280	* strings to sort and then calls msort (short for merge sort) to do the	1492	* strings to sort and then calls msort (short for merge sort) to do the
Lines 1336-1370 Link Here
1336	}	1548	}
1337	return list;	1549	return list;
1338	}	1550	}
1339		1551	#endif
1340		1552
1341		1553
1342	/*	1554	/*
1343	* Returns true if the pattern matches the string.	1555	* Returns true if the pattern matches the string.
1344	*/	1556	*/
1345		1557
1346	int	1558	STATIC inline int
1347	patmatch(pattern, string, squoted)	1559	patmatch(pattern, string)
1348	char *pattern;	1560	char *pattern;
1349	char *string;	1561	const char *string;
1350	int squoted; /* string might have quote chars */
1351	{	1562	{
1352	#ifdef notdef	1563	return pmatch(preglob(pattern, 0, 0), string);
1353	if (pattern[0] == '!' && pattern[1] == '!')
1354	return 1 - pmatch(pattern + 2, string);
1355	else
1356	#endif
1357	return pmatch(pattern, string, squoted);
1358	}	1564	}
1359		1565
1360		1566
		1567	#if !defined(__GLIBC__) \|\| defined(FNMATCH_BROKEN)
1361	STATIC int	1568	STATIC int
1362	pmatch(pattern, string, squoted)	1569	pmatch(pattern, string)
1363	char *pattern;	1570	const char *pattern;
1364	char *string;	1571	const char *string;
1365	int squoted;
1366	{	1572	{
1367	char p, q;	1573	const char p, q;
1368	char c;	1574	char c;
1369		1575
1370	p = pattern;	1576	p = pattern;
Lines 1373-1418 Link Here
1373	switch (c = *p++) {	1579	switch (c = *p++) {
1374	case '\0':	1580	case '\0':
1375	goto breakloop;	1581	goto breakloop;
1376	case CTLESC:	1582	case '\\':
1377	if (squoted && *q == CTLESC)	1583	if (*p) {
1378	q++;	1584	c = *p++;
1379	if (q++ != p++)	1585	}
1380	return 0;	1586	goto dft;
1381	break;
1382	case CTLQUOTEMARK:
1383	continue;
1384	case '?':	1587	case '?':
1385	if (squoted && *q == CTLESC)
1386	q++;
1387	if (*q++ == '\0')	1588	if (*q++ == '\0')
1388	return 0;	1589	return 0;
1389	break;	1590	break;
1390	case '*':	1591	case '*':
1391	c = *p;	1592	c = *p;
1392	while (c == CTLQUOTEMARK \|\| c == '*')	1593	while (c == '*')
1393	c = *++p;	1594	c = *++p;
1394	if (c != CTLESC && c != CTLQUOTEMARK &&	1595	if (c != '\\' && c != '?' && c != '*' && c != '[') {
1395	c != '?' && c != '*' && c != '[') {
1396	while (*q != c) {	1596	while (*q != c) {
1397	if (squoted && *q == CTLESC &&
1398	q[1] == c)
1399	break;
1400	if (*q == '\0')	1597	if (*q == '\0')
1401	return 0;	1598	return 0;
1402	if (squoted && *q == CTLESC)
1403	q++;
1404	q++;	1599	q++;
1405	}	1600	}
1406	}	1601	}
1407	do {	1602	do {
1408	if (pmatch(p, q, squoted))	1603	if (pmatch(p, q))
1409	return 1;	1604	return 1;
1410	if (squoted && *q == CTLESC)
1411	q++;
1412	} while (*q++ != '\0');	1605	} while (*q++ != '\0');
1413	return 0;	1606	return 0;
1414	case '[': {	1607	case '[': {
1415	char *endp;	1608	const char *endp;
1416	int invert, found;	1609	int invert, found;
1417	char chr;	1610	char chr;
1418		1611
Lines 1420-1430 Link Here
1420	if (*endp == '!')	1613	if (*endp == '!')
1421	endp++;	1614	endp++;
1422	for (;;) {	1615	for (;;) {
1423	while (*endp == CTLQUOTEMARK)
1424	endp++;
1425	if (*endp == '\0')	1616	if (*endp == '\0')
1426	goto dft; /* no matching ] */	1617	goto dft; /* no matching ] */
1427	if (*endp == CTLESC)	1618	if (*endp == '\\')
1428	endp++;	1619	endp++;
1429	if (*++endp == ']')	1620	if (*++endp == ']')
1430	break;	1621	break;
Lines 1436-1456 Link Here
1436	}	1627	}
1437	found = 0;	1628	found = 0;
1438	chr = *q++;	1629	chr = *q++;
1439	if (squoted && chr == CTLESC)
1440	chr = *q++;
1441	if (chr == '\0')	1630	if (chr == '\0')
1442	return 0;	1631	return 0;
1443	c = *p++;	1632	c = *p++;
1444	do {	1633	do {
1445	if (c == CTLQUOTEMARK)	1634	if (c == '\\')
1446	continue;
1447	if (c == CTLESC)
1448	c = *p++;	1635	c = *p++;
1449	if (*p == '-' && p[1] != ']') {	1636	if (*p == '-' && p[1] != ']') {
1450	p++;	1637	p++;
1451	while (*p == CTLQUOTEMARK)	1638	if (*p == '\\')
1452	p++;
1453	if (*p == CTLESC)
1454	p++;	1639	p++;
1455	if (chr >= c && chr <= *p)	1640	if (chr >= c && chr <= *p)
1456	found = 1;	1641	found = 1;
Lines 1465-1472 Link Here
1465	break;	1650	break;
1466	}	1651	}
1467	dft: default:	1652	dft: default:
1468	if (squoted && *q == CTLESC)
1469	q++;
1470	if (*q++ != c)	1653	if (*q++ != c)
1471	return 0;	1654	return 0;
1472	break;	1655	break;
Lines 1477-1482 Link Here
1477	return 0;	1660	return 0;
1478	return 1;	1661	return 1;
1479	}	1662	}
		1663	#endif
1480		1664
1481		1665
1482		1666
Lines 1484-1511 Link Here
1484	* Remove any CTLESC characters from a string.	1668	* Remove any CTLESC characters from a string.
1485	*/	1669	*/
1486		1670
1487	void	1671	char *
1488	rmescapes(str)	1672	_rmescapes(str, flag)
1489	char *str;	1673	char *str;
		1674	int flag;
1490	{	1675	{
1491	char p, q;	1676	char p, q, *r;
		1677	static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
		1678	unsigned inquotes;
		1679	int notescaped;
		1680	int globbing;
1492		1681
1493	p = str;	1682	p = strpbrk(str, qchars);
1494	while (p != CTLESC && p != CTLQUOTEMARK) {	1683	if (!p) {
1495	if (*p++ == '\0')	1684	return str;
1496	return;
1497	}	1685	}
1498	q = p;	1686	q = p;
		1687	r = str;
		1688	if (flag & RMESCAPE_ALLOC) {
		1689	size_t len = p - str;
		1690	size_t fulllen = len + strlen(p) + 1;
		1691
		1692	if (flag & RMESCAPE_GROW) {
		1693	r = makestrspace(fulllen, expdest);
		1694	} else if (flag & RMESCAPE_HEAP) {
		1695	r = ckmalloc(fulllen);
		1696	} else {
		1697	r = stalloc(fulllen);
		1698	}
		1699	q = r;
		1700	if (len > 0) {
		1701	#ifdef _GNU_SOURCE
		1702	q = mempcpy(q, str, len);
		1703	#else
		1704	memcpy(q, str, len);
		1705	q += len;
		1706	#endif
		1707	}
		1708	}
		1709	inquotes = (flag & RMESCAPE_QUOTED) ^ RMESCAPE_QUOTED;
		1710	globbing = flag & RMESCAPE_GLOB;
		1711	notescaped = globbing;
1499	while (*p) {	1712	while (*p) {
1500	if (*p == CTLQUOTEMARK) {	1713	if (*p == CTLQUOTEMARK) {
		1714	inquotes = ~inquotes;
1501	p++;	1715	p++;
		1716	notescaped = globbing;
1502	continue;	1717	continue;
1503	}	1718	}
1504	if (*p == CTLESC)	1719	if (*p == '\\') {
		1720	/* naked back slash */
		1721	notescaped = 0;
		1722	goto copy;
		1723	}
		1724	if (*p == CTLESC) {
1505	p++;	1725	p++;
		1726	if (notescaped && inquotes && *p != '/') {
		1727	*q++ = '\\';
		1728	}
		1729	}
		1730	notescaped = globbing;
		1731	copy:
1506	q++ = p++;	1732	q++ = p++;
1507	}	1733	}
1508	*q = '\0';	1734	*q = '\0';
		1735	if (flag & RMESCAPE_GROW) {
		1736	expdest = r;
		1737	STADJUST(q - r + 1, expdest);
		1738	}
		1739	return r;
1509	}	1740	}
1510		1741
1511		1742
Lines 1521-1536 Link Here
1521	{	1752	{
1522	struct stackmark smark;	1753	struct stackmark smark;
1523	int result;	1754	int result;
1524	char *p;
1525		1755
1526	setstackmark(&smark);	1756	setstackmark(&smark);
1527	argbackq = pattern->narg.backquote;	1757	argbackq = pattern->narg.backquote;
1528	STARTSTACKSTR(expdest);	1758	STARTSTACKSTR(expdest);
1529	ifslastp = NULL;	1759	ifslastp = NULL;
1530	argstr(pattern->narg.text, EXP_TILDE \| EXP_CASE);	1760	argstr(pattern->narg.text, EXP_TILDE \| EXP_CASE);
1531	STPUTC('\0', expdest);	1761	STACKSTRNUL(expdest);
1532	p = grabstackstr(expdest);	1762	result = patmatch(stackblock(), val);
1533	result = patmatch(p, val, 0);
1534	popstackmark(&smark);	1763	popstackmark(&smark);
1535	return result;	1764	return result;
1536	}	1765	}
Lines 1539-1563 Link Here
1539	* Our own itoa().	1768	* Our own itoa().
1540	*/	1769	*/
1541		1770
1542	STATIC char *	1771	STATIC int
1543	cvtnum(num, buf)	1772	cvtnum(long num) {
1544	int num;	1773	int len;
1545	char *buf;
1546	{
1547	char temp[32];
1548	int neg = num < 0;
1549	char *p = temp + 31;
1550
1551	temp[31] = '\0';
1552		1774
1553	do {	1775	expdest = makestrspace(32, expdest);
1554	*--p = num % 10 + '0';	1776	len = fmtstr(expdest, 32, "%ld", num);
1555	} while ((num /= 10) != 0);	1777	STADJUST(len, expdest);
		1778	return len;
		1779	}
1556		1780
1557	if (neg)	1781	static void
1558	*--p = '-';	1782	varunset(const char end, const char var, const char *umsg, int varflags)
		1783	{
		1784	const char *msg;
		1785	const char *tail;
1559		1786
1560	while (*p)	1787	tail = nullstr;
1561	STPUTC(*p++, buf);	1788	msg = "parameter not set";
1562	return buf;	1789	if (umsg) {
		1790	if (*end == CTLENDVAR) {
		1791	if (varflags & VSNUL)
		1792	tail = " or null";
		1793	} else
		1794	msg = umsg;
		1795	}
		1796	error("%.*s: %s%s", end - var - 1, var, msg, tail);
1563	}	1797	}

Lines 58-75 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/expand.h (-2 / +9 lines)
58	#define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */	58	#define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
59	#define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */	59	#define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
60	#define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */	60	#define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */
		61	#define EXP_VARTILDE2 0x40 /* expand tildes after colons only */
		62	#define EXP_WORD 0x80 /* expand word in parameter expansion */
		63	#define EXP_QWORD 0x100 /* expand word in quoted parameter expansion */
61		64
62		65
63	union node;	66	union node;
64	void expandhere __P((union node *, int));	67	void expandhere __P((union node *, int));
65	void expandarg __P((union node , struct arglist , int));	68	void expandarg __P((union node , struct arglist , int));
66	void expari __P((int));	69	void expari __P((int));
67	int patmatch __P((char , char , int));	70	#define rmescapes(p) _rmescapes((p), 0)
68	void rmescapes __P((char *));	71	char _rmescapes __P((char , int));
69	int casematch __P((union node , char ));	72	int casematch __P((union node , char ));
70		73
71	/* From arith.y */	74	/* From arith.y */
72	int arith __P((const char *));	75	int arith __P((const char *));
73	int expcmd __P((int , char **));	76	int expcmd __P((int , char **));
		77	#ifdef USE_LEX
74	void arith_lex_reset __P((void));	78	void arith_lex_reset __P((void));
		79	#else
		80	#define arith_lex_reset()
		81	#endif
75	int yylex __P((void));	82	int yylex __P((void));




/*
 * Termios command line History and Editting for NetBSD sh (ash)
 * Copyright (c) 1999
 *	Main code:	Adam Rogoyski <rogoyski@cs.utexas.edu>
 *	Etc:		Dave Cinege <dcinege@psychosis.com>
 *
 * You may use this code as you wish, so long as the original author(s)
 * are attributed in any redistributions of the source code.
 * This code is 'as is' with no warranty.
 * This code may safely be consumed by a BSD or GPL license.
 *
 * v 0.5  19990328	Initial release
 *
 * Future plans: Simple file and path name completion. (like BASH)
 *
 */

/*
Usage and Known bugs:
	Terminal key codes are not extensive, and more will probably
	need to be added. This version was created on Debian GNU/Linux 2.x.
	Delete, Backspace, Home, End, and the arrow keys were tested
	to work in an Xterm and console. Ctrl-A also works as Home.
	Ctrl-E also works as End. Ctrl-D and Ctrl-U perform their respective
	functions. The binary size increase is <3K.

	Editting will not display correctly for lines greater then the
	terminal width. (more then one line.) However, history will.
*/

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <ctype.h>
#include <sys/ioctl.h>

#include "input.h"
#include "output.h"

#include "hetio.h"


#define  MAX_HISTORY   15			/* Maximum length of the linked list for the command line history */

#define ESC	27
#define DEL	127

static struct history *his_front = NULL;	/* First element in command line list */
static struct history *his_end = NULL;		/* Last element in command line list */
static struct termios old_term, new_term;	/* Current termio and the previous termio before starting ash */

static int history_counter = 0;			/* Number of commands in history list */
static int reset_term = 0;			/* Set to true if the terminal needs to be reset upon exit */
static int hetio_inter = 0;

struct history
{
   char *s;
   struct history *p;
   struct history *n;
};


void input_delete    (int);
void input_home      (int *);
void input_end       (int *, int);
void input_backspace (int *, int *);



void hetio_init(void)
{
	hetio_inter = 1;
}


void hetio_reset_term(void)
{
	if (reset_term)
		tcsetattr(1, TCSANOW, &old_term);
}


void setIO(struct termios *new, struct termios *old)	/* Set terminal IO to canonical mode, and save old term settings. */
{
	tcgetattr(0, old);
	memcpy(new, old, sizeof(*new));
	new->c_cc[VMIN] = 1;
	new->c_cc[VTIME] = 0;
	new->c_lflag &= ~ICANON; /* unbuffered input */
	new->c_lflag &= ~ECHO;
	tcsetattr(0, TCSANOW, new);
}

void input_home(int *cursor)				/* Command line input routines */
{
 	while (*cursor > 0) {
		out1c('\b');
		--*cursor;
	}
	flushout(out1);
}


void input_delete(int cursor)
{
	int j = 0;

	memmove(parsenextc + cursor, parsenextc + cursor + 1,
		BUFSIZ - cursor - 1);
	for (j = cursor; j < (BUFSIZ - 1); j++) {
		if (!*(parsenextc + j))
			break;
		else
			out1c(*(parsenextc + j));
	}

	out1str(" \b");

	while (j-- > cursor)
		out1c('\b');
	flushout(out1);
}


void input_end(int *cursor, int len)
{
	while (*cursor < len) {
		out1str("\033[C");
		++*cursor;
	}
	flushout(out1);
}


void
input_backspace(int *cursor, int *len)
{
	int j = 0;

	if (*cursor > 0) {
		out1str("\b \b");
		--*cursor;
		memmove(parsenextc + *cursor, parsenextc + *cursor + 1,
			BUFSIZ - *cursor + 1);

		for (j = *cursor; j < (BUFSIZ - 1); j++) {
			if (!*(parsenextc + j))
				break;
			else
				out1c(*(parsenextc + j));
		}

		out1str(" \b");

		while (j-- > *cursor)
			out1c('\b');

		--*len;
		flushout(out1);
	}
}

int hetio_read_input(int fd)
{
	int nr = 0;

	/* Are we an interactive shell? */
	if (!hetio_inter || fd) {
		return -255;
	} else {
		int len = 0;
		int j = 0;
		int cursor = 0;
		int break_out = 0;
		int ret = 0;
		char c = 0;
		struct history *hp = his_end;

		if (!reset_term) {
			setIO(&new_term, &old_term);
			reset_term = 1;
		} else {
			tcsetattr(0, TCSANOW, &new_term);
		}

		memset(parsenextc, 0, BUFSIZ);

		while (1) {
			if ((ret = read(fd, &c, 1)) < 1)
				return ret;

			switch (c) {
   				case 1:		/* Control-A Beginning of line */
   					input_home(&cursor);
					break;
				case 5:		/* Control-E EOL */
					input_end(&cursor, len);
					break;
				case 4:		/* Control-D */
					if (!len)
						exitshell(0);
					break;
				case 21: 	/* Control-U */
					/* Return to begining of line. */
					for (; cursor > 0; cursor--)
						out1c('\b');
					/* Erase old command. */
					for (j = 0; j < len; j++) {
						/*
						 * Clear buffer while we're at
						 * it.
						 */
						parsenextc[j] = 0;
						out1c(' ');
					}
					/* return to begining of line */
					for (; len > 0; len--)
						out1c('\b');
					flushout(out1);
					break;
				case '\b':	/* Backspace */
				case DEL:
					input_backspace(&cursor, &len);
					break;
				case '\n':	/* Enter */
					*(parsenextc + len++ + 1) = c;
					out1c(c);
					flushout(out1);
					break_out = 1;
					break;
				case ESC:	/* escape sequence follows */
					if ((ret = read(fd, &c, 1)) < 1)
						return ret;

					if (c == '[' ) {    /* 91 */
						if ((ret = read(fd, &c, 1)) < 1)
							return ret;

						switch (c) {
							case 'A':
								if (hp && hp->p) {		/* Up */
									hp = hp->p;
									goto hop;
								}
								break;
							case 'B':
								if (hp && hp->n && hp->n->s) {	/* Down */
									hp = hp->n;
									goto hop;
								}
								break;

hop:						/* hop */
								len = strlen(parsenextc);

								for (; cursor > 0; cursor--)		/* return to begining of line */
									out1c('\b');

		   						for (j = 0; j < len; j++)		/* erase old command */
									out1c(' ');

								for (; j > 0; j--)		/* return to begining of line */
									out1c('\b');

								strcpy (parsenextc, hp->s);		/* write new command */
								len = strlen (hp->s);
								out1str(parsenextc);
								flushout(out1);
								cursor = len;
								break;
							case 'C':		/* Right */
								if (cursor < len) {
									out1str("\033[C");
									cursor++;
									flushout(out1);
						 		}
								break;
							case 'D':		/* Left */
								if (cursor > 0) {
									out1str("\033[D");
									cursor--;
									flushout(out1);
								}
								break;
							case '3':		/* Delete */
								if (cursor != len) {
									input_delete(cursor);
									len--;
								}
								break;
							case '1':		/* Home (Ctrl-A) */
								input_home(&cursor);
								break;
							case '4':		/* End (Ctrl-E) */
								input_end(&cursor, len);
								break;
						}
						if (c == '1' || c == '3' || c == '4')
							if ((ret = read(fd, &c, 1)) < 1)
								return ret;  /* read 126 (~) */
					}

					if (c == 'O') {	/* 79 */
						if ((ret = read(fd, &c, 1)) < 1)
							return ret;
						switch (c) {
							case 'H':		/* Home (xterm) */
      								input_home(&cursor);
								break;
							case 'F':		/* End (xterm_ */
								input_end(&cursor, len);
								break;
						}
					}

					c = 0;
					break;

				default:				/* If it's regular input, do the normal thing */
					if (!isprint(c))		/* Skip non-printable characters */
						break;

	       				if (len >= (BUFSIZ - 2))	/* Need to leave space for enter */
		  				break;

					len++;

					if (cursor == (len - 1)) {	/* Append if at the end of the line */
						*(parsenextc + cursor) = c;
					} else {			/* Insert otherwise */
						memmove(parsenextc + cursor + 1, parsenextc + cursor,
							len - cursor - 1);

						*(parsenextc + cursor) = c;

						for (j = cursor; j < len; j++)
							out1c(*(parsenextc + j));
						for (; j > cursor; j--)
							out1str("\033[D");
					}

					cursor++;
					out1c(c);
					flushout(out1);
					break;
			}

			if (break_out)		/* Enter is the command terminator, no more input. */
				break;
		}

		nr = len + 1;
		tcsetattr(0, TCSANOW, &old_term);

		if (*(parsenextc)) {		/* Handle command history log */
			struct history *h = his_end;

			if (!h) {       /* No previous history */
				h = his_front = malloc(sizeof (struct history));
				h->n = malloc(sizeof (struct history));
				h->p = NULL;
				h->s = strdup(parsenextc);

				h->n->p = h;
				h->n->n = NULL;
				h->n->s = NULL;
				his_end = h->n;
				history_counter++;
			} else {	/* Add a new history command */

				h->n = malloc(sizeof (struct history));

				h->n->p = h;
				h->n->n = NULL;
				h->n->s = NULL;
				h->s = strdup(parsenextc);
				his_end = h->n;

				if (history_counter >= MAX_HISTORY) {	/* After max history, remove the last known command */
					struct history *p = his_front->n;

					p->p = NULL;
					free(his_front->s);
					free(his_front);
					his_front = p;
				} else {
					history_counter++;
				}
			}
		}
	}

	return nr;
}




/*
 * Termios command line History and Editting for NetBSD sh (ash)
 * Copyright (c) 1999
 *	Main code:	Adam Rogoyski <rogoyski@cs.utexas.edu> 
 *	Etc:		Dave Cinege <dcinege@psychosis.com>
 *
 * You may use this code as you wish, so long as the original author(s)
 * are attributed in any redistributions of the source code.
 * This code is 'as is' with no warranty.
 * This code may safely be consumed by a BSD or GPL license.
 *
 * v 0.5  19990328	Initial release 
 *
 * Future plans: Simple file and path name completion. (like BASH)
 *
 */

void hetio_init(void);
int hetio_read_input(int fd);
void hetio_reset_term(void);

extern int hetio_inter;

Lines 60-68 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/histedit.c (-3 / +7 lines)
60	#include "main.h"	60	#include "main.h"
61	#include "output.h"	61	#include "output.h"
62	#include "mystring.h"	62	#include "mystring.h"
63	#include "myhistedit.h"
64	#include "error.h"	63	#include "error.h"
65	#ifndef SMALL	64	#ifndef SMALL
		65	#include "myhistedit.h"
66	#include "eval.h"	66	#include "eval.h"
67	#include "memalloc.h"	67	#include "memalloc.h"
68		68
Lines 219-225 Link Here
219	if (argc == 1)	219	if (argc == 1)
220	error("missing history argument");	220	error("missing history argument");
221		221
		222	#ifdef __GLIBC__
		223	optind = 0;
		224	#else
222	optreset = 1; optind = 1; /* initialize getopt */	225	optreset = 1; optind = 1; /* initialize getopt */
		226	#endif
223	while (not_fcnumber(argv[optind]) &&	227	while (not_fcnumber(argv[optind]) &&
224	(ch = getopt(argc, argv, ":e:lnrs")) != -1)	228	(ch = getopt(argc, argv, ":e:lnrs")) != -1)
225	switch ((char)ch) {	229	switch ((char)ch) {
Lines 277-284 Link Here
277	*/	281	*/
278	if (sflg == 0) {	282	if (sflg == 0) {
279	if (editor == NULL &&	283	if (editor == NULL &&
280	(editor = bltinlookup("FCEDIT", 1)) == NULL &&	284	(editor = bltinlookup("FCEDIT")) == NULL &&
281	(editor = bltinlookup("EDITOR", 1)) == NULL)	285	(editor = bltinlookup("EDITOR")) == NULL)
282	editor = DEFEDITOR;	286	editor = DEFEDITOR;
283	if (editor[0] == '-' && editor[1] == '\0') {	287	if (editor[0] == '-' && editor[1] == '\0') {
284	sflg = 1; /* no edit */	288	sflg = 1; /* no edit */




#include "error.h"
#include "alias.h"
#include "parser.h"
#ifndef SMALL
#include "myhistedit.h"
#endif

#ifdef HETIO
#include "hetio.h"
#endif

#define EOF_NLEFT -99		/* value of parsenleft when EOF pushed back */
#define IBUFSIZ (BUFSIZ + 1)

MKINIT
struct strpush {
	struct strpush *prev;	/* preceding string on stack */
	char *prevstring;
	int prevnleft;
	int prevlleft;
	struct alias *ap;	/* if push was associated with an alias */
	char *string;		/* remember the string since it may change */
};

/*

MKINIT int parselleft;		/* copy of parsefile->lleft */
char *parsenextc;		/* copy of parsefile->nextc */
MKINIT struct parsefile basepf;	/* top level input file */
MKINIT char basebuf[IBUFSIZ];	/* buffer for top level input file */
struct parsefile *parsefile = &basepf;	/* current input file */
int init_editline = 0;		/* editline library initialized? */
int whichprompt;		/* 1 == PS1, 2 == PS2 */

#ifndef SMALL
EditLine *el;			/* cookie for editline package */
#endif

STATIC void pushfile __P((void));
static int preadfd __P((void));

}

RESET {
	if (exception != EXSHELLPROC)
		parselleft = parsenleft = 0;	/* clear input buffer */
	popallfiles();
}

SHELLPROC {
	popallfiles();
}
#endif



	int c;

	while (--nleft > 0) {
		c = pgetc2();
		if (c == PEOF) {
			if (p == line)
				return NULL;

}



/*
 * Read a character from the script, returning PEOF on end of file.
 * Nul characters in the input are silently discarded.

}


/*
 * Same as pgetc(), but ignores PEOA.
 */

int
pgetc2()
{
	int c;
	do {
		c = pgetc_macro();
	} while (c == PEOA);
	return c;
}


static int
preadfd()
{

		}
	} else
#endif

#ifdef HETIO
		nr = hetio_read_input(parsefile->fd);
		if (nr == -255)
#endif
		nr = read(parsefile->fd, buf, IBUFSIZ - 1);


	if (nr <= 0) {
                if (nr < 0) {
                        if (errno == EINTR)
                                goto retry;

                                }
                        }
                }
                nr = -1;
	}
	return nr;
}


{
	char *p, *q;
	int more;
#ifndef SMALL
	int something;
#endif
	char savec;

	while (parsefile->strpush) {
		if (
			parsenleft == -1 && parsefile->strpush->ap &&
			parsenextc[-1] != ' ' && parsenextc[-1] != '\t'
		) {
			return PEOA;
		}
		popstring();
		if (--parsenleft >= 0)
			return (*parsenextc++);

	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
		return PEOF;
	flushout(&output);
#ifdef FLUSHERR
	flushout(&errout);
#endif

again:
	if (parselleft <= 0) {
		if ((parselleft = preadfd()) <= 0) {
			parselleft = parsenleft = EOF_NLEFT;
			return PEOF;
		}

	q = p = parsenextc;

	/* delete nul characters */
#ifndef SMALL
	something = 0;
#endif
	for (more = 1; more;) {
		switch (*p) {
		case '\0':
			p++;	/* Skip nul */
			goto check;

#ifndef SMALL
		case '\t':
		case ' ':
			break;
#endif

		case '\n':
			parsenleft = q - parsenextc;
			more = 0; /* Stop processing here */
			break;

#ifndef SMALL
		default:
			something = 1;
			break;
#endif
		}

		*q++ = *p++;
check:
		if (--parselleft <= 0 && more) {
			parsenleft = q - parsenextc - 1;
			if (parsenleft < 0)
				goto again;
			*q = '\0';
			more = 0;
		}
	}


	if (vflag) {
		out2str(parsenextc);
#ifdef FLUSHERR
		flushout(out2);
#endif
	}

	*q = savec;

 * We handle aliases this way.
 */
void
pushstring(s, ap)
	char *s;
	int len;
	void *ap;
	{
	struct strpush *sp;
	size_t len;

	len = strlen(s);
	INTOFF;
/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
	if (parsefile->strpush) {

		sp = parsefile->strpush = &(parsefile->basestrpush);
	sp->prevstring = parsenextc;
	sp->prevnleft = parsenleft;
	sp->prevlleft = parselleft;
	sp->ap = (struct alias *)ap;
	if (ap) {
		((struct alias *)ap)->flag |= ALIASINUSE;
		sp->string = s;
	}
	parsenextc = s;
	parsenleft = len;
	INTON;

	struct strpush *sp = parsefile->strpush;

	INTOFF;
	if (sp->ap) {
		if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
			checkkwd |= CHKALIAS;
		}
		if (sp->string != sp->ap->val) {
			ckfree(sp->string);
		}
		sp->ap->flag &= ~ALIASINUSE;
		if (sp->ap->flag & ALIASDEAD) {
			unalias(sp->ap->name);
		}
	}
	parsenextc = sp->prevstring;
	parsenleft = sp->prevnleft;
	parselleft = sp->prevlleft;
/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
	if (sp->ap)
		sp->ap->flag &= ~ALIASINUSE;
	parsefile->strpush = sp->prev;
	if (sp != &(parsefile->basestrpush))
		ckfree(sp);

	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
	if (push) {
		pushfile();
		parsefile->buf = 0;
	} else {
		closescript();
		while (parsefile->strpush)
			popstring();
	}
	if (parsefile->fd > 0)
		close(parsefile->fd);
	parsefile->fd = fd;
	if (parsefile->buf == NULL)
		parsefile->buf = ckmalloc(IBUFSIZ);
	parselleft = parsenleft = 0;
	plinno = 1;
}

 */

void
setinputstring(string)
	char *string;
	int push;
	{
	INTOFF;
	if (push)
		pushfile();
	parsenextc = string;
	parsenleft = strlen(string);
	parsefile->buf = NULL;
	plinno = 1;
	INTON;




extern int plinno;
extern int parsenleft;		/* number of characters left in input buffer */
extern char *parsenextc;	/* next character in input buffer */
extern int init_editline;	/* 0 == not setup, 1 == OK, -1 == failed */

char *pfgets __P((char *, int));
int pgetc __P((void));
int pgetc2 __P((void));
int preadbuffer __P((void));
void pungetc __P((void));
void pushstring __P((char *, void *));
void popstring __P((void));
void setinputfile __P((const char *, int));
void setinputfd __P((int, int));
void setinputstring __P((char *));
void popfile __P((void));
void popallfiles __P((void));
void closescript __P((void));

Lines 85-105 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/jobs.c (-133 / +242 lines)
85	#include "mystring.h"	85	#include "mystring.h"
86		86
87		87
88	struct job jobtab; / array of jobs */	88	/* array of jobs */
89	int njobs; /* size of array */	89	STATIC struct job *jobtab;
90	MKINIT short backgndpid = -1; /* pid of last background process */	90	/* size of array */
		91	STATIC int njobs;
		92	/* pid of last background process */
		93	MKINIT pid_t backgndpid;
91	#if JOBS	94	#if JOBS
92	int initialpgrp; /* pgrp of shell on invocation */	95	/* pgrp of shell on invocation */
93	short curjob; /* current job */	96	STATIC int initialpgrp;
		97	/* current job */
		98	STATIC struct job *curjob;
94	#endif	99	#endif
95	static int ttyfd = -1;	100	STATIC int ttyfd = -1;
		101	/* number of presumed living untracked jobs */
		102	STATIC int jobless;
96		103
97	STATIC void restartjob __P((struct job *));	104	STATIC void restartjob __P((struct job *));
98	STATIC void freejob __P((struct job *));	105	STATIC void freejob __P((struct job *));
99	STATIC struct job getjob __P((char ));	106	STATIC struct job getjob __P((char ));
100	STATIC int dowait __P((int, struct job *));	107	STATIC int dowait __P((int, struct job *));
		108	#ifdef SYSV
101	STATIC int onsigchild __P((void));	109	STATIC int onsigchild __P((void));
102	STATIC int waitproc __P((int, struct job , int ));	110	#endif
		111	STATIC int waitproc __P((int, int *));
103	STATIC void cmdtxt __P((union node *));	112	STATIC void cmdtxt __P((union node *));
104	STATIC void cmdputs __P((const char *));	113	STATIC void cmdputs __P((const char *));
105		114
Lines 127-138 Link Here
127	}	136	}
128	#endif	137	#endif
129		138
		139	#if JOBS
130	/*	140	/*
131	* Turn job control on and off.	141	* Turn job control on and off.
132	*	142	*
133	* Note: This code assumes that the third arg to ioctl is a character	143	* Note: This code assumes that the third arg to ioctl is a character
134	* pointer, which is true on Berkeley systems but not System V. Since	144	* pointer, which is true on Berkeley systems but not System V. Since
135	* System V doesn't have job control yet, this isn't a problem now.	145	* System V doesn't have job control yet, this isn't a problem now.
		146	*
		147	* Called with interrupts off.
136	*/	148	*/
137		149
138	MKINIT int jobctl;	150	MKINIT int jobctl;
Lines 144-236 Link Here
144	#ifdef OLD_TTY_DRIVER	156	#ifdef OLD_TTY_DRIVER
145	int ldisc;	157	int ldisc;
146	#endif	158	#endif
		159	int fd;
		160	int pgrp;
147		161
148	if (on == jobctl \|\| rootshell == 0)	162	if (on == jobctl \|\| rootshell == 0)
149	return;	163	return;
150	if (on) {	164	if (on) {
151	#if defined(FIOCLEX) \|\| defined(FD_CLOEXEC)	165	#if defined(FIOCLEX) \|\| defined(FD_CLOEXEC)
152	int err;	166	int ofd;
153	if (ttyfd != -1)	167	ofd = fd = open(_PATH_TTY, O_RDWR);
154	close(ttyfd);	168	if (fd < 0) {
155	if ((ttyfd = open("/dev/tty", O_RDWR)) == -1) {	169	fd += 3;
156	int i;	170	while (!isatty(fd) && --fd >= 0)
157	for (i = 0; i < 3; i++) {	171	;
158	if (isatty(i) && (ttyfd = dup(i)) != -1)
159	break;
160	}	172	}
161	if (i == 3)	173	fd = fcntl(fd, F_DUPFD, 10);
		174	close(ofd);
		175	if (fd < 0)
162	goto out;	176	goto out;
163	}	177	#ifdef linux
164	#ifdef FIOCLEX	178	fcntl(fd, F_SETFD, FD_CLOEXEC);
165	err = ioctl(ttyfd, FIOCLEX, 0);	179	#elif defined(FIOCLEX)
166	#elif FD_CLOEXEC	180	ioctl(fd, FIOCLEX, 0);
167	err = fcntl(ttyfd, FD_CLOEXEC, 1);	181	#elif defined(FD_CLOEXEC)
		182	fcntl(fd, FD_CLOEXEC, 1);
168	#endif	183	#endif
169	if (err == -1) {
170	close(ttyfd);
171	ttyfd = -1;
172	goto out;
173	}
174	#else	184	#else
175	out2str("sh: Need FIOCLEX or FD_CLOEXEC to support job control");	185	warnx("Need FIOCLEX or FD_CLOEXEC to support job control");
176	goto out;	186	mflag = 0;
		187	return;
177	#endif	188	#endif
178	do { /* while we are in the background */	189	do { /* while we are in the background */
179	if ((initialpgrp = tcgetpgrp(ttyfd)) < 0) {	190	if ((pgrp = tcgetpgrp(fd)) < 0) {
180	out:	191	out:
181	out2str("sh: can't access tty; job control turned off\n");	192	warnx("can't access tty; job control turned off");
182	mflag = 0;	193	mflag = on = 0;
183	return;	194	goto close;
184	}	195	}
185	if (initialpgrp == -1)	196	if (pgrp == getpgrp())
186	initialpgrp = getpgrp();	197	break;
187	else if (initialpgrp != getpgrp()) {
188	killpg(0, SIGTTIN);	198	killpg(0, SIGTTIN);
189	continue;	199	} while (1);
190	}	200	initialpgrp = pgrp;
191	} while (0);
192		201
193	#ifdef OLD_TTY_DRIVER	202	#ifdef OLD_TTY_DRIVER
194	if (ioctl(ttyfd, TIOCGETD, (char *)&ldisc) < 0	203	if (ioctl(fd, TIOCGETD, (char *)&ldisc) < 0
195	\|\| ldisc != NTTYDISC) {	204	\|\| ldisc != NTTYDISC) {
196	out2str("sh: need new tty driver to run job control; job control turned off\n");	205	warnx("need new tty driver to run job control; job control turned off");
197	mflag = 0;	206	mflag = on = 0;
198	return;	207	goto close;
199	}	208	}
200	#endif	209	#endif
201	setsignal(SIGTSTP);	210	setsignal(SIGTSTP);
202	setsignal(SIGTTOU);	211	setsignal(SIGTTOU);
203	setsignal(SIGTTIN);	212	setsignal(SIGTTIN);
204	setpgid(0, rootpid);	213	pgrp = rootpid;
205	tcsetpgrp(ttyfd, rootpid);	214	setpgid(0, pgrp);
206	} else { /* turning job control off */	215	tcsetpgrp(fd, pgrp);
207	setpgid(0, initialpgrp);	216	} else {
208	tcsetpgrp(ttyfd, initialpgrp);	217	/* turning job control off */
209	close(ttyfd);	218	fd = ttyfd;
210	ttyfd = -1;	219	pgrp = initialpgrp;
		220	tcsetpgrp(fd, pgrp);
		221	setpgid(0, pgrp);
211	setsignal(SIGTSTP);	222	setsignal(SIGTSTP);
212	setsignal(SIGTTOU);	223	setsignal(SIGTTOU);
213	setsignal(SIGTTIN);	224	setsignal(SIGTTIN);
		225	close:
		226	close(fd);
		227	fd = -1;
214	}	228	}
		229	ttyfd = fd;
215	jobctl = on;	230	jobctl = on;
216	}	231	}
		232	#endif
217		233
218		234
219	#ifdef mkinit
220	INCLUDE <stdlib.h>
221		235
222	SHELLPROC {
223	backgndpid = -1;
224	#if JOBS	236	#if JOBS
225	jobctl = 0;	237	int
226	#endif	238	killcmd(argc, argv)
227	}	239	int argc;
		240	char **argv;
		241	{
		242	extern char *signal_names[];
		243	int signo = -1;
		244	int list = 0;
		245	int i;
		246	pid_t pid;
		247	struct job *jp;
		248
		249	if (argc <= 1) {
		250	usage:
		251	error(
		252	"Usage: kill [-s sigspec \| -signum \| -sigspec] [pid \| job]... or\n"
		253	"kill -l [exitstatus]"
		254	);
		255	}
		256
		257	if (*argv[1] == '-') {
		258	signo = decode_signal(argv[1] + 1, 1);
		259	if (signo < 0) {
		260	int c;
228		261
		262	while ((c = nextopt("ls:")) != '\0')
		263	switch (c) {
		264	case 'l':
		265	list = 1;
		266	break;
		267	case 's':
		268	signo = decode_signal(optionarg, 1);
		269	if (signo < 0) {
		270	error(
		271	"invalid signal number or name: %s",
		272	optionarg
		273	);
		274	}
		275	break;
		276	#ifdef DEBUG
		277	default:
		278	error(
		279	"nextopt returned character code 0%o", c);
229	#endif	280	#endif
		281	}
		282	} else
		283	argptr++;
		284	}
230		285
		286	if (!list && signo < 0)
		287	signo = SIGTERM;
231		288
		289	if ((signo < 0 \|\| !*argptr) ^ list) {
		290	goto usage;
		291	}
		292
		293	if (list) {
		294	if (!*argptr) {
		295	out1str("0\n");
		296	for (i = 1; i < NSIG; i++) {
		297	out1fmt(snlfmt, signal_names[i]);
		298	}
		299	return 0;
		300	}
		301	signo = atoi(*argptr);
		302	if (signo > 128)
		303	signo -= 128;
		304	if (0 < signo && signo < NSIG)
		305	out1fmt(snlfmt, signal_names[signo]);
		306	else
		307	error("invalid signal number or exit status: %s",
		308	*argptr);
		309	return 0;
		310	}
		311
		312	i = 0;
		313	do {
		314	if (**argptr == '%') {
		315	jp = getjob(*argptr);
		316	if (jp->jobctl == 0) {
		317	outfmt(
		318	out2,
		319	"job %s not created "
		320	"under job control\n",
		321	*argptr
		322	);
		323	i = 1;
		324	continue;
		325	}
		326	pid = -jp->ps[0].pid;
		327	} else
		328	pid = atoi(*argptr);
		329	if (kill(pid, signo) != 0) {
		330	outfmt(out2, "%s: %s\n", *argptr, strerror(errno));
		331	i = 1;
		332	}
		333	} while (*++argptr);
		334
		335	return i;
		336	}
232		337
233	#if JOBS
234	int	338	int
235	fgcmd(argc, argv)	339	fgcmd(argc, argv)
236	int argc;	340	int argc;
Lines 246-254 Link Here
246	pgrp = jp->ps[0].pid;	350	pgrp = jp->ps[0].pid;
247	tcsetpgrp(ttyfd, pgrp);	351	tcsetpgrp(ttyfd, pgrp);
248	restartjob(jp);	352	restartjob(jp);
249	INTOFF;
250	status = waitforjob(jp);	353	status = waitforjob(jp);
251	INTON;
252	return status;	354	return status;
253	}	355	}
254		356
Lines 366-377 Link Here
366	}	468	}
367	out1str(s);	469	out1str(s);
368	col += strlen(s);	470	col += strlen(s);
369	do {	471	out1fmt(
370	out1c(' ');	472	"%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ',
371	col++;	473	ps->cmd
372	} while (col < 30);	474	);
373	out1str(ps->cmd);
374	out1c('\n');
375	if (--procno <= 0)	475	if (--procno <= 0)
376	break;	476	break;
377	}	477	}
Lines 399-412 Link Here
399	if (ps->cmd != nullstr)	499	if (ps->cmd != nullstr)
400	ckfree(ps->cmd);	500	ckfree(ps->cmd);
401	}	501	}
402	if (jp->ps != &jp->ps0) {	502	if (jp->ps != &jp->ps0)
403	ckfree(jp->ps);	503	ckfree(jp->ps);
404	jp->ps = &jp->ps0;
405	}
406	jp->nprocs = 0;
407	jp->used = 0;	504	jp->used = 0;
408	#if JOBS	505	#if JOBS
409	if (curjob == jp - jobtab + 1)	506	if (curjob == jp)
410	curjob = 0;	507	curjob = 0;
411	#endif	508	#endif
412	INTON;	509	INTON;
Lines 423-430 Link Here
423	int status, retval;	520	int status, retval;
424	struct job *jp;	521	struct job *jp;
425		522
426	if (argc > 1) {	523	if (--argc > 0) {
427	job = getjob(argv[1]);	524	start:
		525	job = getjob(*++argv);
428	} else {	526	} else {
429	job = NULL;	527	job = NULL;
430	}	528	}
Lines 432-437 Link Here
432	if (job != NULL) {	530	if (job != NULL) {
433	if (job->state) {	531	if (job->state) {
434	status = job->ps[job->nprocs - 1].status;	532	status = job->ps[job->nprocs - 1].status;
		533	if (! iflag)
		534	freejob(job);
		535	if (--argc) {
		536	goto start;
		537	}
435	if (WIFEXITED(status))	538	if (WIFEXITED(status))
436	retval = WEXITSTATUS(status);	539	retval = WEXITSTATUS(status);
437	#if JOBS	540	#if JOBS
Lines 442-467 Link Here
442	/* XXX: limits number of signals */	545	/* XXX: limits number of signals */
443	retval = WTERMSIG(status) + 128;	546	retval = WTERMSIG(status) + 128;
444	}	547	}
445	if (! iflag)
446	freejob(job);
447	return retval;	548	return retval;
448	}	549	}
449	} else {	550	} else {
		551	struct job *end = jobtab + njobs;
450	for (jp = jobtab ; ; jp++) {	552	for (jp = jobtab ; ; jp++) {
451	if (jp >= jobtab + njobs) { /* no running procs */	553	if (jp >= end) {
		554	/* no running procs */
452	return 0;	555	return 0;
453	}	556	}
454	if (jp->used && jp->state == 0)	557	if (jp->used && jp->state == 0)
455	break;	558	break;
456	}	559	}
457	}	560	}
458	if (dowait(1, (struct job *)NULL) == -1)	561	dowait(2, 0);
459	return 128 + SIGINT;	562	if (pendingsigs)
		563	return 128 + pendingsigs;
460	}	564	}
461	}	565	}
462		566
463		567
464		568
		569	#if 0
465	int	570	int
466	jobidcmd(argc, argv)	571	jobidcmd(argc, argv)
467	int argc;	572	int argc;
Lines 472-482 Link Here
472		577
473	jp = getjob(argv[1]);	578	jp = getjob(argv[1]);
474	for (i = 0 ; i < jp->nprocs ; ) {	579	for (i = 0 ; i < jp->nprocs ; ) {
475	out1fmt("%ld", (long)jp->ps[i].pid);	580	out1fmt(
476	out1c(++i < jp->nprocs? ' ' : '\n');	581	"%ld%c", (long)jp->ps[i].pid,
		582	++i < jp->nprocs? ' ' : '\n'
		583	);
477	}	584	}
478	return 0;	585	return 0;
479	}	586	}
		587	#endif
480		588
481		589
482		590
Lines 496-504 Link Here
496	if (name == NULL) {	604	if (name == NULL) {
497	#if JOBS	605	#if JOBS
498	currentjob:	606	currentjob:
499	if ((jobno = curjob) == 0 \|\| jobtab[jobno - 1].used == 0)	607	if (!curjob \|\| !curjob->used)
500	error("No current job");	608	error("No current job");
501	return &jobtab[jobno - 1];	609	return curjob;
502	#else	610	#else
503	error("No current job");	611	error("No current job");
504	#endif	612	#endif
Lines 575-587 Link Here
575	break;	683	break;
576	}	684	}
577	INTOFF;	685	INTOFF;
578	jp->state = 0;
579	jp->used = 1;
580	jp->changed = 0;
581	jp->nprocs = 0;	686	jp->nprocs = 0;
		687	jp->state = 0;
582	#if JOBS	688	#if JOBS
583	jp->jobctl = jobctl;	689	jp->jobctl = jobctl;
584	#endif	690	#endif
		691	jp->changed = 0;
		692	jp->used = 1;
585	if (nprocs > 1) {	693	if (nprocs > 1) {
586	jp->ps = ckmalloc(nprocs * sizeof (struct procstat));	694	jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
587	} else {	695	} else {
Lines 636-658 Link Here
636	TRACE(("Child shell %d\n", getpid()));	744	TRACE(("Child shell %d\n", getpid()));
637	wasroot = rootshell;	745	wasroot = rootshell;
638	rootshell = 0;	746	rootshell = 0;
639	for (i = njobs, p = jobtab ; --i >= 0 ; p++) {
640	if (p == jp)
641	continue; /* don't free current job */
642	if (p->used)
643	freejob(p);
644	}
645	closescript();	747	closescript();
646	INTON;	748	INTON;
647	clear_traps();	749	clear_traps();
648	#if JOBS	750	#if JOBS
649	jobctl = 0; /* do job control only in root shell */	751	jobctl = pid; /* do job control only in root shell */
650	if (wasroot && mode != FORK_NOJOB && mflag) {	752	if (wasroot && mode != FORK_NOJOB && mflag) {
651	if (jp == NULL \|\| jp->nprocs == 0)	753	if (jp == NULL \|\| jp->nprocs == 0)
652	pgrp = getpid();	754	pgrp = getpid();
653	else	755	else
654	pgrp = jp->ps[0].pid;	756	pgrp = jp->ps[0].pid;
655	setpgid(0, pgrp);	757	setpgid(pid, pgrp);
656	if (mode == FORK_FG) {	758	if (mode == FORK_FG) {
657	/* this causes superfluous TIOCSPGRPS */	759	/* this causes superfluous TIOCSPGRPS */
658	if (tcsetpgrp(ttyfd, pgrp) < 0)	760	if (tcsetpgrp(ttyfd, pgrp) < 0)
Lines 661-692 Link Here
661	setsignal(SIGTSTP);	763	setsignal(SIGTSTP);
662	setsignal(SIGTTOU);	764	setsignal(SIGTTOU);
663	} else if (mode == FORK_BG) {	765	} else if (mode == FORK_BG) {
664	ignoresig(SIGINT);
665	ignoresig(SIGQUIT);
666	if ((jp == NULL \|\| jp->nprocs == 0) &&
667	! fd0_redirected_p ()) {
668	close(0);
669	if (open(devnull, O_RDONLY) != 0)
670	error(nullerr, devnull);
671	}
672	}
673	#else	766	#else
674	if (mode == FORK_BG) {	767	if (mode == FORK_BG) {
		768	#endif
675	ignoresig(SIGINT);	769	ignoresig(SIGINT);
676	ignoresig(SIGQUIT);	770	ignoresig(SIGQUIT);
677	if ((jp == NULL \|\| jp->nprocs == 0) &&	771	if ((jp == NULL \|\| jp->nprocs == 0)) {
678	! fd0_redirected_p ()) {	772	close(pid);
679	close(0);
680	if (open(devnull, O_RDONLY) != 0)	773	if (open(devnull, O_RDONLY) != 0)
681	error(nullerr, devnull);	774	error(nullerr, devnull);
682	}	775	}
683	}	776	}
684	#endif	777	for (i = njobs, p = jobtab ; --i >= 0 ; p++)
		778	if (p->used)
		779	freejob(p);
685	if (wasroot && iflag) {	780	if (wasroot && iflag) {
686	setsignal(SIGINT);	781	setsignal(SIGINT);
687	setsignal(SIGQUIT);	782	setsignal(SIGQUIT);
688	setsignal(SIGTERM);	783	setsignal(SIGTERM);
689	}	784	}
		785	jobless = pid;
690	return pid;	786	return pid;
691	}	787	}
692	if (rootshell && mode != FORK_NOJOB && mflag) {	788	if (rootshell && mode != FORK_NOJOB && mflag) {
Lines 705-710 Link Here
705	ps->cmd = nullstr;	801	ps->cmd = nullstr;
706	if (iflag && rootshell && n)	802	if (iflag && rootshell && n)
707	ps->cmd = commandtext(n);	803	ps->cmd = commandtext(n);
		804	} else {
		805	while (jobless && dowait(0, 0) > 0);
		806	jobless++;
708	}	807	}
709	INTON;	808	INTON;
710	TRACE(("In parent shell: child = %d\n", pid));	809	TRACE(("In parent shell: child = %d\n", pid));
Lines 753-759 Link Here
753	error("tcsetpgrp failed, errno=%d\n", errno);	852	error("tcsetpgrp failed, errno=%d\n", errno);
754	}	853	}
755	if (jp->state == JOBSTOPPED)	854	if (jp->state == JOBSTOPPED)
756	curjob = jp - jobtab + 1;	855	curjob = jp;
757	#endif	856	#endif
758	status = jp->ps[jp->nprocs - 1].status;	857	status = jp->ps[jp->nprocs - 1].status;
759	/* convert to 8 bits */	858	/* convert to 8 bits */
Lines 798-826 Link Here
798	{	897	{
799	int pid;	898	int pid;
800	int status;	899	int status;
801	struct procstat *sp;
802	struct job *jp;	900	struct job *jp;
		901	struct job *end;
803	struct job *thisjob;	902	struct job *thisjob;
804	int done;
805	int stopped;
806	int core;	903	int core;
807	int sig;	904	int sig;
808	extern volatile char gotsig[];	905	int state;
809		906
810	TRACE(("dowait(%d) called\n", block));	907	TRACE(("dowait(%d) called\n", block));
811	do {	908	do {
812	pid = waitproc(block, job, &status);	909	pid = waitproc(block, &status);
813	TRACE(("wait returns %d, status=%d\n", pid, status));	910	TRACE(("wait returns %d, status=%d\n", pid, status));
814	} while (pid == -1 && errno == EINTR && gotsig[SIGINT - 1] == 0);	911	} while (!(block & 2) && pid == -1 && errno == EINTR);
815	if (pid <= 0)	912	if (pid <= 0)
816	return pid;	913	return pid;
817	INTOFF;	914	INTOFF;
818	thisjob = NULL;	915	thisjob = NULL;
819	for (jp = jobtab ; jp < jobtab + njobs ; jp++) {	916	end = jobtab + njobs;
820	if (jp->used) {	917	for (jp = jobtab; jp < end; jp++) {
821	done = 1;	918	struct procstat *sp;
822	stopped = 1;	919	struct procstat *spend;
823	for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {	920	if (!jp->used)
		921	continue;
		922	state = JOBDONE;
		923	spend = jp->ps + jp->nprocs;
		924	for (sp = jp->ps; sp < spend; sp++) {
824	if (sp->pid == -1)	925	if (sp->pid == -1)
825	continue;	926	continue;
826	if (sp->pid == pid) {	927	if (sp->pid == pid) {
Lines 829-851 Link Here
829	thisjob = jp;	930	thisjob = jp;
830	}	931	}
831	if (sp->status == -1)	932	if (sp->status == -1)
832	stopped = 0;	933	state = 0;
833	else if (WIFSTOPPED(sp->status))	934	else if (WIFSTOPPED(sp->status))
834	done = 0;	935	state = JOBSTOPPED;
835	}	936	}
836	if (stopped) { /* stopped or done */	937	if (!thisjob)
837	int state = done? JOBDONE : JOBSTOPPED;	938	continue;
838	if (jp->state != state) {	939	if (state) {
839	TRACE(("Job %d: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));	940	/* stopped or done */
840	jp->state = state;	941	if (thisjob->state != state) {
		942	TRACE(("Job %d: changing state from %d to %d\n", thisjob - jobtab + 1, thisjob->state, state));
		943	thisjob->state = state;
841	#if JOBS	944	#if JOBS
842	if (done && curjob == jp - jobtab + 1)	945	if (state == JOBDONE && curjob == thisjob) {
843	curjob = 0; /* no current job */	946	/* no current job */
844	#endif	947	curjob = 0;
845	}	948	}
		949	#endif
846	}	950	}
847	}	951	}
		952	goto gotjob;
848	}	953	}
		954	if (!WIFSTOPPED(status))
		955	jobless--;
		956	gotjob:
849	INTON;	957	INTON;
850	if (! rootshell \|\| ! iflag \|\| (job && thisjob == job)) {	958	if (! rootshell \|\| ! iflag \|\| (job && thisjob == job)) {
851	core = WCOREDUMP(status);	959	core = WCOREDUMP(status);
Lines 871-877 Link Here
871	if (core)	979	if (core)
872	out2str(" - core dumped");	980	out2str(" - core dumped");
873	out2c('\n');	981	out2c('\n');
		982	#ifdef FLUSHERR
874	flushout(&errout);	983	flushout(&errout);
		984	#endif
875	} else {	985	} else {
876	TRACE(("Not printing status: status=%d, sig=%d\n",	986	TRACE(("Not printing status: status=%d, sig=%d\n",
877	status, sig));	987	status, sig));
Lines 925-940 Link Here
925		1035
926		1036
927	STATIC int	1037	STATIC int
928	waitproc(block, jp, status)	1038	waitproc(block, status)
929	int block;	1039	int block;
930	struct job *jp;
931	int *status;	1040	int *status;
932	{	1041	{
933	#ifdef BSD	1042	#ifdef BSD
934	int flags = 0;	1043	int flags = 0;
935		1044
936	#if JOBS	1045	#if JOBS
937	if (jp != NULL && jp->jobctl)	1046	if (jobctl)
938	flags \|= WUNTRACED;	1047	flags \|= WUNTRACED;
939	#endif	1048	#endif
940	if (block == 0)	1049	if (block == 0)
Lines 963-969 Link Here
963	/*	1072	/*
964	* return 1 if there are stopped jobs, otherwise 0	1073	* return 1 if there are stopped jobs, otherwise 0
965	*/	1074	*/
966	int job_warning = 0;	1075	int job_warning;
967	int	1076	int
968	stoppedjobs()	1077	stoppedjobs()
969	{	1078	{
Lines 1088-1097 Link Here
1088	for (np = n->ncmd.args ; np ; np = np->narg.next) {	1197	for (np = n->ncmd.args ; np ; np = np->narg.next) {
1089	cmdtxt(np);	1198	cmdtxt(np);
1090	if (np->narg.next)	1199	if (np->narg.next)
1091	cmdputs(" ");	1200	cmdputs(spcstr);
1092	}	1201	}
1093	for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {	1202	for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
1094	cmdputs(" ");	1203	cmdputs(spcstr);
1095	cmdtxt(np);	1204	cmdtxt(np);
1096	}	1205	}
1097	break;	1206	break;

Lines 38-43 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/jobs.h (-7 / +12 lines)
38	* @(#)jobs.h 8.2 (Berkeley) 5/4/95	38	* @(#)jobs.h 8.2 (Berkeley) 5/4/95
39	*/	39	*/
40		40
		41	#include <stdint.h>
		42	#include <sys/types.h>
		43
41	/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */	44	/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
42	#define FORK_FG 0	45	#define FORK_FG 0
43	#define FORK_BG 1	46	#define FORK_BG 1
Lines 66-85 Link Here
66	struct job {	69	struct job {
67	struct procstat ps0; /* status of process */	70	struct procstat ps0; /* status of process */
68	struct procstat ps; / status or processes when more than one */	71	struct procstat ps; / status or processes when more than one */
69	short nprocs; /* number of processes */	72	pid_t pgrp; /* process group of this job */
70	short pgrp; /* process group of this job */	73	uint32_t
71	char state; /* true if job is finished */	74	nprocs: 16, /* number of processes */
72	char used; /* true if this entry is in used */	75	state: 8, /* true if job is finished */
73	char changed; /* true if status has changed */
74	#if JOBS	76	#if JOBS
75	char jobctl; /* job running under job control */	77	jobctl: 1, /* job running under job control */
76	#endif	78	#endif
		79	used: 1, /* true if this entry is in used */
		80	changed: 1; /* true if status has changed */
77	};	81	};
78		82
79	extern short backgndpid; /* pid of last background process */	83	extern pid_t backgndpid; /* pid of last background process */
80	extern int job_warning; /* user was warned about stopped jobs */	84	extern int job_warning; /* user was warned about stopped jobs */
81		85
82	void setjobctl __P((int));	86	void setjobctl __P((int));
		87	int killcmd __P((int, char **));
83	int fgcmd __P((int, char **));	88	int fgcmd __P((int, char **));
84	int bgcmd __P((int, char **));	89	int bgcmd __P((int, char **));
85	int jobscmd __P((int, char **));	90	int jobscmd __P((int, char **));




#include <stdlib.h>

#include "shell.h"
#include "nodes.h"
#include "exec.h"	/* defines padvance() */
#include "var.h"
#include "output.h"
#include "memalloc.h"
#include "error.h"
#include "mail.h"
#include "mystring.h"


#define MAXMBOXES 10

/* times of mailboxes */
static time_t mailtime[MAXMBOXES];
/* Set if MAIL or MAILPATH is changed. */
static int changed;



/*
 * Print appropriate message(s) if mail has arrived.  If changed is set,
 * then the value of MAIL has changed, so we just update the values.
 * values.
 */

void
chkmail()
	int silent;
{
	int i;
	const char *mpath;
	char *p;
	char *q;
	time_t *mtp;
	struct stackmark smark;
	struct stat64 statb;

	if (silent)
		nmboxes = 10;
	if (nmboxes == 0)
		return;
	setstackmark(&smark);
	mpath = mpathset()? mpathval() : mailval();
	for (mtp = mailtime; mtp < mailtime + MAXMBOXES; mtp++) {
		p = padvance(&mpath, nullstr);
		if (p == NULL)
			break;
		if (*p == '\0')
			continue;
		for (q = p ; *q ; q++);
#ifdef DEBUG
		if (q[-1] != '/')
			abort();
#endif
		q[-1] = '\0';			/* delete trailing '/' */
		if (stat64(p, &statb) < 0) {
			*mtp = 0;
			continue;
		if (statb.st_mtime > mailtime[i] && ! silent) {
			out2str(pathopt? pathopt : "you have mail");
			out2c('\n');
		}
		if (!changed && statb.st_mtime != *mtp) {
			outfmt(
				&errout, snlfmt,
				pathopt? pathopt : "you have mail"
			);
			out2str(pathopt? pathopt : "you have mail");
			out2c('\n');
		}
		*mtp = statb.st_mtime;
#endif
	}
	changed = 0;
	popstackmark(&smark);
}


void
changemail(const char *val)
{
	changed++;
}

Lines 38-41 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mail.h (-1 / +2 lines)
38	* @(#)mail.h 8.2 (Berkeley) 5/4/95	38	* @(#)mail.h 8.2 (Berkeley) 5/4/95
39	*/	39	*/
40		40
41	void chkmail __P((int));	41	void chkmail __P((void));
		42	void changemail __P((const char *));

Lines 79-90 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/main.c (-52 / +41 lines)
79	#include "exec.h"	79	#include "exec.h"
80	#include "cd.h"	80	#include "cd.h"
81		81
		82	#ifdef HETIO
		83	#include "hetio.h"
		84	#endif
		85
82	#define PROFILE 0	86	#define PROFILE 0
83		87
84	int rootpid;	88	int rootpid;
85	int rootshell;	89	int rootshell;
86	STATIC union node *curcmd;
87	STATIC union node *prevcmd;
88	#if PROFILE	90	#if PROFILE
89	short profile_buf[16384];	91	short profile_buf[16384];
90	extern int etext();	92	extern int etext();
Lines 108-160 Link Here
108	int argc;	110	int argc;
109	char **argv;	111	char **argv;
110	{	112	{
		113	char *shinit;
		114	volatile int state;
111	struct jmploc jmploc;	115	struct jmploc jmploc;
112	struct stackmark smark;	116	struct stackmark smark;
113	volatile int state;
114	char *shinit;
115		117
116	#if PROFILE	118	#if PROFILE
117	monitor(4, etext, profile_buf, sizeof profile_buf, 50);	119	monitor(4, etext, profile_buf, sizeof profile_buf, 50);
118	#endif	120	#endif
119	state = 0;	121	state = 0;
120	if (setjmp(jmploc.loc)) {	122	if (setjmp(jmploc.loc)) {
121	/*	123	int status;
122	* When a shell procedure is executed, we raise the	124	int e;
123	* exception EXSHELLPROC to clean up before executing
124	* the shell procedure.
125	*/
126	switch (exception) {
127	case EXSHELLPROC:
128	rootpid = getpid();
129	rootshell = 1;
130	minusc = NULL;
131	state = 3;
132	break;
133		125
		126	reset();
		127
		128	e = exception;
		129	switch (exception) {
134	case EXEXEC:	130	case EXEXEC:
135	exitstatus = exerrno;	131	status = exerrno;
136	break;	132	break;
137		133
138	case EXERROR:	134	case EXERROR:
139	exitstatus = 2;	135	status = 2;
140	break;	136	break;
141		137
142	default:	138	default:
		139	status = exitstatus;
143	break;	140	break;
144	}	141	}
		142	exitstatus = status;
145		143
146	if (exception != EXSHELLPROC) {	144	if (e == EXEXIT \|\| state == 0 \|\| iflag == 0 \|\| ! rootshell)
147	if (state == 0 \|\| iflag == 0 \|\| ! rootshell)	145	exitshell();
148	exitshell(exitstatus);	146
149	}	147	if (e == EXINT
150	reset();
151	if (exception == EXINT
152	#if ATTY	148	#if ATTY
153	&& (! attyset() \|\| equal(termval(), "emacs"))	149	&& (! attyset() \|\| equal(termval(), "emacs"))
154	#endif	150	#endif
155	) {	151	) {
156	out2c('\n');	152	out2c('\n');
157	flushout(&errout);	153	#ifdef FLUSHERR
		154	flushout(out2);
		155	#endif
158	}	156	}
159	popstackmark(&smark);	157	popstackmark(&smark);
160	FORCEINTON; /* enable interrupts */	158	FORCEINTON; /* enable interrupts */
Lines 186-214 Link Here
186	}	184	}
187	state2:	185	state2:
188	state = 3;	186	state = 3;
189	if (getuid() == geteuid() && getgid() == getegid()) {	187	if (
		188	#ifndef linux
		189	getuid() == geteuid() && getgid() == getegid() &&
		190	#endif
		191	iflag
		192	) {
190	if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {	193	if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
191	state = 3;
192	read_profile(shinit);	194	read_profile(shinit);
193	}	195	}
194	}	196	}
195	state3:	197	state3:
196	state = 4;	198	state = 4;
197	if (sflag == 0 \|\| minusc) {
198	static int sigs[] = {
199	SIGINT, SIGQUIT, SIGHUP,
200	#ifdef SIGTSTP
201	SIGTSTP,
202	#endif
203	SIGPIPE
204	};
205	#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
206	int i;
207
208	for (i = 0; i < SIGSSIZE; i++)
209	setsignal(sigs[i]);
210	}
211
212	if (minusc)	199	if (minusc)
213	evalstring(minusc, 0);	200	evalstring(minusc, 0);
214		201
Lines 219-225 Link Here
219	#if PROFILE	206	#if PROFILE
220	monitor(0);	207	monitor(0);
221	#endif	208	#endif
222	exitshell(exitstatus);	209	exitshell();
223	/* NOTREACHED */	210	/* NOTREACHED */
224	}	211	}
225		212
Lines 240-245 Link Here
240		227
241	TRACE(("cmdloop(%d) called\n", top));	228	TRACE(("cmdloop(%d) called\n", top));
242	setstackmark(&smark);	229	setstackmark(&smark);
		230	#ifdef HETIO
		231	if(iflag && top)
		232	hetio_init();
		233	#endif
243	for (;;) {	234	for (;;) {
244	if (pendingsigs)	235	if (pendingsigs)
245	dotrap();	236	dotrap();
Lines 247-253 Link Here
247	if (iflag && top) {	238	if (iflag && top) {
248	inter++;	239	inter++;
249	showjobs(1);	240	showjobs(1);
250	chkmail(0);	241	chkmail();
251	flushout(&output);	242	flushout(&output);
252	}	243	}
253	n = parsecmd(inter);	244	n = parsecmd(inter);
Lines 376-387 Link Here
376	int argc;	367	int argc;
377	char **argv;	368	char **argv;
378	{	369	{
379	struct strlist *sp;
380	exitstatus = 0;	370	exitstatus = 0;
381		371
382	for (sp = cmdenviron; sp ; sp = sp->next)
383	setvareq(savestr(sp->text), VSTRFIXED\|VTEXTFIXED);
384
385	if (argc >= 2) { /* That's what SVR2 does */	372	if (argc >= 2) { /* That's what SVR2 does */
386	char *fullname;	373	char *fullname;
387	struct stackmark smark;	374	struct stackmark smark;
Lines 403-414 Link Here
403	int argc;	390	int argc;
404	char **argv;	391	char **argv;
405	{	392	{
		393	int status;
		394
406	if (stoppedjobs())	395	if (stoppedjobs())
407	return 0;	396	return 0;
		397	status = oexitstatus;
408	if (argc > 1)	398	if (argc > 1)
409	exitstatus = number(argv[1]);	399	status = number(argv[1]);
410	else	400	exitstatus = status;
411	exitstatus = oexitstatus;	401	exraise(EXEXIT);
412	exitshell(exitstatus);
413	/* NOTREACHED */	402	/* NOTREACHED */
414	}	403	}




#	$NetBSD: Makefile,v 1.59 2002/09/15 00:19:22 thorpej Exp $
#	@(#)Makefile	8.4 (Berkeley) 5/5/95

.include <bsd.own.mk>

YHEADER=1
PROG=	sh
SHSRCS=	alias.c arith_yylex.c cd.c echo.c error.c eval.c exec.c expand.c \
	histedit.c input.c jobs.c mail.c main.c memalloc.c miscbltin.c \
	mystring.c options.c parser.c printf.c redir.c show.c trap.c output.c \
	var.c test.c setmode.c times.c hetio.c
GENSRCS=arith.c arith.h builtins.c builtins.h init.c nodes.c \
	nodes.h signames.c syntax.c syntax.h token.h
SRCS=	${SHSRCS} ${GENSRCS}

LDADD+=	-ll -ledit -ltermcap
DPADD+=	${LIBL} ${LIBEDIT} ${LIBTERMCAP}

LFLAGS= -8	# 8-bit lex scanner for arithmetic
YFLAGS=	-d

CPPFLAGS+=-DSHELL -I. -I${.CURDIR}
CPPFLAGS+=-DSMALL -DHETIO

.PATH:	${.CURDIR}/bltin ${NETBSDSRCDIR}/bin/test
CPPFLAGS+=-DSMALL
.endif

.PATH:	${.CURDIR}/bltin ${.CURDIR}/../test

CLEANFILES+= mkinit mknodes mksyntax
CLEANFILES+= ${GENSRCS} y.tab.h

BLTINDEFS=specialbltins.def regularbltins.def assignbltins.def

token.h: mktokens
	sh ${.ALLSRC}

builtins.c builtins.h: mkbuiltins shell.h builtins.def ${BLTINDEFS}
	sh ${.ALLSRC} ${.OBJDIR} '${CFLAGS}'

init.c: mkinit ${SHSRCS}
	./${.ALLSRC}

syntax.c syntax.h: mksyntax
	./${.ALLSRC}

signames.c: mksignames
	./${.ALLSRC}

mkinit: mkinit.c
	${HOST_LINK.c} -o mkinit ${.IMPSRC}

mknodes: mknodes.c
	${HOST_LINK.c} -o mknodes ${.IMPSRC}

.if	(${MACHINE_ARCH} == "powerpc") || \
	(${MACHINE_CPU} == "arm")
TARGET_CHARFLAG= -DTARGET_CHAR="unsigned char"
.else
TARGET_CHARFLAG= -DTARGET_CHAR="signed char"
.endif

mksyntax: mksyntax.c
	${HOST_LINK.c} ${TARGET_CHARFLAG} -o mksyntax ${.IMPSRC}

.include <bsd.prog.mk>

${OBJS}: arith.h builtins.h nodes.h syntax.h token.h




 */

pointer
ckmalloc(size_t nbytes)
	int nbytes;
{
	pointer p;

	if ((p = malloc(nbytes)) == NULL)
	p = malloc(nbytes);
	INTON;
	if (p == NULL)
		error("Out of space");
	return p;
}

 */

pointer
ckrealloc(pointer p, size_t nbytes)
	pointer p;
	int nbytes;
{

	if ((p = realloc(p, nbytes)) == NULL)


char *
savestr(s)
	const char *s;
	{
	char *p = strdup(s);
	if (!p)
		error("Out of space");
	scopy(s, p);
	return p;
}


 * well.
 */

#define MINSIZE ALIGN(504)		/* minimum size of a block */


struct stack_block {

struct stack_block *stackp = &stackbase;
struct stackmark *markp;
char *stacknxt = stackbase.space;
size_t stacknleft = MINSIZE;
char *sstrend = stackbase.space + MINSIZE;
int herefd = -1;



pointer
stalloc(size_t nbytes)
	int nbytes;
{
	char *p;
	size_t aligned;

	aligned = ALIGN(nbytes);
	if (nbytes > stacknleft) {
		size_t len;
		size_t blocksize;
		struct stack_block *sp;

		blocksize = aligned;
		if (blocksize < MINSIZE)
			blocksize = MINSIZE;
		len = sizeof(struct stack_block) - MINSIZE + blocksize;
		if (len < blocksize)
			error("Out of space");
		INTOFF;
		sp = ckmalloc(len);
		sp->prev = stackp;
		stacknxt = sp->space;
		stacknleft = blocksize;
		sstrend = stacknxt + blocksize;
		stackp = sp;
		INTON;
	}
	p = stacknxt;
	stacknxt += aligned;
	stacknleft -= aligned;
	return p;
}


stunalloc(p)
	pointer p;
	{
#ifdef DEBUG
	if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) {
		write(2, "stunalloc\n", 10);
		abort();
	}
#endif
	stacknleft += stacknxt - (char *)p;
	stacknxt = p;
}

	}
	stacknxt = mark->stacknxt;
	stacknleft = mark->stacknleft;
	sstrend = mark->stacknxt + mark->stacknleft;
	INTON;
}


void
growstackblock() {
	char *p;
	size_t newlen, grosslen;
	char *oldspace = stacknxt;
	size_t oldlen = stacknleft;
	struct stack_block *sp;
	struct stack_block *oldstackp;
	struct stack_block *prevstackp;

 	grosslen = stacknleft * 2;
	if (grosslen < stacknleft)
		error("Out of space");
	if (grosslen < 128)
		grosslen += 128 + sizeof(struct stack_block) - MINSIZE;
	newlen = grosslen - (sizeof(struct stack_block) - MINSIZE);

	if (stacknxt == stackp->space && stackp != &stackbase) {
		INTOFF;
		oldstackp = stackp;
		sp = stackp;
		prevstackp = sp->prev;
		sp = ckrealloc((pointer)sp, grosslen);
		sp->prev = prevstackp;
		stackp = sp;
		stacknxt = sp->space;
		stacknleft = newlen;
		sstrend = sp->space + newlen;
		{
		  /* Stack marks pointing to the start of the old block
		   * must be relocated to point to the new block 

		INTON;
	} else {
		p = stalloc(newlen);
		/* free the space we just allocated */
		stacknxt = memcpy(p, oldspace, oldlen);
		stacknleft += newlen;
	}
}



void
grabstackblock(size_t len)
	int len;
{
	len = ALIGN(len);
	stacknxt += len;

 */


void *
growstackstr() {
	size_t len = stackblocksize();
	if (herefd >= 0 && len >= 1024) {
		xwrite(herefd, stackblock(), len);
		sstrnleft = len - 1;
		return stackblock();
	}
	growstackblock();
	sstrnleft = stackblocksize() - len - 1;
	return stackblock() + len;
}


 */

char *
makestrspace(size_t newlen, char *p) {
	size_t len = p - stackblock();
	size_t size = stackblocksize();

	for (;;) {
		size_t nleft;

		size = stackblocksize();
		nleft = size - len;
		if (nleft >= newlen)
			break;
	growstackblock();
	}
	return stackblock() + len;
}



char *
stnputs(const char *s, size_t n, char *p) {
	p = makestrspace(n, p);
	p = mempcpy(p, s, n);
	return p;
}


char *
stputs(const char *s, char *p) {
	return stnputs(s, strlen(s), p);
}




 *	@(#)memalloc.h	8.2 (Berkeley) 5/4/95
 */

#include <stddef.h>

struct stackmark {
	struct stack_block *stackp;
	char *stacknxt;
	size_t stacknleft;
	struct stackmark *marknext;
};


extern char *stacknxt;
extern size_t stacknleft;
extern char *sstrend;
extern int herefd;

pointer ckmalloc __P((size_t));
pointer ckrealloc __P((pointer, size_t));
char *savestr __P((const char *));
pointer stalloc __P((size_t));
void stunalloc __P((pointer));
void setstackmark __P((struct stackmark *));
void popstackmark __P((struct stackmark *));
void growstackblock __P((void));
void grabstackblock __P((size_t));
void *growstackstr __P((void));
char *makestrspace __P((size_t, char *));
char *stnputs __P((const char *, size_t, char *));
char *stputs __P((const char *, char *));


static inline char *_STPUTC(char c, char *p) {
	if (p == sstrend)
		p = growstackstr();
	*p++ = c;
	return p;
}

#define stackblock() stacknxt
#define stackblocksize() stacknleft
#define STARTSTACKSTR(p) (p) = ((void *) stackblock())
#define STPUTC(c, p) (p) = _STPUTC(c, p)
#define CHECKSTRSPACE(n, p) \
	({ \
		char *q = (p); \
		size_t l = (n); \
		size_t m = sstrend - q; \
		if (l > m) \
			(p) = makestrspace(l, q); \
		0; \
	})
#define USTPUTC(c, p)	(*p++ = (c))
#define STACKSTRNUL(p)	((p) == sstrend? (p = growstackstr(), *p = '\0') : (*p = '\0'))
#define STUNPUTC(p)	(--p)
#define STTOPC(p)	p[-1]
#define STADJUST(amount, p)	(p += (amount))
#define grabstackstr(p)	stalloc(((char *) (p)) - stackblock())
#define ungrabstackstr(s, p) stunalloc((s))

#define ckfree(p)	free((pointer)(p))

Lines 70-75 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/miscbltin.c (-12 / +18 lines)
70		70
71	#undef rflag	71	#undef rflag
72		72
		73	#ifdef __GLIBC__
		74	mode_t getmode(const void *, mode_t);
		75	void setmode(const char );
		76
		77	#if !defined(__GLIBC__) \|\| __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
		78	typedef enum __rlimit_resource rlim_t;
		79	#endif
		80	#endif
		81
73		82
74		83
75	/*	84	/*
Lines 89-95 Link Here
89	char c;	98	char c;
90	int rflag;	99	int rflag;
91	char *prompt;	100	char *prompt;
92	char *ifs;	101	const char *ifs;
93	char *p;	102	char *p;
94	int startword;	103	int startword;
95	int status;	104	int status;
Lines 105-116 Link Here
105	}	114	}
106	if (prompt && isatty(0)) {	115	if (prompt && isatty(0)) {
107	out2str(prompt);	116	out2str(prompt);
		117	#ifdef FLUSHERR
108	flushall();	118	flushall();
		119	#endif
109	}	120	}
110	if (*(ap = argptr) == NULL)	121	if (*(ap = argptr) == NULL)
111	error("arg count");	122	error("arg count");
112	if ((ifs = bltinlookup("IFS", 1)) == NULL)	123	if ((ifs = bltinlookup("IFS")) == NULL)
113	ifs = nullstr;	124	ifs = defifs;
114	status = 0;	125	status = 0;
115	startword = 1;	126	startword = 1;
116	backslash = 0;	127	backslash = 0;
Lines 125-131 Link Here
125	if (backslash) {	136	if (backslash) {
126	backslash = 0;	137	backslash = 0;
127	if (c != '\n')	138	if (c != '\n')
128	STPUTC(c, p);	139	goto put;
129	continue;	140	continue;
130	}	141	}
131	if (!rflag && c == '\\') {	142	if (!rflag && c == '\\') {
Lines 138-156 Link Here
138	continue;	149	continue;
139	}	150	}
140	startword = 0;	151	startword = 0;
141	if (backslash && c == '\\') {	152	if (ap[1] != NULL && strchr(ifs, c) != NULL) {
142	if (read(0, &c, 1) != 1) {
143	status = 1;
144	break;
145	}
146	STPUTC(c, p);
147	} else if (ap[1] != NULL && strchr(ifs, c) != NULL) {
148	STACKSTRNUL(p);	153	STACKSTRNUL(p);
149	setvar(*ap, stackblock(), 0);	154	setvar(*ap, stackblock(), 0);
150	ap++;	155	ap++;
151	startword = 1;	156	startword = 1;
152	STARTSTACKSTR(p);	157	STARTSTACKSTR(p);
153	} else {	158	} else {
		159	put:
154	STPUTC(c, p);	160	STPUTC(c, p);
155	}	161	}
156	}	162	}
Lines 225-231 Link Here
225	mask = 0;	231	mask = 0;
226	do {	232	do {
227	if (ap >= '8' \|\| ap < '0')	233	if (ap >= '8' \|\| ap < '0')
228	error("Illegal number: %s", argv[1]);	234	error(illnum, argv[1]);
229	mask = (mask << 3) + (*ap - '0');	235	mask = (mask << 3) + (*ap - '0');
230	} while (*++ap != '\0');	236	} while (*++ap != '\0');
231	umask(mask);	237	umask(mask);




#
#	@(#)mkbuiltins	8.2 (Berkeley) 5/4/95

trap 'rm -f $temp $temp2' EXIT
temp=$(tempfile)
temp2=$(tempfile)

shell=$1
builtins=$2
specialbltins=$3
regularbltins=$4
assignbltins=$5
objdir=$6

havehist=1
if [ -z "${7##*-DSMALL*}" ]; then
	havehist=0
	shift
fi
shell=$1
builtins=$2
objdir=$3

havejobs=1
if [ -z "${7##*-DJOBS=0*}" ]; then
	havejobs=0
	havejobs=1
fi

exec > ${objdir}/builtins.c


!
awk '/^[^#]/ {if(('$havejobs' || $2 != "-j") && ('$havehist' || $2 != "-h")) \
    print $0}' ${builtins} | sed 's/-[hj]//' > $temp
awk '{	printf "int %s __P((int, char **));\n", $1}' $temp
echo '
int (*const builtinfunc[]) __P((int, char **)) = {'
awk '/^[^#]/ {	printf "\t%s,\n", $1}' $temp
echo '};

const struct builtincmd builtincmd[] = {'
awk '{	for (i = 2 ; i <= NF ; i++) {
		print $i "\t" $1
	}}' $temp | sort -k 1,1 | tee $temp2 |
	join -a 1 -e 0 -o 1.1,1.2,2.1 - $specialbltins |
	join -a 1 -e 0 -o 1.1,1.2,1.3,2.1 - $regularbltins |
	join -a 1 -e 0 -o 1.1,1.2,1.3,1.4,2.1 - $assignbltins |
	awk '{  printf "\t{ \"%s\", %s, %d },\n", $1, $2,
		!!$3 + (!!$4 * 2) + (!!$5 * 4)}'
echo '};'

exec > ${objdir}/builtins.h
cat <<\!


#include <sys/cdefs.h>
!
nl -v 0 $temp2 | sort -u -k 3,3 |
tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ |
	awk '{	printf "#define %s (builtincmd + %d)\n", $3, $1}'
printf '\n#define NUMBUILTINS %d\n' $(wc -l < $temp2)
echo '
#define BUILTIN_SPECIAL 0x1
#define BUILTIN_REGULAR 0x2
#define BUILTIN_ASSIGN 0x4

struct builtincmd {
      const char *name;
	int (*const builtinfunc) __P((int, char **));
	unsigned flags;
};

extern int (*const builtinfunc[]) __P((int, char **));
extern const struct builtincmd builtincmd[];'
rm -f $temp




 * interactive shell and control is returned to the main command loop.\n\
 */\n";

char shellproc[] = "\
/*\n\
 * This routine is called to initialize the shell to run a shell procedure.\n\
 */\n";


struct event event[] = {
	{"INIT", "init", init},
	{"RESET", "reset", reset},
	{"SHELLPROC", "initshellproc", shellproc},
	{NULL, NULL}
};


			doinclude(line);
		if (line[0] == 'M' && match("MKINIT", line))
			dodecl(line, fp);
		if (line[0] == '#' && gooddefine(line))
			addstr(line, &defines);
		if (line[0] == '#' && gooddefine(line)) {
		        char *cp;
			char line2[1024];




/*	$NetBSD: mknodes.c,v 1.19 2002/05/25 23:09:06 wiz Exp $	*/

/*-
 * Copyright (c) 1991, 1993

static char sccsid[] = "@(#)mknodes.c	8.2 (Berkeley) 5/4/95";
#else
static const char rcsid[] =
    "$NetBSD: mknodes.c,v 1.19 2002/05/25 23:09:06 wiz Exp $";
#endif
#endif /* not lint */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif


#define MAXTYPES 50		/* max number of node types */
#define MAXFIELDS 20		/* max fields in a structure */

	fputs("\tstruct nodelist *next;\n", hfile);
	fputs("\tunion node *n;\n", hfile);
	fputs("};\n\n\n", hfile);
	fputs("struct funcnode {\n", hfile);
	fputs("\tint count;\n", hfile);
	fputs("\tunion node n;\n", hfile);
	fputs("};\n\n\n", hfile);
	fputs("struct funcnode *copyfunc(union node *);\n", hfile);
	fputs("void freefunc(struct funcnode *);\n", hfile);
	fputs("#endif\n", hfile);

	fputs(writer, cfile);
	while (fgets(line, sizeof line, patfile) != NULL) {



static void
#ifdef __STDC__
error(const char *msg, ...)
#else
error(va_alist)
	va_dcl
#endif
{
	va_list va;

	va_start(va, msg);
#else
	char *msg;
	va_start(va);
	msg = va_arg(va, char *);
#endif

	(void) fprintf(stderr, "line %d: ", linno);
	(void) vfprintf(stderr, msg, va);




/* signames.c -- Create and write `signames.c', which contains an array of
   signal names. */

/* Copyright (C) 1992 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash is free software; you can redistribute it and/or modify it under
   the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 2, or (at your option) any later
   version.

   Bash is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   You should have received a copy of the GNU General Public License along
   with Bash; see the file COPYING.  If not, write to the Free Software
   Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>

#if !defined (NSIG)
#  define NSIG 64
#endif

/*
 * Special traps:
 *	EXIT == 0
 */
#define LASTSIG NSIG-1

char *signal_names[2 * NSIG + 3];

#define signal_names_size (sizeof(signal_names)/sizeof(signal_names[0]))

char *progname;

/* AIX 4.3 defines SIGRTMIN and SIGRTMAX as 888 and 999 respectively.
   I don't want to allocate so much unused space for the intervening signal
   numbers, so we just punt if SIGRTMAX is past the bounds of the
   signal_names array (handled in configure). */
#if defined (SIGRTMAX) && defined (UNUSABLE_RT_SIGNALS)
#  undef SIGRTMAX
#  undef SIGRTMIN
#endif

#if defined (SIGRTMAX) || defined (SIGRTMIN)
#  define RTLEN 14
#  define RTLIM 256
#endif

void
initialize_signames ()
{
  register int i;
#if defined (SIGRTMAX) || defined (SIGRTMIN)
  int rtmin, rtmax, rtcnt;
#endif

  for (i = 1; i < signal_names_size; i++)
    signal_names[i] = (char *)NULL;

  /* `signal' 0 is what we do on exit. */
  signal_names[0] = "EXIT";

  /* Place signal names which can be aliases for more common signal
     names first.  This allows (for example) SIGABRT to overwrite SIGLOST. */

  /* POSIX 1003.1b-1993 real time signals, but take care of incomplete
     implementations. Acoording to the standard, both, SIGRTMIN and
     SIGRTMAX must be defined, SIGRTMIN must be stricly less than
     SIGRTMAX, and the difference must be at least 7, that is, there
     must be at least eight distinct real time signals. */

  /* The generated signal names are SIGRTMIN, SIGRTMIN+1, ...,
     SIGRTMIN+x, SIGRTMAX-x, ..., SIGRTMAX-1, SIGRTMAX. If the number
     of RT signals is odd, there is an extra SIGRTMIN+(x+1).
     These names are the ones used by ksh and /usr/xpg4/bin/sh on SunOS5. */

#if defined (SIGRTMIN)
  rtmin = SIGRTMIN;
  signal_names[rtmin] = "RTMIN";
#endif

#if defined (SIGRTMAX)
  rtmax = SIGRTMAX;
  signal_names[rtmax] = "RTMAX";
#endif

#if defined (SIGRTMAX) && defined (SIGRTMIN)
  if (rtmax > rtmin)
    {
      rtcnt = (rtmax - rtmin - 1) / 2;
      /* croak if there are too many RT signals */
      if (rtcnt >= RTLIM/2)
	{
	  rtcnt = RTLIM/2-1;
	  fprintf(stderr, "%s: error: more than %i real time signals, fix `%s'\n",
		  progname, RTLIM, progname);
	}

      for (i = 1; i <= rtcnt; i++)
	{
	  signal_names[rtmin+i] = (char *)malloc(RTLEN);
	  if (signal_names[rtmin+i])
	    sprintf (signal_names[rtmin+i], "RTMIN+%d", i);
	  signal_names[rtmax-i] = (char *)malloc(RTLEN);
	  if (signal_names[rtmax-i])
	    sprintf (signal_names[rtmax-i], "RTMAX-%d", i);
	}

      if (rtcnt < RTLIM/2-1 && rtcnt != (rtmax-rtmin)/2)
	{
	  /* Need an extra RTMIN signal */
	  signal_names[rtmin+rtcnt+1] = (char *)malloc(RTLEN);
	  if (signal_names[rtmin+rtcnt+1])
	    sprintf (signal_names[rtmin+rtcnt+1], "RTMIN+%d", rtcnt+1);
	}
    }
#endif /* SIGRTMIN && SIGRTMAX */

/* AIX */
#if defined (SIGLOST)	/* resource lost (eg, record-lock lost) */
  signal_names[SIGLOST] = "LOST";
#endif

#if defined (SIGMSG)	/* HFT input data pending */
  signal_names[SIGMSG] = "MSG";
#endif

#if defined (SIGDANGER)	/* system crash imminent */
  signal_names[SIGDANGER] = "DANGER";
#endif

#if defined (SIGMIGRATE) /* migrate process to another CPU */
  signal_names[SIGMIGRATE] = "MIGRATE";
#endif

#if defined (SIGPRE)	/* programming error */
  signal_names[SIGPRE] = "PRE";
#endif

#if defined (SIGVIRT)	/* AIX virtual time alarm */
  signal_names[SIGVIRT] = "VIRT";
#endif

#if defined (SIGALRM1)	/* m:n condition variables */
  signal_names[SIGALRM1] = "ALRM1";
#endif

#if defined (SIGWAITING)	/* m:n scheduling */
  signal_names[SIGWAITING] = "WAITING";
#endif

#if defined (SIGGRANT)	/* HFT monitor mode granted */
  signal_names[SIGGRANT] = "GRANT";
#endif

#if defined (SIGKAP)	/* keep alive poll from native keyboard */
  signal_names[SIGKAP] = "KAP";
#endif

#if defined (SIGRETRACT) /* HFT monitor mode retracted */
  signal_names[SIGRETRACT] = "RETRACT";
#endif

#if defined (SIGSOUND)	/* HFT sound sequence has completed */
  signal_names[SIGSOUND] = "SOUND";
#endif

#if defined (SIGSAK)	/* Secure Attention Key */
  signal_names[SIGSAK] = "SAK";
#endif

/* SunOS5 */
#if defined (SIGLWP)	/* special signal used by thread library */
  signal_names[SIGLWP] = "LWP";
#endif

#if defined (SIGFREEZE)	/* special signal used by CPR */
  signal_names[SIGFREEZE] = "FREEZE";
#endif

#if defined (SIGTHAW)	/* special signal used by CPR */
  signal_names[SIGTHAW] = "THAW";
#endif

#if defined (SIGCANCEL)	/* thread cancellation signal used by libthread */
  signal_names[SIGCANCEL] = "CANCEL";
#endif

/* HP-UX */
#if defined (SIGDIL)	/* DIL signal (?) */
  signal_names[SIGDIL] = "DIL";
#endif

/* System V */
#if defined (SIGCLD)	/* Like SIGCHLD.  */
  signal_names[SIGCLD] = "CLD";
#endif

#if defined (SIGPWR)	/* power state indication */
  signal_names[SIGPWR] = "PWR";
#endif

#if defined (SIGPOLL)	/* Pollable event (for streams)  */
  signal_names[SIGPOLL] = "POLL";
#endif

/* Unknown */
#if defined (SIGWINDOW)
  signal_names[SIGWINDOW] = "WINDOW";
#endif

/* Common */
#if defined (SIGHUP)	/* hangup */
  signal_names[SIGHUP] = "HUP";
#endif

#if defined (SIGINT)	/* interrupt */
  signal_names[SIGINT] = "INT";
#endif

#if defined (SIGQUIT)	/* quit */
  signal_names[SIGQUIT] = "QUIT";
#endif

#if defined (SIGILL)	/* illegal instruction (not reset when caught) */
  signal_names[SIGILL] = "ILL";
#endif

#if defined (SIGTRAP)	/* trace trap (not reset when caught) */
  signal_names[SIGTRAP] = "TRAP";
#endif

#if defined (SIGIOT)	/* IOT instruction */
  signal_names[SIGIOT] = "IOT";
#endif

#if defined (SIGABRT)	/* Cause current process to dump core. */
  signal_names[SIGABRT] = "ABRT";
#endif

#if defined (SIGEMT)	/* EMT instruction */
  signal_names[SIGEMT] = "EMT";
#endif

#if defined (SIGFPE)	/* floating point exception */
  signal_names[SIGFPE] = "FPE";
#endif

#if defined (SIGKILL)	/* kill (cannot be caught or ignored) */
  signal_names[SIGKILL] = "KILL";
#endif

#if defined (SIGBUS)	/* bus error */
  signal_names[SIGBUS] = "BUS";
#endif

#if defined (SIGSEGV)	/* segmentation violation */
  signal_names[SIGSEGV] = "SEGV";
#endif

#if defined (SIGSYS)	/* bad argument to system call */
  signal_names[SIGSYS] = "SYS";
#endif

#if defined (SIGPIPE)	/* write on a pipe with no one to read it */
  signal_names[SIGPIPE] = "PIPE";
#endif

#if defined (SIGALRM)	/* alarm clock */
  signal_names[SIGALRM] = "ALRM";
#endif

#if defined (SIGTERM)	/* software termination signal from kill */
  signal_names[SIGTERM] = "TERM";
#endif

#if defined (SIGURG)	/* urgent condition on IO channel */
  signal_names[SIGURG] = "URG";
#endif

#if defined (SIGSTOP)	/* sendable stop signal not from tty */
  signal_names[SIGSTOP] = "STOP";
#endif

#if defined (SIGTSTP)	/* stop signal from tty */
  signal_names[SIGTSTP] = "TSTP";
#endif

#if defined (SIGCONT)	/* continue a stopped process */
  signal_names[SIGCONT] = "CONT";
#endif

#if defined (SIGCHLD)	/* to parent on child stop or exit */
  signal_names[SIGCHLD] = "CHLD";
#endif

#if defined (SIGTTIN)	/* to readers pgrp upon background tty read */
  signal_names[SIGTTIN] = "TTIN";
#endif

#if defined (SIGTTOU)	/* like TTIN for output if (tp->t_local&LTOSTOP) */
  signal_names[SIGTTOU] = "TTOU";
#endif

#if defined (SIGIO)	/* input/output possible signal */
  signal_names[SIGIO] = "IO";
#endif

#if defined (SIGXCPU)	/* exceeded CPU time limit */
  signal_names[SIGXCPU] = "XCPU";
#endif

#if defined (SIGXFSZ)	/* exceeded file size limit */
  signal_names[SIGXFSZ] = "XFSZ";
#endif

#if defined (SIGVTALRM)	/* virtual time alarm */
  signal_names[SIGVTALRM] = "VTALRM";
#endif

#if defined (SIGPROF)	/* profiling time alarm */
  signal_names[SIGPROF] = "PROF";
#endif

#if defined (SIGWINCH)	/* window changed */
  signal_names[SIGWINCH] = "WINCH";
#endif

/* 4.4 BSD */
#if defined (SIGINFO) && !defined (_SEQUENT_)	/* information request */
  signal_names[SIGINFO] = "INFO";
#endif

#if defined (SIGUSR1)	/* user defined signal 1 */
  signal_names[SIGUSR1] = "USR1";
#endif

#if defined (SIGUSR2)	/* user defined signal 2 */
  signal_names[SIGUSR2] = "USR2";
#endif

#if defined (SIGKILLTHR)	/* BeOS: Kill Thread */
  signal_names[SIGKILLTHR] = "KILLTHR";
#endif

  for (i = 0; i < NSIG; i++)
    if (signal_names[i] == (char *)NULL)
      {
	signal_names[i] = (char *)malloc (18);
	if (signal_names[i])
	  sprintf (signal_names[i], "%d", i);
      }
}

void
write_signames (stream)
     FILE *stream;
{
  register int i;

  fprintf (stream, "/* This file was automatically created by %s.\n",
	   progname);
  fprintf (stream, "   Do not edit.  Edit support/mksignames.c instead. */\n\n");
  fprintf (stream, "#include <signal.h>\n\n");
  fprintf (stream,
	   "/* A translation list so we can be polite to our users. */\n");
  fprintf (stream, "const char *const signal_names[NSIG + 1] = {\n");

  for (i = 0; i <= LASTSIG; i++)
    fprintf (stream, "    \"%s\",\n", signal_names[i]);

  fprintf (stream, "    (char *)0x0\n");
  fprintf (stream, "};\n");
}

int
main (argc, argv)
     int argc;
     char **argv;
{
  char *stream_name;
  FILE *stream;

  progname = argv[0];

  if (argc == 1)
    {
      stream_name = "signames.c";
    }
  else if (argc == 2)
    {
      stream_name = argv[1];
    }
  else
    {
      fprintf (stderr, "Usage: %s [output-file]\n", progname);
      exit (1);
    }

  stream = fopen (stream_name, "w");
  if (!stream)
    {
      fprintf (stderr, "%s: %s: cannot open for writing\n",
	       progname, stream_name);
      exit (2);
    }

  initialize_signames ();
  write_signames (stream);
  exit (0);
}




/*	$NetBSD: mksyntax.c,v 1.25 2002/05/31 16:18:48 christos Exp $	*/

/*-
 * Copyright (c) 1991, 1993

static char sccsid[] = "@(#)mksyntax.c	8.2 (Berkeley) 5/4/95";
#else
static const char rcsid[] =
    "$NetBSD: mksyntax.c,v 1.25 2002/05/31 16:18:48 christos Exp $";
#endif
#endif /* not lint */


	{ "CBACK",	"a backslash character" },
	{ "CSQUOTE",	"single quote" },
	{ "CDQUOTE",	"double quote" },
	{ "CENDQUOTE",	"a terminating quote" },
	{ "CBQUOTE",	"backwards single quote" },
	{ "CVAR",	"a dollar sign" },
	{ "CENDVAR",	"a '}' character" },

	{ "CEOF",	"end of file" },
	{ "CCTL",	"like CWORD, except it must be escaped" },
	{ "CSPCL",	"these terminate a word" },
	{ "CIGN",	"character should be ignored" },
	{ NULL,		NULL }
};


		exit(2);
	}
	size = (1 << nbits) + 1;
	base = 2;
	if (sign)
		base += 1 << (nbits - 1);
	digit_contig = 1;


	fputs("#include <sys/cdefs.h>\n", hfile);
	fputs("#include <ctype.h>\n", hfile);
	fputs("\n", hfile);
	fputs("#ifdef CEOF\n", hfile);
	fputs("#undef CEOF\n", hfile);
	fputs("#endif\n", hfile);
	fputs("\n", hfile);

	/* Generate the #define statements in the header file */
	fputs("/* Syntax classes */\n", hfile);

	putc('\n', hfile);
	fprintf(hfile, "#define SYNBASE %d\n", base);
	fprintf(hfile, "#define PEOF %d\n\n", -base);
	fprintf(hfile, "#define PEOA %d\n\n", -base + 1);
		fprintf(hfile, "#define UPEOF ((char)%d)\n\n", -base);
	else
		fprintf(hfile, "#define UPEOF ((unsigned char)%d)\n\n", -base);
	putc('\n', hfile);
	fputs("#define BASESYNTAX (basesyntax + SYNBASE)\n", hfile);
	fputs("#define DQSYNTAX (dqsyntax + SYNBASE)\n", hfile);

	add("$", "CVAR");
	add("}", "CENDVAR");
	add("<>();&| \t", "CSPCL");
	syntax[1] = "CSPCL";
	print("basesyntax");
	init();
	fputs("\n/* syntax table used when in double quotes */\n", cfile);
	add("\n", "CNL");
	add("\\", "CBACK");
	add("\"", "CENDQUOTE");
	add("`", "CBQUOTE");
	add("$", "CVAR");
	add("}", "CENDVAR");
	/* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */
	add("!*?[=~:/-]", "CCTL");
	print("dqsyntax");
	init();
	fputs("\n/* syntax table used when in single quotes */\n", cfile);
	add("\n", "CNL");
	add("'", "CENDQUOTE");
	/* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */
	add("!*?[=~:/-]\\", "CCTL");
	print("sqsyntax");
	init();
	fputs("\n/* syntax table used when in arithmetic */\n", cfile);
	add("\n", "CNL");
	add("\\", "CBACK");
	add("`", "CBQUOTE");
	add("'", "CSQUOTE");
	add("\"", "CDQUOTE");
	add("$", "CVAR");
	add("}", "CENDVAR");
	add("(", "CLP");

{
	filltable("CWORD");
	syntax[0] = "CEOF";
	syntax[1] = "CIGN";
#ifdef TARGET_CHAR
	syntax[base + (TARGET_CHAR)CTLESC] = "CCTL";
	syntax[base + (TARGET_CHAR)CTLVAR] = "CCTL";


static char *macro[] = {
	"#define is_digit(c)\t((is_type+SYNBASE)[c] & ISDIGIT)",
	"#define is_alpha(c)\t(((c) < CTLESC || (c) > CTLENDARI) && isalpha((unsigned char) (c)))",
	"#define is_name(c)\t(((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalpha((unsigned char) (c))))",
	"#define is_in_name(c)\t(((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalnum((unsigned char) (c))))",
	"#define is_special(c)\t((is_type+SYNBASE)[c] & (ISSPECL|ISDIGIT))",
	NULL
};

Lines 55-75 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mktokens (-15 / +15 lines)
55	TENDBQUOTE 1 "`"	55	TENDBQUOTE 1 "`"
56	TREDIR 0 redirection	56	TREDIR 0 redirection
57	TWORD 0 word	57	TWORD 0 word
58	TIF 0 "if"	58	TNOT 0 "!"
59	TTHEN 1 "then"	59	TCASE 0 "case"
60	TELSE 1 "else"	60	TDO 1 "do"
		61	TDONE 1 "done"
61	TELIF 1 "elif"	62	TELIF 1 "elif"
		63	TELSE 1 "else"
		64	TESAC 1 "esac"
62	TFI 1 "fi"	65	TFI 1 "fi"
63	TWHILE 0 "while"
64	TUNTIL 0 "until"
65	TFOR 0 "for"	66	TFOR 0 "for"
66	TDO 1 "do"	67	TIF 0 "if"
67	TDONE 1 "done"	68	TIN 0 "in"
		69	TTHEN 1 "then"
		70	TUNTIL 0 "until"
		71	TWHILE 0 "while"
68	TBEGIN 0 "{"	72	TBEGIN 0 "{"
69	TEND 1 "}"	73	TEND 1 "}"
70	TCASE 0 "case"
71	TESAC 1 "esac"
72	TNOT 0 "!"
73	!	74	!
74	nl=`wc -l /tmp/ka$$`	75	nl=`wc -l /tmp/ka$$`
75	exec > token.h	76	exec > token.h
Lines 87-96 Link Here
87	echo '};	88	echo '};
88	'	89	'
89	sed 's/"//g' /tmp/ka$$ \| awk '	90	sed 's/"//g' /tmp/ka$$ \| awk '
90	/TIF/{print "#define KWDOFFSET " NR-1; print "";	91	/TNOT/{print "#define KWDOFFSET " NR-1; print "";
91	print "const char *const parsekwd[] = {"}	92	print "STATIC const char *const parsekwd[] = {"}
92	/TIF/,/neverfound/{print " \"" $3 "\","}'	93	/TNOT/,/neverfound/{if (last) print " \"" last "\","; last = $3}
93	echo ' 0	94	END{print " \"" last "\"\n};"}'
94	};'
95		95
96	rm /tmp/ka$$	96	rm /tmp/ka$$

Lines 60-68 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mystring.c (-1 / +85 lines)
60	#include "syntax.h"	60	#include "syntax.h"
61	#include "error.h"	61	#include "error.h"
62	#include "mystring.h"	62	#include "mystring.h"
		63	#include "memalloc.h"
		64	#include "parser.h"
63		65
64		66
65	char nullstr[1]; /* zero length string */	67	char nullstr[1]; /* zero length string */
		68	const char spcstr[] = " ";
		69	const char snlfmt[] = "%s\n";
		70	const char dolatstr[] = { CTLVAR, VSNORMAL\|VSQUOTE, '@', '=', '\0' };
		71	const char illnum[] = "Illegal number: %s";
		72	const char homestr[] = "HOME";
66		73
67	/*	74	/*
68	* equal - #defined in mystring.h	75	* equal - #defined in mystring.h
Lines 73-78 Link Here
73	*/	80	*/
74		81
75		82
		83	#if 0
76	/*	84	/*
77	* scopyn - copy a string from "from" to "to", truncating the string	85	* scopyn - copy a string from "from" to "to", truncating the string
78	* if necessary. "To" is always nul terminated, even if	86	* if necessary. "To" is always nul terminated, even if
Lines 92-97 Link Here
92	}	100	}
93	*to = '\0';	101	*to = '\0';
94	}	102	}
		103	#endif
95		104
96		105
97	/*	106	/*
Lines 122-128 Link Here
122	{	131	{
123		132
124	if (! is_number(s))	133	if (! is_number(s))
125	error("Illegal number: %s", s);	134	error(illnum, s);
126	return atoi(s);	135	return atoi(s);
127	}	136	}
128		137
Lines 142-144 Link Here
142	} while (*++p != '\0');	151	} while (*++p != '\0');
143	return 1;	152	return 1;
144	}	153	}
		154
		155
		156	/*
		157	* Produce a possibly single quoted string suitable as input to the shell.
		158	* The return string is allocated on the stack.
		159	*/
		160
		161	char *
		162	single_quote(const char *s) {
		163	char *p;
		164
		165	STARTSTACKSTR(p);
		166
		167	do {
		168	char *q;
		169	size_t len;
		170
		171	len = strchrnul(s, '\'') - s;
		172
		173	q = p = makestrspace(len + 3, p);
		174
		175	*q++ = '\'';
		176	q = mempcpy(q, s, len);
		177	*q++ = '\'';
		178	s += len;
		179
		180	STADJUST(q - p, p);
		181
		182	len = strspn(s, "'");
		183	if (!len)
		184	break;
		185
		186	q = p = makestrspace(len + 3, p);
		187
		188	*q++ = '"';
		189	q = mempcpy(q, s, len);
		190	*q++ = '"';
		191	s += len;
		192
		193	STADJUST(q - p, p);
		194	} while (*s);
		195
		196	USTPUTC(0, p);
		197
		198	return stackblock();
		199	}
		200
		201	/*
		202	* Like strdup but works with the ash stack.
		203	*/
		204
		205	char *
		206	sstrdup(const char *p)
		207	{
		208	size_t len = strlen(p) + 1;
		209	return memcpy(stalloc(len), p, len);
		210	}
		211
		212	/*
		213	* Wrapper around strcmp for qsort/bsearch/...
		214	*/
		215	int
		216	pstrcmp(const void a, const void b)
		217	{
218	return strcmp((const char const ) a, (const char const ) b);
219	}
220
221	/*
222	* Find a string is in a sorted array.
223	*/
224	const char const
225	findstring(const char s, const char const *array, size_t nmemb)
226	{
227	return bsearch(&s, array, nmemb, sizeof(const char *), pstrcmp);
228	}

Lines 40-49 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mystring.h (+13 lines)
40		40
41	#include <string.h>	41	#include <string.h>
42		42
		43	extern const char snlfmt[];
		44	extern const char spcstr[];
		45	extern const char dolatstr[];
		46	#define DOLATSTRLEN 4
		47	extern const char illnum[];
		48	extern const char homestr[];
		49
		50	#if 0
43	void scopyn __P((const char , char , int));	51	void scopyn __P((const char , char , int));
		52	#endif
44	int prefix __P((const char , const char ));	53	int prefix __P((const char , const char ));
45	int number __P((const char *));	54	int number __P((const char *));
46	int is_number __P((const char *));	55	int is_number __P((const char *));
		56	char single_quote __P((const char ));
		57	char sstrdup __P((const char ));
		58	int pstrcmp __P((const void , const void ));
		59	const char const findstring __P((const char , const char const *, size_t));
47		60
48	#define equal(s1, s2) (strcmp(s1, s2) == 0)	61	#define equal(s1, s2) (strcmp(s1, s2) == 0)
49	#define scopy(s1, s2) ((void)strcpy(s2, s1))	62	#define scopy(s1, s2) ((void)strcpy(s2, s1))




 * Make a copy of a parse tree.
 */

struct funcnode *
copyfunc(union node *n)
	union node *n;
{
	struct funcnode *f;
	size_t blocksize;

	funcblocksize = offsetof(struct funcnode, n);
	funcstringsize = 0;
	calcsize(n);
	blocksize = funcblocksize;
	f = ckmalloc(blocksize + funcstringsize);
	funcblock = (char *) f + offsetof(struct funcnode, n);
	funcstring = (char *) f + blocksize;
	copynode(n);
	f->count = 0;
	return f;
}



nodesavestr(s)
	char   *s;
{
#ifdef _GNU_SOURCE
	char   *rtn = funcstring;

	funcstring = stpcpy(funcstring, s) + 1;
	return rtn;
#else
	register char *p = s;
	register char *q = funcstring;
	char   *rtn = funcstring;

		continue;
	funcstring = q;
	return rtn;
#endif
}



 */

void
freefunc(struct funcnode *f)
	union node *n;
{
	if (f && --f->count < 0)
		ckfree(f);
}




# The last two types should be followed by the text of a C declaration for
# the field.

NSEMI nbinary			# two commands separated by a semicolon
	type	  int
	ch1	  nodeptr		# the first child
	ch2	  nodeptr		# the second child

NCMD ncmd			# a simple command
	type	  int
	assign    nodeptr		# variable assignments
	args	  nodeptr		# the arguments
	redirect  nodeptr		# list of file redirections


NAND nbinary			# the && operator
NOR nbinary			# the || operator

NSEMI nbinary			# two commands separated by a semicolon
	type	  int
	ch1	  nodeptr		# the first child
	ch2	  nodeptr		# the second child

NIF nif				# the if statement.  Elif clauses are handled
	type	  int		    # using multiple if nodes.
	test	  nodeptr		# if test





char *minusc;			/* argument to -c option */

static const char *const optnames[NOPTS] = {
	"errexit",
	"noglob",
	"ignoreeof",
	"interactive",
	"monitor",
	"noexec",
	"stdin",
	"xtrace",
	"verbose",
	"vi",
	"emacs",
	"noclobber",
	"allexport",
	"notify",
	"nounset",
	"quietprofile",
};

const char optletters[NOPTS] = {
	'e',
	'f',
	'I',
	'i',
	'm',
	'n',
	's',
	'x',
	'v',
	'V',
	'E',
	'C',
	'a',
	'b',
	'u',
	'q',
};

char optlist[NOPTS];


STATIC void options __P((int));
STATIC void minus_o __P((char *, int));
STATIC void setoption __P((int, int));
STATIC int getopts __P((char *, char *, char **, int *, int *));


/*

	if (argc > 0)
		argptr++;
	for (i = 0; i < NOPTS; i++)
		optlist[i] = 2;
	options(1);
	if (*argptr == NULL && minusc == NULL)
		sflag = 1;

	if (mflag == 2)
		mflag = iflag;
	for (i = 0; i < NOPTS; i++)
		if (optlist[i] == 2)
			optlist[i] = 0;
	arg0 = argv[0];
	if (sflag == 0 && minusc == NULL) {
		commandname = argv[0];
		arg0 = *argptr++;
		setinputfile(arg0, 0);
		commandname = arg0;
	}
	/* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
	if (*argptr) {
		char *p = *argptr++;
		if (!minusc)
			setinputfile(p, 0);
		arg0 = p;
	}
	if (!sflag)
		commandname = arg0;

	shellparam.p = argptr;
	shellparam.optind = 1;
	shellparam.optoff = -1;
	/* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
	while (*argptr) {
		shellparam.nparam++;

	if (name == NULL) {
		out1str("Current option settings\n");
		for (i = 0; i < NOPTS; i++)
			out1fmt("%-16s%s\n", optnames[i],
				optlist[i] ? "on" : "off");
	} else {
		for (i = 0; i < NOPTS; i++)
			if (equal(name, optnames[i])) {
				setoption(optletters[i], val);
				return;
			}
		error("Illegal option -o %s", name);

	int i;

	for (i = 0; i < NOPTS; i++)
		if (optletters[i] == flag) {
			optlist[i] = val;
			if (val) {
				/* #%$ hack for ksh semantics */
				if (flag == 'V')




#ifdef mkinit
INCLUDE "options.h"

SHELLPROC {
	int i;

	for (i = 0; i < NOPTS; i++)
		optlist[i].val = 0;
	optschanged();

}
#endif


/*
 * Set the shell parameters.
 */

	shellparam.malloc = 1;
	shellparam.nparam = nparam;
	shellparam.p = newparam;
	shellparam.optind = 1;
	shellparam.optoff = -1;
}



	}
	ap2 = shellparam.p;
	while ((*ap2++ = *ap1++) != NULL);
	shellparam.optind = 1;
	shellparam.optoff = -1;
	INTON;
	return 0;
}

getoptsreset(value)
	const char *value;
{
	shellparam.optind = number(value);
	shellparam.optoff = -1;
		shellparam.reset = 1;
	}
}

/*


	if (argc < 3)
		error("Usage: getopts optstring var [arg]");
	else if (argc == 3) {
		optbase = shellparam.p;
		if (shellparam.optind > shellparam.nparam + 1) {
			shellparam.optind = 1;
			shellparam.optoff = -1;
		}
	}
	else {
		optbase = &argv[3];
		if (shellparam.optind > argc - 2) {
			shellparam.optind = 1;
			shellparam.optoff = -1;
		}
		shellparam.reset = 0;
	}

	return getopts(argv[1], argv[2], optbase, &shellparam.optind,
		       &shellparam.optoff);
}

STATIC int
getopts(optstr, optvar, optfirst, optind, optoff)
	char *optstr;
	char *optvar;
	char **optfirst;
	int *optind;
	int *optoff;
{
	char *p, *q;
	char c = '?';
	int done = 0;
	int ind = 0;
	int err = 0;
	char s[10];
	char **optnext = optfirst + *optind - 1;

	if (*optind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
	    strlen(*(optnext - 1)) < *optoff)
		p = NULL;
	else
		p = *(optnext - 1) + *optoff;
	if (p == NULL || *p == '\0') {
		/* Current word is done, advance */
		if (optnext == NULL)
			return 1;
		p = *optnext;
		if (p == NULL || *p != '-' || *++p == '\0') {
atend:
			*optind = optnext - optfirst + 1;
			*optnext = NULL;
			p = NULL;
			done = 1;
			goto out;
		}
		optnext++;
		if (p[0] == '-' && p[1] == '\0')	/* check for "--" */
			goto atend;
	}

	}

	if (*++q == ':') {
		if (*p == '\0' && (p = *optnext) == NULL) {
			if (optstr[0] == ':') {
				s[0] = c;
				s[1] = '\0';

			goto bad;
		}

		if (p == *optnext)
			optnext++;
		setvarsafe("OPTARG", p, 0);
		p = NULL;
	}
	else
		setvarsafe("OPTARG", nullstr, 0);
	*optind = optnext - optfirst + 1;
	goto out;

bad:
	*optind = 1;
	*optnext = NULL;
	p = NULL;
out:
	*optoff = p ? p - *(optnext - 1) : -1;
	fmtstr(s, sizeof(s), "%d", *optind);
	err |= setvarsafe("OPTIND", s, VNOFUNC);
	s[0] = c;
	s[1] = '\0';
	err |= setvarsafe(optvar, s, 0);
	if (err) {
		*optind = 1;
		*optoff = -1;
		flushall();
		exraise(EXERROR);
	}




struct shparam {
	int nparam;		/* # of positional parameters (without $0) */
	unsigned char malloc;	/* if parameter list dynamically allocated */
	unsigned char reset;	/* if getopts has been reset */
	char **p;		/* parameter list */
	int optind;		/* next parameter to be processed by getopts */
	int optoff;		/* used by getopts */
};



#define eflag optlist[0]
#define fflag optlist[1]
#define Iflag optlist[2]
#define iflag optlist[3]
#define mflag optlist[4]
#define nflag optlist[5]
#define sflag optlist[6]
#define xflag optlist[7]
#define vflag optlist[8]
#define Vflag optlist[9]
#define	Eflag optlist[10]
#define	Cflag optlist[11]
#define	aflag optlist[12]
#define	bflag optlist[13]
#define	uflag optlist[14]
#define	qflag optlist[15]

#define NOPTS	16

extern const char optletters[NOPTS];
extern char optlist[NOPTS];
	const char letter;
	char val;
};

#ifdef DEFINE_OPTIONS
struct optent optlist[NOPTS] = {
	{ "errexit",	'e',	0 },
	{ "noglob",	'f',	0 },
	{ "ignoreeof",	'I',	0 },
	{ "interactive",'i',	0 },
	{ "monitor",	'm',	0 },
	{ "noexec",	'n',	0 },
	{ "stdin",	's',	0 },
	{ "xtrace",	'x',	0 },
	{ "verbose",	'v',	0 },
	{ "vi",		'V',	0 },
	{ "emacs",	'E',	0 },
	{ "noclobber",	'C',	0 },
	{ "allexport",	'a',	0 },
	{ "notify",	'b',	0 },
	{ "nounset",	'u',	0 },
	{ "quietprofile", 'q',	0 },
};
#else
extern struct optent optlist[NOPTS];
#endif


extern char *minusc;		/* argument to -c option */

Lines 1-4 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/output.c (-388 / +200 lines)
1	/* $NetBSD: output.c,v 1.25 2002/04/09 00:52:05 thorpej Exp $ */	1	/* $NetBSD: output.c,v 1.26 2002/05/25 23:09:06 wiz Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 1991, 1993	4	* Copyright (c) 1991, 1993
Lines 41-47 Link Here
41	#if 0	41	#if 0
42	static char sccsid[] = "@(#)output.c 8.2 (Berkeley) 5/4/95";	42	static char sccsid[] = "@(#)output.c 8.2 (Berkeley) 5/4/95";
43	#else	43	#else
44	__RCSID("$NetBSD: output.c,v 1.25 2002/04/09 00:52:05 thorpej Exp $");	44	__RCSID("$NetBSD: output.c,v 1.26 2002/05/25 23:09:06 wiz Exp $");
45	#endif	45	#endif
46	#endif /* not lint */	46	#endif /* not lint */
47		47
Lines 65-70 Link Here
65	#include <errno.h>	65	#include <errno.h>
66	#include <unistd.h>	66	#include <unistd.h>
67	#include <stdlib.h>	67	#include <stdlib.h>
		68	#ifdef USE_GLIBC_STDIO
		69	#include <fcntl.h>
		70	#endif
		71	#include <limits.h>
68		72
69	#include "shell.h"	73	#include "shell.h"
70	#include "syntax.h"	74	#include "syntax.h"
Lines 74-142 Link Here
74		78
75		79
76	#define OUTBUFSIZ BUFSIZ	80	#define OUTBUFSIZ BUFSIZ
77	#define BLOCK_OUT -2 /* output to a fixed block of memory */
78	#define MEM_OUT -3 /* output to dynamically allocated memory */	81	#define MEM_OUT -3 /* output to dynamically allocated memory */
79	#define OUTPUT_ERR 01 /* error occurred on output */
80		82
81		83
82	struct output output = {NULL, 0, NULL, OUTBUFSIZ, 1, 0};	84	#ifdef USE_GLIBC_STDIO
83	struct output errout = {NULL, 0, NULL, 100, 2, 0};	85	struct output output = {
84	struct output memout = {NULL, 0, NULL, 0, MEM_OUT, 0};	86	stream: 0, nextc: 0, end: 0, buf: 0, bufsize: 0, fd: 1, flags: 0
		87	};
		88	struct output errout = {
		89	stream: 0, nextc: 0, end: 0, buf: 0, bufsize: 0, fd: 2, flags: 0
		90	}
		91	#ifdef notyet
		92	struct output memout = {
		93	stream: 0, nextc: 0, end: 0, buf: 0, bufsize: 0, fd: MEM_OUT, flags: 0
		94	};
		95	#endif
		96	#else
		97	struct output output = {
		98	nextc: 0, end: 0, buf: 0, bufsize: OUTBUFSIZ, fd: 1, flags: 0
		99	};
		100	struct output errout = {
		101	nextc: 0, end: 0, buf: 0, bufsize: 0, fd: 2, flags: 0
		102	};
		103	#ifdef notyet
		104	struct output memout = {
		105	nextc: 0, end: 0, buf: 0, bufsize: 0, fd: MEM_OUT, flags: 0
		106	};
		107	#endif
		108	#endif
85	struct output *out1 = &output;	109	struct output *out1 = &output;
86	struct output *out2 = &errout;	110	struct output *out2 = &errout;
87		111
88		112
		113	#ifndef USE_GLIBC_STDIO
		114	static void __outstr(const char , size_t, struct output );
		115	#endif
		116	static int xvsnprintf(char , size_t, const char , va_list);
		117
89		118
90	#ifdef mkinit	119	#ifdef mkinit
91		120
92	INCLUDE "output.h"	121	INCLUDE "output.h"
93	INCLUDE "memalloc.h"	122	INCLUDE "memalloc.h"
94		123
		124	INIT {
		125	#ifdef USE_GLIBC_STDIO
		126	initstreams();
		127	#endif
		128	}
		129
95	RESET {	130	RESET {
		131	#ifdef notyet
96	out1 = &output;	132	out1 = &output;
97	out2 = &errout;	133	out2 = &errout;
		134	#ifdef USE_GLIBC_STDIO
		135	if (memout.stream != NULL)
		136	__closememout();
		137	#endif
98	if (memout.buf != NULL) {	138	if (memout.buf != NULL) {
99	ckfree(memout.buf);	139	ckfree(memout.buf);
100	memout.buf = NULL;	140	memout.buf = NULL;
101	}	141	}
		142	#endif
102	}	143	}
103		144
104	#endif	145	#endif
105		146
106		147
107	#ifdef notdef /* no longer used */	148	#ifndef USE_GLIBC_STDIO
108	/*	149	static void
109	* Set up an output file to write to memory rather than a file.	150	__outstr(const char p, size_t len, struct output dest) {
110	*/	151	size_t bufsize;
111		152	size_t offset;
112	void	153	size_t nleft;
113	open_mem(block, length, file)
114	char *block;
115	int length;
116	struct output *file;
117	{
118	file->nextc = block;
119	file->nleft = --length;
120	file->fd = BLOCK_OUT;
121	file->flags = 0;
122	}
123	#endif
124		154
		155	nleft = dest->end - dest->nextc;
		156	if (nleft >= len) {
		157	buffered:
		158	dest->nextc = mempcpy(dest->nextc, p, len);
		159	return;
		160	}
125		161
126	void	162	bufsize = dest->bufsize;
127	out1str(p)	163	if (!bufsize) {
128	const char *p;	164	;
129	{	165	} else if (dest->buf == NULL) {
130	outstr(p, out1);	166	if (dest->fd == MEM_OUT && len > bufsize) {
131	}	167	bufsize = len;
		168	}
		169	offset = 0;
		170	goto alloc;
		171	} else if (dest->fd == MEM_OUT) {
		172	offset = bufsize;
		173	if (bufsize >= len) {
		174	bufsize <<= 1;
		175	} else {
		176	bufsize += len;
		177	}
		178	if (bufsize < offset)
		179	goto err;
		180	alloc:
		181	INTOFF;
		182	dest->buf = ckrealloc(dest->buf, bufsize);
		183	dest->bufsize = bufsize;
		184	dest->end = dest->buf + bufsize;
		185	dest->nextc = dest->buf + offset;
		186	INTON;
		187	} else {
		188	flushout(dest);
		189	}
132		190
		191	nleft = dest->end - dest->nextc;
		192	if (nleft > len)
		193	goto buffered;
133		194
134	void	195	if ((xwrite(dest->fd, p, len))) {
135	out2str(p)	196	err:
136	const char *p;	197	dest->flags \|= OUTPUT_ERR;
137	{	198	}
138	outstr(p, out2);
139	}	199	}
		200	#endif
140		201
141		202
142	void	203	void
Lines 144-194 Link Here
144	const char *p;	205	const char *p;
145	struct output *file;	206	struct output *file;
146	{	207	{
147	while (*p)	208	#ifdef USE_GLIBC_STDIO
148	outc(*p++, file);	209	INTOFF;
149	if (file == out2)	210	fputs(p, file->stream);
150	flushout(file);	211	INTON;
		212	#else
		213	size_t len;
		214
		215	len = strlen(p);
		216	__outstr(p, len, file);
		217	#endif
151	}	218	}
152		219
153		220
154	char out_junk[16];	221	#ifndef USE_GLIBC_STDIO
155		222
156		223
157	void	224	void
158	emptyoutbuf(dest)	225	outcslow(char c, struct output *dest)
159	struct output *dest;	226	{
160	{	227	__outstr(&c, 1, dest);
161	int offset;
162
163	if (dest->fd == BLOCK_OUT) {
164	dest->nextc = out_junk;
165	dest->nleft = sizeof out_junk;
166	dest->flags \|= OUTPUT_ERR;
167	} else if (dest->buf == NULL) {
168	INTOFF;
169	dest->buf = ckmalloc(dest->bufsize);
170	dest->nextc = dest->buf;
171	dest->nleft = dest->bufsize;
172	INTON;
173	} else if (dest->fd == MEM_OUT) {
174	offset = dest->bufsize;
175	INTOFF;
176	dest->bufsize <<= 1;
177	dest->buf = ckrealloc(dest->buf, dest->bufsize);
178	dest->nleft = dest->bufsize - offset;
179	dest->nextc = dest->buf + offset;
180	INTON;
181	} else {
182	flushout(dest);
183	}
184	dest->nleft--;
185	}	228	}
		229	#endif
186		230
187		231
188	void	232	void
189	flushall() {	233	flushall() {
190	flushout(&output);	234	flushout(&output);
		235	#ifdef FLUSHERR
191	flushout(&errout);	236	flushout(&errout);
		237	#endif
192	}	238	}
193		239
194		240
Lines 196-538 Link Here
196	flushout(dest)	242	flushout(dest)
197	struct output *dest;	243	struct output *dest;
198	{	244	{
		245	#ifdef USE_GLIBC_STDIO
		246	INTOFF;
		247	fflush(dest->stream);
		248	INTON;
		249	#else
		250	size_t len;
199		251
200	if (dest->buf == NULL \|\| dest->nextc == dest->buf \|\| dest->fd < 0)	252	len = dest->nextc - dest->buf;
		253	if (dest->buf == NULL \|\| !len \|\| dest->fd < 0)
201	return;	254	return;
202	if (xwrite(dest->fd, dest->buf, dest->nextc - dest->buf) < 0)
203	dest->flags \|= OUTPUT_ERR;
204	dest->nextc = dest->buf;	255	dest->nextc = dest->buf;
205	dest->nleft = dest->bufsize;	256	if ((xwrite(dest->fd, dest->buf, len)))
206	}	257	dest->flags \|= OUTPUT_ERR;
207		258	#endif
208
209	void
210	freestdout() {
211	INTOFF;
212	if (output.buf) {
213	ckfree(output.buf);
214	output.buf = NULL;
215	output.nleft = 0;
216	}
217	INTON;
218	}	259	}
219		260
220		261
221	void	262	void
222	#ifdef __STDC__
223	outfmt(struct output file, const char fmt, ...)	263	outfmt(struct output file, const char fmt, ...)
224	#else
225	void
226	outfmt(va_alist)
227	va_dcl
228	#endif
229	{	264	{
230	va_list ap;	265	va_list ap;
231	#ifndef __STDC__
232	struct output *file;
233	const char *fmt;
234		266
235	va_start(ap);
236	file = va_arg(ap, struct output *);
237	fmt = va_arg(ap, const char *);
238	#else
239	va_start(ap, fmt);	267	va_start(ap, fmt);
240	#endif
241	doformat(file, fmt, ap);	268	doformat(file, fmt, ap);
242	va_end(ap);	269	va_end(ap);
243	}	270	}
244		271
245		272
246	void	273	void
247	#ifdef __STDC__
248	out1fmt(const char *fmt, ...)	274	out1fmt(const char *fmt, ...)
249	#else
250	out1fmt(va_alist)
251	va_dcl
252	#endif
253	{	275	{
254	va_list ap;	276	va_list ap;
255	#ifndef __STDC__
256	const char *fmt;
257		277
258	va_start(ap);
259	fmt = va_arg(ap, const char *);
260	#else
261	va_start(ap, fmt);	278	va_start(ap, fmt);
262	#endif
263	doformat(out1, fmt, ap);	279	doformat(out1, fmt, ap);
264	va_end(ap);	280	va_end(ap);
265	}	281	}
266		282
267	void
268	#ifdef __STDC__
269	dprintf(const char *fmt, ...)
270	#else
271	dprintf(va_alist)
272	va_dcl
273	#endif
274	{
275	va_list ap;
276	#ifndef __STDC__
277	const char *fmt;
278
279	va_start(ap);
280	fmt = va_arg(ap, const char *);
281	#else
282	va_start(ap, fmt);
283	#endif
284	doformat(out2, fmt, ap);
285	va_end(ap);
286	flushout(out2);
287	}
288		283
289	void	284	int
290	#ifdef __STDC__
291	fmtstr(char outbuf, size_t length, const char fmt, ...)	285	fmtstr(char outbuf, size_t length, const char fmt, ...)
292	#else
293	fmtstr(va_alist)
294	va_dcl
295	#endif
296	{	286	{
297	va_list ap;	287	va_list ap;
298	struct output strout;	288	int ret;
299	#ifndef __STDC__
300	char *outbuf;
301	size_t length;
302	const char *fmt;
303		289
304	va_start(ap);
305	outbuf = va_arg(ap, char *);
306	length = va_arg(ap, size_t);
307	fmt = va_arg(ap, const char *);
308	#else
309	va_start(ap, fmt);	290	va_start(ap, fmt);
310	#endif	291	ret = xvsnprintf(outbuf, length, fmt, ap);
311	strout.nextc = outbuf;
312	strout.nleft = length;
313	strout.fd = BLOCK_OUT;
314	strout.flags = 0;
315	doformat(&strout, fmt, ap);
316	outc('\0', &strout);
317	if (strout.flags & OUTPUT_ERR)
318	outbuf[length - 1] = '\0';
319	va_end(ap);	292	va_end(ap);
		293	return ret;
320	}	294	}
321		295
322	/*
323	* Formatted output. This routine handles a subset of the printf formats:
324	* - Formats supported: d, u, o, p, X, s, and c.
325	* - The x format is also accepted but is treated like X.
326	* - The l, ll and q modifiers are accepted.
327	* - The - and # flags are accepted; # only works with the o format.
328	* - Width and precision may be specified with any format except c.
329	* - An * may be given for the width or precision.
330	* - The obsolete practice of preceding the width with a zero to get
331	* zero padding is not supported; use the precision field.
332	* - A % may be printed by writing %% in the format string.
333	*/
334
335	#define TEMPSIZE 24
336
337	#ifdef BSD4_4
338	#define HAVE_VASPRINTF 1
339	#endif
340		296
		297	#ifndef USE_GLIBC_STDIO
341	void	298	void
342	doformat(dest, f, ap)	299	doformat(dest, f, ap)
343	struct output *dest;	300	struct output *dest;
344	const char f; / format string */	301	const char f; / format string */
345	va_list ap;	302	va_list ap;
346	{	303	{
347	#if HAVE_VASPRINTF	304	struct stackmark smark;
348	char *s;	305	char *s;
		306	int len, ret;
		307	size_t size;
		308	va_list ap2;
349		309
350	vasprintf(&s, f, ap);	310	va_copy(ap2, ap);
351	outstr(s, dest);	311	size = dest->end - dest->nextc;
352	free(s);	312	len = xvsnprintf(dest->nextc, size, f, ap2);
353	#else /* !HAVE_VASPRINTF */	313	va_end(ap2);
354	static const char digit[] = "0123456789ABCDEF";	314	if (len < 0) {
355	char c;	315	dest->flags \|= OUTPUT_ERR;
356	char temp[TEMPSIZE];	316	return;
357	int flushleft;
358	int sharp;
359	int width;
360	int prec;
361	int islong;
362	int isquad;
363	char *p;
364	int sign;
365	#ifdef BSD4_4
366	quad_t l;
367	u_quad_t num;
368	#else
369	long l;
370	u_long num;
371	#endif
372	unsigned base;
373	int len;
374	int size;
375	int pad;
376
377	while ((c = *f++) != '\0') {
378	if (c != '%') {
379	outc(c, dest);
380	continue;
381	}
382	flushleft = 0;
383	sharp = 0;
384	width = 0;
385	prec = -1;
386	islong = 0;
387	isquad = 0;
388	for (;;) {
389	if (*f == '-')
390	flushleft++;
391	else if (*f == '#')
392	sharp++;
393	else
394	break;
395	f++;
396	}
397	if (f == '') {
398	width = va_arg(ap, int);
399	f++;
400	} else {
401	while (is_digit(*f)) {
402	width = 10 * width + digit_val(*f++);
403	}
404	}
405	if (*f == '.') {
406	if (++f == '') {
407	prec = va_arg(ap, int);
408	f++;
409	} else {
410	prec = 0;
411	while (is_digit(*f)) {
412	prec = 10 * prec + digit_val(*f++);
413	}
414	}
415	}
416	if (*f == 'l') {
417	f++;
418	if (*f == 'l') {
419	isquad++;
420	f++;
421	} else
422	islong++;
423	} else if (*f == 'q') {
424	isquad++;
425	f++;
426	}	317	}
427	switch (*f) {	318	if (len < size) {
428	case 'd':	319	dest->nextc += len;
429	#ifdef BSD4_4	320	return;
430	if (isquad)
431	l = va_arg(ap, quad_t);
432	else
433	#endif
434	if (islong)
435	l = va_arg(ap, long);
436	else
437	l = va_arg(ap, int);
438	sign = 0;
439	num = l;
440	if (l < 0) {
441	num = -l;
442	sign = 1;
443	}	321	}
444	base = 10;	322	setstackmark(&smark);
445	goto number;	323	s = stalloc((len >= stackblocksize() ? len : stackblocksize()) + 1);
446	case 'u':	324	ret = xvsnprintf(s, len + 1, f, ap);
447	base = 10;	325	if (ret == len)
448	goto uns_number;	326	__outstr(s, len, dest);
449	case 'o':
450	base = 8;
451	goto uns_number;
452	case 'p':
453	outc('0', dest);
454	outc('x', dest);
455	/FALLTHROUGH/
456	case 'x':
457	/* we don't implement 'x'; treat like 'X' */
458	case 'X':
459	base = 16;
460	uns_number: /* an unsigned number */
461	sign = 0;
462	#ifdef BSD4_4
463	if (isquad)
464	num = va_arg(ap, u_quad_t);
465	else
466	#endif
467	if (islong)
468	num = va_arg(ap, unsigned long);
469	else	327	else
470	num = va_arg(ap, unsigned int);	328	dest->flags \|= OUTPUT_ERR;
471	number: /* process a number */	329	popstackmark(&smark);
472	p = temp + TEMPSIZE - 1;
473	*p = '\0';
474	while (num) {
475	*--p = digit[num % base];
476	num /= base;
477	}
478	len = (temp + TEMPSIZE - 1) - p;
479	if (prec < 0)
480	prec = 1;
481	if (sharp && *f == 'o' && prec <= len)
482	prec = len + 1;
483	pad = 0;
484	if (width) {
485	size = len;
486	if (size < prec)
487	size = prec;
488	size += sign;
489	pad = width - size;
490	if (flushleft == 0) {
491	while (--pad >= 0)
492	outc(' ', dest);
493	}
494	}
495	if (sign)
496	outc('-', dest);
497	prec -= len;
498	while (--prec >= 0)
499	outc('0', dest);
500	while (*p)
501	outc(*p++, dest);
502	while (--pad >= 0)
503	outc(' ', dest);
504	break;
505	case 's':
506	p = va_arg(ap, char *);
507	pad = 0;
508	if (width) {
509	len = strlen(p);
510	if (prec >= 0 && len > prec)
511	len = prec;
512	pad = width - len;
513	if (flushleft == 0) {
514	while (--pad >= 0)
515	outc(' ', dest);
516	}
517	}
518	prec++;
519	while (--prec != 0 && *p)
520	outc(*p++, dest);
521	while (--pad >= 0)
522	outc(' ', dest);
523	break;
524	case 'c':
525	c = va_arg(ap, int);
526	outc(c, dest);
527	break;
528	default:
529	outc(*f, dest);
530	break;
531	}
532	f++;
533	}
534	#endif /* !HAVE_VASPRINTF */
535	}	330	}
		331	#endif
536		332
537		333
538		334
Lines 541-587 Link Here
541	*/	337	*/
542		338
543	int	339	int
544	xwrite(fd, buf, nbytes)	340	xwrite(int fd, const void *p, size_t n)
545	int fd;	341	{
546	char *buf;	342	const char *buf = p;
547	int nbytes;
548	{
549	int ntry;
550	int i;
551	int n;
552		343
553	n = nbytes;	344	while (n) {
554	ntry = 0;	345	ssize_t i;
555	for (;;) {	346	size_t m;
556	i = write(fd, buf, n);	347
557	if (i > 0) {	348	m = n;
558	if ((n -= i) <= 0)	349	if (m > SSIZE_MAX)
559	return nbytes;	350	m = SSIZE_MAX;
560	buf += i;	351	do {
561	ntry = 0;	352	i = write(fd, buf, m);
562	} else if (i == 0) {	353	} while (i < 0 && errno == EINTR);
563	if (++ntry > 10)	354	if (i < 0)
564	return nbytes - n;
565	} else if (errno != EINTR) {
566	return -1;	355	return -1;
		356	buf += i;
		357	n -= i;
567	}	358	}
568	}	359	return 0;
569	}	360	}
570		361
571		362
572	/*	363	#ifdef notyet
573	* Version of ioctl that retries after a signal is caught.	364	#ifdef USE_GLIBC_STDIO
574	* XXX unused function	365	void initstreams() {
575	*/	366	output.stream = stdout;
		367	errout.stream = stderr;
		368	}
		369
		370
		371	void
		372	openmemout() {
		373	INTOFF;
		374	memout.stream = open_memstream(&memout.buf, &memout.bufsize);
		375	INTON;
		376	}
		377
576		378
577	int	379	int
578	xioctl(fd, request, arg)	380	__closememout() {
579	int fd;	381	int error;
580	unsigned long request;	382	error = fclose(memout.stream);
581	char * arg;	383	memout.stream = NULL;
		384	return error;
		385	}
		386	#endif
		387	#endif
		388
		389
		390	static int
		391	xvsnprintf(char outbuf, size_t length, const char fmt, va_list ap)
582	{	392	{
583	int i;	393	int ret;
584		394
585	while ((i = ioctl(fd, request, arg)) == -1 && errno == EINTR);	395	INTOFF;
586	return i;	396	ret = vsnprintf(outbuf, length, fmt, ap);
		397	INTON;
		398	return ret;
587	}	399	}




/*	$NetBSD: output.h,v 1.15 2002/05/25 23:13:26 wiz Exp $	*/

/*-
 * Copyright (c) 1991, 1993


#ifndef OUTPUT_INCL

#ifdef __STDC__
#include <stdarg.h>
#ifdef USE_GLIBC_STDIO
#include <stdio.h>
#endif
#include <sys/types.h>

struct output {
#ifdef USE_GLIBC_STDIO
	FILE *stream;
#endif
	char *nextc;
	char *end;
	char *buf;
	size_t bufsize;
	int fd;
	int flags;
};

extern struct output output;
extern struct output errout;
#ifdef notyet
extern struct output memout;
#endif
extern struct output *out1;
extern struct output *out2;

void open_mem __P((char *, int, struct output *));
void out1str __P((const char *));
void out2str __P((const char *));
void outstr __P((const char *, struct output *));
#ifndef USE_GLIBC_STDIO
void outcslow __P((char, struct output *));
#endif
void flushall __P((void));
void flushout __P((struct output *));
void freestdout __P((void));
void outfmt __P((struct output *, const char *, ...))
    __attribute__((__format__(__printf__,2,3)));
void out1fmt __P((const char *, ...))
    __attribute__((__format__(__printf__,1,2)));
int fmtstr __P((char *, size_t, const char *, ...))
    __attribute__((__format__(__printf__,1,2)));
void fmtstr __P((char *, size_t, const char *, ...))
    __attribute__((__format__(__printf__,3,4)));
#ifndef USE_GLIBC_STDIO
void doformat __P((struct output *, const char *, va_list));
#endif
int xwrite __P((int, const void *, size_t));
#ifdef notyet
#ifdef USE_GLIBC_STDIO
void initstreams __P((void));
void openmemout __P((void));
int __closememout __P((void));
#endif
#endif

static inline void
freestdout()
{
	output.nextc = output.buf;
	output.flags = 0;
}

#define OUTPUT_ERR 01		/* error occurred on output */

#ifdef USE_GLIBC_STDIO
#define outc(c, o)	putc((c), (o)->stream)
#define doformat(d, f, a)	vfprintf((d)->stream, (f), (a))
#else
#define outc(c, file)	((file)->nextc == (file)->end ? outcslow((c), (file)) : (*(file)->nextc = (c), (file)->nextc++))
#endif
#define out1c(c)	outc((c), out1)
#define out2c(c)	outc((c), out2)
#define out1str(s)	outstr((s), out1)
#define out2str(s)	outstr((s), out2)
#define outerr(f)	((f)->flags & OUTPUT_ERR)

#define OUTPUT_INCL
#endif




#include "expand.h"	/* defines rmescapes() */
#include "eval.h"	/* defines commandname */
#include "redir.h"	/* defines copyfd() */
#include "exec.h"	/* defines find_builtin() */
#include "syntax.h"
#include "options.h"
#include "input.h"

#include "mystring.h"
#include "alias.h"
#include "show.h"
#include "builtins.h"
#ifndef SMALL
#include "myhistedit.h"
#endif

/* values returned by readtoken */
#include "token.h"

#define OPENBRACE '{'
#define CLOSEBRACE '}'


struct heredoc {




static int noalias = 0;		/* when set, don't handle aliases */
struct heredoc *heredoclist;	/* list of here documents to read */
int parsebackquote;		/* nonzero if we are inside backquotes */
int doprompt;			/* if set, prompt the user */

int lasttoken;			/* last token read */
MKINIT int tokpushback;		/* last token pushed back */
char *wordtext;			/* text of last word returned by readtoken */
int checkkwd;
struct nodelist *backquotelist;
union node *redirnode;
struct heredoc *heredoc;

STATIC union node *andor __P((void));
STATIC union node *pipeline __P((void));
STATIC union node *command __P((void));
STATIC union node *simplecmd __P((void));
STATIC union node *makename __P((void));
STATIC void parsefname __P((void));
STATIC void parseheredoc __P((void));

STATIC void setprompt __P((int));


static inline int
goodname(const char *p)
{
	return !*endofname(p);
}

static inline int
isassignment(const char *p)
{
	const char *q = endofname(p);
	if (p == q)
		return 0;
	return *q == '=';
}


/*
 * Read and parse a command.  Returns NEOF on end of file.  (NULL is a
 * valid parse tree indicating a blank line.)

	tokpushback = 0;
	doprompt = interact;
	if (doprompt)
		setprompt(doprompt);
	else
		setprompt(0);
	needprompt = 0;
	t = readtoken();
	if (t == TEOF)

	union node *n1, *n2, *n3;
	int tok;

	checkkwd = CHKNL | CHKKWD | CHKALIAS;
	if (nlflag == 2 && tokendlist[peektoken()])
		return NULL;
	n1 = NULL;
	for (;;) {
		n2 = andor();
		tok = readtoken();
		if (tok == TBACKGND) {
			if (n2->type == NPIPE) {
				n2->npipe.backgnd = 1;
			} else if (n2->type == NREDIR) {
				n2->type = NBACKGND;
			} else {
				if (n2->type != NREDIR) {
					n3 = stalloc(sizeof(struct nredir));
				n3->nredir.n = n2;
				n3->nredir.redirect = NULL;
				n2 = n3;
			}
				n2->type = NBACKGND;
			}
		}
		if (n1 == NULL) {
			n1 = n2;

		case TNL:
			if (tok == TNL) {
				parseheredoc();
				if (nlflag == 1)
					return n1;
			} else {
				tokpushback++;
			}
			checkkwd = CHKNL | CHKKWD | CHKALIAS;
			if (tokendlist[peektoken()])
				return n1;
			break;

				pungetc();		/* push back EOF on input */
			return n1;
		default:
			if (nlflag == 1)
				synexpect(-1);
			tokpushback++;
			return n1;

			tokpushback++;
			return n1;
		}
		checkkwd = CHKNL | CHKKWD | CHKALIAS;
		n2 = pipeline();
		n3 = (union node *)stalloc(sizeof (struct nbinary));
		n3->type = t;


	negate = 0;
	TRACE(("pipeline: entered\n"));
	if (readtoken() == TNOT) {
		negate = !negate;
		checkkwd = CHKKWD | CHKALIAS;
	} else
	tokpushback++;
	n1 = command();
	if (readtoken() == TPIPE) {

		do {
			prev = lp;
			lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
			checkkwd = CHKNL | CHKKWD | CHKALIAS;
			lp->n = command();
			prev->next = lp;
		} while (readtoken() == TPIPE);

	union node *ap, **app;
	union node *cp, **cpp;
	union node *redir, **rpp;
	union node **rpp2;
	int t;

	checkkwd = 2;
	redir = NULL;
	rpp2 = &redir;
	rpp = &redir;

	/* Check for redirection which may precede command */
	while (readtoken() == TREDIR) {
		*rpp = n2 = redirnode;
		rpp = &n2->nfile.next;
		parsefname();
	}
	tokpushback++;

	while (readtoken() == TNOT) {
		TRACE(("command: TNOT recognized\n"));
		negate = !negate;
	}
	tokpushback++;

	switch (readtoken()) {
	default:
		synexpect(-1);
		/* NOTREACHED */
	case TIF:
		n1 = (union node *)stalloc(sizeof (struct nif));
		n1->type = NIF;

			n2->nif.elsepart = NULL;
			tokpushback++;
		}
		t = TFI;
			synexpect(TFI);
		checkkwd = 1;
		break;
	case TWHILE:
	case TUNTIL: {

			synexpect(TDO);
		}
		n1->nbinary.ch2 = list(0);
		t = TDONE;
			synexpect(TDONE);
		checkkwd = 1;
		break;
	}
	case TFOR:

		n1 = (union node *)stalloc(sizeof (struct nfor));
		n1->type = NFOR;
		n1->nfor.var = wordtext;
		checkkwd = CHKKWD | CHKALIAS;
		if (readtoken() == TIN) {
			app = &ap;
			while (readtoken() == TWORD) {
				n2 = (union node *)stalloc(sizeof (struct narg));

			if (lasttoken != TNL && lasttoken != TSEMI)
				synexpect(-1);
		} else {
			static char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE,
								   '@', '=', '\0'};
			n2 = (union node *)stalloc(sizeof (struct narg));
			n2->type = NARG;
			n2->narg.text = (char *)dolatstr;
			n2->narg.backquote = NULL;
			n2->narg.next = NULL;
			n1->nfor.args = n2;

			if (lasttoken != TNL && lasttoken != TSEMI)
				tokpushback++;
		}
		checkkwd = CHKNL | CHKKWD | CHKALIAS;
		if (readtoken() != TDO)
			synexpect(TDO);
		else if (t == TBEGIN)
			t = TEND;
		else
			synexpect(-1);
		n1->nfor.body = list(0);
		t = TDONE;
			synexpect(t);
		checkkwd = 1;
		break;
	case TCASE:
		n1 = (union node *)stalloc(sizeof (struct ncase));

		n2->narg.text = wordtext;
		n2->narg.backquote = backquotelist;
		n2->narg.next = NULL;
		while (readtoken() == TNL);
		if (lasttoken != TWORD || ! equal(wordtext, "in"))
			synerror("expecting \"in\"");
		cpp = &n1->ncase.cases;
		noalias = 1;
		checkkwd = 2, readtoken();
		do {
			checkkwd = CHKKWD | CHKALIAS;
		} while (readtoken() == TNL);
		if (lasttoken != TIN)
			synexpect(TIN);
		cpp = &n1->ncase.cases;
next_case:
		checkkwd = CHKNL | CHKKWD;
		t = readtoken();
		while(t != TESAC) {
			if (lasttoken == TLP)
				readtoken();
			*cpp = cp = (union node *)stalloc(sizeof (struct nclist));
			cp->type = NCLIST;
			app = &cp->nclist.pattern;

				ap->type = NARG;
				ap->narg.text = wordtext;
				ap->narg.backquote = backquotelist;
				if (readtoken() != TPIPE)
					break;
				app = &ap->narg.next;
				readtoken();
			}
			ap->narg.next = NULL;
			if (lasttoken != TRP)
			if (lasttoken != TRP) {
				synexpect(TRP);
			cp->nclist.body = list(2);
			cp->nclist.body = list(0);

			cpp = &cp->nclist.next;

			checkkwd = CHKNL | CHKKWD;
			if ((t = readtoken()) != TESAC) {
				if (t != TENDCASE)
					noalias = 0;
					synexpect(TENDCASE);
				else
					goto next_case;
					checkkwd = 2;
					readtoken();
				}
			}
			cpp = &cp->nclist.next;
		} while(lasttoken != TESAC);
		noalias = 0;
		*cpp = NULL;
		goto redir;
		break;
	case TLP:
		n1 = (union node *)stalloc(sizeof (struct nredir));
		n1->type = NSUBSHELL;
		n1->nredir.n = list(0);
		n1->nredir.redirect = NULL;
		t = TRP;
			synexpect(TRP);
		checkkwd = 1;
		break;
	case TBEGIN:
		n1 = list(0);
		t = TEND;
			synexpect(TEND);
		checkkwd = 1;
		break;
	/* Handle an empty command like other simple commands.  */
	case TSEMI:
		/*
		 * An empty command before a ; doesn't make much sense, and
		 * should certainly be disallowed in the case of `if ;'.
		 */
		if (!redir)
			synexpect(-1);
	case TAND:
	case TOR:
	case TNL:
	case TEOF:
	case TWORD:
	case TREDIR:
		tokpushback++;
		return simplecmd();
		goto checkneg;
	default:
		synexpect(-1);
		/* NOTREACHED */
	}

	if (readtoken() != t)
		synexpect(t);

redir:
	/* Now check for redirection which may follow command */
	checkkwd = CHKKWD | CHKALIAS;
	rpp = rpp2;
	while (readtoken() == TREDIR) {
		*rpp = n2 = redirnode;
		rpp = &n2->nfile.next;

		n1->nredir.redirect = redir;
	}

checkneg:
	if (negate) {
		n2 = (union node *)stalloc(sizeof (struct nnot));
		n2->type = NNOT;
		n2->nnot.com = n1;
		return n2;
	}
	else
		return n1;
}


STATIC union node *
simplecmd() {
	union node **rpp, *redir;
	{
	union node *args, **app;
	union node *n = NULL;
	union node *vars, **vpp;
	union node **rpp, *redir;
	int savecheckkwd;
	/* If we don't have any redirections already, then we must reset */
	/* rpp to be the address of the local redir variable.  */
	if (redir == 0)
		rpp = &redir;

	args = NULL;
	app = &args;
	vars = NULL;
	vpp = &vars;
	redir = NULL;
	rpp = &redir;
	 */
	orig_rpp = rpp;

	while (readtoken() == TNOT) {
		TRACE(("command: TNOT recognized\n"));
		negate = !negate;
	}
	tokpushback++;

	savecheckkwd = CHKALIAS;
	for (;;) {
		checkkwd = savecheckkwd;
		switch (readtoken()) {
		case TWORD:
			n = (union node *)stalloc(sizeof (struct narg));
			n->type = NARG;
			n->narg.text = wordtext;
			n->narg.backquote = backquotelist;
			if (savecheckkwd && isassignment(wordtext)) {
				*vpp = n;
				vpp = &n->narg.next;
			} else {
			*app = n;
			app = &n->narg.next;
				savecheckkwd = 0;
			}
			break;
		case TREDIR:
			*rpp = n = redirnode;
			rpp = &n->nfile.next;
			parsefname();	/* read name of redirection file */
			break;
		case TLP:
			if (
				args && app == &args->narg.next &&
				!vars && !redir
			) {
				struct builtincmd *bcmd;
				const char *name;

			/* We have a function */
			if (readtoken() != TRP)
				synexpect(TRP);
				name = n->narg.text;
				if (
					!goodname(name) || (
						(bcmd = find_builtin(name)) &&
						bcmd->flags & BUILTIN_SPECIAL
					)
				)
				synerror("Bad function name");
#endif
			n->type = NDEFUN;
				checkkwd = CHKNL | CHKKWD | CHKALIAS;
			n->narg.next = command();
				return n;
			}
			/* fall through */
		default:
			tokpushback++;
			goto out;
		}
	}
out:
	*app = NULL;
	*vpp = NULL;
	*rpp = NULL;
	n = (union node *)stalloc(sizeof (struct ncmd));
	n->type = NCMD;
	n->ncmd.backgnd = 0;
	n->ncmd.args = args;
	n->ncmd.assign = vars;
	n->ncmd.redirect = redir;

checkneg:
	if (negate) {
		n2 = (union node *)stalloc(sizeof (struct nnot));
		n2->type = NNOT;
		n2->nnot.com = n;
		return n2;
	}
	else
		return n;
}


	struct heredoc *here;
	union node *n;

	while (heredoclist) {
		here = heredoclist;
	heredoclist = 0;

	while (here) {
		if (needprompt) {
			setprompt(2);
			needprompt = 0;

		n->narg.text = wordtext;
		n->narg.backquote = backquotelist;
		here->here->nhere.doc = n;
		here = here->next;
	}
}


STATIC int
readtoken() {
	int t;
	int savecheckkwd = checkkwd;
#ifdef DEBUG
	int alreadyseen = tokpushback;
#endif
	struct alias *ap;

top:
	t = xxreadtoken();

	if (checkkwd) {
		/*
		 * eat newlines
		 */
	if (checkkwd & CHKNL) {
			checkkwd = 0;
			while (t == TNL) {
				parseheredoc();
				t = xxreadtoken();
			}
	}

	if (t != TWORD || quoteflag) {
		goto out;
	}

		/*
	 * check for keywords
		 */
	if (checkkwd & CHKKWD) {
		{
			const char *const *pp;

		if ((pp = findkwd(wordtext))) {
			lasttoken = t = pp - parsekwd + KWDOFFSET;
				{
					lasttoken = t = pp - 
					    parsekwd + KWDOFFSET;
					TRACE(("keyword %s recognized\n", tokname[t]));
					goto out;
				}
			}

	if (checkkwd & CHKALIAS) {
		struct alias *ap;
		if ((ap = lookupalias(wordtext, 1)) != NULL) {
			if (*ap->val) {
				pushstring(ap->val, ap);
			}
				goto top;
			}
		}
out:
	checkkwd = 0;
	}
#ifdef DEBUG
	if (!alreadyseen)
	    TRACE(("token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));

	startlinno = plinno;
	for (;;) {	/* until token or start of word found */
		c = pgetc_macro();
		if (c == ' ' || c == '\t')
			continue;		/* quick check for white space first */
		switch (c) {
		case ' ': case '\t':
		case PEOA:
			continue;
		case '#':
			while ((c = pgetc()) != '\n' && c != PEOF);

				startlinno = ++plinno;
				if (doprompt)
					setprompt(2);
				else
					setprompt(0);
				continue;
			}
			pungetc();

#define PARSEBACKQNEW()	{oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
#define	PARSEARITH()	{goto parsearith; parsearith_return:;}

/*
 * Keep track of nested doublequotes in dblquote and doublequotep.
 * We use dblquote for the first 32 levels, and we expand to a malloc'ed
 * region for levels above that. Usually we never need to malloc.
 * This code assumes that an int is 32 bits. We don't use uint32_t,
 * because the rest of the code does not.
 */
#define ISDBLQUOTE() ((varnest < 32) ? (dblquote & (1 << varnest)) : \
    (dblquotep[(varnest / 32) - 1] & (1 << (varnest % 32))))

#define SETDBLQUOTE() \
    if (varnest < 32) \
	dblquote |= (1 << varnest); \
    else \
	dblquotep[(varnest / 32) - 1] |= (1 << (varnest % 32))

#define CLRDBLQUOTE() \
    if (varnest < 32) \
	dblquote &= ~(1 << varnest); \
    else \
	dblquotep[(varnest / 32) - 1] &= ~(1 << (varnest % 32))

STATIC int
readtoken1(firstc, syntax, eofmark, striptabs)
	int firstc;

	char line[EOFMARKLEN + 1];
	struct nodelist *bqlist;
	int quotef;
	int *dblquotep = NULL;
	size_t maxnest = 32;
	int dblquote;
	int varnest;	/* levels of variables expansion */
	int arinest;	/* levels of arithmetic expansion */
	int parenlevel;	/* levels of parens in arithmetic */
	int dqvarnest;	/* levels of variables expansion within double quotes */
	int oldstyle;
	char const *prevsyntax;	/* syntax before arithmetic */
#if __GNUC__
	/* Avoid longjmp clobbering */
	(void) &maxnest;
	(void) &dblquotep;
	(void) &out;
	(void) &quotef;
	(void) &dblquote;
	(void) &varnest;
	(void) &arinest;
	(void) &parenlevel;
	(void) &dqvarnest;
	(void) &oldstyle;
	(void) &prevsyntax;
	(void) &syntax;


	startlinno = plinno;
	dblquote = 0;
	if (syntax == DQSYNTAX)
		dblquote = 1;
		SETDBLQUOTE();
	}
	quotef = 0;
	bqlist = NULL;
	varnest = 0;
	arinest = 0;
	parenlevel = 0;
	dqvarnest = 0;

	STARTSTACKSTR(out);
	loop: {	/* for each line, until end of word */

#endif
		CHECKEND();	/* set c to PEOF if at end of here document */
		for (;;) {	/* until end of line or end of word */
			CHECKSTRSPACE(4, out);	/* permit 4 calls to USTPUTC */
			switch(syntax[c]) {
			case CNL:	/* '\n' */
				if (syntax == BASESYNTAX)

				plinno++;
				if (doprompt)
					setprompt(2);
				else
					setprompt(0);
				c = pgetc();
				goto loop;		/* continue outer loop */
			case CWORD:
				USTPUTC(c, out);
				break;
			case CCTL:
				if (eofmark == NULL || dblquote)
					USTPUTC(CTLESC, out);
				USTPUTC(c, out);
				break;
			case CBACK:	/* backslash */
				c = pgetc2();
				if (c == PEOF) {
					USTPUTC(CTLESC, out);
					USTPUTC('\\', out);
					pungetc();
				} else if (c == '\n') {
					if (doprompt)
						setprompt(2);
					else
						setprompt(0);
				} else {
					if (
						dblquote &&
						c != '\\' && c != '`' &&
						c != '$' && (
							c != '"' ||
							eofmark != NULL
						)
					) {
						USTPUTC(CTLESC, out);
						USTPUTC('\\', out);
					}
					if (SQSYNTAX[c] == CCTL)
						USTPUTC(CTLESC, out);
					else if (eofmark == NULL)
						USTPUTC(CTLQUOTEMARK, out);
					USTPUTC(c, out);
					quotef++;
				}
				break;
			case CSQUOTE:
				if (syntax != SQSYNTAX) {
				    if (eofmark == NULL)
					    USTPUTC(CTLQUOTEMARK, out);
				    syntax = SQSYNTAX;
quotemark:
				if (eofmark == NULL) {
					USTPUTC(CTLQUOTEMARK, out);
				}
				break;
			case CDQUOTE:
				syntax = DQSYNTAX;
				dblquote = 1;
				goto quotemark;
			case CENDQUOTE:
				if (eofmark != NULL && arinest == 0 &&
				    varnest == 0) {
					USTPUTC(c, out);
				} else {
					if (dqvarnest == 0) {
						if (c != '"' || ISDBLQUOTE()) {
							syntax = ARISYNTAX;
							CLRDBLQUOTE();
						} else {
							syntax = DQSYNTAX;
							SETDBLQUOTE();
							USTPUTC(CTLQUOTEMARK, out);
						}
					} else if (eofmark == NULL) {
						if (c != '"' || ISDBLQUOTE()) {
							syntax = BASESYNTAX;
						dblquote = 0;
						} else {
							syntax = DQSYNTAX;
							SETDBLQUOTE();
							USTPUTC(CTLQUOTEMARK, out);
						}
					}
					quotef++;
					goto quotemark;
				}
				break;
			case CVAR:	/* '$' */
				PARSESUB();		/* parse substitution */
				break;
			case CENDVAR:	/* '}' */
				if (varnest > 0) {
					varnest--;
					if (dqvarnest > 0) {
						dqvarnest--;
					}
					USTPUTC(CTLENDVAR, out);
				} else {
					USTPUTC(c, out);

							USTPUTC(CTLENDARI, out);
							syntax = prevsyntax;
							if (syntax == DQSYNTAX)
								dblquote = 1;
							else
								dblquote = 0;
						} else
							USTPUTC(')', out);
					} else {

				break;
			case CEOF:
				goto endword;		/* exit outer loop */
			case CIGN:
				break;
			default:
				if (varnest == 0)
					goto endword;	/* exit outer loop */
				if (c != PEOA) {
				USTPUTC(c, out);
			}
			}
			c = pgetc_macro();
		}
	}

	backquotelist = bqlist;
	grabstackblock(len);
	wordtext = out;
	if (dblquotep != NULL)
	    ckfree(dblquotep);
	return lasttoken = TWORD;
/* end of readtoken routine */



checkend: {
	if (eofmark) {
		if (c == PEOA) {
			c = pgetc2();
		}
		if (striptabs) {
			while (c == '\t') {
				c = pgetc2();
			}
		}
		if (c == *eofmark) {
			if (pfgets(line, sizeof line) != NULL) {

					plinno++;
					needprompt = doprompt;
				} else {
					pushstring(line, NULL);
				}
			}
		}

	static const char types[] = "}-+?=";

	c = pgetc();
	if (
		c <= PEOA  ||
		(c != '(' && c != '{' && !is_name(c) && !is_special(c))
	) {
		USTPUTC('$', out);
		pungetc();
	} else if (c == '(') {	/* $(command) or $((arith)) */

		typeloc = out - stackblock();
		USTPUTC(VSNORMAL, out);
		subtype = VSNORMAL;
		if (c == '{') {
			c = pgetc();
			if (c == '#') {
				if ((c = pgetc()) == '}')
					c = '#';
				else
					subtype = VSLENGTH;

			else
				subtype = 0;
		}
		if (c > PEOA && is_name(c)) {
			do {
				STPUTC(c, out);
				c = pgetc();
			} while (c > PEOA && is_in_name(c));
		} else if (is_digit(c)) {
			do {
				USTPUTC(c, out);

		} else {
			pungetc();
		}
		if (dblquote || arinest)
			flags |= VSQUOTE;
		*(stackblock() + typeloc) = subtype | flags;
		if (subtype != VSNORMAL) {
			varnest++;
			if (dblquote || arinest) {
				dqvarnest++;
				dblquotep[(maxnest / 32) - 1] = 0;
				maxnest += 32;
			}
		}
	}

	char *volatile str;
	struct jmploc jmploc;
	struct jmploc *volatile savehandler;
	size_t savelen;
	int saveprompt;
#ifdef __GNUC__
	(void) &saveprompt;

                   reread it as input, interpreting it normally.  */
                char *pout;
                int pc;
                size_t psavelen;
                char *pstr;



					plinno++;
					if (doprompt)
						setprompt(2);
					else
						setprompt(0);
					/*
					 * If eating a newline, avoid putting
					 * the newline into the new character

					continue;
				}
                                if (pc != '\\' && pc != '`' && pc != '$'
                                    && (!dblquote || pc != '"'))
                                        STPUTC('\\', pout);
				if (pc > PEOA) {
				break;
				}
				/* fall through */
				plinno++;
				needprompt = doprompt;
				break;

			case PEOF:
			case PEOA:
			        startlinno = plinno;
				synerror("EOF in backquote substitution");

			case '\n':
				plinno++;
				needprompt = doprompt;
 				break;

			default:

                psavelen = pout - stackblock();
                if (psavelen > 0) {
			pstr = grabstackstr(pout);
			setinputstring(pstr);
                }
        }
	nlpp = &bqlist;

		doprompt = 0;
	}

	n = list(2);

	if (oldstyle)
		doprompt = saveprompt;

	}
	parsebackquote = savepbq;
	handler = savehandler;
	if (arinest || dblquote)
		USTPUTC(CTLBACKQ | CTLQUOTE, out);
	else
		USTPUTC(CTLBACKQ, out);

		prevsyntax = syntax;
		syntax = ARISYNTAX;
		USTPUTC(CTLARI, out);
		if (dblquote)
			USTPUTC('"',out);
		else
			USTPUTC(' ',out);



#ifdef mkinit
INCLUDE "parser.h"
RESET {
	tokpushback = 0;
	checkkwd = 0;



/*
 * Return of a legal variable name (a letter or underscore followed by zero or
 * more letters, underscores, and digits).
 */

char *
endofname(const char *name)
	{
	char *p;

	p = (char *) name;
	if (! is_name(*p))
		return p;
	while (*++p) {
		if (! is_in_name(*p))
			break;
	}
	return p;
}





STATIC void
synerror(const char *msg)
{
	error("Syntax error: %s", msg);
	if (commandname)
		outfmt(&errout, "%s: %d: ", commandname, startlinno);
	outfmt(&errout, "Syntax error: %s\n", msg);
	error((char *)NULL);
	/* NOTREACHED */
}


	{
	switch (whichprompt) {
	case 0:
		return nullstr;
	case 1:
		return ps1val();
	case 2:

		return "<internal prompt error>";
	}
}

const char *const *
findkwd(const char *s) {
	return findstring(
		s, parsekwd, sizeof(parsekwd) / sizeof(const char *)
	);
}

Lines 60-71 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/parser.h (-5 / +13 lines)
60	#define VSPLUS 0x3 /* ${var+text} */	60	#define VSPLUS 0x3 /* ${var+text} */
61	#define VSQUESTION 0x4 /* ${var?message} */	61	#define VSQUESTION 0x4 /* ${var?message} */
62	#define VSASSIGN 0x5 /* ${var=text} */	62	#define VSASSIGN 0x5 /* ${var=text} */
63	#define VSTRIMLEFT 0x6 /* ${var#pattern} */	63	#define VSTRIMRIGHT 0x6 /* ${var%pattern} */
64	#define VSTRIMLEFTMAX 0x7 /* ${var##pattern} */	64	#define VSTRIMRIGHTMAX 0x7 /* ${var%%pattern} */
65	#define VSTRIMRIGHT 0x8 /* ${var%pattern} */	65	#define VSTRIMLEFT 0x8 /* ${var#pattern} */
66	#define VSTRIMRIGHTMAX 0x9 /* ${var%%pattern} */	66	#define VSTRIMLEFTMAX 0x9 /* ${var##pattern} */
67	#define VSLENGTH 0xa /* ${#var} */	67	#define VSLENGTH 0xa /* ${#var} */
68		68
		69	/* values of checkkwd variable */
		70	#define CHKALIAS 0x1
		71	#define CHKKWD 0x2
		72	#define CHKNL 0x4
		73
69		74
70	/*	75	/*
71	* NEOF is returned by parsecmd when it encounters an end of file. It	76	* NEOF is returned by parsecmd when it encounters an end of file. It
Lines 75-83 Link Here
75	extern int tokpushback;	80	extern int tokpushback;
76	#define NEOF ((union node *)&tokpushback)	81	#define NEOF ((union node *)&tokpushback)
77	extern int whichprompt; /* 1 == PS1, 2 == PS2 */	82	extern int whichprompt; /* 1 == PS1, 2 == PS2 */
		83	extern int checkkwd;
		84	extern int startlinno; /* line # where last token started */
78		85
79		86
80	union node *parsecmd(int);	87	union node *parsecmd(int);
81	void fixredir(union node , const char , int);	88	void fixredir(union node , const char , int);
82	int goodname(char *);
83	const char getprompt(void );	89	const char getprompt(void );
		90	const char const findkwd(const char *);
		91	char endofname(const char );




#endif
#endif /* not lint */

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/param.h>	/* PIPE_BUF */
#include <signal.h>

MKINIT
struct redirtab {
	struct redirtab *next;
	int renamed[10];
	int nullredirs;
};


MKINIT struct redirtab *redirlist;
MKINIT int nullredirs;

STATIC int openredirect __P((union node *));
#ifdef notyet
STATIC void dupredirect __P((union node *, int, char[10 ]));
#else
STATIC void dupredirect __P((union node *, int));
#endif

STATIC void openredirect __P((union node *, char[10 ]));
STATIC int openhere __P((union node *));
STATIC int noclobberopen __P((const char *));


/*

	int flags;
	{
	union node *n;
	struct redirtab *sv;
	int i;
	int fd;
	int newfd;
	int *p;
#if notyet
	char memory[10];	/* file descriptors to write to memory */

	for (i = 10 ; --i >= 0 ; )
		memory[i] = 0;
	memory[1] = flags & REDIR_BACKQ;
#endif
	if (!redir) {
		if (flags & REDIR_PUSH)
			nullredirs++;
		return;
	}
	sv = NULL;
	INTOFF;
	if (flags & REDIR_PUSH) {
		struct redirtab *q;
		q = ckmalloc(sizeof (struct redirtab));
		q->next = redirlist;
		redirlist = q;
		q->nullredirs = nullredirs;
		for (i = 0 ; i < 10 ; i++)
			q->renamed[i] = EMPTY;
		nullredirs = 0;
		sv = q;
	}
	n = redir;
	do {
		fd = n->nfile.fd;
		try = 0;
		if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
		    n->ndup.dupfd == fd)
			continue; /* redirect from/to same file descriptor */

		newfd = openredirect(n);
		if (fd == newfd)
			continue;
		if (sv && *(p = &sv->renamed[fd]) == EMPTY) {
			int i = fcntl(fd, F_DUPFD, 10);
			if (i == -1) {
				i = errno;
				if (i != EBADF) {
					const char *m = strerror(i);
					close(newfd);
					error("%d: %s", fd, m);
					/* FALLTHROUGH*/
				default:
					INTON;
					error("%d: %s", fd, strerror(errno));
					/* NOTREACHED */
				}
			} else {
				*p = i;
				sv->renamed[fd] = i;
				close(fd);
			}
			INTON;
		} else {
			close(fd);
		}
#ifdef notyet
		dupredirect(n, newfd, memory);
#else
		dupredirect(n, newfd);
#endif
	} while ((n = n->nfile.next));
	INTON;
#ifdef notyet
	if (memory[1])
		out1 = &memout;
	if (memory[2])
		out2 = &memout;
#endif
}


STATIC int
openredirect(redir)
	union node *redir;
	char memory[10];
	{
	int fd = redir->nfile.fd;
	char *fname;
	int f;
	int flags = O_WRONLY|O_CREAT|O_TRUNC;

	/*
	 * We suppress interrupts so that we won't leave open file
	 * descriptors around.  This may not be such a good idea because
	 * an open of a device or a fifo can block indefinitely.
	 */
	INTOFF;
	memory[fd] = 0;
	switch (redir->nfile.type) {
	case NFROM:
		fname = redir->nfile.expfname;
		if ((f = open64(fname, O_RDONLY)) < 0)
			goto eopen;
		break;
	case NFROMTO:
		fname = redir->nfile.expfname;
		if ((f = open64(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
			goto ecreate;
		break;
	case NTO:
		/* Take care of noclobber mode. */
		if (Cflag) {
			fname = redir->nfile.expfname;
			if ((f = noclobberopen(fname)) < 0)
				goto ecreate;
			break;
		}
		/* FALLTHROUGH */
	case NCLOBBER:
		fname = redir->nfile.expfname;
		if ((f = open64(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
			goto ecreate;
		break;
	case NAPPEND:
		fname = redir->nfile.expfname;
		if ((f = open64(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)
			goto ecreate;
		break;
	default:
#ifdef DEBUG
		abort();
#endif
		/* Fall through to eliminate warning. */
	case NTOFD:
	case NFROMFD:
		f = -1;
		break;
	case NHERE:
	case NXHERE:
		f = openhere(redir);
		break;
	}

	return f;
ecreate:
	error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
eopen:
	error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
}


STATIC void
#ifdef notyet
dupredirect(redir, f, memory)
#else
dupredirect(redir, f)
#endif
	union node *redir;
	int f;
#ifdef notyet
	char memory[10];
#endif
	{
	int fd = redir->nfile.fd;

#ifdef notyet
	memory[fd] = 0;
#endif
	if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
		if (redir->ndup.dupfd >= 0) {	/* if not ">&-" */
#ifdef notyet
			if (memory[redir->ndup.dupfd])
				memory[fd] = 1;
			else
#endif
				copyfd(redir->ndup.dupfd, fd);
		}
		INTON;
		return;
	case NHERE:
	case NXHERE:
		f = openhere(redir);
		break;
	default:
		abort();
	}

	if (f != fd) {
		copyfd(f, fd);
		close(f);
	}
	INTON;
	return;
ecreate:
	error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
eopen:
	error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
}



	union node *redir;
	{
	int pip[2];
	size_t len = 0;

	if (pipe(pip) < 0)
		error("Pipe call failed");

 */

void
popredir(int drop) {
	struct redirtab *rp = redirlist;
	int i;

	INTOFF;
	if (--nullredirs >= 0)
		goto out;
	for (i = 0 ; i < 10 ; i++) {
		if (rp->renamed[i] != EMPTY) {
			if (!drop) {
                                fd0_redirected--;
			close(i);
			if (rp->renamed[i] >= 0) {
				copyfd(rp->renamed[i], i);
				close(rp->renamed[i]);
			}
			close(rp->renamed[i]);
		}
	}
	INTOFF;
	redirlist = rp->next;
	nullredirs = rp->nullredirs;
	ckfree(rp);
out:
	INTON;
}


INCLUDE "redir.h"

RESET {
	clearredir(0);
		popredir();
}

SHELLPROC {
	clearredir();
}

#endif

/* Return true if fd 0 has already been redirected at least once.  */
int
fd0_redirected_p () {
        return fd0_redirected != 0;
}

/*
 * Discard all saved file descriptors.
 */

void
clearredir(int drop) {
	for (;;) {
		nullredirs = 0;
		if (!redirlist)
			break;
		popredir(drop);
			if (rp->renamed[i] >= 0) {
				close(rp->renamed[i]);
			}
			rp->renamed[i] = EMPTY;
		}
	}
}


 */

int
copyfd(int from, int to)
	int from;
	int to;
{
	int newfd;

	newfd = fcntl(from, F_DUPFD, to);
	if (newfd < 0) {
		int errno2 = errno;
		if (errno2 == EMFILE)
			return EMPTY;
		else
			error("%d: %s", from, strerror(errno2));
	}
	return newfd;
}


/*
 * Open a file in noclobber mode.
 * The code was copied from bash.
 */
int
noclobberopen(fname)
	const char *fname;
{
	int r, fd;
	struct stat64 finfo, finfo2;

	/*
	 * If the file exists and is a regular file, return an error
	 * immediately.
	 */
	r = stat64(fname, &finfo);
	if (r == 0 && S_ISREG(finfo.st_mode)) {
		errno = EEXIST;
		return -1;
	}

	/*
	 * If the file was not present (r != 0), make sure we open it
	 * exclusively so that if it is created before we open it, our open
	 * will fail.  Make sure that we do not truncate an existing file.
	 * Note that we don't turn on O_EXCL unless the stat failed -- if the
	 * file was not a regular file, we leave O_EXCL off.
	 */
	if (r != 0)
		return open64(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
	fd = open64(fname, O_WRONLY|O_CREAT, 0666);

	/* If the open failed, return the file descriptor right away. */
	if (fd < 0)
		return fd;

	/*
	 * OK, the open succeeded, but the file may have been changed from a
	 * non-regular file to a regular file between the stat and the open.
	 * We are assuming that the O_EXCL open handles the case where FILENAME
	 * did not exist and is symlinked to an existing file between the stat
	 * and open.
	 */

	/*
	 * If we can open it and fstat the file descriptor, and neither check
	 * revealed that it was a regular file, and the file has not been
	 * replaced, return the file descriptor.
	 */
	 if (fstat64(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
	     finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
	 	return fd;

	/* The file has been replaced.  badness. */
	close(fd);
	errno = EEXIST;
	return -1;
}


int
redirectsafe(union node *redir, int flags)
{
	int err;
	int e;
	volatile int saveint;
	struct jmploc *volatile savehandler = handler;
	struct jmploc jmploc;

	SAVEINT(saveint);
	exception = -1;
	if (setjmp(jmploc.loc))
		err = 2;
	else {
		handler = &jmploc;
		redirect(redir, flags);
		err = 0;
	}
	handler = savehandler;
	e = exception;
	if (e >= 0 && e != EXERROR)
		longjmp(handler->loc, 1);
	RESTOREINT(saveint);
	return err;
}





/* flags passed to redirect */
#define REDIR_PUSH 01		/* save previous values of file descriptors */
#ifdef notyet
#define REDIR_BACKQ 02		/* save the command output in memory */
#endif

union node;
void redirect __P((union node *, int));
void popredir __P((int));
void clearredir __P((int));
void clearredir __P((void));
int copyfd __P((int, int));
int redirectsafe __P((union node *, int));





alias
bg
cd
command
false
fc
fg
getopts
jobs
kill
newgrp
read
true
umask
unalias
wait




/*	$NetBSD: setmode.c,v 1.28 2000/01/25 15:43:43 enami Exp $	*/

/*
 * Copyright (c) 1989, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Dave Borman at Cray Research, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char sccsid[] = "@(#)setmode.c	8.2 (Berkeley) 3/25/94";
#else
__RCSID("$NetBSD: setmode.c,v 1.28 2000/01/25 15:43:43 enami Exp $");
#endif
#endif /* LIBC_SCCS and not lint */

#include <sys/types.h>
#include <sys/stat.h>

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

#ifdef SETMODE_DEBUG
#include <stdio.h>
#endif

#ifdef __weak_alias
__weak_alias(getmode,_getmode)
__weak_alias(setmode,_setmode)
#endif

#ifdef __GLIBC__
#define S_ISTXT __S_ISVTX
#endif

#define	SET_LEN	6		/* initial # of bitcmd struct to malloc */
#define	SET_LEN_INCR 4		/* # of bitcmd structs to add as needed */

typedef struct bitcmd {
	char	cmd;
	char	cmd2;
	mode_t	bits;
} BITCMD;

#define	CMD2_CLR	0x01
#define	CMD2_SET	0x02
#define	CMD2_GBITS	0x04
#define	CMD2_OBITS	0x08
#define	CMD2_UBITS	0x10

static BITCMD	*addcmd __P((BITCMD *, int, int, int, u_int));
static void	 compress_mode __P((BITCMD *));
#ifdef SETMODE_DEBUG
static void	 dumpmode __P((BITCMD *));
#endif

/*
 * Given the old mode and an array of bitcmd structures, apply the operations
 * described in the bitcmd structures to the old mode, and return the new mode.
 * Note that there is no '=' command; a strict assignment is just a '-' (clear
 * bits) followed by a '+' (set bits).
 */
mode_t
getmode(bbox, omode)
	const void *bbox;
	mode_t omode;
{
	const BITCMD *set;
	mode_t clrval, newmode, value;

	_DIAGASSERT(bbox != NULL);

	set = (const BITCMD *)bbox;
	newmode = omode;
	for (value = 0;; set++)
		switch(set->cmd) {
		/*
		 * When copying the user, group or other bits around, we "know"
		 * where the bits are in the mode so that we can do shifts to
		 * copy them around.  If we don't use shifts, it gets real
		 * grundgy with lots of single bit checks and bit sets.
		 */
		case 'u':
			value = (newmode & S_IRWXU) >> 6;
			goto common;

		case 'g':
			value = (newmode & S_IRWXG) >> 3;
			goto common;

		case 'o':
			value = newmode & S_IRWXO;
common:			if (set->cmd2 & CMD2_CLR) {
				clrval =
				    (set->cmd2 & CMD2_SET) ?  S_IRWXO : value;
				if (set->cmd2 & CMD2_UBITS)
					newmode &= ~((clrval<<6) & set->bits);
				if (set->cmd2 & CMD2_GBITS)
					newmode &= ~((clrval<<3) & set->bits);
				if (set->cmd2 & CMD2_OBITS)
					newmode &= ~(clrval & set->bits);
			}
			if (set->cmd2 & CMD2_SET) {
				if (set->cmd2 & CMD2_UBITS)
					newmode |= (value<<6) & set->bits;
				if (set->cmd2 & CMD2_GBITS)
					newmode |= (value<<3) & set->bits;
				if (set->cmd2 & CMD2_OBITS)
					newmode |= value & set->bits;
			}
			break;

		case '+':
			newmode |= set->bits;
			break;

		case '-':
			newmode &= ~set->bits;
			break;

		case 'X':
			if (omode & (S_IFDIR|S_IXUSR|S_IXGRP|S_IXOTH))
				newmode |= set->bits;
			break;

		case '\0':
		default:
#ifdef SETMODE_DEBUG
			(void)printf("getmode:%04o -> %04o\n", omode, newmode);
#endif
			return (newmode);
		}
}

#define	ADDCMD(a, b, c, d) do {						\
	if (set >= endset) {						\
		BITCMD *newset;						\
		setlen += SET_LEN_INCR;					\
		newset = realloc(saveset, sizeof(BITCMD) * setlen);	\
		if (newset == NULL) {					\
			free(saveset);					\
			return (NULL);					\
		}							\
		set = newset + (set - saveset);				\
		saveset = newset;					\
		endset = newset + (setlen - 2);				\
	}								\
	set = addcmd(set, (a), (b), (c), (d));				\
} while (/*CONSTCOND*/0)

#define	STANDARD_BITS	(S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)

void *
setmode(p)
	const char *p;
{
	int perm, who;
	char op, *ep;
	BITCMD *set, *saveset, *endset;
	sigset_t sigset, sigoset;
	mode_t mask;
	int equalopdone = 0;	/* pacify gcc */
	int permXbits, setlen;

	if (!*p)
		return (NULL);

	/*
	 * Get a copy of the mask for the permissions that are mask relative.
	 * Flip the bits, we want what's not set.  Since it's possible that
	 * the caller is opening files inside a signal handler, protect them
	 * as best we can.
	 */
	sigfillset(&sigset);
	(void)sigprocmask(SIG_BLOCK, &sigset, &sigoset);
	(void)umask(mask = umask(0));
	mask = ~mask;
	(void)sigprocmask(SIG_SETMASK, &sigoset, NULL);

	setlen = SET_LEN + 2;
	
	if ((set = malloc((u_int)(sizeof(BITCMD) * setlen))) == NULL)
		return (NULL);
	saveset = set;
	endset = set + (setlen - 2);

	/*
	 * If an absolute number, get it and return; disallow non-octal digits
	 * or illegal bits.
	 */
	if (isdigit((unsigned char)*p)) {
		perm = (mode_t)strtol(p, &ep, 8);
		if (*ep || perm & ~(STANDARD_BITS|S_ISTXT)) {
			free(saveset);
			return (NULL);
		}
		ADDCMD('=', (STANDARD_BITS|S_ISTXT), perm, mask);
		set->cmd = 0;
		return (saveset);
	}

	/*
	 * Build list of structures to set/clear/copy bits as described by
	 * each clause of the symbolic mode.
	 */
	for (;;) {
		/* First, find out which bits might be modified. */
		for (who = 0;; ++p) {
			switch (*p) {
			case 'a':
				who |= STANDARD_BITS;
				break;
			case 'u':
				who |= S_ISUID|S_IRWXU;
				break;
			case 'g':
				who |= S_ISGID|S_IRWXG;
				break;
			case 'o':
				who |= S_IRWXO;
				break;
			default:
				goto getop;
			}
		}

getop:		if ((op = *p++) != '+' && op != '-' && op != '=') {
			free(saveset);
			return (NULL);
		}
		if (op == '=')
			equalopdone = 0;

		who &= ~S_ISTXT;
		for (perm = 0, permXbits = 0;; ++p) {
			switch (*p) {
			case 'r':
				perm |= S_IRUSR|S_IRGRP|S_IROTH;
				break;
			case 's':
				/*
				 * If specific bits where requested and 
				 * only "other" bits ignore set-id. 
				 */
				if (who == 0 || (who & ~S_IRWXO))
					perm |= S_ISUID|S_ISGID;
				break;
			case 't':
				/*
				 * If specific bits where requested and 
				 * only "other" bits ignore set-id. 
				 */
				if (who == 0 || (who & ~S_IRWXO)) {
					who |= S_ISTXT;
					perm |= S_ISTXT;
				}
				break;
			case 'w':
				perm |= S_IWUSR|S_IWGRP|S_IWOTH;
				break;
			case 'X':
				permXbits = S_IXUSR|S_IXGRP|S_IXOTH;
				break;
			case 'x':
				perm |= S_IXUSR|S_IXGRP|S_IXOTH;
				break;
			case 'u':
			case 'g':
			case 'o':
				/*
				 * When ever we hit 'u', 'g', or 'o', we have
				 * to flush out any partial mode that we have,
				 * and then do the copying of the mode bits.
				 */
				if (perm) {
					ADDCMD(op, who, perm, mask);
					perm = 0;
				}
				if (op == '=')
					equalopdone = 1;
				if (op == '+' && permXbits) {
					ADDCMD('X', who, permXbits, mask);
					permXbits = 0;
				}
				ADDCMD(*p, who, op, mask);
				break;

			default:
				/*
				 * Add any permissions that we haven't already
				 * done.
				 */
				if (perm || (op == '=' && !equalopdone)) {
					if (op == '=')
						equalopdone = 1;
					ADDCMD(op, who, perm, mask);
					perm = 0;
				}
				if (permXbits) {
					ADDCMD('X', who, permXbits, mask);
					permXbits = 0;
				}
				goto apply;
			}
		}

apply:		if (!*p)
			break;
		if (*p != ',')
			goto getop;
		++p;
	}
	set->cmd = 0;
#ifdef SETMODE_DEBUG
	(void)printf("Before compress_mode()\n");
	dumpmode(saveset);
#endif
	compress_mode(saveset);
#ifdef SETMODE_DEBUG
	(void)printf("After compress_mode()\n");
	dumpmode(saveset);
#endif
	return (saveset);
}

static BITCMD *
addcmd(set, op, who, oparg, mask)
	BITCMD *set;
	int oparg, who;
	int op;
	u_int mask;
{

	_DIAGASSERT(set != NULL);

	switch (op) {
	case '=':
		set->cmd = '-';
		set->bits = who ? who : STANDARD_BITS;
		set++;

		op = '+';
		/* FALLTHROUGH */
	case '+':
	case '-':
	case 'X':
		set->cmd = op;
		set->bits = (who ? who : mask) & oparg;
		break;

	case 'u':
	case 'g':
	case 'o':
		set->cmd = op;
		if (who) {
			set->cmd2 = ((who & S_IRUSR) ? CMD2_UBITS : 0) |
				    ((who & S_IRGRP) ? CMD2_GBITS : 0) |
				    ((who & S_IROTH) ? CMD2_OBITS : 0);
			set->bits = (mode_t)~0;
		} else {
			set->cmd2 = CMD2_UBITS | CMD2_GBITS | CMD2_OBITS;
			set->bits = mask;
		}
	
		if (oparg == '+')
			set->cmd2 |= CMD2_SET;
		else if (oparg == '-')
			set->cmd2 |= CMD2_CLR;
		else if (oparg == '=')
			set->cmd2 |= CMD2_SET|CMD2_CLR;
		break;
	}
	return (set + 1);
}

#ifdef SETMODE_DEBUG
static void
dumpmode(set)
	BITCMD *set;
{

	_DIAGASSERT(set != NULL);

	for (; set->cmd; ++set)
		(void)printf("cmd: '%c' bits %04o%s%s%s%s%s%s\n",
		    set->cmd, set->bits, set->cmd2 ? " cmd2:" : "",
		    set->cmd2 & CMD2_CLR ? " CLR" : "",
		    set->cmd2 & CMD2_SET ? " SET" : "",
		    set->cmd2 & CMD2_UBITS ? " UBITS" : "",
		    set->cmd2 & CMD2_GBITS ? " GBITS" : "",
		    set->cmd2 & CMD2_OBITS ? " OBITS" : "");
}
#endif

/*
 * Given an array of bitcmd structures, compress by compacting consecutive
 * '+', '-' and 'X' commands into at most 3 commands, one of each.  The 'u',
 * 'g' and 'o' commands continue to be separate.  They could probably be 
 * compacted, but it's not worth the effort.
 */
static void
compress_mode(set)
	BITCMD *set;
{
	BITCMD *nset;
	int setbits, clrbits, Xbits, op;

	_DIAGASSERT(set != NULL);

	for (nset = set;;) {
		/* Copy over any 'u', 'g' and 'o' commands. */
		while ((op = nset->cmd) != '+' && op != '-' && op != 'X') {
			*set++ = *nset++;
			if (!op)
				return;
		}

		for (setbits = clrbits = Xbits = 0;; nset++) {
			if ((op = nset->cmd) == '-') {
				clrbits |= nset->bits;
				setbits &= ~nset->bits;
				Xbits &= ~nset->bits;
			} else if (op == '+') {
				setbits |= nset->bits;
				clrbits &= ~nset->bits;
				Xbits &= ~nset->bits;
			} else if (op == 'X')
				Xbits |= nset->bits & ~setbits;
			else
				break;
		}
		if (clrbits) {
			set->cmd = '-';
			set->cmd2 = 0;
			set->bits = clrbits;
			set++;
		}
		if (setbits) {
			set->cmd = '+';
			set->cmd2 = 0;
			set->bits = setbits;
			set++;
		}
		if (Xbits) {
			set->cmd = 'X';
			set->cmd2 = 0;
			set->bits = Xbits;
			set++;
		}
	}
}




or
.Ic until ;
or if the command is the left hand operand of an
.Dq &&
or
.Dq ||
operator.

operators (their meaning is discussed later). Following is a list of operators:
.Bl -ohang -offset indent
.It "Control operators:"
.Dl &  &&  \&(  \&)  \&;  ;; | || \*[Lt]newline\*[Gt]
.It "Redirection operators:"
.Dl \*[Lt]  \*[Gt]  \*[Gt]|  \*[Lt]\*[Lt]  \*[Gt]\*[Gt]  \*[Lt]&  \*[Gt]&  \*[Lt]\*[Lt]-  \*[Lt]\*[Gt]
.El
.Ss Quoting
Quoting is used to remove the special meaning of certain characters or

Append standard output (or n) to file.
.It [n] Ns \*[Lt] file
Redirect standard input (or n) from file.
.It [n1] Ns \*[Lt]& Ns n2
Duplicate standard input (or n1) from file descriptor n2.
.It [n] Ns \*[Lt]&-
Close standard input (or n).
.It [n1] Ns \*[Gt]& Ns n2
Duplicate standard output (or n1) from n2.
.It [n] Ns \*[Gt]&-
Close standard output (or n).
.It [n] Ns \*[Lt]\*[Gt] file
Open file for reading and writing on standard input (or n).

takes place before redirection, it can be modified by redirection.  For
example:
.Pp
.Dl $ command1 2\*[Gt]&1 | command2
.Pp
sends both the standard output and standard error of command1
to the standard input of command2.
.Pp
A ; or \*[Lt]newline\*[Gt] terminator causes the preceding AND-OR-list (described
next) to be executed sequentially; a & causes asynchronous execution of
the preceding AND-OR-list.
.Pp
Note that unlike some other shells, each process in the pipeline is a
child of the invoking shell (unless it is a shell builtin, in which case
it executes in the current shell -- but any effect it has on the
environment is wiped).
.Ss Background Commands -- &
If a command is terminated by the control operator ampersand (&), the
shell executes the command asynchronously -- that is, the shell does not
wait for the command to finish before executing the next command.
.Pp
The format for running a command in background is:
.Pp
.Dl command1 & [command2 & ...]
.Pp
If the shell is not interactive, the standard input of an asynchronous
command is set to

command and immediately proceed onto the next command; otherwise it waits
for the command to terminate before proceeding to the next one.
.Ss Short-Circuit List Operators
.Dq &&
and
.Dq ||
are AND-OR list operators.
.Dq &&
executes the first command, and then executes the second command iff the
exit status of the first command is zero.
.Dq ||
is similar, but executes the second command iff the exit status of the first
command is nonzero.
.Dq &&
and
.Dq ||
both have the same priority.

they were one program:
.Pp
.Bd -literal -offset indent
{ printf \*q hello \*q ; printf \*q world\\n" ; } \*[Gt] greeting
.Ed
.Pp
Note that

.Ss Shell Patterns
A pattern consists of normal characters, which match themselves,
and meta-characters.   The meta-characters are
.Dq \&! ,
.Dq * ,
.Dq \&? ,
and
.Dq \&[ .
These characters lose their special meanings if they are quoted.  When
command or variable substitution is performed and the dollar sign or back
quotes are not double quoted, the value of the variable or the output of

.Ss Builtins
This section lists the builtin commands which are builtin because they
need to perform some operation that can't be performed by a separate
process.
be builtin for efficiency (e.g.
.Xr printf 1 ,
.Xr echo 1 ,
.Xr test 1 ,
etc).
.Bl -tag -width 5n
.It :
.It true
A null command that returns a 0 (true) exit value.
.It \&. file
The commands in the specified file are read and executed by the shell.

.It command Ar command Ar arg ...
Execute the specified builtin command.  (This is useful when you
have a shell function with the same name as a builtin command.)
.It cd Ar -
.It Xo cd Op Fl LP
.Op Ar directory
.Xc
Switch to the specified directory (default
.Ev HOME ) .
If an entry for
.Ev CDPATH
appears in the environment of the

.Ev CDPATH
is the same as that of
.Ev PATH .
If a single dash is specified as the argument, it will be replaced by the
value of
.Ev OLDPWD .
The
.Ic cd
command will print out the name of the
directory that it actually switched to if this is different from the name
that the user gave.  These may be different either because the
.Ev CDPATH
mechanism was used or because the argument is a single dash.
The
.Fl P
option causes the physical directory structure to be used, that is, all
symbolic links are resolved to their repective values.  The
.Fl L
option turns off the effect of any preceding
.Fl P
options.
.It Xo echo Op Fl n
.Ar args... 
.Xc
Print the arguments on the standard output, separated by spaces.
Unless the
.Fl n
option is present, a newline is output following the arguments.
.Pp
If any of the following sequences of characters is encountered during
output, the sequence is not output.  Instead, the specified action is
performed:
.Bl -tag -width indent
.It Li \eb
A backspace character is output.
.It Li \ec
Subsequent output is suppressed.  This is normally used at the end of the
last argument to suppress the trailing newline that
.Ic echo
would otherwise output.
.It Li \ef
Output a form feed.
.It Li \en
Output a newline character.
.It Li \er
Output a carriage return.
.It Li \et
Output a (horizontal) tab character.
.It Li \ev
Output a vertical tab.
.It Li \e0 Ns Ar digits
Output the character whose value is given by zero to three octal digits.
If there are zero digits, a nul character is output.
.It Li \e\e
Output a backslash.
.El
.Pp
All other backslash sequences elicit undefined behaviour.
.It eval Ar string ...
Concatenate all the arguments with spaces.  Then re-parse and execute
the command.

will set the variable
.Va var
to a
.Dq \&? ;
.Ic getopts
will then unset
.Ev OPTARG

otherwise, it will set
.Va var
to
.Dq \&? .
.Pp
The following code fragment shows how one might process the arguments
for a command that can take the options

.It jobs
This command lists out all the background processes
which are children of the current shell process.
.It pwd Op Fl LP
Print the current directory.  The builtin command may
differ from the program of the same name because the
builtin command remembers what the current directory

renamed, the builtin version of
.Ic pwd
will continue to print the old name for the directory.
The
.Fl P
option causes the phyical value of the current working directory to be shown,
that is, all symbolic links are resolved to their repective values.  The
.Fl L
option turns off the effect of any preceding
.Fl P
options.
.It Xo read Op Fl p Ar prompt
.Op Fl r
.Ar variable

option is specified and the standard input is a terminal.  Then a line is
read from the standard input.  The trailing newline is deleted from the
line and the line is split as described in the section on word splitting
above, and the pieces are assigned to the variables in order.
At least one variable must be specified.
If there are
more pieces than variables, the remaining pieces (along with the
characters in
.Ev IFS

.Fl p
option specified the output will be formatted suitably for non-interactive use.
.Pp
.It Xo printf Ar format
.Op Ar arguments  ...
.Xc
.Ic printf
formats and prints its arguments, after the first, under control
of the
.Ar format  .
The
.Ar format
is a character string which contains three types of objects: plain characters,
which are simply copied to standard output, character escape sequences which
are converted and copied to the standard output, and format specifications,
each of which causes printing of the next successive
.Ar argument  .
.Pp
The
.Ar arguments
after the first are treated as strings if the corresponding format is
either
.Cm b ,
.Cm c
or
.Cm s ;
otherwise it is evaluated as a C constant, with the following extensions:
.Pp
.Bl -bullet -offset indent -compact
.It
A leading plus or minus sign is allowed.
.It
If the leading character is a single or double quote, the value is the
.Tn ASCII
code of the next character.
.El
.Pp
The format string is reused as often as necessary to satisfy the
.Ar arguments  .
Any extra format specifications are evaluated with zero or the null
string.
.Pp
Character escape sequences are in backslash notation as defined in
.St -ansiC .
The characters and their meanings
are as follows:
.Bl -tag -width Ds -offset indent
.It Cm \ee
Write an \*[Lt]escape\*[Gt] character.
.It Cm \ea
Write a \*[Lt]bell\*[Gt] character.
.It Cm \eb
Write a \*[Lt]backspace\*[Gt] character.
.It Cm \ef
Write a \*[Lt]form-feed\*[Gt] character.
.It Cm \en
Write a \*[Lt]new-line\*[Gt] character.
.It Cm \er
Write a \*[Lt]carriage return\*[Gt] character.
.It Cm \et
Write a \*[Lt]tab\*[Gt] character.
.It Cm \ev
Write a \*[Lt]vertical tab\*[Gt] character.
.It Cm \e\'
Write a \*[Lt]single quote\*[Gt] character.
.It Cm \e\e
Write a backslash character.
.It Cm \e Ns Ar num
Write an 8-bit character whose
.Tn ASCII
value is the 1-, 2-, or 3-digit
octal number
.Ar num .
.El
.Pp
Each format specification is introduced by the percent character
(``%'').
The remainder of the format specification includes,
in the following order:
.Bl -tag -width Ds
.It "Zero or more of the following flags:"
.Bl -tag -width Ds
.It Cm #
A `#' character
specifying that the value should be printed in an ``alternative form''.
For
.Cm c  ,
.Cm d ,
and
.Cm s  ,
formats, this option has no effect.  For the
.Cm o
formats the precision of the number is increased to force the first
character of the output string to a zero.  For the
.Cm x
.Pq Cm X
format, a non-zero result has the string
.Li 0x
.Pq Li 0X
prepended to it.  For
.Cm e  ,
.Cm E ,
.Cm f  ,
.Cm g ,
and
.Cm G  ,
formats, the result will always contain a decimal point, even if no
digits follow the point (normally, a decimal point only appears in the
results of those formats if a digit follows the decimal point).  For
.Cm g
and
.Cm G
formats, trailing zeros are not removed from the result as they
would otherwise be;
.It Cm \&\-
A minus sign `\-' which specifies
.Em left adjustment
of the output in the indicated field;
.It Cm \&+
A `+' character specifying that there should always be
a sign placed before the number when using signed formats.
.It Sq \&\ \&
A space specifying that a blank should be left before a positive number
for a signed format.  A `+' overrides a space if both are used;
.It Cm \&0
A zero `0' character indicating that zero-padding should be used
rather than blank-padding.  A `\-' overrides a `0' if both are used;
.El
.It "Field Width:"
An optional digit string specifying a
.Em field width ;
if the output string has fewer characters than the field width it will
be blank-padded on the left (or right, if the left-adjustment indicator
has been given) to make up the field width (note that a leading zero
is a flag, but an embedded zero is part of a field width);
.It Precision :
An optional period,
.Sq Cm \&.\& ,
followed by an optional digit string giving a
.Em precision
which specifies the number of digits to appear after the decimal point,
for
.Cm e
and
.Cm f
formats, or the maximum number of characters to be printed
from a string; if the digit string is missing, the precision is treated
as zero;
.It Format :
A character which indicates the type of format to use (one of
.Cm diouxXfwEgGbcs ) .
.El
.Pp
A field width or precision may be
.Sq Cm \&*
instead of a digit string.
In this case an
.Ar argument
supplies the field width or precision.
.Pp
The format characters and their meanings are:
.Bl -tag -width Fl
.It Cm diouXx
The
.Ar argument
is printed as a signed decimal (d or i), unsigned octal, unsigned decimal,
or unsigned hexadecimal (X or x), respectively.
.It Cm f
The
.Ar argument
is printed in the style
.Sm off
.Pf [\-]ddd Cm \&. No ddd
.Sm on
where the number of d's
after the decimal point is equal to the precision specification for
the argument.
If the precision is missing, 6 digits are given; if the precision
is explicitly 0, no digits and no decimal point are printed.
.It Cm eE
The
.Ar argument
is printed in the style
.Sm off
.Pf [\-]d Cm \&. No ddd Cm e No \\*(Pmdd
.Sm on
where there
is one digit before the decimal point and the number after is equal to
the precision specification for the argument; when the precision is
missing, 6 digits are produced.
An upper-case E is used for an `E' format.
.It Cm gG
The
.Ar argument
is printed in style
.Cm f
or in style
.Cm e
.Pq Cm E
whichever gives full precision in minimum space.
.It Cm b
Characters from the string
.Ar argument
are printed with backslash-escape sequences expanded as in
.Ic echo .
.It Cm c
The first character of
.Ar argument
is printed.
.It Cm s
Characters from the string
.Ar argument
are printed until the end is reached or until the number of characters
indicated by the precision specification is reached; however if the
precision is 0 or missing, all characters in the string are printed.
.It Cm \&%
Print a `%'; no argument is used.
.El
.Pp
In no case does a non-existent or small field width cause truncation of
a field; padding takes place only if the specified field width exceeds
the actual width.
.It Xo set
.Oo {
.Fl options | Cm +options | Cm -- }

and so on, decreasing
the value of
.Va $#
by one. If n is greater than the number of positional parameters,
.Ic shift
will issue an error message, and exit with return status 2.
.It test Ar expression
.It \&[ Ar expression Cm ]
The
.Ic test
utility evaluates the expression and, if it evaluates
to true, returns a zero (true) exit status; otherwise
it returns 1 (false).
If there is no expression, test also
returns 1 (false).
.Pp
All operators and flags are separate arguments to the
.Ic test
utility.
.Pp
The following primaries are used to construct expression:
.Bl -tag -width Ar
.It Fl b Ar file
True if
.Ar file
exists and is a block special
file.
.It Fl c Ar file
True if
.Ar file
exists and is a character
special file.
.It Fl d Ar file
True if
.Ar file
exists and is a directory.
.It Fl e Ar file
True if
.Ar file
exists (regardless of type).
.It Fl f Ar file
True if
.Ar file
exists and is a regular file.
.It Fl g Ar file
True if
.Ar file
exists and its set group ID flag
is set.
.It Fl h Ar file
True if
.Ar file
exists and is a symbolic link.
.It Fl k Ar file
True if
.Ar file
exists and its sticky bit is set.
.It Fl n Ar string
True if the length of
.Ar string
is nonzero.
.It Fl p Ar file
True if
.Ar file
is a named pipe
.Po Tn FIFO Pc .
.It Fl r Ar file
True if
.Ar file
exists and is readable.
.It Fl s Ar file
True if
.Ar file
exists and has a size greater
than zero.
.It Fl t Ar file_descriptor
True if the file whose file descriptor number
is
.Ar file_descriptor
is open and is associated with a terminal.
.It Fl u Ar file
True if
.Ar file
exists and its set user ID flag
is set.
.It Fl w Ar file
True if
.Ar file
exists and is writable.
True
indicates only that the write flag is on.
The file is not writable on a read-only file
system even if this test indicates true.
.It Fl x Ar file
True if
.Ar file
exists and is executable.
True
indicates only that the execute flag is on.
If
.Ar file
is a directory, true indicates that
.Ar file
can be searched.
.It Fl z Ar string
True if the length of
.Ar string
is zero.
.It Fl L Ar file
True if
.Ar file
exists and is a symbolic link.
This operator is retained for compatibility with previous versions of
this program. Do not rely on its existence; use
.Fl h
instead.
.It Fl O Ar file
True if
.Ar file
exists and its owner matches the effective user id of this process.
.It Fl G Ar file
True if
.Ar file
exists and its group matches the effective group id of this process.
.It Fl S Ar file
True if
.Ar file
exists and is a socket.
.It Ar file1 Fl nt Ar file2
True if
.Ar file1
exists and is newer than
.Ar file2 .
.It Ar file1 Fl ot Ar file2
True if
.Ar file1
exists and is older than
.Ar file2 .
.It Ar file1 Fl ef Ar file2
True if
.Ar file1
and
.Ar file2
exist and refer to the same file.
.It Ar string
True if
.Ar string
is not the null
string.
.It Ar \&s\&1 Cm \&= Ar \&s\&2
True if the strings
.Ar \&s\&1
and
.Ar \&s\&2
are identical.
.It Ar \&s\&1 Cm \&!= Ar \&s\&2
True if the strings
.Ar \&s\&1
and
.Ar \&s\&2
are not identical.
.It Ar \&s\&1 Cm \&\*[Lt] Ar \&s\&2
True if string
.Ar \&s\&1
comes before
.Ar \&s\&2
based on the ASCII value of their characters.
.It Ar \&s\&1 Cm \&\*[Gt] Ar \&s\&2
True if string
.Ar \&s\&1
comes after
.Ar \&s\&2
based on the ASCII value of their characters.
.It Ar \&n\&1 Fl \&eq Ar \&n\&2
True if the integers
.Ar \&n\&1
and
.Ar \&n\&2
are algebraically
equal.
.It Ar \&n\&1 Fl \&ne Ar \&n\&2
True if the integers
.Ar \&n\&1
and
.Ar \&n\&2
are not
algebraically equal.
.It Ar \&n\&1 Fl \&gt Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically
greater than the integer
.Ar \&n\&2 .
.It Ar \&n\&1 Fl \&ge Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically
greater than or equal to the integer
.Ar \&n\&2 .
.It Ar \&n\&1 Fl \&lt Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically less
than the integer
.Ar \&n\&2 .
.It Ar \&n\&1 Fl \&le Ar \&n\&2
True if the integer
.Ar \&n\&1
is algebraically less
than or equal to the integer
.Ar \&n\&2 .
.El
.Pp
These primaries can be combined with the following operators:
.Bl -tag -width Ar
.It Cm \&! Ar expression
True if
.Ar expression
is false.
.It Ar expression1 Fl a Ar expression2
True if both
.Ar expression1
and
.Ar expression2
are true.
.It Ar expression1 Fl o Ar expression2
True if either
.Ar expression1
or
.Ar expression2
are true.
.It Cm \&( Ns Ar expression Ns Cm \&)
True if expression is true.
.El
.Pp
The
.Fl a
operator has higher precedence than the
.Fl o
operator.
.It times
Print the accumulated user and system times for the shell and for processes
run from the shell.  The return status is 0.
.It Xo trap
.Op Ar action Ar signal ...
.Ar signal ...
.Xc
Cause the shell to parse and execute action when any of the specified
signals are received. The signals are specified by signal number or as

.Ic trap
command has no effect on signals that were
ignored on entry to the shell.
Issuing
.Ic trap
with option
.Ar -l
will print a list of valid signal names.
.Ic trap
without any arguments cause it to write a list of signals and their
associated action to the standard output in a format that is suitable

.Pp
List trapped signals and their corresponding action
.Pp
.Dl trap -l
.Pp
Print a list of valid signals
.Pp
.Dl trap '' SIGINT QUIT tstp 30
.Pp
Ignore signals INT QUIT TSTP USR1

children of the shell, and is used in the history editing modes.
.It Ev HISTSIZE
The number of lines in the history buffer for the shell.
.It Ev PWD
The logical value of the current working directory.  This is set by the
.Ic cd
command.
.It Ev OLDPWD
The previous logical value of the current working directory.  This is set by
the
.Ic cd
command.
.It Ev PPID
The process ID of the parent process of the shell.
.El
.Sh FILES
.Bl -item -width HOMEprofilexxxx




/*	$NetBSD: shell.h,v 1.14 2002/05/25 23:09:06 wiz Exp $	*/

/*-
 * Copyright (c) 1991, 1993

 */


#ifndef JOBS
#define JOBS 1
#endif
#ifndef BSD
#define BSD 1
#endif

#ifdef __STDC__
typedef void *pointer;
#ifndef NULL
#define NULL (void *)0
#endif
#define STATIC static
typedef char *pointer;
#ifndef NULL
#define NULL 0
#endif
#endif /*  not __STDC__ */
#define STATIC	/* empty */
#define MKINIT	/* empty */

#include <sys/cdefs.h>

#else
#define TRACE(param)
#endif

#if defined(__GNUC__) && __GNUC__ < 3
#define va_copy __va_copy
#endif




/*	$NetBSD: show.c,v 1.22 2002/05/25 23:09:06 wiz Exp $	*/

/*-
 * Copyright (c) 1991, 1993

#if 0
static char sccsid[] = "@(#)show.c	8.3 (Berkeley) 5/4/95";
#else
__RCSID("$NetBSD: show.c,v 1.22 2002/05/25 23:09:06 wiz Exp $");
#endif
#endif /* not lint */

#include <stdio.h>
#ifdef __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#include "shell.h"
#include "parser.h"

		putc('\t', fp);
	}
}
#endif




#endif


#ifdef DEBUG
void
trputc(c)
	int c;

	if (c == '\n')
		fflush(tracefile);
}
#endif

void
#ifdef __STDC__
trace(const char *fmt, ...)
#else
trace(va_alist)
	va_dcl
#endif
{
#ifdef DEBUG
	va_list va;

	va_start(va, fmt);
#else
	char *fmt;
	va_start(va);
	fmt = va_arg(va, char *);
#endif
	if (tracefile != NULL) {
		(void) vfprintf(tracefile, fmt, va);
		if (strchr(fmt, '\n'))
			(void) fflush(tracefile);
	}
	va_end(va);
#endif
}


#ifdef DEBUG
void
trputs(s)
	const char *s;

	}
	putc('"', tracefile);
}
#endif


void
trargs(ap)
	char **ap;
{
#ifdef DEBUG
	if (tracefile == NULL)
		return;
	while (*ap) {

			putc('\n', tracefile);
	}
	fflush(tracefile);
#endif
}


#ifdef DEBUG
void
opentrace() {
	char s[100];

#ifdef not_this_way
	{
		char *p;
		if ((p = getenv(homestr)) == NULL) {
			if (geteuid() == 0)
				p = "/";
			else




.
:
break
builtin
continue
eval
exec
exit
export
readonly
return
set
shift
times
trap
unset

Lines 48-53 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/trap.c (-160 / +98 lines)
48	#include <signal.h>	48	#include <signal.h>
49	#include <unistd.h>	49	#include <unistd.h>
50	#include <stdlib.h>	50	#include <stdlib.h>
		51	#include <string.h>
51		52
52	#include "shell.h"	53	#include "shell.h"
53	#include "main.h"	54	#include "main.h"
Lines 63-68 Link Here
63	#include "trap.h"	64	#include "trap.h"
64	#include "mystring.h"	65	#include "mystring.h"
65		66
		67	#ifdef HETIO
		68	#include "hetio.h"
		69	#endif
66		70
67	/*	71	/*
68	* Sigmode records the current value of the signal handlers for the various	72	* Sigmode records the current value of the signal handlers for the various
Lines 77-135 Link Here
77	#define S_RESET 5 /* temporary - to reset a hard ignored sig */	81	#define S_RESET 5 /* temporary - to reset a hard ignored sig */
78		82
79		83
80	char trap[NSIG+1]; / trap handler commands */	84	/* trap handler commands */
81	MKINIT char sigmode[NSIG]; /* current value of signal */	85	char *trap[NSIG];
82	char gotsig[NSIG]; /* indicates specified signal received */	86	/* current value of signal */
83	int pendingsigs; /* indicates some signal received */	87	STATIC char sigmode[NSIG - 1];
84		88	/* indicates specified signal received */
85	static int getsigaction __P((int, sig_t *));	89	STATIC char gotsig[NSIG - 1];
86	static int signame_to_signum __P((const char *));	90	/* last pending signal */
87	void printsignals __P((void));	91	volatile sig_atomic_t pendingsigs;
88
89	/*
90	* return the signal number described by `p' (as a number or a name)
91	* or -1 if it isn't one
92	*/
93
94	static int
95	signame_to_signum(p)
96	const char *p;
97	{
98	int i;
99
100	if (is_number(p))
101	return number(p);
102
103	if (strcasecmp(p, "exit") == 0 )
104	return 0;
105		92
106	if (strncasecmp(p, "sig", 3) == 0)	93	extern char *signal_names[];
107	p += 3;
108		94
109	for (i = 0; i < NSIG; ++i)	95	#ifdef mkinit
110	if (strcasecmp (p, sys_signame[i]) == 0)	96	INCLUDE <signal.h>
111	return i;	97	INIT {
112	return -1;	98	signal(SIGCHLD, SIG_DFL);
113	}	99	}
		100	#endif
114		101
115	/*
116	* Print a list of valid signal names
117	*/
118	void
119	printsignals(void)
120	{
121	int n;
122
123	out1str("EXIT ");
124
125	for (n = 1; n < NSIG; n++) {
126	out1fmt("%s", sys_signame[n]);
127	if ((n == NSIG/2) \|\| n == (NSIG - 1))
128	out1str("\n");
129	else
130	out1c(' ');
131	}
132	}
133		102
134	/*	103	/*
135	* The trap builtin.	104	* The trap builtin.
Lines 144-198 Link Here
144	char **ap;	113	char **ap;
145	int signo;	114	int signo;
146		115
147	if (argc <= 1) {	116	nextopt(nullstr);
148	for (signo = 0 ; signo <= NSIG ; signo++) {	117	ap = argptr;
149	if (trap[signo] != NULL)	118	if (!*ap) {
150	out1fmt("trap -- '%s' %s\n", trap[signo],	119	for (signo = 0 ; signo < NSIG ; signo++) {
151	(signo) ? sys_signame[signo] : "EXIT");	120	if (trap[signo] != NULL) {
		121	out1fmt(
		122	"trap -- %s %s\n",
		123	single_quote(trap[signo]),
		124	signal_names[signo]
		125	);
152	}	126	}
153	return 0;
154	}	127	}
155	ap = argv + 1;
156
157	action = NULL;
158
159	if (strcmp(*ap, "--") == 0)
160	if (*++ap == NULL)
161	return 0;
162
163	if (signame_to_signum(*ap) == -1) {
164	if ((*ap)[0] =='-') {
165	if ((*ap)[1] == NULL)
166	ap++;
167	else if ((ap)[1] == 'l' && (ap)[2] == NULL) {
168	printsignals();
169	return 0;	128	return 0;
170	}	129	}
171	else	130	if (!ap[1])
172	error("bad option %s\n", *ap);	131	action = NULL;
173	}
174	else	132	else
175	action = *ap++;	133	action = *ap++;
176	}
177
178	while (*ap) {	134	while (*ap) {
179	if (is_number(*ap))	135	if ((signo = decode_signal(*ap, 0)) < 0)
180	signo = number(*ap);
181	else
182	signo = signame_to_signum(*ap);
183
184	if (signo < 0 \|\| signo > NSIG)
185	error("%s: bad trap", *ap);	136	error("%s: bad trap", *ap);
186
187	INTOFF;	137	INTOFF;
188	if (action)	138	if (action) {
		139	if (action[0] == '-' && action[1] == '\0')
		140	action = NULL;
		141	else
189	action = savestr(action);	142	action = savestr(action);
190		143	}
191	if (trap[signo])	144	if (trap[signo])
192	ckfree(trap[signo]);	145	ckfree(trap[signo]);
193
194	trap[signo] = action;	146	trap[signo] = action;
195
196	if (signo != 0)	147	if (signo != 0)
197	setsignal(signo);	148	setsignal(signo);
198	INTON;	149	INTON;
Lines 211-217 Link Here
211	clear_traps() {	162	clear_traps() {
212	char **tp;	163	char **tp;
213		164
214	for (tp = trap ; tp <= &trap[NSIG] ; tp++) {	165	for (tp = trap ; tp < &trap[NSIG] ; tp++) {
215	if (tp && tp) { / trap not NULL or SIG_IGN */	166	if (tp && tp) { / trap not NULL or SIG_IGN */
216	INTOFF;	167	INTOFF;
217	ckfree(*tp);	168	ckfree(*tp);
Lines 230-242 Link Here
230	* out what it should be set to.	181	* out what it should be set to.
231	*/	182	*/
232		183
233	long	184	void
234	setsignal(signo)	185	setsignal(signo)
235	int signo;	186	int signo;
236	{	187	{
237	int action;	188	int action;
238	sig_t sigact = SIG_DFL;
239	char *t;	189	char *t;
		190	struct sigaction act;
240		191
241	if ((t = trap[signo]) == NULL)	192	if ((t = trap[signo]) == NULL)
242	action = S_DFL;	193	action = S_DFL;
Lines 279-293 Link Here
279	/*	230	/*
280	* current setting unknown	231	* current setting unknown
281	*/	232	*/
282	if (!getsigaction(signo, &sigact)) {	233	if (sigaction(signo, 0, &act) == -1) {
283	/*	234	/*
284	* Pretend it worked; maybe we should give a warning	235	* Pretend it worked; maybe we should give a warning
285	* here, but other shells don't. We don't alter	236	* here, but other shells don't. We don't alter
286	* sigmode, so that we retry every time.	237	* sigmode, so that we retry every time.
287	*/	238	*/
288	return 0;	239	return;
289	}	240	}
290	if (sigact == SIG_IGN) {	241	if (act.sa_handler == SIG_IGN) {
291	if (mflag && (signo == SIGTSTP \|\|	242	if (mflag && (signo == SIGTSTP \|\|
292	signo == SIGTTIN \|\| signo == SIGTTOU)) {	243	signo == SIGTTIN \|\| signo == SIGTTOU)) {
293	t = S_IGN; / don't hard ignore these */	244	t = S_IGN; / don't hard ignore these */
Lines 298-328 Link Here
298	}	249	}
299	}	250	}
300	if (t == S_HARD_IGN \|\| t == action)	251	if (t == S_HARD_IGN \|\| t == action)
301	return 0;	252	return;
302	switch (action) {	253	switch (action) {
303	case S_DFL: sigact = SIG_DFL; break;	254	case S_CATCH:
304	case S_CATCH: sigact = onsig; break;	255	act.sa_handler = onsig;
305	case S_IGN: sigact = SIG_IGN; break;	256	break;
		257	case S_IGN:
		258	act.sa_handler = SIG_IGN;
		259	break;
		260	default:
		261	act.sa_handler = SIG_DFL;
306	}	262	}
307	*t = action;	263	*t = action;
308	siginterrupt(signo, 1);	264	act.sa_flags = 0;
309	return (long)signal(signo, sigact);	265	sigfillset(&act.sa_mask);
310	}	266	sigaction(signo, &act, 0);
311
312	/*
313	* Return the current setting for sig w/o changing it.
314	*/
315	static int
316	getsigaction(signo, sigact)
317	int signo;
318	sig_t *sigact;
319	{
320	struct sigaction sa;
321
322	if (sigaction(signo, (struct sigaction *)0, &sa) == -1)
323	return 0;
324	*sigact = (sig_t) sa.sa_handler;
325	return 1;
326	}	267	}
327		268
328	/*	269	/*
Lines 340-361 Link Here
340	}	281	}
341		282
342		283
343	#ifdef mkinit
344	INCLUDE <signal.h>
345	INCLUDE "trap.h"
346
347	SHELLPROC {
348	char *sm;
349
350	clear_traps();
351	for (sm = sigmode ; sm < sigmode + NSIG ; sm++) {
352	if (*sm == S_IGN)
353	*sm = S_HARD_IGN;
354	}
355	}
356	#endif
357
358
359		284
360	/*	285	/*
361	* Signal handler.	286	* Signal handler.
Lines 365-377 Link Here
365	onsig(signo)	290	onsig(signo)
366	int signo;	291	int signo;
367	{	292	{
368	signal(signo, onsig);
369	if (signo == SIGINT && trap[SIGINT] == NULL) {	293	if (signo == SIGINT && trap[SIGINT] == NULL) {
370	onint();	294	if (suppressint) {
		295	((sig_atomic_t ) &intpending)++;
371	return;	296	return;
372	}	297	}
		298	onint();
		299	}
373	gotsig[signo - 1] = 1;	300	gotsig[signo - 1] = 1;
374	pendingsigs++;	301	pendingsigs = signo;
375	}	302	}
376		303
377		304
Lines 383-405 Link Here
383		310
384	void	311	void
385	dotrap() {	312	dotrap() {
386	int i;	313	char *p;
387	int savestatus;	314	int savestatus;
388		315
389	for (;;) {	316	while (pendingsigs = 0, barrier(), (p = memchr(gotsig, 1, NSIG - 1))) {
390	for (i = 1 ; ; i++) {	317	*p = 0;
391	if (gotsig[i - 1])
392	break;
393	if (i >= NSIG)
394	goto done;
395	}
396	gotsig[i - 1] = 0;
397	savestatus=exitstatus;	318	savestatus=exitstatus;
398	evalstring(trap[i], 0);	319	evalstring(trap[p - gotsig + 1], 0);
399	exitstatus=savestatus;	320	exitstatus=savestatus;
400	}	321	}
401	done:
402	pendingsigs = 0;
403	}	322	}
404		323
405		324
Lines 415-426 Link Here
415	{	334	{
416	static int is_interactive;	335	static int is_interactive;
417		336
418	if (on == is_interactive)	337	if (++on == is_interactive)
419	return;	338	return;
		339	is_interactive = on;
420	setsignal(SIGINT);	340	setsignal(SIGINT);
421	setsignal(SIGQUIT);	341	setsignal(SIGQUIT);
422	setsignal(SIGTERM);	342	setsignal(SIGTERM);
423	is_interactive = on;
424	}	343	}
425		344
426		345
Lines 430-458 Link Here
430	*/	349	*/
431		350
432	void	351	void
433	exitshell(status)	352	exitshell(void)
434	int status;
435	{	353	{
436	struct jmploc loc1, loc2;	354	struct jmploc loc;
437	char *p;	355	char *p;
		356	int status;
438		357
		358	status = exitstatus;
439	TRACE(("exitshell(%d) pid=%d\n", status, getpid()));	359	TRACE(("exitshell(%d) pid=%d\n", status, getpid()));
440	if (setjmp(loc1.loc)) {	360	#ifdef HETIO
441	goto l1;	361	hetio_reset_term();
442	}	362	#endif
443	if (setjmp(loc2.loc)) {	363	if (setjmp(loc.loc)) {
444	goto l2;	364	goto out;
445	}	365	}
446	handler = &loc1;	366	handler = &loc;
447	if ((p = trap[0]) != NULL && *p != '\0') {	367	if ((p = trap[0]) != NULL && *p != '\0') {
448	trap[0] = NULL;	368	trap[0] = NULL;
449	evalstring(p, 0);	369	evalstring(p, 0);
450	}	370	}
451	l1: handler = &loc2; /* probably unnecessary */
452	flushall();	371	flushall();
453	#if JOBS	372	out:
454	setjobctl(0);	373	_exit(status);
455	#endif
456	l2: _exit(status);
457	/* NOTREACHED */	374	/* NOTREACHED */
458	}	375	}
		376
		377	int decode_signal(const char *string, int minsig)
		378	{
		379	int signo;
		380
		381	if (is_number(string)) {
		382	signo = atoi(string);
		383	if (signo >= NSIG) {
		384	return -1;
		385	}
		386	return signo;
		387	}
		388
		389	for (signo = minsig; signo < NSIG; signo++) {
		390	if (!strcasecmp(string, signal_names[signo])) {
		391	return signo;
		392	}
		393	}
		394
		395	return -1;
		396	}




 *	@(#)trap.h	8.3 (Berkeley) 6/5/95
 */

#include <signal.h>

extern volatile sig_atomic_t pendingsigs;
extern char *trap[];

int trapcmd __P((int, char **));
void clear_traps __P((void));
void setsignal __P((int));
void ignoresig __P((int));
void onsig __P((int));
void dotrap __P((void));
void setinteractive __P((int));
void exitshell __P((void)) __attribute__((noreturn));
int decode_signal __P((const char *, int));




#include "error.h"
#include "mystring.h"
#include "parser.h"
#include "mail.h"
#ifndef SMALL
#include "myhistedit.h"
#endif

#define VTABSIZE 39


struct localvar *localvars;
	struct var *var;
	int flags;
	const char *text;
	void (*func) __P((const char *));
};


const char defpathvar[] =
	"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
#ifdef IFS_BROKEN
const char defifsvar[] = "IFS= \t\n";
#else
const char defifs[] = " \t\n";
#endif
struct var vifs;
struct var vmail;
struct var vmpath;
struct var vpath;
struct var vps1;
struct var vps2;
struct var vvers;
struct var voptind;

struct var varinit[] = {
#if ATTY
	{ 0,	VSTRFIXED|VTEXTFIXED|VUNSET,	"ATTY=",	0 },
	  NULL },
#endif
#ifdef IFS_BROKEN
	{ 0,	VSTRFIXED|VTEXTFIXED,		defifsvar,	0 },
#else
	{ 0,	VSTRFIXED|VTEXTFIXED|VUNSET,	"IFS=",		0 },
#endif
	{ 0,	VSTRFIXED|VTEXTFIXED|VUNSET,	"MAIL=",	changemail },
	{ 0,	VSTRFIXED|VTEXTFIXED|VUNSET,	"MAILPATH=",	changemail },
	{ 0,	VSTRFIXED|VTEXTFIXED,		defpathvar,	changepath },
	{ 0,	VSTRFIXED|VTEXTFIXED,		"PS1=$ ",	0 },
	{ 0,	VSTRFIXED|VTEXTFIXED,		"PS2=> ",	0 },
	{ 0,	VSTRFIXED|VTEXTFIXED,		"OPTIND=1",	getoptsreset },
	{ &vpath,	VSTRFIXED|VTEXTFIXED,		"PATH=" _PATH_DEFPATH,
	  changepath },
	/*
	 * vps1 depends on uid
	 */
	{ &vps2,	VSTRFIXED|VTEXTFIXED,		"PS2=> ",
	  NULL },
#ifndef SMALL
	{ 0,	VSTRFIXED|VTEXTFIXED|VUNSET,	"TERM=",	0 },
	{ 0,	VSTRFIXED|VTEXTFIXED|VUNSET,	"HISTSIZE=",	sethistsize },
#endif
	{ &voptind,	VSTRFIXED|VTEXTFIXED,		"OPTIND=1",
	  getoptsreset },
	{ NULL,	0,				NULL,
	  NULL }
};

STATIC struct var *vartab[VTABSIZE];

STATIC struct var **hashvar __P((const char *));
STATIC void showvars __P((const char *, int, int));
STATIC struct var **findvar __P((struct var **, const char *));

/*
 * Initialize the varable symbol tables and import the environment
 */

#ifdef mkinit
INCLUDE <unistd.h>
INCLUDE "cd.h"
INCLUDE "output.h"
INCLUDE "var.h"
MKINIT char **environ;
INIT {
	char **envp;
	static char ppid[32 + 5] = "PPID=";

	initvar();
	for (envp = environ ; *envp ; envp++) {

			setvareq(*envp, VEXPORT|VTEXTFIXED);
		}
	}

	fmtstr(ppid + 5, sizeof(ppid) - 5, "%ld", (long) getppid());
	setvareq(ppid, VTEXTFIXED);
	setpwd(0, 0);
}
#endif


/*
 * This routine initializes the builtin variables.  It is called when the
 * shell is initialized.
 */

void
initvar() {
	const struct varinit *ip;
	struct var *vp;
	struct var *end;
	struct var **vpp;

	vp = varinit;
	end = vp + sizeof(varinit) / sizeof(varinit[0]);
	do {
		vpp = hashvar(vp->text);
			vp->next = *vpp;
			*vpp = vp;
	} while (++vp < end);
			vp->flags = ip->flags;
			vp->func = ip->func;
		}
	}
	/*
	 * PS1 depends on uid
	 */
	if (!geteuid())
		vps1.text = "PS1=# ";
		vps1.next = *vpp;
		*vpp = &vps1;
		vps1.text = strdup(geteuid() ? "PS1=$ " : "PS1=# ");
		vps1.flags = VSTRFIXED|VTEXTFIXED;
	}
}

/*

	const char *name, *val;
	int flags;
{
	int err;
	volatile int saveint;
	struct jmploc *volatile savehandler = handler;
	struct jmploc jmploc;
#ifdef __GNUC__
	(void) &err;
#endif

	SAVEINT(saveint);
	if (setjmp(jmploc.loc))
		err = 1;
	else {
		handler = &jmploc;
		setvar(name, val, flags);
		err = 0;
	}
	handler = savehandler;
	RESTOREINT(saveint);
	return err;
}


	const char *name, *val;
	int flags;
{
	char *p, *q;
	size_t namelen;
	char *d;
	int len;
	int namelen;
	char *nameeq;
	size_t vallen;

	q = endofname(name);
	p = strchrnul(q, '=');
	if (! is_name(*p))
		isbad = 1;
	p++;
	for (;;) {
		if (! is_in_name(*p)) {
			if (*p == '\0' || *p == '=')
				break;
			isbad = 1;
		}
		p++;
	}
	namelen = p - name;
	if (!namelen || p != q)
		error("%.*s: bad variable name", namelen, name);
	vallen = 0;
	if (val == NULL) {
		flags |= VUNSET;
	} else {
		vallen = strlen(val);
	}
	INTOFF;
	p = mempcpy(nameeq = ckmalloc(namelen + vallen + 2), name, namelen);
	*p++ = '=';
	if (vallen) {
		p = mempcpy(p, val, vallen);
	}
	*p = '\0';
		scopy(val, d);
	setvareq(nameeq, flags);
	INTON;
}



{
	struct var *vp, **vpp;

	if (aflag)
		flags |= VEXPORT;
	vpp = hashvar(s);
	flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
	vp = *findvar(vpp, s);
	INTOFF;
	if (vp) {
			if (vp->flags & VREADONLY) {
				size_t len = strchr(s, '=') - s;
				error("%.*s: is read only", len, s);
			}
			INTOFF;

			if (vp->func && (flags & VNOFUNC) == 0)
				(*vp->func)(strchr(s, '=') + 1);

			if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
				ckfree(vp->text);

		flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VUNSET);
	} else {
			vp->text = s;

			/*
			 * We could roll this to a function, to handle it as
			 * a regular variable function callback, but why bother?
			 */
			if (vp == &vmpath || (vp == &vmail && ! mpathset()))
				chkmail(1);
			INTON;
			return;
		}
	}
	/* not found */
	vp = ckmalloc(sizeof (*vp));
	vp->flags = flags;
	vp->text = s;
	vp->next = *vpp;
	vp->func = NULL;
	*vpp = vp;
	}
	vp->text = s;
	vp->flags = flags;
	INTON;
}



 */

void
listsetvar(struct strlist *list, int flags)
{
	{
	struct strlist *lp;

	INTOFF;
	for (lp = list ; lp ; lp = lp->next) {
		setvareq(savestr(lp->text), flags);
	}
	INTON;
}

	{
	struct var *v;

	if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) {
		if (varequal(v->text, name)) {
			if (v->flags & VUNSET)
				return NULL;
			return strchr(v->text, '=') + 1;
		}
	}
	return NULL;
}



/*
 * Search the environment of a builtin command.
 * is nonzero, return the value of a variable even if it hasn't been
 * exported.
 */

char *
bltinlookup(name)
	const char *name;
	int doall;
{
	struct strlist *sp;
	struct var *v;

	for (sp = cmdenviron ; sp ; sp = sp->next) {
		if (varequal(sp->text, name))
			return strchr(sp->text, '=') + 1;
	}
	return lookupvar(name);
		if (varequal(v->text, name)) {
			if ((v->flags & VUNSET)
			 || (!doall && (v->flags & VEXPORT) == 0))
				return NULL;
			return strchr(v->text, '=') + 1;
		}
	}
	return NULL;
}




char **
environment() {
	int nenv;
	struct var **vpp;
	struct var *vp;
	char **env;
	char **ep;
	void *epend;

	STARTSTACKSTR(ep);
	epend = sstrend;
	vpp = vartab;
	do {
				nenv++;
	}
	ep = env = stalloc((nenv + 1) * sizeof *env);
	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
		for (vp = *vpp ; vp ; vp = vp->next)
			if (vp->flags & VEXPORT && !(vp->flags & VUNSET)) {
				if (ep == epend) {
					ep = growstackstr();
					epend = sstrend;
	return env;
}


/*
 * Called when a shell procedure is invoked to clear out nonexported
 * variables.  It is also necessary to reallocate variables of with
 * VSTACK set since these are currently allocated on the stack.
 */

#ifdef mkinit
void shprocvar __P((void));

SHELLPROC {
	shprocvar();
}
#endif

void
shprocvar() {
	struct var **vpp;
	struct var *vp, **prev;

	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
		for (prev = vpp ; (vp = *prev) != NULL ; ) {
			if ((vp->flags & VEXPORT) == 0) {
				*prev = vp->next;
				if ((vp->flags & VTEXTFIXED) == 0)
					ckfree(vp->text);
				if ((vp->flags & VSTRFIXED) == 0)
					ckfree(vp);
			} else {
				if (vp->flags & VSTACK) {
					vp->text = savestr(vp->text);
					vp->flags &=~ VSTACK;
				}
				prev = &vp->next;
			}
		}
				*ep++ = (char *) vp->text;
	}
	} while (++vpp < vartab + VTABSIZE);
	if (ep == epend)
		ep = growstackstr();
	*ep++ = NULL;
	return grabstackstr(ep);
}



	int argc;
	char **argv;
{
	showvars(nullstr, VUNSET, VUNSET);
	struct var *vp;

	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
		for (vp = *vpp ; vp ; vp = vp->next) {
			if ((vp->flags & VUNSET) == 0)
				out1fmt("%s\n", vp->text);
		}
	}
	return 0;
}


	int argc;
	char **argv;
{
	struct var **vpp;
	struct var *vp;
	char *name;
	const char *p;
	char **aptr;
	int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
	int notp;

	notp = nextopt("p") - 'p';
	if (notp && ((name = *(aptr = argptr)))) {
		do {
		while ((name = *argptr++) != NULL) {
			if ((p = strchr(name, '=')) != NULL) {
				p++;
			} else {
				if ((vp = *findvar(hashvar(name), name))) {
				for (vp = *vpp ; vp ; vp = vp->next) {
					if (varequal(vp->text, name)) {
						vp->flags |= flag;
					continue;
					}
				}
			}
			setvar(name, p, flag);
		} while ((name = *++aptr) != NULL);
		}
	} else {
		for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
			for (vp = *vpp ; vp ; vp = vp->next) {
				if ((vp->flags & flag) == 0)
					continue;
				if (pflag) {
					out1fmt("%s %s\n", argv[0], vp->text);
				} else {
		showvars(argv[0], flag, 0);
						out1c(*p);
					out1c('\n');
				}
			}
		}
	}
	return 0;
}

		vp = NULL;
	} else {
		vpp = hashvar(name);
		vp = *findvar(vpp, name);
		if (vp == NULL) {
			if (strchr(name, '='))
				setvareq(savestr(name), VSTRFIXED);


	for (ap = argptr; *ap ; ap++) {
		if (flg_func)
			unsetfunc(*ap);
		if (flg_var)
			ret |= unsetvar(*ap);
	}

	struct var **vpp;
	struct var *vp;

	vpp = findvar(hashvar(s), s);
	vp = *vpp;
	if (vp) {
			if (vp->flags & VREADONLY)
				return (1);
			INTOFF;

			INTON;
			return (0);
		}
	}

	return (0);
}



 * either '=' or '\0'.
 */

int
varequal(p, q)
	const char *p, *q;
	{

		return 1;
	return 0;
}

STATIC void
showvars(const char *prefix, int mask, int xor)
{
	struct var **vpp;
	struct var *vp;
	const char *sep = *prefix ? spcstr : prefix;

	vpp = vartab;
	do {
		for (vp = *vpp ; vp ; vp = vp->next) {
			if ((vp->flags & mask) ^ xor) {
				const char *p;
				const char *q;
				int len;

				p = strchr(vp->text, '=');
				q = nullstr;
				if (!(vp->flags & VUNSET))
					q = single_quote(++p);
				len = p - vp->text;

				out1fmt(
					"%s%s%.*s%s\n", prefix, sep, len,
					vp->text, q
				);
			}
		}
	} while (++vpp < vartab + VTABSIZE);
}

STATIC struct var **
findvar(struct var **vpp, const char *name)
{
	for (; *vpp; vpp = &(*vpp)->next) {
		if (varequal((*vpp)->text, name)) {
			break;
		}
	}
	return vpp;
}




struct var {
	struct var *next;		/* next entry in hash list */
	int flags;			/* flags are defined above */
	const char *text;		/* name=value */
	void (*func) __P((const char *));
					/* function to be called when  */
					/* the variable gets set/unset */

	struct localvar *next;		/* next local variable in list */
	struct var *vp;			/* the variable that was made local */
	int flags;			/* saved flags */
	const char *text;		/* saved text */
};


extern struct localvar *localvars;
extern struct var varinit[];

#if ATTY
#define vatty varinit[0]
#define vifs varinit[1]
#else
#define vifs varinit[0]
#endif
#define vmail (&vifs)[1]
#define vmpath (&vmail)[1]
#define vpath (&vmpath)[1]
#define vps1 (&vpath)[1]
#define vps2 (&vps1)[1]
#define voptind (&vps2)[1]
#ifndef SMALL
#define vterm (&voptind)[1]
#define vhistsize (&vterm)[1]
#endif

#ifdef IFS_BROKEN
extern const char defifsvar[];
#define defifs (defifsvar + 4)
#else
extern const char defifs[];
#endif
extern const char defpathvar[];
#define defpath (defpathvar + 5)

/*
 * The following macros access the values of the above variables.

void setvar __P((const char *, const char *, int));
void setvareq __P((char *, int));
struct strlist;
void listsetvar __P((struct strlist *, int));
char *lookupvar __P((const char *));
char *bltinlookup __P((const char *));
char **environment __P((void));
void shprocvar __P((void));
int showvarscmd __P((int, char **));
int exportcmd __P((int, char **));
int localcmd __P((int, char **));

int unsetcmd __P((int, char **));
int unsetvar __P((const char *));
int setvarsafe __P((const char *, const char *, int));
int varequal __P((const char *, const char *));




#!/bin/sh
# 
# Quick script to reformat yacc commands
# so byacc isnt required.
# 
# Expects:
# 	yacc -d -o yourfile.c yourfile.y
# Executes:
# 	yacc -d -b yourfile yourfile.y
# 	mv yourfile.tab.c yourfile.c
# 	mv yourfile.tab.h yourfile.h
#

yaccbin="/usr/bin/yacc"
yaccflags="-d"

[ ! ${#} -gt 0 ] && exit 1
while getopts ":o:" opt
do
        case $opt in
                o) output=${OPTARG%*.c} ;;
                ?) ;;
        esac
done
${yaccbin} ${yaccflags} -b ${output} ${output}.y || exit 1
for files in ${output}.tab.{c,h}
do
	mv ${files} $(sed 's/.tab//' <<< ${files}) || exit 1
done

Return to bug 15319

Lines 55-60 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/arith.y (-3 / +4 lines)
55		55
56	const char arith_buf, arith_startbuf;	56	const char arith_buf, arith_startbuf;
57		57
		58	int yyparse __P((void));
58	void yyerror __P((const char *));	59	void yyerror __P((const char *));
59	#ifdef TESTARITH	60	#ifdef TESTARITH
60	int main __P((int , char *[]));	61	int main __P((int , char *[]));
Lines 84-91 Link Here
84		85
85		86
86	expr: ARITH_LPAREN expr ARITH_RPAREN = { $$ = $2; }	87	expr: ARITH_LPAREN expr ARITH_RPAREN = { $$ = $2; }
87	\| expr ARITH_OR expr = { $$ = $1 ? $1 : $3 ? $3 : 0; }	88	\| expr ARITH_OR expr = { $$ = $1 \|\| $3; }
88	\| expr ARITH_AND expr = { $$ = $1 ? ( $3 ? $3 : 0 ) : 0; }	89	\| expr ARITH_AND expr = { $$ = $1 && $3; }
89	\| expr ARITH_BOR expr = { $$ = $1 \| $3; }	90	\| expr ARITH_BOR expr = { $$ = $1 \| $3; }
90	\| expr ARITH_BXOR expr = { $$ = $1 ^ $3; }	91	\| expr ARITH_BXOR expr = { $$ = $1 ^ $3; }
91	\| expr ARITH_BAND expr = { $$ = $1 & $3; }	92	\| expr ARITH_BAND expr = { $$ = $1 & $3; }
Lines 166-172 Link Here
166	p = grabstackstr(concat);	167	p = grabstackstr(concat);
167	}	168	}
168	} else	169	} else
169	p = "";	170	p = nullstr;
170		171
171	i = arith(p);	172	i = arith(p);
172		173

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/arith_yylex.c (+162 lines)
		1	/* $Id: arith_yylex.c,v 1.3 2002/10/26 11:37:45 herbert Exp $ */
		2
		3	/*-
		4	* Copyright (c) 2002
		5	* Herbert Xu.
		6	* Copyright (c) 1993
		7	* The Regents of the University of California. All rights reserved.
		8	*
		9	* This code is derived from software contributed to Berkeley by
		10	* Kenneth Almquist.
		11	*
		12	* Redistribution and use in source and binary forms, with or without
		13	* modification, are permitted provided that the following conditions
		14	* are met:
		15	* 1. Redistributions of source code must retain the above copyright
		16	* notice, this list of conditions and the following disclaimer.
		17	* 2. Redistributions in binary form must reproduce the above copyright
		18	* notice, this list of conditions and the following disclaimer in the
		19	* documentation and/or other materials provided with the distribution.
		20	* 3. Neither the name of the University nor the names of its contributors
		21	* may be used to endorse or promote products derived from this software
		22	* without specific prior written permission.
		23	*
		24	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
		25	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		27	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
		28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		30	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		31	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
		32	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
		33	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		34	* SUCH DAMAGE.
		35	*/
		36
		37	#include <stdlib.h>
		38	#include "arith.h"
		39	#include "expand.h"
		40	#include "error.h"
		41
		42	extern int yylval;
		43	extern const char arith_buf, arith_startbuf;
		44
		45	int
		46	yylex()
		47	{
		48	int value;
		49	const char *buf = arith_buf;
		50
		51	for (;;) {
		52	switch (*buf) {
		53	case ' ':
		54	case '\t':
		55	case '\n':
		56	buf++;
		57	continue;
		58	default:
		59	err:
		60	error("arith: syntax error: \"%s\"", arith_startbuf);
		61	/* NOTREACHED */
		62	case '0':
		63	case '1':
		64	case '2':
65	case '3':
66	case '4':
67	case '5':
68	case '6':
69	case '7':
70	case '8':
71	case '9':
72	yylval = strtol(buf, (char **) &arith_buf, 0);
73	return ARITH_NUM;
74	case '=':
75	if (*++buf != '=') {
76	goto err;
77	}
78	value = ARITH_EQ;
79	break;
80	case '>':
81	switch (*++buf) {
82	case '=':
83	value = ARITH_GE;
84	break;
85	case '>':
86	value = ARITH_RSHIFT;
87	break;
88	default:
89	value = ARITH_GT;
90	goto out;
91	}
92	break;
93	case '<':
94	switch (*++buf) {
95	case '=':
96	value = ARITH_LE;
97	break;
98	case '<':
99	value = ARITH_LSHIFT;
100	break;
101	default:
102	value = ARITH_LT;
103	goto out;
104	}
105	break;
106	case '\|':
107	if (*++buf != '\|') {
108	value = ARITH_BOR;
109	goto out;
110	}
111	value = ARITH_OR;
112	break;
113	case '&':
114	if (*++buf != '&') {
115	value = ARITH_BAND;
116	goto out;
117	}
118	value = ARITH_AND;
119	break;
120	case '!':
121	if (*++buf != '=') {
122	value = ARITH_NOT;
123	goto out;
124	}
125	value = ARITH_NE;
126	break;
127	case 0:
128	value = 0;
129	goto out;
130	case '(':
131	value = ARITH_LPAREN;
132	break;
133	case ')':
134	value = ARITH_RPAREN;
135	break;
136	case '*':
137	value = ARITH_MUL;
138	break;
139	case '/':
140	value = ARITH_DIV;
141	break;
142	case '%':
143	value = ARITH_REM;
144	break;
145	case '+':
146	value = ARITH_ADD;
147	break;
148	case '-':
149	value = ARITH_SUB;
150	break;
151	case '~':
152	value = ARITH_BNOT;
153	break;
154	}
155	break;
156	}
157
158	buf++;
159	out:
160	arith_buf = buf;
161	return value;
162	}

Lines 44-107 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/bltin/echo.c (-46 / +30 lines)
44		44
45	#define main echocmd	45	#define main echocmd
46		46
		47	#ifdef USE_GLIBC_STDIO
		48	#include <stdio.h>
		49
		50	#include "../mystring.h"
		51	#else
47	#include "bltin.h"	52	#include "bltin.h"
		53	#endif
48		54
49	/* #define eflag 1 */	55	int print_escape_str(const char *);
50		56
51	int	57	int
52	main(argc, argv) char **argv; {	58	main(int argc, char **argv) {
53	register char **ap;
54	register char *p;
55	register char c;
56	int count;
57	int nflag = 0;	59	int nflag = 0;
58	#ifndef eflag	60	int c = ' ';
59	int eflag = 0;
60	#endif
61		61
62	ap = argv;	62	argv++;
63	if (argc)	63	if (argv && equal(argv, "-n")) {
64	ap++;	64	argv++;
65	if ((p = *ap) != NULL) {	65	nflag = 1;
66	if (equal(p, "-n")) {
67	nflag++;
68	ap++;
69	} else if (equal(p, "-e")) {
70	#ifndef eflag
71	eflag++;
72	#endif
73	ap++;
74	}	66	}
		67
		68	if (!*argv) {
		69	goto end;
75	}	70	}
76	while ((p = *ap++) != NULL) {	71
77	while ((c = *p++) != '\0') {	72	do {
78	if (c == '\\' && eflag) {	73	if (print_escape_str(*argv)) {
79	switch (*p++) {
80	case 'b': c = '\b'; break;
81	case 'c': return 0; /* exit */
82	case 'f': c = '\f'; break;
83	case 'n': c = '\n'; break;
84	case 'r': c = '\r'; break;
85	case 't': c = '\t'; break;
86	case 'v': c = '\v'; break;
87	case '\\': break; /* c = '\\' */
88	case '0':
89	c = 0;
90	count = 3;
91	while (--count >= 0 && (unsigned)(*p - '0') < 8)
92	c = (c << 3) + (*p++ - '0');
93	break;	74	break;
94	default:	75	}
95	p--;	76	if (!*++argv) {
		77	end:
		78	if (nflag) {
96	break;	79	break;
97	}	80	}
		81	c = '\n';
98	}	82	}
99	putchar(c);	83	putchar(c);
100	}	84	} while (c == ' ');
101	if (*ap)	85	#ifdef SHELL
102	putchar(' ');
103	}
104	if (! nflag)
105	putchar('\n');
106	return 0;	86	return 0;
		87	#else
		88	fflush(stdout);
		89	return ferror(stdout);
		90	#endif
107	}	91	}

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/bltin/printf.1 (+281 lines)
		1	.\" $NetBSD: printf.1,v 1.15 2002/02/08 01:36:31 ross Exp $
		2	.\"
		3	.\" Copyright (c) 1989, 1990, 1993
		4	.\" The Regents of the University of California. All rights reserved.
		5	.\"
		6	.\" This code is derived from software contributed to Berkeley by
		7	.\" the Institute of Electrical and Electronics Engineers, Inc.
		8	.\"
		9	.\" Redistribution and use in source and binary forms, with or without
		10	.\" modification, are permitted provided that the following conditions
		11	.\" are met:
		12	.\" 1. Redistributions of source code must retain the above copyright
		13	.\" notice, this list of conditions and the following disclaimer.
		14	.\" 2. Redistributions in binary form must reproduce the above copyright
		15	.\" notice, this list of conditions and the following disclaimer in the
		16	.\" documentation and/or other materials provided with the distribution.
		17	.\" 3. All advertising materials mentioning features or use of this software
		18	.\" must display the following acknowledgement:
		19	.\" This product includes software developed by the University of
		20	.\" California, Berkeley and its contributors.
		21	.\" 4. Neither the name of the University nor the names of its contributors
		22	.\" may be used to endorse or promote products derived from this software
		23	.\" without specific prior written permission.
		24	.\"
		25	.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
		26	.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		27	.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		28	.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
		29	.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		30	.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		31	.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		32	.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
		33	.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
		34	.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		35	.\" SUCH DAMAGE.
		36	.\"
		37	.\" from: @(#)printf.1 8.1 (Berkeley) 6/6/93
		38	.\"
		39	.Dd November 5, 1993
		40	.Dt PRINTF 1
		41	.Os
		42	.Sh NAME
		43	.Nm printf
		44	.Nd formatted output
		45	.Sh SYNOPSIS
		46	.Nm
		47	.Ar format
		48	.Op Ar arguments ...
		49	.Sh DESCRIPTION
		50	.Nm
		51	formats and prints its arguments, after the first, under control
		52	of the
		53	.Ar format .
		54	The
		55	.Ar format
		56	is a character string which contains three types of objects: plain characters,
		57	which are simply copied to standard output, character escape sequences which
		58	are converted and copied to the standard output, and format specifications,
		59	each of which causes printing of the next successive
		60	.Ar argument .
		61	.Pp
		62	The
		63	.Ar arguments
		64	after the first are treated as strings if the corresponding format is
65	either
66	.Cm b ,
67	.Cm c
68	or
69	.Cm s ;
70	otherwise it is evaluated as a C constant, with the following extensions:
71	.Pp
72	.Bl -bullet -offset indent -compact
73	.It
74	A leading plus or minus sign is allowed.
75	.It
76	If the leading character is a single or double quote, the value is the
77	.Tn ASCII
78	code of the next character.
79	.El
80	.Pp
81	The format string is reused as often as necessary to satisfy the
82	.Ar arguments .
83	Any extra format specifications are evaluated with zero or the null
84	string.
85	.Pp
86	Character escape sequences are in backslash notation as defined in
87	.St -ansiC .
88	The characters and their meanings
89	are as follows:
90	.Bl -tag -width Ds -offset indent
91	.It Cm \ee
92	Write an \[Lt]escape\[Gt] character.
93	.It Cm \ea
94	Write a \[Lt]bell\[Gt] character.
95	.It Cm \eb
96	Write a \[Lt]backspace\[Gt] character.
97	.It Cm \ef
98	Write a \[Lt]form-feed\[Gt] character.
99	.It Cm \en
100	Write a \[Lt]new-line\[Gt] character.
101	.It Cm \er
102	Write a \[Lt]carriage return\[Gt] character.
103	.It Cm \et
104	Write a \[Lt]tab\[Gt] character.
105	.It Cm \ev
106	Write a \[Lt]vertical tab\[Gt] character.
107	.It Cm \e\'
108	Write a \[Lt]single quote\[Gt] character.
109	.It Cm \e\e
110	Write a backslash character.
111	.It Cm \e Ns Ar num
112	Write an 8-bit character whose
113	.Tn ASCII
114	value is the 1-, 2-, or 3-digit
115	octal number
116	.Ar num .
117	.El
118	.Pp
119	Each format specification is introduced by the percent character
120	(``%'').
121	The remainder of the format specification includes,
122	in the following order:
123	.Bl -tag -width Ds
124	.It "Zero or more of the following flags:"
125	.Bl -tag -width Ds
126	.It Cm #
127	A `#' character
128	specifying that the value should be printed in an ``alternative form''.
129	For
130	.Cm c ,
131	.Cm d ,
132	and
133	.Cm s ,
134	formats, this option has no effect. For the
135	.Cm o
136	formats the precision of the number is increased to force the first
137	character of the output string to a zero. For the
138	.Cm x
139	.Pq Cm X
140	format, a non-zero result has the string
141	.Li 0x
142	.Pq Li 0X
143	prepended to it. For
144	.Cm e ,
145	.Cm E ,
146	.Cm f ,
147	.Cm g ,
148	and
149	.Cm G ,
150	formats, the result will always contain a decimal point, even if no
151	digits follow the point (normally, a decimal point only appears in the
152	results of those formats if a digit follows the decimal point). For
153	.Cm g
154	and
155	.Cm G
156	formats, trailing zeros are not removed from the result as they
157	would otherwise be;
158	.It Cm \&\-
159	A minus sign `\-' which specifies
160	.Em left adjustment
161	of the output in the indicated field;
162	.It Cm \&+
163	A `+' character specifying that there should always be
164	a sign placed before the number when using signed formats.
165	.It Sq \&\ \&
166	A space specifying that a blank should be left before a positive number
167	for a signed format. A `+' overrides a space if both are used;
168	.It Cm \&0
169	A zero `0' character indicating that zero-padding should be used
170	rather than blank-padding. A `\-' overrides a `0' if both are used;
171	.El
172	.It "Field Width:"
173	An optional digit string specifying a
174	.Em field width ;
175	if the output string has fewer characters than the field width it will
176	be blank-padded on the left (or right, if the left-adjustment indicator
177	has been given) to make up the field width (note that a leading zero
178	is a flag, but an embedded zero is part of a field width);
179	.It Precision :
180	An optional period,
181	.Sq Cm \&.\& ,
182	followed by an optional digit string giving a
183	.Em precision
184	which specifies the number of digits to appear after the decimal point,
185	for
186	.Cm e
187	and
188	.Cm f
189	formats, or the maximum number of characters to be printed
190	from a string; if the digit string is missing, the precision is treated
191	as zero;
192	.It Format :
193	A character which indicates the type of format to use (one of
194	.Cm diouxXfwEgGbcs ) .
195	.El
196	.Pp
197	A field width or precision may be
198	.Sq Cm \&*
199	instead of a digit string.
200	In this case an
201	.Ar argument
202	supplies the field width or precision.
203	.Pp
204	The format characters and their meanings are:
205	.Bl -tag -width Fl
206	.It Cm diouXx
207	The
208	.Ar argument
209	is printed as a signed decimal (d or i), unsigned octal, unsigned decimal,
210	or unsigned hexadecimal (X or x), respectively.
211	.It Cm f
212	The
213	.Ar argument
214	is printed in the style
215	.Sm off
216	.Pf [\-]ddd Cm \&. No ddd
217	.Sm on
218	where the number of d's
219	after the decimal point is equal to the precision specification for
220	the argument.
221	If the precision is missing, 6 digits are given; if the precision
222	is explicitly 0, no digits and no decimal point are printed.
223	.It Cm eE
224	The
225	.Ar argument
226	is printed in the style
227	.Sm off
228	.Pf [\-]d Cm \&. No ddd Cm e No \\*(Pmdd
229	.Sm on
230	where there
231	is one digit before the decimal point and the number after is equal to
232	the precision specification for the argument; when the precision is
233	missing, 6 digits are produced.
234	An upper-case E is used for an `E' format.
235	.It Cm gG
236	The
237	.Ar argument
238	is printed in style
239	.Cm f
240	or in style
241	.Cm e
242	.Pq Cm E
243	whichever gives full precision in minimum space.
244	.It Cm b
245	Characters from the string
246	.Ar argument
247	are printed with backslash-escape sequences expanded.
248	.It Cm c
249	The first character of
250	.Ar argument
251	is printed.
252	.It Cm s
253	Characters from the string
254	.Ar argument
255	are printed until the end is reached or until the number of characters
256	indicated by the precision specification is reached; however if the
257	precision is 0 or missing, all characters in the string are printed.
258	.It Cm \&%
259	Print a `%'; no argument is used.
260	.El
261	.Pp
262	In no case does a non-existent or small field width cause truncation of
263	a field; padding takes place only if the specified field width exceeds
264	the actual width.
265	.Sh EXIT STATUS
266	.Nm
267	exits 0 on success, 1 on failure.
268	.Sh SEE ALSO
269	.Xr echo 1 ,
270	.Xr printf 3 ,
271	.Xr printf 9
272	.Sh STANDARDS
273	The
274	.Nm
275	utility conforms to
276	.St -p1003.2-92 .
277	.Sh BUGS
278	Since the floating point numbers are translated from
279	.Tn ASCII
280	to floating-point and
281	then back again, floating-point precision may be lost.

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/bltin/printf.c (+532 lines)
		1	/* $NetBSD: printf.c,v 1.24 2002/06/14 11:32:15 tron Exp $ */
		2
		3	/*
		4	* Copyright (c) 1989, 1993
		5	* The Regents of the University of California. All rights reserved.
		6	*
		7	* Redistribution and use in source and binary forms, with or without
		8	* modification, are permitted provided that the following conditions
		9	* are met:
		10	* 1. Redistributions of source code must retain the above copyright
		11	* notice, this list of conditions and the following disclaimer.
		12	* 2. Redistributions in binary form must reproduce the above copyright
		13	* notice, this list of conditions and the following disclaimer in the
		14	* documentation and/or other materials provided with the distribution.
		15	* 3. All advertising materials mentioning features or use of this software
		16	* must display the following acknowledgement:
		17	* This product includes software developed by the University of
		18	* California, Berkeley and its contributors.
		19	* 4. Neither the name of the University nor the names of its contributors
		20	* may be used to endorse or promote products derived from this software
		21	* without specific prior written permission.
		22	*
		23	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
		24	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		25	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		26	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
		27	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		28	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		29	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		30	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
		31	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
		32	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		33	* SUCH DAMAGE.
		34	*/
		35
		36	#include <sys/cdefs.h>
		37	#ifndef lint
		38	#if !defined(BUILTIN) && !defined(SHELL)
		39	__COPYRIGHT("@(#) Copyright (c) 1989, 1993\n\
		40	The Regents of the University of California. All rights reserved.\n");
		41	#endif
		42	#endif
		43
		44	#ifndef lint
		45	#if 0
		46	static char sccsid[] = "@(#)printf.c 8.2 (Berkeley) 3/22/95";
		47	#else
		48	__RCSID("$NetBSD: printf.c,v 1.24 2002/06/14 11:32:15 tron Exp $");
		49	#endif
		50	#endif /* not lint */
		51
		52	#include <sys/types.h>
		53
		54	#include <ctype.h>
		55	#include <err.h>
		56	#include <errno.h>
		57	#include <inttypes.h>
		58	#include <limits.h>
		59	#include <locale.h>
		60	#include <stdarg.h>
		61	#ifndef SHELL
		62	#include <stdio.h>
		63	#endif
		64	#include <stdlib.h>
65	#include <string.h>
66	#include <unistd.h>
67
68	int print_escape_str(const char *);
69	static size_t print_escape(const char *);
70
71	static int getchr(void);
72	static double getdouble(void);
73	static intmax_t getintmax(void);
74	static uintmax_t getuintmax __P ((void));
75	static char *getstr(void);
76	static char mklong(const char , int);
77	static void check_conversion(const char , const char );
78	static void usage(void);
79
80	static int rval;
81	static char **gargv;
82
83	#ifdef BUILTIN
84	int progprintf(int, char **);
85	#else
86	int main(int, char **);
87	#endif
88
89	#define isodigit(c) ((c) >= '0' && (c) <= '7')
90	#define octtobin(c) ((c) - '0')
91	#define hextobin(c) ((c) >= 'A' && (c) <= 'F' ? c - 'A' + 10 : (c) >= 'a' && (c) <= 'f' ? c - 'a' + 10 : c - '0')
92
93	#ifdef SHELL
94	#define main printfcmd
95	#include "bltin.h"
96	#else
97	#define nullstr ""
98	#endif
99
100	#define PF(f, func) { \
101	switch (param - array) { \
102	case 0: \
103	(void)printf(f, func); \
104	break; \
105	case 1: \
106	(void)printf(f, array[0], func); \
107	break; \
108	default: \
109	(void)printf(f, array[0], array[1], func); \
110	break; \
111	} \
112	}
113
114	int
115	#ifdef BUILTIN
116	progprintf(int argc, char **argv)
117	#else
118	main(int argc, char **argv)
119	#endif
120	{
121	char *fmt;
122	char *format;
123
124	#if !defined(SHELL) && !defined(BUILTIN)
125	(void)setlocale (LC_ALL, "");
126	#endif
127
128	if (--argc < 1) {
129	usage();
130	return (1);
131	}
132
133	format = *++argv;
134	gargv = ++argv;
135
136	#define SKIP1 "#-+ 0"
137	#define SKIP2 "*0123456789"
138	do {
139	/*
140	* Basic algorithm is to scan the format string for conversion
141	* specifications -- once one is found, find out if the field
142	* width or precision is a '*'; if it is, gather up value.
143	* Note, format strings are reused as necessary to use up the
144	* provided arguments, arguments of zero/null string are
145	* provided to use up the format string.
146	*/
147
148	/* find next format specification */
149	for (fmt = format; *fmt; fmt++) {
150	switch (*fmt) {
151	case '%': {
152	char *start;
153	char convch, nextch;
154	int array[2];
155	int *param;
156
157	start = fmt++;
158
159	if (*fmt == '%') {
160	(void)putchar('%');
161	break;
162	} else if (*fmt == 'b') {
163	char *p = getstr();
164	if (print_escape_str(p)) {
165	return (rval);
166	}
167	break;
168	}
169
170	param = array;
171
172	/* skip to field width */
173	fmt += strspn(fmt, SKIP1);
174	if (fmt == '')
175	*param++ = getintmax();
176
177	/* skip to possible '.', get following precision */
178	fmt += strspn(fmt, SKIP2);
179	if (*fmt == '.')
180	++fmt;
181	if (fmt == '')
182	*param++ = getintmax();
183
184	fmt += strspn(fmt, SKIP2);
185	if (!*fmt) {
186	warnx ("missing format character");
187	return(1);
188	}
189
190	convch = *fmt;
191	nextch = *(fmt + 1);
192	*(fmt + 1) = '\0';
193	switch(convch) {
194	case 'c': {
195	char p = getchr();
196	PF(start, p);
197	break;
198	}
199	case 's': {
200	char *p = getstr();
201	PF(start, p);
202	break;
203	}
204	case 'd':
205	case 'i': {
206	char *f = mklong(start, convch);
207	intmax_t p = getintmax();
208	PF(f, p);
209	break;
210	}
211	case 'o':
212	case 'u':
213	case 'x':
214	case 'X': {
215	char *f = mklong(start, convch);
216	uintmax_t p = getuintmax();
217	PF(f, p);
218	break;
219	}
220	case 'e':
221	case 'E':
222	case 'f':
223	case 'g':
224	case 'G': {
225	double p = getdouble();
226	PF(start, p);
227	break;
228	}
229	default:
230	warnx ("%s: invalid directive", start);
231	return(1);
232	}
233	*(fmt + 1) = nextch;
234	break;
235	}
236
237	case '\\':
238	fmt += print_escape(fmt);
239	break;
240
241	default:
242	(void)putchar(*fmt);
243	break;
244	}
245	}
246	} while (gargv > argv && *gargv);
247
248	#ifdef SHELL
249	return (rval);
250	#else
251	fflush(stdout);
252	return (rval ? rval : ferror(stdout));
253	#endif
254	}
255
256
257	/*
258	* Print SysV echo(1) style escape string
259	* Halts processing string and returns 1 if a \c escape is encountered.
260	*/
261	int
262	print_escape_str(const char *str)
263	{
264	char value;
265	char c;
266
267	for (; (value = *str); str++) {
268	if (value == '\\') {
269	c = *++str;
270	/*
271	* %b string octal constants are not like those in C.
272	* They start with a \0, and are followed by 0, 1, 2,
273	* or 3 octal digits.
274	*/
275	if (c == '0') {
276	unsigned j;
277	unsigned char i;
278	i = 3;
279	j = 0;
280	do {
281	unsigned k = octtobin(*++str);
282	if (k > 7) {
283	str--;
284	break;
285	}
286	j <<= 3;
287	j += k;
288	} while (--i);
289	value = j;
290	} else if (c == 'c') {
291	return 1;
292	} else {
293	str--;
294	str += print_escape(str);
295	continue;
296	}
297	}
298	putchar(value);
299	}
300
301	return 0;
302	}
303
304	/*
305	* Print "standard" escape characters
306	*/
307	static size_t
308	print_escape(const char *str)
309	{
310	const char *start = str;
311	int value;
312	size_t c = 1;
313
314	str++;
315
316	switch (*str) {
317	case '0': case '1': case '2': case '3':
318	case '4': case '5': case '6': case '7':
319	for (c = 4, value = 0; --c && isodigit(*str); str++) {
320	value <<= 3;
321	value += octtobin(*str);
322	}
323	c = str - start - 1;
324	break;
325
326	#ifdef notrequired
327	case 'x':
328	str++;
329	for (value = 0; isxdigit((unsigned char)*str); str++) {
330	value <<= 4;
331	value += hextobin(*str);
332	}
333	if (value > UCHAR_MAX) {
334	warnx ("escape sequence out of range for character");
335	rval = 1;
336	}
337	c = str - start - 1;
338	break;
339	#endif
340
341	case '\\': /* backslash */
342	value = '\\';
343	break;
344
345	#ifdef notrequired
346	case '\'': /* single quote */
347	value = '\'';
348	break;
349
350	case '"': /* double quote */
351	value = '"';
352	break;
353	#endif
354
355	case 'a': /* alert */
356	value = '\a';
357	break;
358
359	case 'b': /* backspace */
360	value = '\b';
361	break;
362
363	#ifdef notrequired
364	case 'e': /* escape */
365	#ifdef __GNUC__
366	value = '\e';
367	#else
368	value = 033;
369	#endif
370	break;
371	#endif
372
373	case 'f': /* form-feed */
374	value = '\f';
375	break;
376
377	case 'n': /* newline */
378	value = '\n';
379	break;
380
381	case 'r': /* carriage-return */
382	value = '\r';
383	break;
384
385	case 't': /* tab */
386	value = '\t';
387	break;
388
389	case 'v': /* vertical-tab */
390	value = '\v';
391	break;
392
393	default:
394	#if 0
395	value = *str;
396	warnx("unknown escape sequence `\\%c'", *str);
397	rval = 1;
398	#else
399	value = '\\';
400	c = 0;
401	#endif
402	break;
403	}
404
405	putchar(value);
406	return c;
407	}
408
409	static char *
410	mklong(const char *str, int ch)
411	{
412	static char copy[64];
413	size_t len;
414
415	len = strlen(str) + 2;
416	(void)memmove(copy, str, len - 3);
417	copy[len - 3] = 'j';
418	copy[len - 2] = ch;
419	copy[len - 1] = '\0';
420	return (copy);
421	}
422
423	static int
424	getchr(void)
425	{
426	int val = 0;
427
428	if (*gargv)
429	val = **gargv++;
430	return val;
431	}
432
433	static char *
434	getstr(void)
435	{
436	char *val = nullstr;
437
438	if (*gargv)
439	val = *gargv++;
440	return val;
441	}
442
443	static intmax_t
444	getintmax(void)
445	{
446	intmax_t val = 0;
447	char *ep;
448	const char arg = gargv;
449
450	if (!arg)
451	goto out;
452
453	gargv++;
454
455	val = (unsigned char) arg[1];
456	if (arg == '\"' \|\| arg == '\'')
457	goto out;
458
459	errno = 0;
460	val = strtoimax(arg, &ep, 0);
461	check_conversion(arg, ep);
462	out:
463	return val;
464	}
465
466	static uintmax_t
467	getuintmax(void)
468	{
469	uintmax_t val = 0;
470	char *ep;
471	const char arg = gargv;
472
473	if (!arg)
474	goto out;
475
476	gargv++;
477
478	val = (unsigned char) arg[1];
479	if (arg == '\"' \|\| arg == '\'')
480	goto out;
481
482	errno = 0;
483	val = strtoumax(arg, &ep, 0);
484	check_conversion(arg, ep);
485	out:
486	return val;
487	}
488
489	static double
490	getdouble(void)
491	{
492	double val = 0;
493	char *ep;
494	const char arg = gargv;
495
496	if (!arg)
497	goto out;
498
499	gargv++;
500
501	if (arg == '\"' \|\| arg == '\'') {
502	val = (unsigned char) arg[1];
503	goto out;
504	}
505
506	errno = 0;
507	val = strtod(arg, &ep);
508	check_conversion(arg, ep);
509	out:
510	return val;
511	}
512
513	static void
514	check_conversion(const char s, const char ep)
515	{
516	if (*ep) {
517	if (ep == s)
518	warnx ("%s: expected numeric value", s);
519	else
520	warnx ("%s: not completely converted", s);
521	rval = 1;
522	} else if (errno == ERANGE) {
523	warnx ("%s: %s", s, strerror(ERANGE));
524	rval = 1;
525	}
526	}
527
528	static void
529	usage(void)
530	{
531	(void)fprintf(stderr, "usage: printf format [arg ...]\n");
532	}

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/bltin/test.1 (+312 lines)
		1	.\" $NetBSD: test.1,v 1.17 2002/02/08 01:22:01 ross Exp $
		2	.\"
		3	.\" Copyright (c) 1991, 1993
		4	.\" The Regents of the University of California. All rights reserved.
		5	.\"
		6	.\" This code is derived from software contributed to Berkeley by
		7	.\" the Institute of Electrical and Electronics Engineers, Inc.
		8	.\"
		9	.\" Redistribution and use in source and binary forms, with or without
		10	.\" modification, are permitted provided that the following conditions
		11	.\" are met:
		12	.\" 1. Redistributions of source code must retain the above copyright
		13	.\" notice, this list of conditions and the following disclaimer.
		14	.\" 2. Redistributions in binary form must reproduce the above copyright
		15	.\" notice, this list of conditions and the following disclaimer in the
		16	.\" documentation and/or other materials provided with the distribution.
		17	.\" 3. All advertising materials mentioning features or use of this software
		18	.\" must display the following acknowledgement:
		19	.\" This product includes software developed by the University of
		20	.\" California, Berkeley and its contributors.
		21	.\" 4. Neither the name of the University nor the names of its contributors
		22	.\" may be used to endorse or promote products derived from this software
		23	.\" without specific prior written permission.
		24	.\"
		25	.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
		26	.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		27	.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
		28	.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
		29	.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		30	.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
		31	.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
		32	.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
		33	.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
		34	.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
		35	.\" SUCH DAMAGE.
		36	.\"
		37	.\" @(#)test.1 8.1 (Berkeley) 5/31/93
		38	.\"
		39	.Dd May 31, 1993
		40	.Dt TEST 1
		41	.Os
		42	.Sh NAME
		43	.Nm test ,
		44	.Nm \&[
		45	.Nd condition evaluation utility
		46	.Sh SYNOPSIS
		47	.Nm test
		48	.Ar expression
		49	.Nm \&[
		50	.Ar expression Cm ]
		51	.Sh DESCRIPTION
		52	The
		53	.Nm test
		54	utility evaluates the expression and, if it evaluates
		55	to true, returns a zero (true) exit status; otherwise
		56	it returns 1 (false).
		57	If there is no expression, test also
		58	returns 1 (false).
		59	.Pp
		60	All operators and flags are separate arguments to the
		61	.Nm test
		62	utility.
		63	.Pp
		64	The following primaries are used to construct expression:
65	.Bl -tag -width Ar
66	.It Fl b Ar file
67	True if
68	.Ar file
69	exists and is a block special
70	file.
71	.It Fl c Ar file
72	True if
73	.Ar file
74	exists and is a character
75	special file.
76	.It Fl d Ar file
77	True if
78	.Ar file
79	exists and is a directory.
80	.It Fl e Ar file
81	True if
82	.Ar file
83	exists (regardless of type).
84	.It Fl f Ar file
85	True if
86	.Ar file
87	exists and is a regular file.
88	.It Fl g Ar file
89	True if
90	.Ar file
91	exists and its set group ID flag
92	is set.
93	.It Fl h Ar file
94	True if
95	.Ar file
96	exists and is a symbolic link.
97	.It Fl k Ar file
98	True if
99	.Ar file
100	exists and its sticky bit is set.
101	.It Fl n Ar string
102	True if the length of
103	.Ar string
104	is nonzero.
105	.It Fl p Ar file
106	True if
107	.Ar file
108	is a named pipe
109	.Po Tn FIFO Pc .
110	.It Fl r Ar file
111	True if
112	.Ar file
113	exists and is readable.
114	.It Fl s Ar file
115	True if
116	.Ar file
117	exists and has a size greater
118	than zero.
119	.It Fl t Ar file_descriptor
120	True if the file whose file descriptor number
121	is
122	.Ar file_descriptor
123	is open and is associated with a terminal.
124	.It Fl u Ar file
125	True if
126	.Ar file
127	exists and its set user ID flag
128	is set.
129	.It Fl w Ar file
130	True if
131	.Ar file
132	exists and is writable.
133	True
134	indicates only that the write flag is on.
135	The file is not writable on a read-only file
136	system even if this test indicates true.
137	.It Fl x Ar file
138	True if
139	.Ar file
140	exists and is executable.
141	True
142	indicates only that the execute flag is on.
143	If
144	.Ar file
145	is a directory, true indicates that
146	.Ar file
147	can be searched.
148	.It Fl z Ar string
149	True if the length of
150	.Ar string
151	is zero.
152	.It Fl L Ar file
153	True if
154	.Ar file
155	exists and is a symbolic link.
156	This operator is retained for compatibility with previous versions of
157	this program. Do not rely on its existence; use
158	.Fl h
159	instead.
160	.It Fl O Ar file
161	True if
162	.Ar file
163	exists and its owner matches the effective user id of this process.
164	.It Fl G Ar file
165	True if
166	.Ar file
167	exists and its group matches the effective group id of this process.
168	.It Fl S Ar file
169	True if
170	.Ar file
171	exists and is a socket.
172	.It Ar file1 Fl nt Ar file2
173	True if
174	.Ar file1
175	exists and is newer than
176	.Ar file2 .
177	.It Ar file1 Fl ot Ar file2
178	True if
179	.Ar file1
180	exists and is older than
181	.Ar file2 .
182	.It Ar file1 Fl ef Ar file2
183	True if
184	.Ar file1
185	and
186	.Ar file2
187	exist and refer to the same file.
188	.It Ar string
189	True if
190	.Ar string
191	is not the null
192	string.
193	.It Ar \&s\&1 Cm \&= Ar \&s\&2
194	True if the strings
195	.Ar \&s\&1
196	and
197	.Ar \&s\&2
198	are identical.
199	.It Ar \&s\&1 Cm \&!= Ar \&s\&2
200	True if the strings
201	.Ar \&s\&1
202	and
203	.Ar \&s\&2
204	are not identical.
205	.It Ar \&s\&1 Cm \&\*[Lt] Ar \&s\&2
206	True if string
207	.Ar \&s\&1
208	comes before
209	.Ar \&s\&2
210	based on the ASCII value of their characters.
211	.It Ar \&s\&1 Cm \&\*[Gt] Ar \&s\&2
212	True if string
213	.Ar \&s\&1
214	comes after
215	.Ar \&s\&2
216	based on the ASCII value of their characters.
217	.It Ar \&n\&1 Fl \&eq Ar \&n\&2
218	True if the integers
219	.Ar \&n\&1
220	and
221	.Ar \&n\&2
222	are algebraically
223	equal.
224	.It Ar \&n\&1 Fl \&ne Ar \&n\&2
225	True if the integers
226	.Ar \&n\&1
227	and
228	.Ar \&n\&2
229	are not
230	algebraically equal.
231	.It Ar \&n\&1 Fl \&gt Ar \&n\&2
232	True if the integer
233	.Ar \&n\&1
234	is algebraically
235	greater than the integer
236	.Ar \&n\&2 .
237	.It Ar \&n\&1 Fl \&ge Ar \&n\&2
238	True if the integer
239	.Ar \&n\&1
240	is algebraically
241	greater than or equal to the integer
242	.Ar \&n\&2 .
243	.It Ar \&n\&1 Fl \&lt Ar \&n\&2
244	True if the integer
245	.Ar \&n\&1
246	is algebraically less
247	than the integer
248	.Ar \&n\&2 .
249	.It Ar \&n\&1 Fl \&le Ar \&n\&2
250	True if the integer
251	.Ar \&n\&1
252	is algebraically less
253	than or equal to the integer
254	.Ar \&n\&2 .
255	.El
256	.Pp
257	These primaries can be combined with the following operators:
258	.Bl -tag -width Ar
259	.It Cm \&! Ar expression
260	True if
261	.Ar expression
262	is false.
263	.It Ar expression1 Fl a Ar expression2
264	True if both
265	.Ar expression1
266	and
267	.Ar expression2
268	are true.
269	.It Ar expression1 Fl o Ar expression2
270	True if either
271	.Ar expression1
272	or
273	.Ar expression2
274	are true.
275	.It Cm \&( Ns Ar expression Ns Cm \&)
276	True if expression is true.
277	.El
278	.Pp
279	The
280	.Fl a
281	operator has higher precedence than the
282	.Fl o
283	operator.
284	.Sh GRAMMAR AMBIGUITY
285	The
286	.Nm test
287	grammar is inherently ambiguous. In order to assure a degree of consistency,
288	the cases described in
289	.St -p1003.2
290	section 4.62.4,
291	are evaluated consistently according to the rules specified in the
292	standards document. All other cases are subject to the ambiguity in the
293	command semantics.
294	.Sh EXIT STATUS
295	The
296	.Nm test
297	utility exits with one of the following values:
298	.Bl -tag -width Ds
299	.It 0
300	expression evaluated to true.
301	.It 1
302	expression evaluated to false or expression was
303	missing.
304	.It \*[Gt]1
305	An error occurred.
306	.El
307	.Sh STANDARDS
308	The
309	.Nm test
310	utility implements a superset of the
311	.St -p1003.2
312	specification.

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/bltin/test.c (+545 lines)
		1	/* $NetBSD: test.c,v 1.25 2002/05/25 23:12:16 wiz Exp $ */
		2
		3	/*
		4	* test(1); version 7-like -- author Erik Baalbergen
		5	* modified by Eric Gisin to be used as built-in.
		6	* modified by Arnold Robbins to add SVR3 compatibility
		7	* (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
		8	* modified by J.T. Conklin for NetBSD.
		9	*
		10	* This program is in the Public Domain.
		11	*/
		12
		13	#include <sys/cdefs.h>
		14	#ifndef lint
		15	__RCSID("$NetBSD: test.c,v 1.25 2002/05/25 23:12:16 wiz Exp $");
		16	#endif
		17
		18	#include <sys/stat.h>
		19	#include <sys/types.h>
		20
		21	#include <ctype.h>
		22	#include <err.h>
		23	#include <errno.h>
		24	#include <stdlib.h>
		25	#include <string.h>
		26	#include <unistd.h>
		27	#include <stdarg.h>
		28	#include "bltin.h"
		29
		30	/* test(1) accepts the following grammar:
		31	oexpr ::= aexpr \| aexpr "-o" oexpr ;
		32	aexpr ::= nexpr \| nexpr "-a" aexpr ;
		33	nexpr ::= primary \| "!" primary
		34	primary ::= unary-operator operand
		35	\| operand binary-operator operand
		36	\| operand
		37	\| "(" oexpr ")"
		38	;
		39	unary-operator ::= "-r"\|"-w"\|"-x"\|"-f"\|"-d"\|"-c"\|"-b"\|"-p"\|
		40	"-u"\|"-g"\|"-k"\|"-s"\|"-t"\|"-z"\|"-n"\|"-o"\|"-O"\|"-G"\|"-L"\|"-S";
		41
		42	binary-operator ::= "="\|"!="\|"-eq"\|"-ne"\|"-ge"\|"-gt"\|"-le"\|"-lt"\|
		43	"-nt"\|"-ot"\|"-ef";
		44	operand ::= <any legal UNIX file name>
		45	*/
		46
		47	enum token {
		48	EOI,
		49	FILRD,
		50	FILWR,
		51	FILEX,
		52	FILEXIST,
		53	FILREG,
		54	FILDIR,
		55	FILCDEV,
		56	FILBDEV,
		57	FILFIFO,
		58	FILSOCK,
		59	FILSYM,
		60	FILGZ,
		61	FILTT,
		62	FILSUID,
		63	FILSGID,
		64	FILSTCK,
65	FILNT,
66	FILOT,
67	FILEQ,
68	FILUID,
69	FILGID,
70	STREZ,
71	STRNZ,
72	STREQ,
73	STRNE,
74	STRLT,
75	STRGT,
76	INTEQ,
77	INTNE,
78	INTGE,
79	INTGT,
80	INTLE,
81	INTLT,
82	UNOT,
83	BAND,
84	BOR,
85	LPAREN,
86	RPAREN,
87	OPERAND
88	};
89
90	enum token_types {
91	UNOP,
92	BINOP,
93	BUNOP,
94	BBINOP,
95	PAREN
96	};
97
98	static struct t_op {
99	const char *op_text;
100	short op_num, op_type;
101	} const ops [] = {
102	{"-r", FILRD, UNOP},
103	{"-w", FILWR, UNOP},
104	{"-x", FILEX, UNOP},
105	{"-e", FILEXIST,UNOP},
106	{"-f", FILREG, UNOP},
107	{"-d", FILDIR, UNOP},
108	{"-c", FILCDEV,UNOP},
109	{"-b", FILBDEV,UNOP},
110	{"-p", FILFIFO,UNOP},
111	{"-u", FILSUID,UNOP},
112	{"-g", FILSGID,UNOP},
113	{"-k", FILSTCK,UNOP},
114	{"-s", FILGZ, UNOP},
115	{"-t", FILTT, UNOP},
116	{"-z", STREZ, UNOP},
117	{"-n", STRNZ, UNOP},
118	{"-h", FILSYM, UNOP}, /* for backwards compat */
119	{"-O", FILUID, UNOP},
120	{"-G", FILGID, UNOP},
121	{"-L", FILSYM, UNOP},
122	{"-S", FILSOCK,UNOP},
123	{"=", STREQ, BINOP},
124	{"!=", STRNE, BINOP},
125	{"<", STRLT, BINOP},
126	{">", STRGT, BINOP},
127	{"-eq", INTEQ, BINOP},
128	{"-ne", INTNE, BINOP},
129	{"-ge", INTGE, BINOP},
130	{"-gt", INTGT, BINOP},
131	{"-le", INTLE, BINOP},
132	{"-lt", INTLT, BINOP},
133	{"-nt", FILNT, BINOP},
134	{"-ot", FILOT, BINOP},
135	{"-ef", FILEQ, BINOP},
136	{"!", UNOT, BUNOP},
137	{"-a", BAND, BBINOP},
138	{"-o", BOR, BBINOP},
139	{"(", LPAREN, PAREN},
140	{")", RPAREN, PAREN},
141	{0, 0, 0}
142	};
143
144	static char **t_wp;
145	static struct t_op const *t_wp_op;
146
147	static void syntax(const char , const char );
148	static int oexpr(enum token);
149	static int aexpr(enum token);
150	static int nexpr(enum token);
151	static int primary(enum token);
152	static int binop(void);
153	static int filstat(char *, enum token);
154	static enum token t_lex(char *);
155	static int isoperand(void);
156	static int getn(const char *);
157	static int newerf(const char , const char );
158	static int olderf(const char , const char );
159	static int equalf(const char , const char );
160	static int test_eaccess(const char *, int);
161	static int bash_group_member(gid_t);
162
163	#ifndef SHELL
164	static void error(const char *, ...) __attribute__((__noreturn__));
165
166	static void
167	error(const char *msg, ...)
168	{
169	va_list ap;
170
171	va_start(ap, msg);
172	verrx(2, msg, ap);
173	/NOTREACHED/
174	va_end(ap);
175	}
176	#endif
177
178	#ifdef SHELL
179	int testcmd(int, char **);
180
181	int
182	testcmd(int argc, char **argv)
183	#else
184	int main(int, char *[]);
185
186	int
187	main(int argc, char *argv[])
188	#endif
189	{
190	int res;
191
192	#ifndef SHELL
193	setprogname(argv[0]);
194	#endif
195	if (strcmp(argv[0], "[") == 0) {
196	if (strcmp(argv[--argc], "]"))
197	error("missing ]");
198	argv[argc] = NULL;
199	}
200
201	if (argc < 2)
202	return 1;
203
204	t_wp = &argv[1];
205	res = !oexpr(t_lex(*t_wp));
206
207	if (t_wp != NULL && ++t_wp != NULL)
208	syntax(*t_wp, "unexpected operator");
209
210	return res;
211	}
212
213	static void
214	syntax(const char op, const char msg)
215	{
216	if (op && *op)
217	error("%s: %s", op, msg);
218	else
219	error("%s", msg);
220	}
221
222	static int
223	oexpr(enum token n)
224	{
225	int res;
226
227	res = aexpr(n);
228	if (t_lex(*++t_wp) == BOR)
229	return oexpr(t_lex(*++t_wp)) \|\| res;
230	t_wp--;
231	return res;
232	}
233
234	static int
235	aexpr(enum token n)
236	{
237	int res;
238
239	res = nexpr(n);
240	if (t_lex(*++t_wp) == BAND)
241	return aexpr(t_lex(*++t_wp)) && res;
242	t_wp--;
243	return res;
244	}
245
246	static int
247	nexpr(enum token n)
248	{
249	if (n == UNOT)
250	return !nexpr(t_lex(*++t_wp));
251	return primary(n);
252	}
253
254	static int
255	primary(enum token n)
256	{
257	enum token nn;
258	int res;
259
260	if (n == EOI)
261	return 0; /* missing expression */
262	if (n == LPAREN) {
263	if ((nn = t_lex(*++t_wp)) == RPAREN)
264	return 0; /* missing expression */
265	res = oexpr(nn);
266	if (t_lex(*++t_wp) != RPAREN)
267	syntax(NULL, "closing paren expected");
268	return res;
269	}
270	if (t_wp_op && t_wp_op->op_type == UNOP) {
271	/* unary expression */
272	if (*++t_wp == NULL)
273	syntax(t_wp_op->op_text, "argument expected");
274	switch (n) {
275	case STREZ:
276	return strlen(*t_wp) == 0;
277	case STRNZ:
278	return strlen(*t_wp) != 0;
279	case FILTT:
280	return isatty(getn(*t_wp));
281	default:
282	return filstat(*t_wp, n);
283	}
284	}
285
286	if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) {
287	return binop();
288	}
289
290	return strlen(*t_wp) > 0;
291	}
292
293	static int
294	binop(void)
295	{
296	const char opnd1, opnd2;
297	struct t_op const *op;
298
299	opnd1 = *t_wp;
300	(void) t_lex(*++t_wp);
301	op = t_wp_op;
302
303	if ((opnd2 = ++t_wp) == (char )0)
304	syntax(op->op_text, "argument expected");
305
306	switch (op->op_num) {
307	case STREQ:
308	return strcmp(opnd1, opnd2) == 0;
309	case STRNE:
310	return strcmp(opnd1, opnd2) != 0;
311	case STRLT:
312	return strcmp(opnd1, opnd2) < 0;
313	case STRGT:
314	return strcmp(opnd1, opnd2) > 0;
315	case INTEQ:
316	return getn(opnd1) == getn(opnd2);
317	case INTNE:
318	return getn(opnd1) != getn(opnd2);
319	case INTGE:
320	return getn(opnd1) >= getn(opnd2);
321	case INTGT:
322	return getn(opnd1) > getn(opnd2);
323	case INTLE:
324	return getn(opnd1) <= getn(opnd2);
325	case INTLT:
326	return getn(opnd1) < getn(opnd2);
327	case FILNT:
328	return newerf (opnd1, opnd2);
329	case FILOT:
330	return olderf (opnd1, opnd2);
331	case FILEQ:
332	return equalf (opnd1, opnd2);
333	default:
334	abort();
335	/* NOTREACHED */
336	}
337	}
338
339	static int
340	filstat(char *nm, enum token mode)
341	{
342	struct stat64 s;
343
344	if (mode == FILSYM ? lstat64(nm, &s) : stat64(nm, &s))
345	return 0;
346
347	switch (mode) {
348	case FILRD:
349	return test_eaccess(nm, R_OK) == 0;
350	case FILWR:
351	return test_eaccess(nm, W_OK) == 0;
352	case FILEX:
353	return test_eaccess(nm, X_OK) == 0;
354	case FILEXIST:
355	return 1;
356	case FILREG:
357	return S_ISREG(s.st_mode);
358	case FILDIR:
359	return S_ISDIR(s.st_mode);
360	case FILCDEV:
361	return S_ISCHR(s.st_mode);
362	case FILBDEV:
363	return S_ISBLK(s.st_mode);
364	case FILFIFO:
365	return S_ISFIFO(s.st_mode);
366	case FILSOCK:
367	return S_ISSOCK(s.st_mode);
368	case FILSYM:
369	return S_ISLNK(s.st_mode);
370	case FILSUID:
371	return (s.st_mode & S_ISUID) != 0;
372	case FILSGID:
373	return (s.st_mode & S_ISGID) != 0;
374	case FILSTCK:
375	return (s.st_mode & S_ISVTX) != 0;
376	case FILGZ:
377	return s.st_size > (off_t)0;
378	case FILUID:
379	return s.st_uid == geteuid();
380	case FILGID:
381	return s.st_gid == getegid();
382	default:
383	return 1;
384	}
385	}
386
387	static enum token
388	t_lex(char *s)
389	{
390	struct t_op const *op;
391
392	op = ops;
393
394	if (s == 0) {
395	t_wp_op = (struct t_op *)0;
396	return EOI;
397	}
398	while (op->op_text) {
399	if (strcmp(s, op->op_text) == 0) {
400	if ((op->op_type == UNOP && isoperand()) \|\|
401	(op->op_num == LPAREN && *(t_wp+1) == 0))
402	break;
403	t_wp_op = op;
404	return op->op_num;
405	}
406	op++;
407	}
408	t_wp_op = (struct t_op *)0;
409	return OPERAND;
410	}
411
412	static int
413	isoperand(void)
414	{
415	struct t_op const *op;
416	char s, t;
417
418	op = ops;
419	if ((s = *(t_wp+1)) == 0)
420	return 1;
421	if ((t = *(t_wp+2)) == 0)
422	return 0;
423	while (op->op_text) {
424	if (strcmp(s, op->op_text) == 0)
425	return op->op_type == BINOP &&
426	(t[0] != ')' \|\| t[1] != '\0');
427	op++;
428	}
429	return 0;
430	}
431
432	/* atoi with error detection */
433	static int
434	getn(const char *s)
435	{
436	char *p;
437	long r;
438
439	errno = 0;
440	r = strtol(s, &p, 10);
441
442	if (errno != 0)
443	error("%s: out of range", s);
444
445	while (isspace((unsigned char)*p))
446	p++;
447
448	if (*p)
449	error("%s: bad number", s);
450
451	return (int) r;
452	}
453
454	static int
455	newerf (const char f1, const char f2)
456	{
457	struct stat b1, b2;
458
459	return (stat (f1, &b1) == 0 &&
460	stat (f2, &b2) == 0 &&
461	b1.st_mtime > b2.st_mtime);
462	}
463
464	static int
465	olderf (const char f1, const char f2)
466	{
467	struct stat b1, b2;
468
469	return (stat (f1, &b1) == 0 &&
470	stat (f2, &b2) == 0 &&
471	b1.st_mtime < b2.st_mtime);
472	}
473
474	static int
475	equalf (const char f1, const char f2)
476	{
477	struct stat b1, b2;
478
479	return (stat (f1, &b1) == 0 &&
480	stat (f2, &b2) == 0 &&
481	b1.st_dev == b2.st_dev &&
482	b1.st_ino == b2.st_ino);
483	}
484
485	/* Do the same thing access(2) does, but use the effective uid and gid,
486	and don't make the mistake of telling root that any file is
487	executable. */
488	static int
489	test_eaccess(const char *path, int mode)
490	{
491	struct stat64 st;
492	int euid = geteuid();
493
494	if (stat64(path, &st) < 0)
495	return (-1);
496
497	if (euid == 0) {
498	/* Root can read or write any file. */
499	if (mode != X_OK)
500	return (0);
501
502	/* Root can execute any file that has any one of the execute
503	bits set. */
504	if (st.st_mode & (S_IXUSR \| S_IXGRP \| S_IXOTH))
505	return (0);
506	}
507
508	if (st.st_uid == euid) /* owner */
509	mode <<= 6;
510	else if (bash_group_member(st.st_gid))
511	mode <<= 3;
512
513	if (st.st_mode & mode)
514	return (0);
515
516	return (-1);
517	}
518
519	/* Return non-zero if GID is one that we have in our groups list. */
520	static int
521	bash_group_member(gid_t gid)
522	{
523	register int i;
524	gid_t *group_array;
525	int ngroups;
526
527	/* Short-circuit if possible, maybe saving a call to getgroups(). */
528	if (gid == getgid() \|\| gid == getegid())
529	return (1);
530
531	ngroups = getgroups(0, NULL);
532	#ifdef SHELL
533	group_array = stalloc(ngroups * sizeof(gid_t));
534	#else
535	group_array = alloca(ngroups * sizeof(gid_t));
536	#endif
537	getgroups(ngroups, group_array);
538
539	/* Search through the list looking for GID. */
540	for (i = 0; i < ngroups; i++)
541	if (gid == group_array[i])
542	return (1);
543
544	return (0);
545	}

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/bltin/times.c (+32 lines)
	1	/*
	2	* Copyright (c) 1999 Herbert Xu <herbert@debian.org>
	3	* This file contains code for the times builtin.
	4	* $Id: times.c,v 1.6 2001/12/12 20:35:08 herbert Exp $
	5	*/
	6
	7	#include <sys/times.h>
	8	#include <unistd.h>
	9	#ifdef USE_GLIBC_STDIO
	10	#include <stdio.h>
	11	#else
	12	#include "bltin.h"
	13	#endif
	14
	15	#define main timescmd
	16
	17	int main() {
	18	struct tms buf;
	19	long int clk_tck = sysconf(_SC_CLK_TCK);
	20
	21	times(&buf);
	22	printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
	23	(int) (buf.tms_utime / clk_tck / 60),
	24	((double) buf.tms_utime) / clk_tck,
	25	(int) (buf.tms_stime / clk_tck / 60),
	26	((double) buf.tms_stime) / clk_tck,
	27	(int) (buf.tms_cutime / clk_tck / 60),
	28	((double) buf.tms_cutime) / clk_tck,
	29	(int) (buf.tms_cstime / clk_tck / 60),
	30	((double) buf.tms_cstime) / clk_tck);
	31	return 0;
	32	}

Lines 49-60 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/builtins.def (-3 / +6 lines)
49	#	49	#
50	# NOTE: bltincmd must come first!	50	# NOTE: bltincmd must come first!
51		51
52	bltincmd command	52	bltincmd builtin
53	#alloccmd alloc	53	#alloccmd alloc
54	bgcmd -j bg	54	bgcmd -j bg
55	breakcmd break continue	55	breakcmd break continue
56	#catfcmd catf	56	#catfcmd catf
57	cdcmd cd chdir	57	cdcmd cd chdir
		58	commandcmd command
58	dotcmd .	59	dotcmd .
59	echocmd echo	60	echocmd echo
60	evalcmd eval	61	evalcmd eval
Lines 68-79 Link Here
68	fgcmd -j fg	69	fgcmd -j fg
69	getoptscmd getopts	70	getoptscmd getopts
70	hashcmd hash	71	hashcmd hash
71	jobidcmd jobid	72	#jobidcmd jobid
72	jobscmd jobs	73	jobscmd jobs
		74	killcmd -j kill
73	#linecmd line	75	#linecmd line
74	localcmd local	76	localcmd local
75	#nlechocmd nlecho	77	#nlechocmd nlecho
76	#printfcmd printf	78	printfcmd printf
77	pwdcmd pwd	79	pwdcmd pwd
78	readcmd read	80	readcmd read
79	returncmd return	81	returncmd return
Lines 91-93 Link Here
91	aliascmd alias	93	aliascmd alias
92	ulimitcmd ulimit	94	ulimitcmd ulimit
93	testcmd test [	95	testcmd test [
		96	timescmd times

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/ash.postinst (+54 lines)
	1	#!/bin/sh
	2	#
	3	# post-install script for the Debian GNU/Linux ash package
	4	#
	5	# $Id: ash.postinst,v 1.9 2002/10/26 11:27:48 herbert Exp $
	6
	7	set -e
	8
	9	check_divert() {
	10	div=$(dpkg-divert --list $1)
	11	distrib=${3:-$1.distrib}
	12	case $div in
	13	'' \| *by\ dash)
	14	;;
	15	*by\ ash)
	16	dst=${div% by ash}
	17	dst=${dst##* to }
	18
	19	# Work around dpkg-divert bug.
	20	if [ -e "$dst" ]; then
	21	mv "$dst" "$dst.ash-tmp"
	22	fi
	23	dpkg-divert --remove $1
	24	if [ -e "$dst.ash-tmp" ]; then
	25	mv "$dst.ash-tmp" "$dst"
	26	fi
	27
	28	dpkg-divert --package dash --divert $distrib --add $1
	29	if [ "$dst" != $distrib ] && [ -e "$dst" ]; then
	30	mv "$dst" $distrib
	31	fi
	32	ln -sf $2 $1
	33	;;
	34	*)
	35	d=${1%/*}
	36	if
	37	[ -h $1 ] && [ -f $1 ] && [ -f $d/$4 ] &&
	38	cmp $1 $d/$4
	39	then
	40	ln -sf $2 $1
	41	fi
	42	;;
	43	esac
	44	}
	45
	46	dcv='dpkg --compare-versions'
	47
	48	if [ "$1" = configure ] && [ -n "$2" ] && $dcv "$2" lt 0.4.3; then
	49	check_divert /bin/sh dash '' ash
	50	check_divert /usr/share/man/man1/sh.1.gz dash.1.gz \
	51	/usr/share/man/man1/sh.distrib.1.gz ash.1.gz
	52	fi
	53
	54	#DEBHELPER#

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/control (+53 lines)
	1	Source: dash
	2	Section: shells
	3	Priority: optional
	4	Maintainer: Herbert Xu <herbert@debian.org>
	5	Build-Depends: byacc, debhelper (>= 4), pmake
	6	Standards-Version: 3.5.8
	7
	8	Package: dash
	9	Architecture: any
	10	Pre-Depends: ${shlibs:Depends}
	11	Description: The Debian Almquist Shell
	12	"dash" is a POSIX compliant shell that is much smaller than "bash".
	13	We take advantage of that by making it the shell on the installation
	14	root floppy, where space is at a premium.
	15	.
	16	It can be usefully installed as /bin/sh (because it executes scripts
	17	somewhat faster than "bash"), or as the default shell either of root
	18	or of a second user with a userid of 0 (because it depends on fewer
	19	libraries, and is therefore less likely to be affected by an upgrade
	20	problem or a disk failure). It is also useful for checking that a
	21	script uses only POSIX syntax.
	22	.
	23	"bash" is a better shell for most users, since it has some nice
	24	features absent from "dash", and is a required part of the system.
	25
	26	Package: dash-udeb
	27	Architecture: any
	28	Depends: ${shlibs:Depends}
	29	Section: debian-installer
	30	Priority: standard
	31	Description: The Debian Almquist Shell for boot floppies
	32	"dash" is a POSIX compliant shell that is much smaller than "bash".
	33	We take advantage of that by making it the shell on the installation
	34	root floppy, where space is at a premium.
	35	.
	36	It can be usefully installed as /bin/sh (because it executes scripts
	37	somewhat faster than "bash"), or as the default shell either of root
	38	or of a second user with a userid of 0 (because it depends on fewer
	39	libraries, and is therefore less likely to be affected by an upgrade
	40	problem or a disk failure). It is also useful for checking that a
	41	script uses only POSIX syntax.
	42	.
	43	"bash" is a better shell for most users, since it has some nice
	44	features absent from "dash", and is a required part of the system.
	45
	46	Package: ash
	47	Architecture: all
	48	Pre-Depends: dash
	49	Description: Compatibility package for the Debian Almquist Shell
	50	This package exists so that users of the "ash" package can upgrade to the
	51	"dash" package which replaces the former. It includes the /bin/ash symlink.
	52	You can remove this package if you do not use /bin/ash explicitly.
	53

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/copyright (+44 lines)
	1	This package was debianized by Mark W. Eichin eichin@kitten.gen.ma.us on
	2	Mon, 24 Feb 1997 16:00:16 -0500.
	3
	4	This package was re-ported from NetBSD and debianized by
	5	Herbert Xu herbert@debian.org on Thu, 19 Jun 1997 19:29:16 +1000.
	6
	7	It was downloaded from ftp.netbsd.org.
	8
	9	Copyright:
	10
	11	Copyright (c) 1989-1994
	12	The Regents of the University of California. All rights reserved.
	13	Copyright (c) 1997-2002
	14	Herbert Xu <herbert@debian.org>
	15
	16	This code is derived from software contributed to Berkeley by Kenneth Almquist.
	17
	18	Please refer to /usr/share/common-licenses/BSD for details.
	19
	20	mksignames.c:
	21
	22	This file is not directly linked with dash. However, its output is.
	23
	24	Copyright (C) 1992 Free Software Foundation, Inc.
	25
	26	This file is part of GNU Bash, the Bourne Again SHell.
	27
	28	Bash is free software; you can redistribute it and/or modify it under
	29	the terms of the GNU General Public License as published by the Free
	30	Software Foundation; either version 2, or (at your option) any later
	31	version.
	32
	33	Bash is distributed in the hope that it will be useful, but WITHOUT ANY
	34	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	35	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	36	for more details.
	37
	38	You should have received a copy of the GNU General Public License with
	39	your Debian GNU/Linux system, in /usr/share/common-licenses/GPL, or with the
	40	Debian GNU/Linux hello source package as the file COPYING. If not,
	41	write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
	42	Boston, MA 02111 USA.
	43
	44	$Id: copyright,v 1.6 2003/01/01 01:51:50 herbert Exp $

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/dash.config (+39 lines)
	1	#!/bin/sh
	2	#
	3	# debconf script for the Debian GNU/Linux ash package
	4	#
	5	# $Id: dash.config,v 1.1 2002/09/14 06:17:50 herbert Exp $
	6
	7	set -e
	8
	9	. /usr/share/debconf/confmodule
	10
	11	db_version 2.0
	12
	13	if [ "$1" = configure ] && [ -z "$2" ]; then
	14	set +e
	15	db_fget ash/sh seen
	16	err=$?
	17	set -e
	18
	19	case $err in
	20	0)
	21	if [ "$RET" = true ]; then
	22	db_fset dash/sh seen true
	23	db_get ash/sh
	24	db_set dash/sh "$RET"
	25	exit
	26	fi
	27	;;
	28	10)
	29	# ash/sh does not exist
	30	;;
	31	*)
	32	echo "db_fget exited with $err" >&2
	33	exit $err
	34	;;
	35	esac
	36	fi
	37
	38	db_input low dash/sh \|\| true
	39	db_go

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/dash.prerm (+24 lines)
	1	#!/bin/sh
	2	#
	3	# pre-removal script for the Debian GNU/Linux ash package
	4	#
	5	# $Id: dash.prerm,v 1.1 2002/09/14 06:17:50 herbert Exp $
	6
	7	set -e
	8
	9	remove_divert() {
	10	div=$(dpkg-divert --list $1)
	11	if [ -n "$div" ] && [ -z "${div%%*by dash}" ]; then
	12	distrib=${div% by dash}
	13	distrib=${distrib##* to }
	14	mv $distrib $1
	15	dpkg-divert --remove $1
	16	fi
	17	}
	18
	19	if [ "$1" = remove ] \|\| [ "$1" = deconfigure ]; then
	20	remove_divert /bin/sh
	21	remove_divert /usr/share/man/man1/sh.1.gz
	22	fi
	23
	24	#DEBHELPER#

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/debian/rules (+101 lines)
		1	#!/usr/bin/make -f
		2	# $Id: rules,v 1.38 2002/12/16 08:07:10 herbert Exp $
		3
		4	# Uncomment this to turn on verbose mode.
		5	#export DH_VERBOSE=1
		6
		7	# This has to be exported to make some magic below work.
		8	export DH_OPTIONS
		9
		10	DEB_HOST_ARCH := $(shell dpkg-architecture -qDEB_HOST_ARCH)
		11
		12	CDEF := \
		13	-Wall -DBSD=1 -DSMALL -D_GNU_SOURCE -DGLOB_BROKEN -DHAVE_VASPRINTF=1 \
		14	-DIFS_BROKEN -DGCC_BROKEN_NG \
		15	-D__COPYRIGHT\(x\)= -D__RCSID\(x\)= -D_DIAGASSERT\(x\)=
		16
		17	OPT := -g -O2 -fstrict-aliasing
		18	OPTSM := -g -Os -fstrict-aliasing -fomit-frame-pointer -DREALLY_SMALL
		19
		20	ifeq ($(DEB_HOST_ARCH),i386)
		21	OPTSM += \
		22	-malign-loops=0 -malign-jumps=0 -malign-functions=0 \
		23	-mpreferred-stack-boundary=2 -DUSE_NORETURN
		24	endif
		25
		26	setup: setup-stamp
		27	setup-stamp:
		28	rm -rf obj obj-udeb
		29	mkdir obj obj-udeb
		30	chmod u+x debian/bsdyacc
		31	touch setup-stamp
		32
		33	build: setup-stamp
		34	dh_testdir
		35
		36	pmake CFLAGS:='$(CDEF) $(OPT)' \
		37	YACC:='$${.CURDIR}/debian/bsdyacc'
		38	MAKEOBJDIR=obj-udeb pmake CFLAGS:='$(CDEF) $(OPTSM)' \
		39	YACC:='$${.CURDIR}/debian/bsdyacc'
		40
		41	clean:
		42	dh_testdir
		43	dh_testroot
		44	rm -f setup-stamp
		45
		46	rm -rf obj obj-udeb
		47
		48	dh_clean
		49
		50	install: build
		51	dh_testdir
		52	dh_testroot
		53	dh_clean -k
		54	dh_installdirs
		55
		56	install obj/sh debian/dash/bin/dash
		57	install -m 644 sh.1 debian/dash/usr/share/man/man1/dash.1
		58	install obj-udeb/sh debian/dash-udeb/bin/dash
		59	ln -s dash debian/dash-udeb/bin/sh
		60	ln -s dash debian/ash/bin/ash
		61	ln -s dash.1.gz debian/ash/usr/share/man/man1/ash.1.gz
		62
		63	# This single target is used to build all the packages, all at once, or
		64	# one at a time. So keep in mind: any options passed to commands here will
65	# affect _all_ packages. Anything you want to only affect one package
66	# should be put in another target, such as the install target.
67	binary-common:
68	dh_testdir
69	dh_testroot
70	dh_installdebconf
71	dh_installdocs -Ndash-udeb
72	dh_installexamples
73	dh_installmenu
74	dh_installcron
75	dh_installchangelogs -Ndash-udeb
76	ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))
77	dh_strip
78	endif
79	dh_compress
80	dh_fixperms
81	dh_installdeb -Ndash-udeb
82	dh_shlibdeps
83	dh_gencontrol
84	dh_md5sums
85	dh_builddeb
86
87	# Build architecture-independent files here.
88	binary-indep: install
89	$(MAKE) -f debian/rules DH_OPTIONS=-i binary-common
90
91	# Build architecture-dependent files here.
92	binary-arch: install
93	$(MAKE) -f debian/rules DH_OPTIONS=-a binary-common
94
95	for i in ../dash-udeb_*.deb; do mv $$i $${i%deb}udeb; done
96	sed '/^[^ ]\.udeb/d; s/^\(dash-udeb_[^ ]\.\)deb/\1udeb/' \
97	debian/files > debian/files.new
98	mv debian/files.new debian/files
99
100	binary: binary-indep binary-arch
101	.PHONY: build clean binary-indep binary-arch binary binary-common install setup

Lines 49-61 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/exec.h (-4 / +7 lines)
49	int cmdtype;	49	int cmdtype;
50	union param {	50	union param {
51	int index;	51	int index;
52	union node *func;	52	struct funcnode *func;
		53	const struct builtincmd *cmd;
53	} u;	54	} u;
54	};	55	};
55		56
56		57
57	#define DO_ERR 1 /* find_command prints errors */	58	#define DO_ERR 1 /* find_command prints errors */
58	#define DO_ABS 2 /* find_command checks absolute paths */	59	#define DO_ABS 2 /* find_command checks absolute paths */
		60	#define DO_NOFUN 4 /* find_command ignores functions */
		61	#define DO_BRUTE 8 /* find_command ignores hash table */
59		62
60	extern const char pathopt; / set by padvance */	63	extern const char pathopt; / set by padvance */
61	extern int exerrno; /* last exec error */	64	extern int exerrno; /* last exec error */
Lines 65-76 Link Here
65	char padvance __P((const char , const char ));	68	char padvance __P((const char , const char ));
66	int hashcmd __P((int, char **));	69	int hashcmd __P((int, char **));
67	void find_command __P((char , struct cmdentry , int, const char *));	70	void find_command __P((char , struct cmdentry , int, const char *));
68	int find_builtin __P((char *));	71	struct builtincmd find_builtin __P((const char ));
69	void hashcd __P((void));	72	void hashcd __P((void));
70	void changepath __P((const char *));	73	void changepath __P((const char *));
71	void deletefuncs __P((void));
72	void getcmdentry __P((char , struct cmdentry ));	74	void getcmdentry __P((char , struct cmdentry ));
73	void addcmdentry __P((char , struct cmdentry ));	75	void addcmdentry __P((char , struct cmdentry ));
74	void defun __P((char , union node ));	76	void defun __P((char , union node ));
75	int unsetfunc __P((char *));	77	void unsetfunc __P((char *));
76	int typecmd __P((int, char **));	78	int typecmd __P((int, char **));
		79	int commandcmd __P((int, char **));

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/hetio.c (+397 lines)
		1	/*
		2	* Termios command line History and Editting for NetBSD sh (ash)
		3	* Copyright (c) 1999
		4	* Main code: Adam Rogoyski <rogoyski@cs.utexas.edu>
		5	* Etc: Dave Cinege <dcinege@psychosis.com>
		6	*
		7	* You may use this code as you wish, so long as the original author(s)
		8	* are attributed in any redistributions of the source code.
		9	* This code is 'as is' with no warranty.
		10	* This code may safely be consumed by a BSD or GPL license.
		11	*
		12	* v 0.5 19990328 Initial release
		13	*
		14	* Future plans: Simple file and path name completion. (like BASH)
		15	*
		16	*/
		17
		18	/*
		19	Usage and Known bugs:
		20	Terminal key codes are not extensive, and more will probably
		21	need to be added. This version was created on Debian GNU/Linux 2.x.
		22	Delete, Backspace, Home, End, and the arrow keys were tested
		23	to work in an Xterm and console. Ctrl-A also works as Home.
		24	Ctrl-E also works as End. Ctrl-D and Ctrl-U perform their respective
		25	functions. The binary size increase is <3K.
		26
		27	Editting will not display correctly for lines greater then the
		28	terminal width. (more then one line.) However, history will.
		29	*/
		30
		31	#include <stdio.h>
		32	#include <unistd.h>
		33	#include <stdlib.h>
		34	#include <string.h>
		35	#include <termios.h>
		36	#include <ctype.h>
		37	#include <sys/ioctl.h>
		38
		39	#include "input.h"
		40	#include "output.h"
		41
		42	#include "hetio.h"
		43
		44
		45	#define MAX_HISTORY 15 /* Maximum length of the linked list for the command line history */
		46
		47	#define ESC 27
		48	#define DEL 127
		49
		50	static struct history his_front = NULL; / First element in command line list */
		51	static struct history his_end = NULL; / Last element in command line list */
		52	static struct termios old_term, new_term; /* Current termio and the previous termio before starting ash */
		53
		54	static int history_counter = 0; /* Number of commands in history list */
		55	static int reset_term = 0; /* Set to true if the terminal needs to be reset upon exit */
		56	static int hetio_inter = 0;
		57
		58	struct history
		59	{
		60	char *s;
		61	struct history *p;
		62	struct history *n;
		63	};
		64
65
66	void input_delete (int);
67	void input_home (int *);
68	void input_end (int *, int);
69	void input_backspace (int , int );
70
71
72
73	void hetio_init(void)
74	{
75	hetio_inter = 1;
76	}
77
78
79	void hetio_reset_term(void)
80	{
81	if (reset_term)
82	tcsetattr(1, TCSANOW, &old_term);
83	}
84
85
86	void setIO(struct termios new, struct termios old) /* Set terminal IO to canonical mode, and save old term settings. */
87	{
88	tcgetattr(0, old);
89	memcpy(new, old, sizeof(*new));
90	new->c_cc[VMIN] = 1;
91	new->c_cc[VTIME] = 0;
92	new->c_lflag &= ~ICANON; /* unbuffered input */
93	new->c_lflag &= ~ECHO;
94	tcsetattr(0, TCSANOW, new);
95	}
96
97	void input_home(int cursor) / Command line input routines */
98	{
99	while (*cursor > 0) {
100	out1c('\b');
101	--*cursor;
102	}
103	flushout(out1);
104	}
105
106
107	void input_delete(int cursor)
108	{
109	int j = 0;
110
111	memmove(parsenextc + cursor, parsenextc + cursor + 1,
112	BUFSIZ - cursor - 1);
113	for (j = cursor; j < (BUFSIZ - 1); j++) {
114	if (!*(parsenextc + j))
115	break;
116	else
117	out1c(*(parsenextc + j));
118	}
119
120	out1str(" \b");
121
122	while (j-- > cursor)
123	out1c('\b');
124	flushout(out1);
125	}
126
127
128	void input_end(int *cursor, int len)
129	{
130	while (*cursor < len) {
131	out1str("\033[C");
132	++*cursor;
133	}
134	flushout(out1);
135	}
136
137
138	void
139	input_backspace(int cursor, int len)
140	{
141	int j = 0;
142
143	if (*cursor > 0) {
144	out1str("\b \b");
145	--*cursor;
146	memmove(parsenextc + cursor, parsenextc + cursor + 1,
147	BUFSIZ - *cursor + 1);
148
149	for (j = *cursor; j < (BUFSIZ - 1); j++) {
150	if (!*(parsenextc + j))
151	break;
152	else
153	out1c(*(parsenextc + j));
154	}
155
156	out1str(" \b");
157
158	while (j-- > *cursor)
159	out1c('\b');
160
161	--*len;
162	flushout(out1);
163	}
164	}
165
166	int hetio_read_input(int fd)
167	{
168	int nr = 0;
169
170	/* Are we an interactive shell? */
171	if (!hetio_inter \|\| fd) {
172	return -255;
173	} else {
174	int len = 0;
175	int j = 0;
176	int cursor = 0;
177	int break_out = 0;
178	int ret = 0;
179	char c = 0;
180	struct history *hp = his_end;
181
182	if (!reset_term) {
183	setIO(&new_term, &old_term);
184	reset_term = 1;
185	} else {
186	tcsetattr(0, TCSANOW, &new_term);
187	}
188
189	memset(parsenextc, 0, BUFSIZ);
190
191	while (1) {
192	if ((ret = read(fd, &c, 1)) < 1)
193	return ret;
194
195	switch (c) {
196	case 1: /* Control-A Beginning of line */
197	input_home(&cursor);
198	break;
199	case 5: /* Control-E EOL */
200	input_end(&cursor, len);
201	break;
202	case 4: /* Control-D */
203	if (!len)
204	exitshell(0);
205	break;
206	case 21: /* Control-U */
207	/* Return to begining of line. */
208	for (; cursor > 0; cursor--)
209	out1c('\b');
210	/* Erase old command. */
211	for (j = 0; j < len; j++) {
212	/*
213	* Clear buffer while we're at
214	* it.
215	*/
216	parsenextc[j] = 0;
217	out1c(' ');
218	}
219	/* return to begining of line */
220	for (; len > 0; len--)
221	out1c('\b');
222	flushout(out1);
223	break;
224	case '\b': /* Backspace */
225	case DEL:
226	input_backspace(&cursor, &len);
227	break;
228	case '\n': /* Enter */
229	*(parsenextc + len++ + 1) = c;
230	out1c(c);
231	flushout(out1);
232	break_out = 1;
233	break;
234	case ESC: /* escape sequence follows */
235	if ((ret = read(fd, &c, 1)) < 1)
236	return ret;
237
238	if (c == '[' ) { /* 91 */
239	if ((ret = read(fd, &c, 1)) < 1)
240	return ret;
241
242	switch (c) {
243	case 'A':
244	if (hp && hp->p) { /* Up */
245	hp = hp->p;
246	goto hop;
247	}
248	break;
249	case 'B':
250	if (hp && hp->n && hp->n->s) { /* Down */
251	hp = hp->n;
252	goto hop;
253	}
254	break;
255
256	hop: /* hop */
257	len = strlen(parsenextc);
258
259	for (; cursor > 0; cursor--) /* return to begining of line */
260	out1c('\b');
261
262	for (j = 0; j < len; j++) /* erase old command */
263	out1c(' ');
264
265	for (; j > 0; j--) /* return to begining of line */
266	out1c('\b');
267
268	strcpy (parsenextc, hp->s); /* write new command */
269	len = strlen (hp->s);
270	out1str(parsenextc);
271	flushout(out1);
272	cursor = len;
273	break;
274	case 'C': /* Right */
275	if (cursor < len) {
276	out1str("\033[C");
277	cursor++;
278	flushout(out1);
279	}
280	break;
281	case 'D': /* Left */
282	if (cursor > 0) {
283	out1str("\033[D");
284	cursor--;
285	flushout(out1);
286	}
287	break;
288	case '3': /* Delete */
289	if (cursor != len) {
290	input_delete(cursor);
291	len--;
292	}
293	break;
294	case '1': /* Home (Ctrl-A) */
295	input_home(&cursor);
296	break;
297	case '4': /* End (Ctrl-E) */
298	input_end(&cursor, len);
299	break;
300	}
301	if (c == '1' \|\| c == '3' \|\| c == '4')
302	if ((ret = read(fd, &c, 1)) < 1)
303	return ret; /* read 126 (~) */
304	}
305
306	if (c == 'O') { /* 79 */
307	if ((ret = read(fd, &c, 1)) < 1)
308	return ret;
309	switch (c) {
310	case 'H': /* Home (xterm) */
311	input_home(&cursor);
312	break;
313	case 'F': /* End (xterm_ */
314	input_end(&cursor, len);
315	break;
316	}
317	}
318
319	c = 0;
320	break;
321
322	default: /* If it's regular input, do the normal thing */
323	if (!isprint(c)) /* Skip non-printable characters */
324	break;
325
326	if (len >= (BUFSIZ - 2)) /* Need to leave space for enter */
327	break;
328
329	len++;
330
331	if (cursor == (len - 1)) { /* Append if at the end of the line */
332	*(parsenextc + cursor) = c;
333	} else { /* Insert otherwise */
334	memmove(parsenextc + cursor + 1, parsenextc + cursor,
335	len - cursor - 1);
336
337	*(parsenextc + cursor) = c;
338
339	for (j = cursor; j < len; j++)
340	out1c(*(parsenextc + j));
341	for (; j > cursor; j--)
342	out1str("\033[D");
343	}
344
345	cursor++;
346	out1c(c);
347	flushout(out1);
348	break;
349	}
350
351	if (break_out) /* Enter is the command terminator, no more input. */
352	break;
353	}
354
355	nr = len + 1;
356	tcsetattr(0, TCSANOW, &old_term);
357
358	if ((parsenextc)) { / Handle command history log */
359	struct history *h = his_end;
360
361	if (!h) { /* No previous history */
362	h = his_front = malloc(sizeof (struct history));
363	h->n = malloc(sizeof (struct history));
364	h->p = NULL;
365	h->s = strdup(parsenextc);
366
367	h->n->p = h;
368	h->n->n = NULL;
369	h->n->s = NULL;
370	his_end = h->n;
371	history_counter++;
372	} else { /* Add a new history command */
373
374	h->n = malloc(sizeof (struct history));
375
376	h->n->p = h;
377	h->n->n = NULL;
378	h->n->s = NULL;
379	h->s = strdup(parsenextc);
380	his_end = h->n;
381
382	if (history_counter >= MAX_HISTORY) { /* After max history, remove the last known command */
383	struct history *p = his_front->n;
384
385	p->p = NULL;
386	free(his_front->s);
387	free(his_front);
388	his_front = p;
389	} else {
390	history_counter++;
391	}
392	}
393	}
394	}
395
396	return nr;
397	}

Lines 48-64 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/input.h (-3 / +3 lines)
48	extern int plinno;	48	extern int plinno;
49	extern int parsenleft; /* number of characters left in input buffer */	49	extern int parsenleft; /* number of characters left in input buffer */
50	extern char parsenextc; / next character in input buffer */	50	extern char parsenextc; / next character in input buffer */
51	extern int init_editline; /* 0 == not setup, 1 == OK, -1 == failed */
52		51
53	char pfgets __P((char , int));	52	char pfgets __P((char , int));
54	int pgetc __P((void));	53	int pgetc __P((void));
		54	int pgetc2 __P((void));
55	int preadbuffer __P((void));	55	int preadbuffer __P((void));
56	void pungetc __P((void));	56	void pungetc __P((void));
57	void pushstring __P((char , int, void ));	57	void pushstring __P((char , void ));
58	void popstring __P((void));	58	void popstring __P((void));
59	void setinputfile __P((const char *, int));	59	void setinputfile __P((const char *, int));
60	void setinputfd __P((int, int));	60	void setinputfd __P((int, int));
61	void setinputstring __P((char *, int));	61	void setinputstring __P((char *));
62	void popfile __P((void));	62	void popfile __P((void));
63	void popallfiles __P((void));	63	void popallfiles __P((void));
64	void closescript __P((void));	64	void closescript __P((void));

Lines 1-40 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/Makefile (-25 / +16 lines)
1	# $NetBSD: Makefile,v 1.57.2.2 2002/12/06 23:29:26 he Exp $	1	# $NetBSD: Makefile,v 1.59 2002/09/15 00:19:22 thorpej Exp $
2	# @(#)Makefile 8.4 (Berkeley) 5/5/95	2	# @(#)Makefile 8.4 (Berkeley) 5/5/95
3		3
4	.include <bsd.own.mk>	4	.include <bsd.own.mk>
5		5
6	YHEADER=1	6	YHEADER=1
7	PROG= sh	7	PROG= sh
8	SHSRCS= alias.c cd.c echo.c error.c eval.c exec.c expand.c \	8	SHSRCS= alias.c arith_yylex.c cd.c echo.c error.c eval.c exec.c expand.c \
9	histedit.c input.c jobs.c mail.c main.c memalloc.c miscbltin.c \	9	histedit.c input.c jobs.c mail.c main.c memalloc.c miscbltin.c \
10	mystring.c options.c parser.c redir.c show.c trap.c output.c var.c \	10	mystring.c options.c parser.c printf.c redir.c show.c trap.c output.c \
11	test.c	11	var.c test.c setmode.c times.c hetio.c
12	GENSRCS=arith.c arith.h arith_lex.c builtins.c builtins.h init.c nodes.c \	12	GENSRCS=arith.c arith.h builtins.c builtins.h init.c nodes.c \
13	nodes.h syntax.c syntax.h token.h	13	nodes.h signames.c syntax.c syntax.h token.h
14	SRCS= ${SHSRCS} ${GENSRCS}	14	SRCS= ${SHSRCS} ${GENSRCS}
15		15
16	LDADD+= -ll -ledit -ltermcap
17	DPADD+= ${LIBL} ${LIBEDIT} ${LIBTERMCAP}
18
19	LFLAGS= -8 # 8-bit lex scanner for arithmetic
20	YFLAGS= -d	16	YFLAGS= -d
21		17
22	CPPFLAGS+=-DSHELL -I. -I${.CURDIR}	18	CPPFLAGS+=-DSHELL -I. -I${.CURDIR}
		19	CPPFLAGS+=-DSMALL -DHETIO
23		20
24	.ifdef SMALLPROG	21	.PATH: ${.CURDIR}/bltin ${NETBSDSRCDIR}/bin/test
25	CPPFLAGS+=-DSMALL
26	.endif
27
28	.PATH: ${.CURDIR}/bltin ${.CURDIR}/../test
29		22
30	CLEANFILES+= mkinit mknodes mksyntax	23	CLEANFILES+= mkinit mknodes mksyntax
31	CLEANFILES+= ${GENSRCS} y.tab.h	24	CLEANFILES+= ${GENSRCS} y.tab.h
32		25
		26	BLTINDEFS=specialbltins.def regularbltins.def assignbltins.def
		27
33	token.h: mktokens	28	token.h: mktokens
34	sh ${.ALLSRC}	29	sh ${.ALLSRC}
35		30
36	builtins.c builtins.h: mkbuiltins shell.h builtins.def	31	builtins.c builtins.h: mkbuiltins shell.h builtins.def ${BLTINDEFS}
37	sh ${.ALLSRC} ${.OBJDIR}	32	sh ${.ALLSRC} ${.OBJDIR} '${CFLAGS}'
38		33
39	init.c: mkinit ${SHSRCS}	34	init.c: mkinit ${SHSRCS}
40	./${.ALLSRC}	35	./${.ALLSRC}
Lines 45-66 Link Here
45	syntax.c syntax.h: mksyntax	40	syntax.c syntax.h: mksyntax
46	./${.ALLSRC}	41	./${.ALLSRC}
47		42
		43	signames.c: mksignames
		44	./${.ALLSRC}
		45
48	mkinit: mkinit.c	46	mkinit: mkinit.c
49	${HOST_LINK.c} -o mkinit ${.IMPSRC}	47	${HOST_LINK.c} -o mkinit ${.IMPSRC}
50		48
51	mknodes: mknodes.c	49	mknodes: mknodes.c
52	${HOST_LINK.c} -o mknodes ${.IMPSRC}	50	${HOST_LINK.c} -o mknodes ${.IMPSRC}
53		51
54	.if (${MACHINE_ARCH} == "powerpc") \|\| \
55	(${MACHINE_CPU} == "arm")
56	TARGET_CHARFLAG= -DTARGET_CHAR="unsigned char"
57	.else
58	TARGET_CHARFLAG= -DTARGET_CHAR="signed char"
59	.endif
60
61	mksyntax: mksyntax.c	52	mksyntax: mksyntax.c
62	${HOST_LINK.c} ${TARGET_CHARFLAG} -o mksyntax ${.IMPSRC}	53	${HOST_LINK.c} ${TARGET_CHARFLAG} -o mksyntax ${.IMPSRC}
63		54
64	.include <bsd.prog.mk>	55	.include <bsd.prog.mk>
65		56
66	${OBJS}: builtins.h nodes.h syntax.h token.h	57	${OBJS}: arith.h builtins.h nodes.h syntax.h token.h

Lines 60-74 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/memalloc.c (-51 / +70 lines)
60	*/	60	*/
61		61
62	pointer	62	pointer
63	ckmalloc(nbytes)	63	ckmalloc(size_t nbytes)
64	int nbytes;
65	{	64	{
66	pointer p;	65	pointer p;
67		66
68	INTOFF;	67	if ((p = malloc(nbytes)) == NULL)
69	p = malloc(nbytes);
70	INTON;
71	if (p == NULL)
72	error("Out of space");	68	error("Out of space");
73	return p;	69	return p;
74	}	70	}
Lines 79-87 Link Here
79	*/	75	*/
80		76
81	pointer	77	pointer
82	ckrealloc(p, nbytes)	78	ckrealloc(pointer p, size_t nbytes)
83	pointer p;
84	int nbytes;
85	{	79	{
86		80
87	if ((p = realloc(p, nbytes)) == NULL)	81	if ((p = realloc(p, nbytes)) == NULL)
Lines 96-107 Link Here
96		90
97	char *	91	char *
98	savestr(s)	92	savestr(s)
99	char *s;	93	const char *s;
100	{	94	{
101	char *p;	95	char *p = strdup(s);
102		96	if (!p)
103	p = ckmalloc(strlen(s) + 1);	97	error("Out of space");
104	scopy(s, p);
105	return p;	98	return p;
106	}	99	}
107		100
Lines 115-121 Link Here
115	* well.	108	* well.
116	*/	109	*/
117		110
118	#define MINSIZE 504 /* minimum size of a block */	111	#define MINSIZE ALIGN(504) /* minimum size of a block */
119		112
120		113
121	struct stack_block {	114	struct stack_block {
Lines 127-163 Link Here
127	struct stack_block *stackp = &stackbase;	120	struct stack_block *stackp = &stackbase;
128	struct stackmark *markp;	121	struct stackmark *markp;
129	char *stacknxt = stackbase.space;	122	char *stacknxt = stackbase.space;
130	int stacknleft = MINSIZE;	123	size_t stacknleft = MINSIZE;
131	int sstrnleft;	124	char *sstrend = stackbase.space + MINSIZE;
132	int herefd = -1;	125	int herefd = -1;
133		126
134		127
135		128
136	pointer	129	pointer
137	stalloc(nbytes)	130	stalloc(size_t nbytes)
138	int nbytes;
139	{	131	{
140	char *p;	132	char *p;
		133	size_t aligned;
141		134
142	nbytes = ALIGN(nbytes);	135	aligned = ALIGN(nbytes);
143	if (nbytes > stacknleft) {	136	if (nbytes > stacknleft) {
144	int blocksize;	137	size_t len;
		138	size_t blocksize;
145	struct stack_block *sp;	139	struct stack_block *sp;
146		140
147	blocksize = nbytes;	141	blocksize = aligned;
148	if (blocksize < MINSIZE)	142	if (blocksize < MINSIZE)
149	blocksize = MINSIZE;	143	blocksize = MINSIZE;
		144	len = sizeof(struct stack_block) - MINSIZE + blocksize;
		145	if (len < blocksize)
		146	error("Out of space");
150	INTOFF;	147	INTOFF;
151	sp = ckmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);	148	sp = ckmalloc(len);
152	sp->prev = stackp;	149	sp->prev = stackp;
153	stacknxt = sp->space;	150	stacknxt = sp->space;
154	stacknleft = blocksize;	151	stacknleft = blocksize;
		152	sstrend = stacknxt + blocksize;
155	stackp = sp;	153	stackp = sp;
156	INTON;	154	INTON;
157	}	155	}
158	p = stacknxt;	156	p = stacknxt;
159	stacknxt += nbytes;	157	stacknxt += aligned;
160	stacknleft -= nbytes;	158	stacknleft -= aligned;
161	return p;	159	return p;
162	}	160	}
163		161
Lines 166-175 Link Here
166	stunalloc(p)	164	stunalloc(p)
167	pointer p;	165	pointer p;
168	{	166	{
169	if (p == NULL) { /DEBUG /	167	#ifdef DEBUG
		168	if (!p \|\| (stacknxt < (char )p) \|\| ((char )p < stackp->space)) {
170	write(2, "stunalloc\n", 10);	169	write(2, "stunalloc\n", 10);
171	abort();	170	abort();
172	}	171	}
		172	#endif
173	stacknleft += stacknxt - (char *)p;	173	stacknleft += stacknxt - (char *)p;
174	stacknxt = p;	174	stacknxt = p;
175	}	175	}
Lines 203-208 Link Here
203	}	203	}
204	stacknxt = mark->stacknxt;	204	stacknxt = mark->stacknxt;
205	stacknleft = mark->stacknleft;	205	stacknleft = mark->stacknleft;
		206	sstrend = mark->stacknxt + mark->stacknleft;
206	INTON;	207	INTON;
207	}	208	}
208		209
Lines 220-241 Link Here
220	void	221	void
221	growstackblock() {	222	growstackblock() {
222	char *p;	223	char *p;
223	int newlen = ALIGN(stacknleft * 2 + 100);	224	size_t newlen, grosslen;
224	char *oldspace = stacknxt;	225	char *oldspace = stacknxt;
225	int oldlen = stacknleft;	226	size_t oldlen = stacknleft;
226	struct stack_block *sp;	227	struct stack_block *sp;
227	struct stack_block *oldstackp;	228	struct stack_block *oldstackp;
		229	struct stack_block *prevstackp;
		230
		231	grosslen = stacknleft * 2;
		232	if (grosslen < stacknleft)
		233	error("Out of space");
		234	if (grosslen < 128)
		235	grosslen += 128 + sizeof(struct stack_block) - MINSIZE;
		236	newlen = grosslen - (sizeof(struct stack_block) - MINSIZE);
228		237
229	if (stacknxt == stackp->space && stackp != &stackbase) {	238	if (stacknxt == stackp->space && stackp != &stackbase) {
230	INTOFF;	239	INTOFF;
231	oldstackp = stackp;	240	oldstackp = stackp;
232	sp = stackp;	241	sp = stackp;
233	stackp = sp->prev;	242	prevstackp = sp->prev;
234	sp = ckrealloc((pointer)sp, sizeof(struct stack_block) - MINSIZE + newlen);	243	sp = ckrealloc((pointer)sp, grosslen);
235	sp->prev = stackp;	244	sp->prev = prevstackp;
236	stackp = sp;	245	stackp = sp;
237	stacknxt = sp->space;	246	stacknxt = sp->space;
238	stacknleft = newlen;	247	stacknleft = newlen;
		248	sstrend = sp->space + newlen;
239	{	249	{
240	/* Stack marks pointing to the start of the old block	250	/* Stack marks pointing to the start of the old block
241	* must be relocated to point to the new block	251	* must be relocated to point to the new block
Lines 252-268 Link Here
252	INTON;	262	INTON;
253	} else {	263	} else {
254	p = stalloc(newlen);	264	p = stalloc(newlen);
255	memcpy(p, oldspace, oldlen);	265	/* free the space we just allocated */
256	stacknxt = p; /* free the space */	266	stacknxt = memcpy(p, oldspace, oldlen);
257	stacknleft += newlen; /* we just allocated */	267	stacknleft += newlen;
258	}	268	}
259	}	269	}
260		270
261		271
262		272
263	void	273	void
264	grabstackblock(len)	274	grabstackblock(size_t len)
265	int len;
266	{	275	{
267	len = ALIGN(len);	276	len = ALIGN(len);
268	stacknxt += len;	277	stacknxt += len;
Lines 290-305 Link Here
290	*/	299	*/
291		300
292		301
293	char *	302	void *
294	growstackstr() {	303	growstackstr() {
295	int len = stackblocksize();	304	size_t len = stackblocksize();
296	if (herefd >= 0 && len >= 1024) {	305	if (herefd >= 0 && len >= 1024) {
297	xwrite(herefd, stackblock(), len);	306	xwrite(herefd, stackblock(), len);
298	sstrnleft = len - 1;
299	return stackblock();	307	return stackblock();
300	}	308	}
301	growstackblock();	309	growstackblock();
302	sstrnleft = stackblocksize() - len - 1;
303	return stackblock() + len;	310	return stackblock() + len;
304	}	311	}
305		312
Lines 309-329 Link Here
309	*/	316	*/
310		317
311	char *	318	char *
312	makestrspace() {	319	makestrspace(size_t newlen, char *p) {
313	int len = stackblocksize() - sstrnleft;	320	size_t len = p - stackblock();
		321	size_t size = stackblocksize();
		322
		323	for (;;) {
		324	size_t nleft;
		325
		326	size = stackblocksize();
		327	nleft = size - len;
		328	if (nleft >= newlen)
		329	break;
314	growstackblock();	330	growstackblock();
315	sstrnleft = stackblocksize() - len;	331	}
316	return stackblock() + len;	332	return stackblock() + len;
317	}	333	}
318		334
319		335
320		336
321	void	337	char *
322	ungrabstackstr(s, p)	338	stnputs(const char s, size_t n, char p) {
323	char *s;	339	p = makestrspace(n, p);
324	char *p;	340	p = mempcpy(p, s, n);
325	{	341	return p;
326	stacknleft += stacknxt - s;	342	}
327	stacknxt = s;	343
328	sstrnleft = stacknleft - (p - s);	344
		345	char *
		346	stputs(const char s, char p) {
		347	return stnputs(s, strlen(s), p);
329	}	348	}

Lines 38-81 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/memalloc.h (-19 / +37 lines)
38	* @(#)memalloc.h 8.2 (Berkeley) 5/4/95	38	* @(#)memalloc.h 8.2 (Berkeley) 5/4/95
39	*/	39	*/
40		40
		41	#include <stddef.h>
		42
41	struct stackmark {	43	struct stackmark {
42	struct stack_block *stackp;	44	struct stack_block *stackp;
43	char *stacknxt;	45	char *stacknxt;
44	int stacknleft;	46	size_t stacknleft;
45	struct stackmark *marknext;	47	struct stackmark *marknext;
46	};	48	};
47		49
48		50
49	extern char *stacknxt;	51	extern char *stacknxt;
50	extern int stacknleft;	52	extern size_t stacknleft;
51	extern int sstrnleft;	53	extern char *sstrend;
52	extern int herefd;	54	extern int herefd;
53		55
54	pointer ckmalloc __P((int));	56	pointer ckmalloc __P((size_t));
55	pointer ckrealloc __P((pointer, int));	57	pointer ckrealloc __P((pointer, size_t));
56	char savestr __P((char ));	58	char savestr __P((const char ));
57	pointer stalloc __P((int));	59	pointer stalloc __P((size_t));
58	void stunalloc __P((pointer));	60	void stunalloc __P((pointer));
59	void setstackmark __P((struct stackmark *));	61	void setstackmark __P((struct stackmark *));
60	void popstackmark __P((struct stackmark *));	62	void popstackmark __P((struct stackmark *));
61	void growstackblock __P((void));	63	void growstackblock __P((void));
62	void grabstackblock __P((int));	64	void grabstackblock __P((size_t));
63	char *growstackstr __P((void));	65	void *growstackstr __P((void));
64	char *makestrspace __P((void));	66	char makestrspace __P((size_t, char ));
65	void ungrabstackstr __P((char , char ));	67	char stnputs __P((const char , size_t, char *));
		68	char stputs __P((const char , char *));
66		69
67		70
		71	static inline char _STPUTC(char c, char p) {
		72	if (p == sstrend)
		73	p = growstackstr();
		74	*p++ = c;
		75	return p;
		76	}
68		77
69	#define stackblock() stacknxt	78	#define stackblock() stacknxt
70	#define stackblocksize() stacknleft	79	#define stackblocksize() stacknleft
71	#define STARTSTACKSTR(p) p = stackblock(), sstrnleft = stackblocksize()	80	#define STARTSTACKSTR(p) (p) = ((void *) stackblock())
72	#define STPUTC(c, p) (--sstrnleft >= 0? (p++ = (c)) : (p = growstackstr(), p++ = (c)))	81	#define STPUTC(c, p) (p) = _STPUTC(c, p)
73	#define CHECKSTRSPACE(n, p) { if (sstrnleft < n) p = makestrspace(); }	82	#define CHECKSTRSPACE(n, p) \
74	#define USTPUTC(c, p) (--sstrnleft, *p++ = (c))	83	({ \
75	#define STACKSTRNUL(p) (sstrnleft == 0? (p = growstackstr(), p = '\0') : (p = '\0'))	84	char *q = (p); \
76	#define STUNPUTC(p) (++sstrnleft, --p)	85	size_t l = (n); \
		86	size_t m = sstrend - q; \
		87	if (l > m) \
		88	(p) = makestrspace(l, q); \
		89	0; \
		90	})
		91	#define USTPUTC(c, p) (*p++ = (c))
		92	#define STACKSTRNUL(p) ((p) == sstrend? (p = growstackstr(), p = '\0') : (p = '\0'))
		93	#define STUNPUTC(p) (--p)
77	#define STTOPC(p) p[-1]	94	#define STTOPC(p) p[-1]
78	#define STADJUST(amount, p) (p += (amount), sstrnleft -= (amount))	95	#define STADJUST(amount, p) (p += (amount))
79	#define grabstackstr(p) stalloc(stackblocksize() - sstrnleft)	96	#define grabstackstr(p) stalloc(((char *) (p)) - stackblock())
		97	#define ungrabstackstr(s, p) stunalloc((s))
80		98
81	#define ckfree(p) free((pointer)(p))	99	#define ckfree(p) free((pointer)(p))

Lines 37-57 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mkbuiltins (-24 / +33 lines)
37	#	37	#
38	# @(#)mkbuiltins 8.2 (Berkeley) 5/4/95	38	# @(#)mkbuiltins 8.2 (Berkeley) 5/4/95
39		39
40	temp=/tmp/ka$$	40	trap 'rm -f $temp $temp2' EXIT
		41	temp=$(tempfile)
		42	temp2=$(tempfile)
		43
		44	shell=$1
		45	builtins=$2
		46	specialbltins=$3
		47	regularbltins=$4
		48	assignbltins=$5
		49	objdir=$6
41		50
42	havehist=1	51	havehist=1
43	if [ "X$1" = "X-h" ]; then	52	if [ -z "${7##-DSMALL}" ]; then
44	havehist=0	53	havehist=0
45	shift
46	fi	54	fi
47	shell=$1
48	builtins=$2
49	objdir=$3
50		55
51	havejobs=0	56	havejobs=1
52	if grep '^#define JOBS[ ]*1' ${shell} > /dev/null	57	if [ -z "${7##-DJOBS=0}" ]; then
53	then	58	havejobs=0
54	havejobs=1
55	fi	59	fi
56		60
57	exec > ${objdir}/builtins.c	61	exec > ${objdir}/builtins.c
Lines 65-83 Link Here
65		69
66	!	70	!
67	awk '/^[^#]/ {if(('$havejobs' \|\| $2 != "-j") && ('$havehist' \|\| $2 != "-h")) \	71	awk '/^[^#]/ {if(('$havejobs' \|\| $2 != "-j") && ('$havehist' \|\| $2 != "-h")) \
68	print $0}' ${builtins} \| sed 's/-j//' > $temp	72	print $0}' ${builtins} \| sed 's/-[hj]//' > $temp
69	awk '{ printf "int %s __P((int, char **));\n", $1}' $temp	73	awk '{ printf "int %s __P((int, char **));\n", $1}' $temp
70	echo '	74	echo '
71	int (const builtinfunc[]) __P((int, char *)) = {'
72	awk '/^[^#]/ { printf "\t%s,\n", $1}' $temp
73	echo '};
74
75	const struct builtincmd builtincmd[] = {'	75	const struct builtincmd builtincmd[] = {'
76	awk '{ for (i = 2 ; i <= NF ; i++) {	76	awk '{ for (i = 2 ; i <= NF ; i++) {
77	printf "\t{ \"%s\", %d },\n", $i, NR-1	77	print $i "\t" $1
78	}}' $temp	78	}}' $temp \| sort -k 1,1 \| tee $temp2 \|
79	echo ' { NULL, 0 }	79	join -a 1 -e 0 -o 1.1,1.2,2.1 - $specialbltins \|
80	};'	80	join -a 1 -e 0 -o 1.1,1.2,1.3,2.1 - $regularbltins \|
		81	join -a 1 -e 0 -o 1.1,1.2,1.3,1.4,2.1 - $assignbltins \|
		82	awk '{ printf "\t{ \"%s\", %s, %d },\n", $1, $2,
		83	!!$3 + (!!$4 * 2) + (!!$5 * 4)}'
		84	echo '};'
81		85
82	exec > ${objdir}/builtins.h	86	exec > ${objdir}/builtins.h
83	cat <<\!	87	cat <<\!
Lines 87-100 Link Here
87		91
88	#include <sys/cdefs.h>	92	#include <sys/cdefs.h>
89	!	93	!
90	tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ < $temp \|	94	nl -v 0 $temp2 \| sort -u -k 3,3 \|
91	awk '{ printf "#define %s %d\n", $1, NR-1}'	95	tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ \|
		96	awk '{ printf "#define %s (builtincmd + %d)\n", $3, $1}'
		97	printf '\n#define NUMBUILTINS %d\n' $(wc -l < $temp2)
92	echo '	98	echo '
		99	#define BUILTIN_SPECIAL 0x1
		100	#define BUILTIN_REGULAR 0x2
		101	#define BUILTIN_ASSIGN 0x4
		102
93	struct builtincmd {	103	struct builtincmd {
94	const char *name;	104	const char *name;
95	int code;	105	int (const builtinfunc) __P((int, char *));
		106	unsigned flags;
96	};	107	};
97		108
98	extern int (const builtinfunc[]) __P((int, char *));
99	extern const struct builtincmd builtincmd[];'	109	extern const struct builtincmd builtincmd[];'
100	rm -f $temp

Lines 131-146 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mkinit.c (-8 lines)
131	* interactive shell and control is returned to the main command loop.\n\	131	* interactive shell and control is returned to the main command loop.\n\
132	*/\n";	132	*/\n";
133		133
134	char shellproc[] = "\
135	/*\n\
136	* This routine is called to initialize the shell to run a shell procedure.\n\
137	*/\n";
138
139		134
140	struct event event[] = {	135	struct event event[] = {
141	{"INIT", "init", init},	136	{"INIT", "init", init},
142	{"RESET", "reset", reset},	137	{"RESET", "reset", reset},
143	{"SHELLPROC", "initshellproc", shellproc},
144	{NULL, NULL}	138	{NULL, NULL}
145	};	139	};
146		140
Lines 218-225 Link Here
218	doinclude(line);	212	doinclude(line);
219	if (line[0] == 'M' && match("MKINIT", line))	213	if (line[0] == 'M' && match("MKINIT", line))
220	dodecl(line, fp);	214	dodecl(line, fp);
221	if (line[0] == '#' && gooddefine(line))
222	addstr(line, &defines);
223	if (line[0] == '#' && gooddefine(line)) {	215	if (line[0] == '#' && gooddefine(line)) {
224	char *cp;	216	char *cp;
225	char line2[1024];	217	char line2[1024];

Lines 1-4 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mknodes.c (-25 / +9 lines)
1	/* $NetBSD: mknodes.c,v 1.18 2000/07/27 04:06:49 cgd Exp $ */	1	/* $NetBSD: mknodes.c,v 1.19 2002/05/25 23:09:06 wiz Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 1991, 1993	4	* Copyright (c) 1991, 1993
Lines 47-53 Link Here
47	static char sccsid[] = "@(#)mknodes.c 8.2 (Berkeley) 5/4/95";	47	static char sccsid[] = "@(#)mknodes.c 8.2 (Berkeley) 5/4/95";
48	#else	48	#else
49	static const char rcsid[] =	49	static const char rcsid[] =
50	"$NetBSD: mknodes.c,v 1.18 2000/07/27 04:06:49 cgd Exp $";	50	"$NetBSD: mknodes.c,v 1.19 2002/05/25 23:09:06 wiz Exp $";
51	#endif	51	#endif
52	#endif /* not lint */	52	#endif /* not lint */
53		53
Lines 59-70 Link Here
59	#include <stdio.h>	59	#include <stdio.h>
60	#include <stdlib.h>	60	#include <stdlib.h>
61	#include <string.h>	61	#include <string.h>
62	#ifdef __STDC__
63	#include <stdarg.h>	62	#include <stdarg.h>
64	#else
65	#include <varargs.h>
66	#endif
67
68		63
69	#define MAXTYPES 50 /* max number of node types */	64	#define MAXTYPES 50 /* max number of node types */
70	#define MAXFIELDS 20 /* max fields in a structure */	65	#define MAXFIELDS 20 /* max fields in a structure */
Lines 270-282 Link Here
270	fputs("\tstruct nodelist *next;\n", hfile);	265	fputs("\tstruct nodelist *next;\n", hfile);
271	fputs("\tunion node *n;\n", hfile);	266	fputs("\tunion node *n;\n", hfile);
272	fputs("};\n\n\n", hfile);	267	fputs("};\n\n\n", hfile);
273	fputs("#ifdef __STDC__\n", hfile);	268	fputs("struct funcnode {\n", hfile);
274	fputs("union node copyfunc(union node );\n", hfile);	269	fputs("\tint count;\n", hfile);
275	fputs("void freefunc(union node *);\n", hfile);	270	fputs("\tunion node n;\n", hfile);
276	fputs("#else\n", hfile);	271	fputs("};\n\n\n", hfile);
277	fputs("union node *copyfunc();\n", hfile);	272	fputs("struct funcnode copyfunc(union node );\n", hfile);
278	fputs("void freefunc();\n", hfile);	273	fputs("void freefunc(struct funcnode *);\n", hfile);
279	fputs("#endif\n", hfile);
280		274
281	fputs(writer, cfile);	275	fputs(writer, cfile);
282	while (fgets(line, sizeof line, patfile) != NULL) {	276	while (fgets(line, sizeof line, patfile) != NULL) {
Lines 451-471 Link Here
451		445
452		446
453	static void	447	static void
454	#ifdef __STDC__
455	error(const char *msg, ...)	448	error(const char *msg, ...)
456	#else
457	error(va_alist)
458	va_dcl
459	#endif
460	{	449	{
461	va_list va;	450	va_list va;
462	#ifdef __STDC__	451
463	va_start(va, msg);	452	va_start(va, msg);
464	#else
465	char *msg;
466	va_start(va);
467	msg = va_arg(va, char *);
468	#endif
469		453
470	(void) fprintf(stderr, "line %d: ", linno);	454	(void) fprintf(stderr, "line %d: ", linno);
471	(void) vfprintf(stderr, msg, va);	455	(void) vfprintf(stderr, msg, va);

Line 0 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mksignames.c (+419 lines)
		1	/* signames.c -- Create and write `signames.c', which contains an array of
		2	signal names. */
		3
		4	/* Copyright (C) 1992 Free Software Foundation, Inc.
		5
		6	This file is part of GNU Bash, the Bourne Again SHell.
		7
		8	Bash is free software; you can redistribute it and/or modify it under
		9	the terms of the GNU General Public License as published by the Free
		10	Software Foundation; either version 2, or (at your option) any later
		11	version.
		12
		13	Bash is distributed in the hope that it will be useful, but WITHOUT ANY
		14	WARRANTY; without even the implied warranty of MERCHANTABILITY or
		15	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
		16	for more details.
		17
		18	You should have received a copy of the GNU General Public License along
		19	with Bash; see the file COPYING. If not, write to the Free Software
		20	Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
		21
		22	#include <stdio.h>
		23	#include <sys/types.h>
		24	#include <signal.h>
		25	#include <stdlib.h>
		26
		27	#if !defined (NSIG)
		28	# define NSIG 64
		29	#endif
		30
		31	/*
		32	* Special traps:
		33	* EXIT == 0
		34	*/
		35	#define LASTSIG NSIG-1
		36
		37	char signal_names[2 NSIG + 3];
		38
		39	#define signal_names_size (sizeof(signal_names)/sizeof(signal_names[0]))
		40
		41	char *progname;
		42
		43	/* AIX 4.3 defines SIGRTMIN and SIGRTMAX as 888 and 999 respectively.
		44	I don't want to allocate so much unused space for the intervening signal
		45	numbers, so we just punt if SIGRTMAX is past the bounds of the
		46	signal_names array (handled in configure). */
		47	#if defined (SIGRTMAX) && defined (UNUSABLE_RT_SIGNALS)
		48	# undef SIGRTMAX
		49	# undef SIGRTMIN
		50	#endif
		51
		52	#if defined (SIGRTMAX) \|\| defined (SIGRTMIN)
		53	# define RTLEN 14
		54	# define RTLIM 256
		55	#endif
		56
		57	void
		58	initialize_signames ()
		59	{
		60	register int i;
		61	#if defined (SIGRTMAX) \|\| defined (SIGRTMIN)
		62	int rtmin, rtmax, rtcnt;
		63	#endif
		64
65	for (i = 1; i < signal_names_size; i++)
66	signal_names[i] = (char *)NULL;
67
68	/* `signal' 0 is what we do on exit. */
69	signal_names[0] = "EXIT";
70
71	/* Place signal names which can be aliases for more common signal
72	names first. This allows (for example) SIGABRT to overwrite SIGLOST. */
73
74	/* POSIX 1003.1b-1993 real time signals, but take care of incomplete
75	implementations. Acoording to the standard, both, SIGRTMIN and
76	SIGRTMAX must be defined, SIGRTMIN must be stricly less than
77	SIGRTMAX, and the difference must be at least 7, that is, there
78	must be at least eight distinct real time signals. */
79
80	/* The generated signal names are SIGRTMIN, SIGRTMIN+1, ...,
81	SIGRTMIN+x, SIGRTMAX-x, ..., SIGRTMAX-1, SIGRTMAX. If the number
82	of RT signals is odd, there is an extra SIGRTMIN+(x+1).
83	These names are the ones used by ksh and /usr/xpg4/bin/sh on SunOS5. */
84
85	#if defined (SIGRTMIN)
86	rtmin = SIGRTMIN;
87	signal_names[rtmin] = "RTMIN";
88	#endif
89
90	#if defined (SIGRTMAX)
91	rtmax = SIGRTMAX;
92	signal_names[rtmax] = "RTMAX";
93	#endif
94
95	#if defined (SIGRTMAX) && defined (SIGRTMIN)
96	if (rtmax > rtmin)
97	{
98	rtcnt = (rtmax - rtmin - 1) / 2;
99	/* croak if there are too many RT signals */
100	if (rtcnt >= RTLIM/2)
101	{
102	rtcnt = RTLIM/2-1;
103	fprintf(stderr, "%s: error: more than %i real time signals, fix `%s'\n",
104	progname, RTLIM, progname);
105	}
106
107	for (i = 1; i <= rtcnt; i++)
108	{
109	signal_names[rtmin+i] = (char *)malloc(RTLEN);
110	if (signal_names[rtmin+i])
111	sprintf (signal_names[rtmin+i], "RTMIN+%d", i);
112	signal_names[rtmax-i] = (char *)malloc(RTLEN);
113	if (signal_names[rtmax-i])
114	sprintf (signal_names[rtmax-i], "RTMAX-%d", i);
115	}
116
117	if (rtcnt < RTLIM/2-1 && rtcnt != (rtmax-rtmin)/2)
118	{
119	/* Need an extra RTMIN signal */
120	signal_names[rtmin+rtcnt+1] = (char *)malloc(RTLEN);
121	if (signal_names[rtmin+rtcnt+1])
122	sprintf (signal_names[rtmin+rtcnt+1], "RTMIN+%d", rtcnt+1);
123	}
124	}
125	#endif /* SIGRTMIN && SIGRTMAX */
126
127	/* AIX */
128	#if defined (SIGLOST) /* resource lost (eg, record-lock lost) */
129	signal_names[SIGLOST] = "LOST";
130	#endif
131
132	#if defined (SIGMSG) /* HFT input data pending */
133	signal_names[SIGMSG] = "MSG";
134	#endif
135
136	#if defined (SIGDANGER) /* system crash imminent */
137	signal_names[SIGDANGER] = "DANGER";
138	#endif
139
140	#if defined (SIGMIGRATE) /* migrate process to another CPU */
141	signal_names[SIGMIGRATE] = "MIGRATE";
142	#endif
143
144	#if defined (SIGPRE) /* programming error */
145	signal_names[SIGPRE] = "PRE";
146	#endif
147
148	#if defined (SIGVIRT) /* AIX virtual time alarm */
149	signal_names[SIGVIRT] = "VIRT";
150	#endif
151
152	#if defined (SIGALRM1) /* m:n condition variables */
153	signal_names[SIGALRM1] = "ALRM1";
154	#endif
155
156	#if defined (SIGWAITING) /* m:n scheduling */
157	signal_names[SIGWAITING] = "WAITING";
158	#endif
159
160	#if defined (SIGGRANT) /* HFT monitor mode granted */
161	signal_names[SIGGRANT] = "GRANT";
162	#endif
163
164	#if defined (SIGKAP) /* keep alive poll from native keyboard */
165	signal_names[SIGKAP] = "KAP";
166	#endif
167
168	#if defined (SIGRETRACT) /* HFT monitor mode retracted */
169	signal_names[SIGRETRACT] = "RETRACT";
170	#endif
171
172	#if defined (SIGSOUND) /* HFT sound sequence has completed */
173	signal_names[SIGSOUND] = "SOUND";
174	#endif
175
176	#if defined (SIGSAK) /* Secure Attention Key */
177	signal_names[SIGSAK] = "SAK";
178	#endif
179
180	/* SunOS5 */
181	#if defined (SIGLWP) /* special signal used by thread library */
182	signal_names[SIGLWP] = "LWP";
183	#endif
184
185	#if defined (SIGFREEZE) /* special signal used by CPR */
186	signal_names[SIGFREEZE] = "FREEZE";
187	#endif
188
189	#if defined (SIGTHAW) /* special signal used by CPR */
190	signal_names[SIGTHAW] = "THAW";
191	#endif
192
193	#if defined (SIGCANCEL) /* thread cancellation signal used by libthread */
194	signal_names[SIGCANCEL] = "CANCEL";
195	#endif
196
197	/* HP-UX */
198	#if defined (SIGDIL) /* DIL signal (?) */
199	signal_names[SIGDIL] = "DIL";
200	#endif
201
202	/* System V */
203	#if defined (SIGCLD) /* Like SIGCHLD. */
204	signal_names[SIGCLD] = "CLD";
205	#endif
206
207	#if defined (SIGPWR) /* power state indication */
208	signal_names[SIGPWR] = "PWR";
209	#endif
210
211	#if defined (SIGPOLL) /* Pollable event (for streams) */
212	signal_names[SIGPOLL] = "POLL";
213	#endif
214
215	/* Unknown */
216	#if defined (SIGWINDOW)
217	signal_names[SIGWINDOW] = "WINDOW";
218	#endif
219
220	/* Common */
221	#if defined (SIGHUP) /* hangup */
222	signal_names[SIGHUP] = "HUP";
223	#endif
224
225	#if defined (SIGINT) /* interrupt */
226	signal_names[SIGINT] = "INT";
227	#endif
228
229	#if defined (SIGQUIT) /* quit */
230	signal_names[SIGQUIT] = "QUIT";
231	#endif
232
233	#if defined (SIGILL) /* illegal instruction (not reset when caught) */
234	signal_names[SIGILL] = "ILL";
235	#endif
236
237	#if defined (SIGTRAP) /* trace trap (not reset when caught) */
238	signal_names[SIGTRAP] = "TRAP";
239	#endif
240
241	#if defined (SIGIOT) /* IOT instruction */
242	signal_names[SIGIOT] = "IOT";
243	#endif
244
245	#if defined (SIGABRT) /* Cause current process to dump core. */
246	signal_names[SIGABRT] = "ABRT";
247	#endif
248
249	#if defined (SIGEMT) /* EMT instruction */
250	signal_names[SIGEMT] = "EMT";
251	#endif
252
253	#if defined (SIGFPE) /* floating point exception */
254	signal_names[SIGFPE] = "FPE";
255	#endif
256
257	#if defined (SIGKILL) /* kill (cannot be caught or ignored) */
258	signal_names[SIGKILL] = "KILL";
259	#endif
260
261	#if defined (SIGBUS) /* bus error */
262	signal_names[SIGBUS] = "BUS";
263	#endif
264
265	#if defined (SIGSEGV) /* segmentation violation */
266	signal_names[SIGSEGV] = "SEGV";
267	#endif
268
269	#if defined (SIGSYS) /* bad argument to system call */
270	signal_names[SIGSYS] = "SYS";
271	#endif
272
273	#if defined (SIGPIPE) /* write on a pipe with no one to read it */
274	signal_names[SIGPIPE] = "PIPE";
275	#endif
276
277	#if defined (SIGALRM) /* alarm clock */
278	signal_names[SIGALRM] = "ALRM";
279	#endif
280
281	#if defined (SIGTERM) /* software termination signal from kill */
282	signal_names[SIGTERM] = "TERM";
283	#endif
284
285	#if defined (SIGURG) /* urgent condition on IO channel */
286	signal_names[SIGURG] = "URG";
287	#endif
288
289	#if defined (SIGSTOP) /* sendable stop signal not from tty */
290	signal_names[SIGSTOP] = "STOP";
291	#endif
292
293	#if defined (SIGTSTP) /* stop signal from tty */
294	signal_names[SIGTSTP] = "TSTP";
295	#endif
296
297	#if defined (SIGCONT) /* continue a stopped process */
298	signal_names[SIGCONT] = "CONT";
299	#endif
300
301	#if defined (SIGCHLD) /* to parent on child stop or exit */
302	signal_names[SIGCHLD] = "CHLD";
303	#endif
304
305	#if defined (SIGTTIN) /* to readers pgrp upon background tty read */
306	signal_names[SIGTTIN] = "TTIN";
307	#endif
308
309	#if defined (SIGTTOU) /* like TTIN for output if (tp->t_local&LTOSTOP) */
310	signal_names[SIGTTOU] = "TTOU";
311	#endif
312
313	#if defined (SIGIO) /* input/output possible signal */
314	signal_names[SIGIO] = "IO";
315	#endif
316
317	#if defined (SIGXCPU) /* exceeded CPU time limit */
318	signal_names[SIGXCPU] = "XCPU";
319	#endif
320
321	#if defined (SIGXFSZ) /* exceeded file size limit */
322	signal_names[SIGXFSZ] = "XFSZ";
323	#endif
324
325	#if defined (SIGVTALRM) /* virtual time alarm */
326	signal_names[SIGVTALRM] = "VTALRM";
327	#endif
328
329	#if defined (SIGPROF) /* profiling time alarm */
330	signal_names[SIGPROF] = "PROF";
331	#endif
332
333	#if defined (SIGWINCH) /* window changed */
334	signal_names[SIGWINCH] = "WINCH";
335	#endif
336
337	/* 4.4 BSD */
338	#if defined (SIGINFO) && !defined (_SEQUENT_) /* information request */
339	signal_names[SIGINFO] = "INFO";
340	#endif
341
342	#if defined (SIGUSR1) /* user defined signal 1 */
343	signal_names[SIGUSR1] = "USR1";
344	#endif
345
346	#if defined (SIGUSR2) /* user defined signal 2 */
347	signal_names[SIGUSR2] = "USR2";
348	#endif
349
350	#if defined (SIGKILLTHR) /* BeOS: Kill Thread */
351	signal_names[SIGKILLTHR] = "KILLTHR";
352	#endif
353
354	for (i = 0; i < NSIG; i++)
355	if (signal_names[i] == (char *)NULL)
356	{
357	signal_names[i] = (char *)malloc (18);
358	if (signal_names[i])
359	sprintf (signal_names[i], "%d", i);
360	}
361	}
362
363	void
364	write_signames (stream)
365	FILE *stream;
366	{
367	register int i;
368
369	fprintf (stream, "/* This file was automatically created by %s.\n",
370	progname);
371	fprintf (stream, " Do not edit. Edit support/mksignames.c instead. */\n\n");
372	fprintf (stream, "#include <signal.h>\n\n");
373	fprintf (stream,
374	"/* A translation list so we can be polite to our users. */\n");
375	fprintf (stream, "const char *const signal_names[NSIG + 1] = {\n");
376
377	for (i = 0; i <= LASTSIG; i++)
378	fprintf (stream, " \"%s\",\n", signal_names[i]);
379
380	fprintf (stream, " (char *)0x0\n");
381	fprintf (stream, "};\n");
382	}
383
384	int
385	main (argc, argv)
386	int argc;
387	char **argv;
388	{
389	char *stream_name;
390	FILE *stream;
391
392	progname = argv[0];
393
394	if (argc == 1)
395	{
396	stream_name = "signames.c";
397	}
398	else if (argc == 2)
399	{
400	stream_name = argv[1];
401	}
402	else
403	{
404	fprintf (stderr, "Usage: %s [output-file]\n", progname);
405	exit (1);
406	}
407
408	stream = fopen (stream_name, "w");
409	if (!stream)
410	{
411	fprintf (stderr, "%s: %s: cannot open for writing\n",
412	progname, stream_name);
413	exit (2);
414	}
415
416	initialize_signames ();
417	write_signames (stream);
418	exit (0);
419	}

Lines 1-4 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/mksyntax.c (-16 / +20 lines)
1	/* $NetBSD: mksyntax.c,v 1.24.4.1 2002/05/31 16:42:05 tv Exp $ */	1	/* $NetBSD: mksyntax.c,v 1.25 2002/05/31 16:18:48 christos Exp $ */
2		2
3	/*-	3	/*-
4	* Copyright (c) 1991, 1993	4	* Copyright (c) 1991, 1993
Lines 47-53 Link Here
47	static char sccsid[] = "@(#)mksyntax.c 8.2 (Berkeley) 5/4/95";	47	static char sccsid[] = "@(#)mksyntax.c 8.2 (Berkeley) 5/4/95";
48	#else	48	#else
49	static const char rcsid[] =	49	static const char rcsid[] =
50	"$NetBSD: mksyntax.c,v 1.24.4.1 2002/05/31 16:42:05 tv Exp $";	50	"$NetBSD: mksyntax.c,v 1.25 2002/05/31 16:18:48 christos Exp $";
51	#endif	51	#endif
52	#endif /* not lint */	52	#endif /* not lint */
53		53
Lines 73-78 Link Here
73	{ "CBACK", "a backslash character" },	73	{ "CBACK", "a backslash character" },
74	{ "CSQUOTE", "single quote" },	74	{ "CSQUOTE", "single quote" },
75	{ "CDQUOTE", "double quote" },	75	{ "CDQUOTE", "double quote" },
		76	{ "CENDQUOTE", "a terminating quote" },
76	{ "CBQUOTE", "backwards single quote" },	77	{ "CBQUOTE", "backwards single quote" },
77	{ "CVAR", "a dollar sign" },	78	{ "CVAR", "a dollar sign" },
78	{ "CENDVAR", "a '}' character" },	79	{ "CENDVAR", "a '}' character" },
Lines 81-86 Link Here
81	{ "CEOF", "end of file" },	82	{ "CEOF", "end of file" },
82	{ "CCTL", "like CWORD, except it must be escaped" },	83	{ "CCTL", "like CWORD, except it must be escaped" },
83	{ "CSPCL", "these terminate a word" },	84	{ "CSPCL", "these terminate a word" },
		85	{ "CIGN", "character should be ignored" },
84	{ NULL, NULL }	86	{ NULL, NULL }
85	};	87	};
86		88
Lines 168-174 Link Here
168	exit(2);	170	exit(2);
169	}	171	}
170	size = (1 << nbits) + 1;	172	size = (1 << nbits) + 1;
171	base = 1;	173	base = 2;
172	if (sign)	174	if (sign)
173	base += 1 << (nbits - 1);	175	base += 1 << (nbits - 1);
174	digit_contig = 1;	176	digit_contig = 1;
Lines 179-184 Link Here
179		181
180	fputs("#include <sys/cdefs.h>\n", hfile);	182	fputs("#include <sys/cdefs.h>\n", hfile);
181	fputs("#include <ctype.h>\n", hfile);	183	fputs("#include <ctype.h>\n", hfile);
		184	fputs("\n", hfile);
		185	fputs("#ifdef CEOF\n", hfile);
		186	fputs("#undef CEOF\n", hfile);
		187	fputs("#endif\n", hfile);
		188	fputs("\n", hfile);
182		189
183	/* Generate the #define statements in the header file */	190	/* Generate the #define statements in the header file */
184	fputs("/* Syntax classes */\n", hfile);	191	fputs("/* Syntax classes */\n", hfile);
Lines 201-210 Link Here
201	putc('\n', hfile);	208	putc('\n', hfile);
202	fprintf(hfile, "#define SYNBASE %d\n", base);	209	fprintf(hfile, "#define SYNBASE %d\n", base);
203	fprintf(hfile, "#define PEOF %d\n\n", -base);	210	fprintf(hfile, "#define PEOF %d\n\n", -base);
204	if (sign)	211	fprintf(hfile, "#define PEOA %d\n\n", -base + 1);
205	fprintf(hfile, "#define UPEOF ((char)%d)\n\n", -base);
206	else
207	fprintf(hfile, "#define UPEOF ((unsigned char)%d)\n\n", -base);
208	putc('\n', hfile);	212	putc('\n', hfile);
209	fputs("#define BASESYNTAX (basesyntax + SYNBASE)\n", hfile);	213	fputs("#define BASESYNTAX (basesyntax + SYNBASE)\n", hfile);
210	fputs("#define DQSYNTAX (dqsyntax + SYNBASE)\n", hfile);	214	fputs("#define DQSYNTAX (dqsyntax + SYNBASE)\n", hfile);
Lines 227-258 Link Here
227	add("$", "CVAR");	231	add("$", "CVAR");
228	add("}", "CENDVAR");	232	add("}", "CENDVAR");
229	add("<>();&\| \t", "CSPCL");	233	add("<>();&\| \t", "CSPCL");
		234	syntax[1] = "CSPCL";
230	print("basesyntax");	235	print("basesyntax");
231	init();	236	init();
232	fputs("\n/* syntax table used when in double quotes */\n", cfile);	237	fputs("\n/* syntax table used when in double quotes */\n", cfile);
233	add("\n", "CNL");	238	add("\n", "CNL");
234	add("\\", "CBACK");	239	add("\\", "CBACK");
235	add("\"", "CDQUOTE");	240	add("\"", "CENDQUOTE");
236	add("`", "CBQUOTE");	241	add("`", "CBQUOTE");
237	add("$", "CVAR");	242	add("$", "CVAR");
238	add("}", "CENDVAR");	243	add("}", "CENDVAR");
239	/* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */	244	/* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */
240	add("!*?[=~:/-", "CCTL");	245	add("!*?[=~:/-]", "CCTL");
241	print("dqsyntax");	246	print("dqsyntax");
242	init();	247	init();
243	fputs("\n/* syntax table used when in single quotes */\n", cfile);	248	fputs("\n/* syntax table used when in single quotes */\n", cfile);
244	add("\n", "CNL");	249	add("\n", "CNL");
245	add("'", "CSQUOTE");	250	add("'", "CENDQUOTE");
246	/* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */	251	/* ':/' for tilde expansion, '-' for [a\-x] pattern ranges */
247	add("!*?[=~:/-", "CCTL");	252	add("!*?[=~:/-]\\", "CCTL");
248	print("sqsyntax");	253	print("sqsyntax");
249	init();	254	init();
250	fputs("\n/* syntax table used when in arithmetic */\n", cfile);	255	fputs("\n/* syntax table used when in arithmetic */\n", cfile);
251	add("\n", "CNL");	256	add("\n", "CNL");
252	add("\\", "CBACK");	257	add("\\", "CBACK");
253	add("`", "CBQUOTE");	258	add("`", "CBQUOTE");
254	add("'", "CSQUOTE");
255	add("\"", "CDQUOTE");
256	add("$", "CVAR");	259	add("$", "CVAR");
257	add("}", "CENDVAR");	260	add("}", "CENDVAR");
258	add("(", "CLP");	261	add("(", "CLP");
Lines 298-303 Link Here
298	{	301	{
299	filltable("CWORD");	302	filltable("CWORD");
300	syntax[0] = "CEOF";	303	syntax[0] = "CEOF";
		304	syntax[1] = "CIGN";
301	#ifdef TARGET_CHAR	305	#ifdef TARGET_CHAR
302	syntax[base + (TARGET_CHAR)CTLESC] = "CCTL";	306	syntax[base + (TARGET_CHAR)CTLESC] = "CCTL";
303	syntax[base + (TARGET_CHAR)CTLVAR] = "CCTL";	307	syntax[base + (TARGET_CHAR)CTLVAR] = "CCTL";
Lines 374-382 Link Here
374		378
375	static char *macro[] = {	379	static char *macro[] = {
376	"#define is_digit(c)\t((is_type+SYNBASE)[c] & ISDIGIT)",	380	"#define is_digit(c)\t((is_type+SYNBASE)[c] & ISDIGIT)",
377	"#define is_alpha(c)\t((c) != UPEOF && ((c) < CTLESC \|\| (c) > CTLENDARI) && isalpha((unsigned char) (c)))",	381	"#define is_alpha(c)\t(((c) < CTLESC \|\| (c) > CTLENDARI) && isalpha((unsigned char) (c)))",
378	"#define is_name(c)\t((c) != UPEOF && ((c) < CTLESC \|\| (c) > CTLENDARI) && ((c) == '_' \|\| isalpha((unsigned char) (c))))",	382	"#define is_name(c)\t(((c) < CTLESC \|\| (c) > CTLENDARI) && ((c) == '_' \|\| isalpha((unsigned char) (c))))",
379	"#define is_in_name(c)\t((c) != UPEOF && ((c) < CTLESC \|\| (c) > CTLENDARI) && ((c) == '_' \|\| isalnum((unsigned char) (c))))",	383	"#define is_in_name(c)\t(((c) < CTLESC \|\| (c) > CTLENDARI) && ((c) == '_' \|\| isalnum((unsigned char) (c))))",
380	"#define is_special(c)\t((is_type+SYNBASE)[c] & (ISSPECL\|ISDIGIT))",	384	"#define is_special(c)\t((is_type+SYNBASE)[c] & (ISSPECL\|ISDIGIT))",
381	NULL	385	NULL
382	};	386	};

Lines 70-87 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/nodes.c.pat (-13 / +23 lines)
70	* Make a copy of a parse tree.	70	* Make a copy of a parse tree.
71	*/	71	*/
72		72
73	union node *	73	struct funcnode *
74	copyfunc(n)	74	copyfunc(union node *n)
75	union node *n;
76	{	75	{
77	if (n == NULL)	76	struct funcnode *f;
78	return NULL;	77	size_t blocksize;
79	funcblocksize = 0;	78
		79	funcblocksize = offsetof(struct funcnode, n);
80	funcstringsize = 0;	80	funcstringsize = 0;
81	calcsize(n);	81	calcsize(n);
82	funcblock = ckmalloc(funcblocksize + funcstringsize);	82	blocksize = funcblocksize;
83	funcstring = (char *) funcblock + funcblocksize;	83	f = ckmalloc(blocksize + funcstringsize);
84	return copynode(n);	84	funcblock = (char *) f + offsetof(struct funcnode, n);
		85	funcstring = (char *) f + blocksize;
		86	copynode(n);
		87	f->count = 0;
		88	return f;
85	}	89	}
86		90
87		91
Lines 144-149 Link Here
144	nodesavestr(s)	148	nodesavestr(s)
145	char *s;	149	char *s;
146	{	150	{
		151	#ifdef _GNU_SOURCE
		152	char *rtn = funcstring;
		153
		154	funcstring = stpcpy(funcstring, s) + 1;
		155	return rtn;
		156	#else
147	register char *p = s;	157	register char *p = s;
148	register char *q = funcstring;	158	register char *q = funcstring;
149	char *rtn = funcstring;	159	char *rtn = funcstring;
Lines 152-157 Link Here
152	continue;	162	continue;
153	funcstring = q;	163	funcstring = q;
154	return rtn;	164	return rtn;
		165	#endif
155	}	166	}
156		167
157		168
Lines 161-169 Link Here
161	*/	172	*/
162		173
163	void	174	void
164	freefunc(n)	175	freefunc(struct funcnode *f)
165	union node *n;
166	{	176	{
167	if (n)	177	if (f && --f->count < 0)
168	ckfree(n);	178	ckfree(f);
169	}	179	}

Lines 52-65 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/nodetypes (-6 / +6 lines)
52	# The last two types should be followed by the text of a C declaration for	52	# The last two types should be followed by the text of a C declaration for
53	# the field.	53	# the field.
54		54
55	NSEMI nbinary # two commands separated by a semicolon
56	type int
57	ch1 nodeptr # the first child
58	ch2 nodeptr # the second child
59
60	NCMD ncmd # a simple command	55	NCMD ncmd # a simple command
61	type int	56	type int
62	backgnd int # set to run command in background	57	assign nodeptr # variable assignments
63	args nodeptr # the arguments	58	args nodeptr # the arguments
64	redirect nodeptr # list of file redirections	59	redirect nodeptr # list of file redirections
65		60
Lines 79-84 Link Here
79	NAND nbinary # the && operator	74	NAND nbinary # the && operator
80	NOR nbinary # the \|\| operator	75	NOR nbinary # the \|\| operator
81		76
		77	NSEMI nbinary # two commands separated by a semicolon
		78	type int
		79	ch1 nodeptr # the first child
		80	ch2 nodeptr # the second child
		81
82	NIF nif # the if statement. Elif clauses are handled	82	NIF nif # the if statement. Elif clauses are handled
83	type int # using multiple if nodes.	83	type int # using multiple if nodes.
84	test nodeptr # if test	84	test nodeptr # if test

Lines 75-85 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/options.c (-69 / +103 lines)
75		75
76	char minusc; / argument to -c option */	76	char minusc; / argument to -c option */
77		77
		78	static const char *const optnames[NOPTS] = {
		79	"errexit",
		80	"noglob",
		81	"ignoreeof",
		82	"interactive",
		83	"monitor",
		84	"noexec",
		85	"stdin",
		86	"xtrace",
		87	"verbose",
		88	"vi",
		89	"emacs",
		90	"noclobber",
		91	"allexport",
		92	"notify",
		93	"nounset",
		94	"quietprofile",
		95	};
		96
		97	const char optletters[NOPTS] = {
		98	'e',
		99	'f',
		100	'I',
		101	'i',
		102	'm',
		103	'n',
		104	's',
		105	'x',
		106	'v',
		107	'V',
		108	'E',
		109	'C',
		110	'a',
		111	'b',
		112	'u',
		113	'q',
		114	};
		115
		116	char optlist[NOPTS];
		117
78		118
79	STATIC void options __P((int));	119	STATIC void options __P((int));
80	STATIC void minus_o __P((char *, int));	120	STATIC void minus_o __P((char *, int));
81	STATIC void setoption __P((int, int));	121	STATIC void setoption __P((int, int));
82	STATIC int getopts __P((char , char , char , char , char *));	122	STATIC int getopts __P((char , char , char *, int , int *));
83		123
84		124
85	/*	125	/*
Lines 97-103 Link Here
97	if (argc > 0)	137	if (argc > 0)
98	argptr++;	138	argptr++;
99	for (i = 0; i < NOPTS; i++)	139	for (i = 0; i < NOPTS; i++)
100	optlist[i].val = 2;	140	optlist[i] = 2;
101	options(1);	141	options(1);
102	if (*argptr == NULL && minusc == NULL)	142	if (*argptr == NULL && minusc == NULL)
103	sflag = 1;	143	sflag = 1;
Lines 106-126 Link Here
106	if (mflag == 2)	146	if (mflag == 2)
107	mflag = iflag;	147	mflag = iflag;
108	for (i = 0; i < NOPTS; i++)	148	for (i = 0; i < NOPTS; i++)
109	if (optlist[i].val == 2)	149	if (optlist[i] == 2)
110	optlist[i].val = 0;	150	optlist[i] = 0;
111	arg0 = argv[0];	151	arg0 = argv[0];
112	if (sflag == 0 && minusc == NULL) {
113	commandname = argv[0];
114	arg0 = *argptr++;
115	setinputfile(arg0, 0);
116	commandname = arg0;
117	}
118	/* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */	152	/* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
119	if (argptr && minusc && *argptr)	153	if (*argptr) {
120	arg0 = *argptr++;	154	char p = argptr++;
		155	if (!minusc)
		156	setinputfile(p, 0);
		157	arg0 = p;
		158	}
		159	if (!sflag)
		160	commandname = arg0;
121		161
122	shellparam.p = argptr;	162	shellparam.p = argptr;
123	shellparam.reset = 1;	163	shellparam.optind = 1;
		164	shellparam.optoff = -1;
124	/* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */	165	/* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
125	while (*argptr) {	166	while (*argptr) {
126	shellparam.nparam++;	167	shellparam.nparam++;
Lines 210-221 Link Here
210	if (name == NULL) {	251	if (name == NULL) {
211	out1str("Current option settings\n");	252	out1str("Current option settings\n");
212	for (i = 0; i < NOPTS; i++)	253	for (i = 0; i < NOPTS; i++)
213	out1fmt("%-16s%s\n", optlist[i].name,	254	out1fmt("%-16s%s\n", optnames[i],
214	optlist[i].val ? "on" : "off");	255	optlist[i] ? "on" : "off");
215	} else {	256	} else {
216	for (i = 0; i < NOPTS; i++)	257	for (i = 0; i < NOPTS; i++)
217	if (equal(name, optlist[i].name)) {	258	if (equal(name, optnames[i])) {
218	setoption(optlist[i].letter, val);	259	setoption(optletters[i], val);
219	return;	260	return;
220	}	261	}
221	error("Illegal option -o %s", name);	262	error("Illegal option -o %s", name);
Lines 231-238 Link Here
231	int i;	272	int i;
232		273
233	for (i = 0; i < NOPTS; i++)	274	for (i = 0; i < NOPTS; i++)
234	if (optlist[i].letter == flag) {	275	if (optletters[i] == flag) {
235	optlist[i].val = val;	276	optlist[i] = val;
236	if (val) {	277	if (val) {
237	/* #%$ hack for ksh semantics */	278	/* #%$ hack for ksh semantics */
238	if (flag == 'V')	279	if (flag == 'V')
Lines 248-267 Link Here
248		289
249		290
250		291
251	#ifdef mkinit
252	INCLUDE "options.h"
253
254	SHELLPROC {
255	int i;
256
257	for (i = 0; i < NOPTS; i++)
258	optlist[i].val = 0;
259	optschanged();
260
261	}
262	#endif
263
264
265	/*	292	/*
266	* Set the shell parameters.	293	* Set the shell parameters.
267	*/	294	*/
Lines 284-290 Link Here
284	shellparam.malloc = 1;	311	shellparam.malloc = 1;
285	shellparam.nparam = nparam;	312	shellparam.nparam = nparam;
286	shellparam.p = newparam;	313	shellparam.p = newparam;
287	shellparam.optnext = NULL;	314	shellparam.optind = 1;
		315	shellparam.optoff = -1;
288	}	316	}
289		317
290		318
Lines 332-338 Link Here
332	}	360	}
333	ap2 = shellparam.p;	361	ap2 = shellparam.p;
334	while ((ap2++ = ap1++) != NULL);	362	while ((ap2++ = ap1++) != NULL);
335	shellparam.optnext = NULL;	363	shellparam.optind = 1;
		364	shellparam.optoff = -1;
336	INTON;	365	INTON;
337	return 0;	366	return 0;
338	}	367	}
Lines 365-374 Link Here
365	getoptsreset(value)	394	getoptsreset(value)
366	const char *value;	395	const char *value;
367	{	396	{
368	if (number(value) == 1) {	397	shellparam.optind = number(value);
369	shellparam.optnext = NULL;	398	shellparam.optoff = -1;
370	shellparam.reset = 1;
371	}
372	}	399	}
373		400
374	/*	401	/*
Lines 387-436 Link Here
387		414
388	if (argc < 3)	415	if (argc < 3)
389	error("Usage: getopts optstring var [arg]");	416	error("Usage: getopts optstring var [arg]");
390	else if (argc == 3)	417	else if (argc == 3) {
391	optbase = shellparam.p;	418	optbase = shellparam.p;
392	else	419	if (shellparam.optind > shellparam.nparam + 1) {
		420	shellparam.optind = 1;
		421	shellparam.optoff = -1;
		422	}
		423	}
		424	else {
393	optbase = &argv[3];	425	optbase = &argv[3];
394		426	if (shellparam.optind > argc - 2) {
395	if (shellparam.reset == 1) {	427	shellparam.optind = 1;
396	shellparam.optnext = optbase;	428	shellparam.optoff = -1;
397	shellparam.optptr = NULL;	429	}
398	shellparam.reset = 0;
399	}	430	}
400		431
401	return getopts(argv[1], argv[2], optbase, &shellparam.optnext,	432	return getopts(argv[1], argv[2], optbase, &shellparam.optind,
402	&shellparam.optptr);	433	&shellparam.optoff);
403	}	434	}
404		435
405	STATIC int	436	STATIC int
406	getopts(optstr, optvar, optfirst, optnext, optpptr)	437	getopts(optstr, optvar, optfirst, optind, optoff)
407	char *optstr;	438	char *optstr;
408	char *optvar;	439	char *optvar;
409	char **optfirst;	440	char **optfirst;
410	char ***optnext;	441	int *optind;
411	char **optpptr;	442	int *optoff;
412	{	443	{
413	char p, q;	444	char p, q;
414	char c = '?';	445	char c = '?';
415	int done = 0;	446	int done = 0;
416	int ind = 0;
417	int err = 0;	447	int err = 0;
418	char s[10];	448	char s[10];
		449	char *optnext = optfirst + optind - 1;
419		450
420	if ((p = optpptr) == NULL \|\| p == '\0') {	451	if (optind <= 1 \|\| optoff < 0 \|\| !(*(optnext - 1)) \|\|
		452	strlen((optnext - 1)) < optoff)
		453	p = NULL;
		454	else
		455	p = (optnext - 1) + optoff;
		456	if (p == NULL \|\| *p == '\0') {
421	/* Current word is done, advance */	457	/* Current word is done, advance */
422	if (*optnext == NULL)	458	if (optnext == NULL)
423	return 1;	459	return 1;
424	p = **optnext;	460	p = *optnext;
425	if (p == NULL \|\| p != '-' \|\| ++p == '\0') {	461	if (p == NULL \|\| p != '-' \|\| ++p == '\0') {
426	atend:	462	atend:
427	ind = *optnext - optfirst + 1;	463	*optind = optnext - optfirst + 1;
428	*optnext = NULL;
429	p = NULL;	464	p = NULL;
430	done = 1;	465	done = 1;
431	goto out;	466	goto out;
432	}	467	}
433	(*optnext)++;	468	optnext++;
434	if (p[0] == '-' && p[1] == '\0') /* check for "--" */	469	if (p[0] == '-' && p[1] == '\0') /* check for "--" */
435	goto atend;	470	goto atend;
436	}	471	}
Lines 455-461 Link Here
455	}	490	}
456		491
457	if (*++q == ':') {	492	if (*++q == ':') {
458	if (p == '\0' && (p = *optnext) == NULL) {	493	if (p == '\0' && (p = optnext) == NULL) {
459	if (optstr[0] == ':') {	494	if (optstr[0] == ':') {
460	s[0] = c;	495	s[0] = c;
461	s[1] = '\0';	496	s[1] = '\0';
Lines 470-499 Link Here
470	goto bad;	505	goto bad;
471	}	506	}
472		507
473	if (p == **optnext)	508	if (p == *optnext)
474	(*optnext)++;	509	optnext++;
475	setvarsafe("OPTARG", p, 0);	510	setvarsafe("OPTARG", p, 0);
476	p = NULL;	511	p = NULL;
477	}	512	}
478	else	513	else
479	setvarsafe("OPTARG", "", 0);	514	setvarsafe("OPTARG", nullstr, 0);
480	ind = *optnext - optfirst + 1;	515	*optind = optnext - optfirst + 1;
481	goto out;	516	goto out;
482		517
483	bad:	518	bad:
484	ind = 1;	519	*optind = 1;
485	*optnext = NULL;
486	p = NULL;	520	p = NULL;
487	out:	521	out:
488	*optpptr = p;	522	optoff = p ? p - (optnext - 1) : -1;
489	fmtstr(s, sizeof(s), "%d", ind);	523	fmtstr(s, sizeof(s), "%d", *optind);
490	err \|= setvarsafe("OPTIND", s, VNOFUNC);	524	err \|= setvarsafe("OPTIND", s, VNOFUNC);
491	s[0] = c;	525	s[0] = c;
492	s[1] = '\0';	526	s[1] = '\0';
493	err \|= setvarsafe(optvar, s, 0);	527	err \|= setvarsafe(optvar, s, 0);
494	if (err) {	528	if (err) {
495	*optnext = NULL;	529	*optind = 1;
496	*optpptr = NULL;	530	*optoff = -1;
497	flushall();	531	flushall();
498	exraise(EXERROR);	532	exraise(EXERROR);
499	}	533	}

Lines 41-101 Link Here

(-)bin_NetBSD-1.6release.orig/src/bin/sh/options.h (-47 / +20 lines)
41	struct shparam {	41	struct shparam {
42	int nparam; /* # of positional parameters (without $0) */	42	int nparam; /* # of positional parameters (without $0) */
43	unsigned char malloc; /* if parameter list dynamically allocated */	43	unsigned char malloc; /* if parameter list dynamically allocated */
44	unsigned char reset; /* if getopts has been reset */
45	char *p; / parameter list */	44	char *p; / parameter list */
46	char *optnext; / next parameter to be processed by getopts */	45	int optind; /* next parameter to be processed by getopts */
47	char optptr; / used by getopts */	46	int optoff; /* used by getopts */
48	};	47	};
49		48
50		49
51		50
52	#define eflag optlist[0].val	51	#define eflag optlist[0]
53	#define fflag optlist[1].val	52	#define fflag optlist[1]
54	#define Iflag optlist[2].val	53	#define Iflag optlist[2]
55	#define iflag optlist[3].val	54	#define iflag optlist[3]
56	#define mflag optlist[4].val	55	#define mflag optlist[4]
57	#define nflag optlist[5].val	56	#define nflag optlist[5]
58	#define sflag optlist[6].val	57	#define sflag optlist[6]
59	#define xflag optlist[7].val	58	#define xflag optlist[7]
60	#define vflag optlist[8].val	59	#define vflag optlist[8]
61	#define Vflag optlist[9].val	60	#define Vflag optlist[9]
62	#define Eflag optlist[10].val	61	#define Eflag optlist[10]
63	#define Cflag optlist[11].val	62	#define Cflag optlist[11]
64	#define aflag optlist[12].val	63	#define aflag optlist[12]
65	#define bflag optlist[13].val	64	#define bflag optlist[13]
66	#define uflag optlist[14].val	65	#define uflag optlist[14]
67	#define qflag optlist[15].val	66	#define qflag optlist[15]
68		67
69	#define NOPTS 16	68	#define NOPTS 16
70		69
71	struct optent {	70	extern const char optletters[NOPTS];
72	const char *name;	71	extern char optlist[NOPTS];
73	const char letter;
74	char val;
75	};
76
77	#ifdef DEFINE_OPTIONS
78	struct optent optlist[NOPTS] = {
79	{ "errexit", 'e', 0 },
80	{ "noglob", 'f', 0 },
81	{ "ignoreeof", 'I', 0 },
82	{ "interactive",'i', 0 },
83	{ "monitor", 'm', 0 },
84	{ "noexec", 'n', 0 },
85	{ "stdin", 's', 0 },
86	{ "xtrace", 'x', 0 },
87	{ "verbose", 'v', 0 },
88	{ "vi", 'V', 0 },
89	{ "emacs", 'E', 0 },
90	{ "noclobber", 'C', 0 },
91	{ "allexport", 'a', 0 },
92	{ "notify", 'b', 0 },
93	{ "nounset", 'u', 0 },
94	{ "quietprofile", 'q', 0 },
95	};
96	#else
97	extern struct optent optlist[NOPTS];
98	#endif
99		72
100		73
101	extern char minusc; / argument to -c option */	74	extern char minusc; / argument to -c option */