[unix-history] / bin / sh / input.c

/*-
 * Copyright (c) 1991 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. 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.
 */

#ifndef lint
/*static char sccsid[] = "from: @(#)input.c	5.4 (Berkeley) 7/1/91";*/
static char rcsid[] = "input.c,v 1.4 1993/08/01 18:58:15 mycroft Exp";
#endif /* not lint */

/*
 * This file implements the input routines used by the parser.
 */

#include <stdio.h>	/* defines BUFSIZ */
#include "shell.h"
#include <fcntl.h>
#include <errno.h>
#include "syntax.h"
#include "input.h"
#include "output.h"
#include "memalloc.h"
#include "error.h"

#define EOF_NLEFT -99		/* value of parsenleft when EOF pushed back */


/*
 * The parsefile structure pointed to by the global variable parsefile
 * contains information about the current file being read.
 */

MKINIT
struct parsefile {
	int linno;		/* current line */
	int fd;			/* file descriptor (or -1 if string) */
	int nleft;		/* number of chars left in buffer */
	char *nextc;		/* next char in buffer */
	struct parsefile *prev;	/* preceding file on stack */
	char *buf;		/* input buffer */
};


int plinno = 1;			/* input line number */
MKINIT int parsenleft;		/* copy of parsefile->nleft */
char *parsenextc;		/* copy of parsefile->nextc */
MKINIT struct parsefile basepf;	/* top level input file */
char basebuf[BUFSIZ];		/* buffer for top level input file */
struct parsefile *parsefile = &basepf;	/* current input file */
char *pushedstring;		/* copy of parsenextc when text pushed back */
int pushednleft;		/* copy of parsenleft when text pushed back */

#ifdef __STDC__
STATIC void pushfile(void);
#else
STATIC void pushfile();
#endif


#ifdef mkinit
INCLUDE "input.h"
INCLUDE "error.h"

INIT {
	extern char basebuf[];

	basepf.nextc = basepf.buf = basebuf;
}

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

SHELLPROC {
	popallfiles();
}
#endif


/*
 * Read a line from the script.
 */

char *
pfgets(line, len)
	char *line;
	{
	register char *p = line;
	int nleft = len;
	int c;

	while (--nleft > 0) {
		c = pgetc_macro();
		if (c == PEOF) {
			if (p == line)
				return NULL;
			break;
		}
		*p++ = c;
		if (c == '\n')
			break;
	}
	*p = '\0';
	return line;
}


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

int
pgetc() {
	return pgetc_macro();
}


/*
 * Refill the input buffer and return the next input character:
 *
 * 1) If a string was pushed back on the input, switch back to the regular
 *    buffer.
 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
 *    from a string so we can't refill the buffer, return EOF.
 * 3) Call read to read in the characters.
 * 4) Delete all nul characters from the buffer.
 */

int
preadbuffer() {
	register char *p, *q;
	register int i;

	if (pushedstring) {
		parsenextc = pushedstring;
		pushedstring = NULL;
		parsenleft = pushednleft;
		if (--parsenleft >= 0)
			return *parsenextc++;
	}
	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
		return PEOF;
	flushout(&output);
	flushout(&errout);
retry:
	p = parsenextc = parsefile->buf;
	i = read(parsefile->fd, p, BUFSIZ);
	if (i <= 0) {
                if (i < 0) {
                        if (errno == EINTR)
                                goto retry;
                        if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
                                int flags = fcntl(0, F_GETFL, 0);
                                if (flags >= 0 && flags & O_NONBLOCK) {
                                        flags &=~ O_NONBLOCK;
                                        if (fcntl(0, F_SETFL, flags) >= 0) {
						out2str("sh: turning off NDELAY mode\n");
                                                goto retry;
                                        }
                                }
                        }
                }
                parsenleft = EOF_NLEFT;
                return PEOF;
	}
	parsenleft = i - 1;

	/* delete nul characters */
	for (;;) {
		if (*p++ == '\0')
			break;
		if (--i <= 0)
			return *parsenextc++;		/* no nul characters */
	}
	q = p - 1;
	while (--i > 0) {
		if (*p != '\0')
			*q++ = *p;
		p++;
	}
	if (q == parsefile->buf)
		goto retry;			/* buffer contained nothing but nuls */
	parsenleft = q - parsefile->buf - 1;
	return *parsenextc++;
}


/*
 * Undo the last call to pgetc.  Only one character may be pushed back.
 * PEOF may be pushed back.
 */

void
pungetc() {
	parsenleft++;
	parsenextc--;
}


/*
 * Push a string back onto the input.  This code doesn't work if the user
 * tries to push back more than one string at once.
 */

void
ppushback(string, length)
	char *string;
	{
	pushedstring = parsenextc;
	pushednleft = parsenleft;
	parsenextc = string;
	parsenleft = length;
}


/*
 * Set the input to take input from a file.  If push is set, push the
 * old input onto the stack first.
 */

void
setinputfile(fname, push)
	char *fname;
	{
	int fd;
	int fd2;

	INTOFF;
	if ((fd = open(fname, O_RDONLY)) < 0)
		error("Can't open %s", fname);
	if (fd < 10) {
		fd2 = copyfd(fd, 10);
		close(fd);
		if (fd2 < 0)
			error("Out of file descriptors");
		fd = fd2;
	}
	setinputfd(fd, push);
	INTON;
}


/*
 * Like setinputfile, but takes an open file descriptor.  Call this with
 * interrupts off.
 */

void
setinputfd(fd, push) {
	if (push) {
		pushfile();
		parsefile->buf = ckmalloc(BUFSIZ);
	}
	if (parsefile->fd > 0)
		close(parsefile->fd);
	parsefile->fd = fd;
	if (parsefile->buf == NULL)
		parsefile->buf = ckmalloc(BUFSIZ);
	parsenleft = 0;
	plinno = 1;
}


/*
 * Like setinputfile, but takes input from a string.
 */

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


/*
 * To handle the "." command, a stack of input files is used.  Pushfile
 * adds a new entry to the stack and popfile restores the previous level.
 */

STATIC void
pushfile() {
	struct parsefile *pf;

	parsefile->nleft = parsenleft;
	parsefile->nextc = parsenextc;
	parsefile->linno = plinno;
	pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
	pf->prev = parsefile;
	pf->fd = -1;
	parsefile = pf;
}


void
popfile() {
	struct parsefile *pf = parsefile;

	INTOFF;
	if (pf->fd >= 0)
		close(pf->fd);
	if (pf->buf)
		ckfree(pf->buf);
	parsefile = pf->prev;
	ckfree(pf);
	parsenleft = parsefile->nleft;
	parsenextc = parsefile->nextc;
	plinno = parsefile->linno;
	INTON;
}


/*
 * Return to top level.
 */

void
popallfiles() {
	while (parsefile != &basepf)
		popfile();
}


/*
 * Close the file(s) that the shell is reading commands from.  Called
 * after a fork is done.
 */

void
closescript() {
	popallfiles();
	if (parsefile->fd > 0) {
		close(parsefile->fd);
		parsefile->fd = 0;
	}
}
Commit	Line	Data
15637ed4 RG	1	/*-
	2	* Copyright (c) 1991 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* This code is derived from software contributed to Berkeley by
	6	* Kenneth Almquist.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. All advertising materials mentioning features or use of this software
	17	* must display the following acknowledgement:
	18	* This product includes software developed by the University of
	19	* California, Berkeley and its contributors.
	20	* 4. 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	#ifndef lint
78ed81a3	38	/static char sccsid[] = "from: @(#)input.c 5.4 (Berkeley) 7/1/91";/
78ed81a3	39	static char rcsid[] = "input.c,v 1.4 1993/08/01 18:58:15 mycroft Exp";
15637ed4 RG	40	#endif /* not lint */
	41
	42	/*
	43	* This file implements the input routines used by the parser.
	44	*/
	45
	46	#include <stdio.h> /* defines BUFSIZ */
	47	#include "shell.h"
	48	#include <fcntl.h>
	49	#include <errno.h>
	50	#include "syntax.h"
	51	#include "input.h"
	52	#include "output.h"
	53	#include "memalloc.h"
	54	#include "error.h"
	55
	56	#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
	57
	58
	59	/*
	60	* The parsefile structure pointed to by the global variable parsefile
	61	* contains information about the current file being read.
	62	*/
	63
	64	MKINIT
	65	struct parsefile {
	66	int linno; /* current line */
	67	int fd; /* file descriptor (or -1 if string) */
	68	int nleft; /* number of chars left in buffer */
	69	char nextc; / next char in buffer */
	70	struct parsefile prev; / preceding file on stack */
	71	char buf; / input buffer */
	72	};
	73
	74
	75	int plinno = 1; /* input line number */
	76	MKINIT int parsenleft; /* copy of parsefile->nleft */
	77	char parsenextc; / copy of parsefile->nextc */
	78	MKINIT struct parsefile basepf; /* top level input file */
	79	char basebuf[BUFSIZ]; /* buffer for top level input file */
	80	struct parsefile parsefile = &basepf; / current input file */
	81	char pushedstring; / copy of parsenextc when text pushed back */
	82	int pushednleft; /* copy of parsenleft when text pushed back */
	83
	84	#ifdef __STDC__
	85	STATIC void pushfile(void);
	86	#else
	87	STATIC void pushfile();
	88	#endif
	89
	90
	91
	92	#ifdef mkinit
	93	INCLUDE "input.h"
	94	INCLUDE "error.h"
	95
	96	INIT {
	97	extern char basebuf[];
	98
	99	basepf.nextc = basepf.buf = basebuf;
	100	}
	101
	102	RESET {
	103	if (exception != EXSHELLPROC)
104	parsenleft = 0; /* clear input buffer */
105	popallfiles();
106	}
107
108	SHELLPROC {
109	popallfiles();
110	}
111	#endif
112
113
114	/*
115	* Read a line from the script.
116	*/
117
118	char *
119	pfgets(line, len)
120	char *line;
121	{
122	register char *p = line;
123	int nleft = len;
124	int c;
125
126	while (--nleft > 0) {
127	c = pgetc_macro();
128	if (c == PEOF) {
129	if (p == line)
130	return NULL;
131	break;
132	}
133	*p++ = c;
134	if (c == '\n')
135	break;
136	}
137	*p = '\0';
138	return line;
139	}
140
141
142
143	/*
144	* Read a character from the script, returning PEOF on end of file.
145	* Nul characters in the input are silently discarded.
146	*/
147
148	int
149	pgetc() {
150	return pgetc_macro();
151	}
152
153
154	/*
155	* Refill the input buffer and return the next input character:
156	*
157	* 1) If a string was pushed back on the input, switch back to the regular
158	* buffer.
159	* 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
160	* from a string so we can't refill the buffer, return EOF.
161	* 3) Call read to read in the characters.
162	* 4) Delete all nul characters from the buffer.
163	*/
164
165	int
166	preadbuffer() {
167	register char p, q;
168	register int i;
169
170	if (pushedstring) {
171	parsenextc = pushedstring;
172	pushedstring = NULL;
173	parsenleft = pushednleft;
174	if (--parsenleft >= 0)
175	return *parsenextc++;
176	}
177	if (parsenleft == EOF_NLEFT \|\| parsefile->buf == NULL)
178	return PEOF;
179	flushout(&output);
180	flushout(&errout);
181	retry:
182	p = parsenextc = parsefile->buf;
183	i = read(parsefile->fd, p, BUFSIZ);
184	if (i <= 0) {
185	if (i < 0) {
186	if (errno == EINTR)
187	goto retry;
188	if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
189	int flags = fcntl(0, F_GETFL, 0);
190	if (flags >= 0 && flags & O_NONBLOCK) {
191	flags &=~ O_NONBLOCK;
192	if (fcntl(0, F_SETFL, flags) >= 0) {
193	out2str("sh: turning off NDELAY mode\n");
194	goto retry;
195	}
196	}
197	}
198	}
199	parsenleft = EOF_NLEFT;
200	return PEOF;
201	}
202	parsenleft = i - 1;
203
204	/* delete nul characters */
205	for (;;) {
206	if (*p++ == '\0')
207	break;
208	if (--i <= 0)
209	return parsenextc++; / no nul characters */
210	}
211	q = p - 1;
212	while (--i > 0) {
213	if (*p != '\0')
214	q++ = p;
215	p++;
216	}
217	if (q == parsefile->buf)
218	goto retry; /* buffer contained nothing but nuls */
219	parsenleft = q - parsefile->buf - 1;
220	return *parsenextc++;
221	}
222
223
224	/*
225	* Undo the last call to pgetc. Only one character may be pushed back.
226	* PEOF may be pushed back.
227	*/
228
229	void
230	pungetc() {
231	parsenleft++;
232	parsenextc--;
233	}
234
235
236	/*
237	* Push a string back onto the input. This code doesn't work if the user
238	* tries to push back more than one string at once.
239	*/
240
241	void
242	ppushback(string, length)
243	char *string;
244	{
245	pushedstring = parsenextc;
246	pushednleft = parsenleft;
247	parsenextc = string;
248	parsenleft = length;
249	}
250
251
252
253	/*
254	* Set the input to take input from a file. If push is set, push the
255	* old input onto the stack first.
256	*/
257
258	void
259	setinputfile(fname, push)
260	char *fname;
261	{
262	int fd;
263	int fd2;
264
265	INTOFF;
266	if ((fd = open(fname, O_RDONLY)) < 0)
267	error("Can't open %s", fname);
268	if (fd < 10) {
269	fd2 = copyfd(fd, 10);
270	close(fd);
271	if (fd2 < 0)
272	error("Out of file descriptors");
273	fd = fd2;
274	}
275	setinputfd(fd, push);
276	INTON;
277	}
278
279
280	/*
281	* Like setinputfile, but takes an open file descriptor. Call this with
282	* interrupts off.
283	*/
284
285	void
286	setinputfd(fd, push) {
287	if (push) {
288	pushfile();
289	parsefile->buf = ckmalloc(BUFSIZ);
290	}
291	if (parsefile->fd > 0)
292	close(parsefile->fd);
293	parsefile->fd = fd;
294	if (parsefile->buf == NULL)
295	parsefile->buf = ckmalloc(BUFSIZ);
296	parsenleft = 0;
297	plinno = 1;
298	}
299
300
301	/*
302	* Like setinputfile, but takes input from a string.
303	*/
304
305	void
306	setinputstring(string, push)
307	char *string;
308	{
309	INTOFF;
310	if (push)
311	pushfile();
312	parsenextc = string;
313	parsenleft = strlen(string);
314	parsefile->buf = NULL;
315	plinno = 1;
316	INTON;
317	}
318
319
320
321	/*
322	* To handle the "." command, a stack of input files is used. Pushfile
323	* adds a new entry to the stack and popfile restores the previous level.
324	*/
325
326	STATIC void
327	pushfile() {
328	struct parsefile *pf;
329
330	parsefile->nleft = parsenleft;
331	parsefile->nextc = parsenextc;
332	parsefile->linno = plinno;
333	pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
334	pf->prev = parsefile;
335	pf->fd = -1;
336	parsefile = pf;
337	}
338
339
340	void
341	popfile() {
342	struct parsefile *pf = parsefile;
343
344	INTOFF;
345	if (pf->fd >= 0)
346	close(pf->fd);
347	if (pf->buf)
348	ckfree(pf->buf);
349	parsefile = pf->prev;
350	ckfree(pf);
351	parsenleft = parsefile->nleft;
352	parsenextc = parsefile->nextc;
353	plinno = parsefile->linno;
354	INTON;
355	}
356
357
358	/*
359	* Return to top level.
360	*/
361
362	void
363	popallfiles() {
364	while (parsefile != &basepf)
365	popfile();
366	}
367
368
369
370	/*
371	* Close the file(s) that the shell is reading commands from. Called
372	* after a fork is done.
373	*/
374
375	void
376	closescript() {
377	popallfiles();
378	if (parsefile->fd > 0) {
379	close(parsefile->fd);
380	parsefile->fd = 0;
381	}
382	}