input.c revision 53891 
1/*-
2 * Copyright (c) 1991, 1993
3 *	The Regents of the University of California.  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
38#if 0
39static char sccsid[] = "@(#)input.c	8.3 (Berkeley) 6/9/95";
40#endif
41static const char rcsid[] =
42  "$FreeBSD: head/bin/sh/input.c 53891 1999-11-29 19:11:01Z cracauer $";
43#endif /* not lint */
44
45#include <stdio.h>	/* defines BUFSIZ */
46#include <fcntl.h>
47#include <errno.h>
48#include <unistd.h>
49#include <stdlib.h>
50#include <string.h>
51
52/*
53 * This file implements the input routines used by the parser.
54 */
55
56#include "shell.h"
57#include "redir.h"
58#include "syntax.h"
59#include "input.h"
60#include "output.h"
61#include "options.h"
62#include "memalloc.h"
63#include "error.h"
64#include "alias.h"
65#include "parser.h"
66#include "myhistedit.h"
67
68#define EOF_NLEFT -99		/* value of parsenleft when EOF pushed back */
69
70MKINIT
71struct strpush {
72	struct strpush *prev;	/* preceding string on stack */
73	char *prevstring;
74	int prevnleft;
75	int prevlleft;
76	struct alias *ap;	/* if push was associated with an alias */
77};
78
79/*
80 * The parsefile structure pointed to by the global variable parsefile
81 * contains information about the current file being read.
82 */
83
84MKINIT
85struct parsefile {
86	struct parsefile *prev;	/* preceding file on stack */
87	int linno;		/* current line */
88	int fd;			/* file descriptor (or -1 if string) */
89	int nleft;		/* number of chars left in this line */
90	int lleft;		/* number of lines left in this buffer */
91	char *nextc;		/* next char in buffer */
92	char *buf;		/* input buffer */
93	struct strpush *strpush; /* for pushing strings at this level */
94	struct strpush basestrpush; /* so pushing one is fast */
95};
96
97
98int plinno = 1;			/* input line number */
99MKINIT int parsenleft;		/* copy of parsefile->nleft */
100MKINIT int parselleft;		/* copy of parsefile->lleft */
101char *parsenextc;		/* copy of parsefile->nextc */
102MKINIT struct parsefile basepf;	/* top level input file */
103char basebuf[BUFSIZ];		/* buffer for top level input file */
104struct parsefile *parsefile = &basepf;	/* current input file */
105int init_editline = 0;		/* editline library initialized? */
106int whichprompt;		/* 1 == PS1, 2 == PS2 */
107
108EditLine *el;			/* cookie for editline package */
109
110STATIC void pushfile __P((void));
111static int preadfd __P((void));
112
113#ifdef mkinit
114INCLUDE "input.h"
115INCLUDE "error.h"
116
117INIT {
118	extern char basebuf[];
119
120	basepf.nextc = basepf.buf = basebuf;
121}
122
123RESET {
124	if (exception != EXSHELLPROC)
125		parselleft = parsenleft = 0;	/* clear input buffer */
126	popallfiles();
127}
128
129SHELLPROC {
130	popallfiles();
131}
132#endif
133
134
135/*
136 * Read a line from the script.
137 */
138
139char *
140pfgets(line, len)
141	char *line;
142	int len;
143{
144	char *p = line;
145	int nleft = len;
146	int c;
147
148	while (--nleft > 0) {
149		c = pgetc_macro();
150		if (c == PEOF) {
151			if (p == line)
152				return NULL;
153			break;
154		}
155		*p++ = c;
156		if (c == '\n')
157			break;
158	}
159	*p = '\0';
160	return line;
161}
162
163
164
165/*
166 * Read a character from the script, returning PEOF on end of file.
167 * Nul characters in the input are silently discarded.
168 */
169
170int
171pgetc()
172{
173	return pgetc_macro();
174}
175
176
177static int
178preadfd()
179{
180	int nr;
181	parsenextc = parsefile->buf;
182
183retry:
184#ifndef NO_HISTORY
185	if (parsefile->fd == 0 && el) {
186		const char *rl_cp;
187
188		rl_cp = el_gets(el, &nr);
189		if (rl_cp == NULL)
190			nr = 0;
191		else {
192			/* XXX - BUFSIZE should redesign so not necessary */
193			(void) strcpy(parsenextc, rl_cp);
194		}
195	} else
196#endif
197		nr = read(parsefile->fd, parsenextc, BUFSIZ - 1);
198
199	if (nr <= 0) {
200                if (nr < 0) {
201                        if (errno == EINTR)
202                                goto retry;
203                        if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
204                                int flags = fcntl(0, F_GETFL, 0);
205                                if (flags >= 0 && flags & O_NONBLOCK) {
206                                        flags &=~ O_NONBLOCK;
207                                        if (fcntl(0, F_SETFL, flags) >= 0) {
208						out2str("sh: turning off NDELAY mode\n");
209                                                goto retry;
210                                        }
211                                }
212                        }
213                }
214                nr = -1;
215	}
216	return nr;
217}
218
219/*
220 * Refill the input buffer and return the next input character:
221 *
222 * 1) If a string was pushed back on the input, pop it;
223 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
224 *    from a string so we can't refill the buffer, return EOF.
225 * 3) If there is more in this buffer, use it else call read to fill it.
226 * 4) Process input up to the next newline, deleting nul characters.
227 */
228
229int
230preadbuffer()
231{
232	char *p, *q;
233	int more;
234	int something;
235	char savec;
236
237	if (parsefile->strpush) {
238		popstring();
239		if (--parsenleft >= 0)
240			return (*parsenextc++);
241	}
242	if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
243		return PEOF;
244	flushout(&output);
245	flushout(&errout);
246
247again:
248	if (parselleft <= 0) {
249		if ((parselleft = preadfd()) == -1) {
250			parselleft = parsenleft = EOF_NLEFT;
251			return PEOF;
252		}
253	}
254
255	q = p = parsenextc;
256
257	/* delete nul characters */
258	something = 0;
259	for (more = 1; more;) {
260		switch (*p) {
261		case '\0':
262			p++;	/* Skip nul */
263			goto check;
264
265		case '\t':
266		case ' ':
267			break;
268
269		case '\n':
270			parsenleft = q - parsenextc;
271			more = 0; /* Stop processing here */
272			break;
273
274		default:
275			something = 1;
276			break;
277		}
278
279		*q++ = *p++;
280check:
281		if (--parselleft <= 0) {
282			parsenleft = q - parsenextc - 1;
283			if (parsenleft < 0)
284				goto again;
285			*q = '\0';
286			more = 0;
287		}
288	}
289
290	savec = *q;
291	*q = '\0';
292
293#ifndef NO_HISTORY
294	if (parsefile->fd == 0 && hist && something) {
295		INTOFF;
296		history(hist, whichprompt == 1 ? H_ENTER : H_ADD, parsenextc);
297		INTON;
298	}
299#endif
300
301	if (vflag) {
302		out2str(parsenextc);
303		flushout(out2);
304	}
305
306	*q = savec;
307
308	return *parsenextc++;
309}
310
311/*
312 * Undo the last call to pgetc.  Only one character may be pushed back.
313 * PEOF may be pushed back.
314 */
315
316void
317pungetc() {
318	parsenleft++;
319	parsenextc--;
320}
321
322/*
323 * Push a string back onto the input at this current parsefile level.
324 * We handle aliases this way.
325 */
326void
327pushstring(s, len, ap)
328	char *s;
329	int len;
330	void *ap;
331	{
332	struct strpush *sp;
333
334	INTOFF;
335/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
336	if (parsefile->strpush) {
337		sp = ckmalloc(sizeof (struct strpush));
338		sp->prev = parsefile->strpush;
339		parsefile->strpush = sp;
340	} else
341		sp = parsefile->strpush = &(parsefile->basestrpush);
342	sp->prevstring = parsenextc;
343	sp->prevnleft = parsenleft;
344	sp->prevlleft = parselleft;
345	sp->ap = (struct alias *)ap;
346	if (ap)
347		((struct alias *)ap)->flag |= ALIASINUSE;
348	parsenextc = s;
349	parsenleft = len;
350	INTON;
351}
352
353void
354popstring()
355{
356	struct strpush *sp = parsefile->strpush;
357
358	INTOFF;
359	parsenextc = sp->prevstring;
360	parsenleft = sp->prevnleft;
361	parselleft = sp->prevlleft;
362/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
363	if (sp->ap)
364		sp->ap->flag &= ~ALIASINUSE;
365	parsefile->strpush = sp->prev;
366	if (sp != &(parsefile->basestrpush))
367		ckfree(sp);
368	INTON;
369}
370
371/*
372 * Set the input to take input from a file.  If push is set, push the
373 * old input onto the stack first.
374 */
375
376void
377setinputfile(fname, push)
378	char *fname;
379	int push;
380{
381	int fd;
382	int fd2;
383
384	INTOFF;
385	if ((fd = open(fname, O_RDONLY)) < 0)
386		error("Can't open %s: %s", fname, strerror(errno));
387	if (fd < 10) {
388		fd2 = copyfd(fd, 10);
389		close(fd);
390		if (fd2 < 0)
391			error("Out of file descriptors");
392		fd = fd2;
393	}
394	setinputfd(fd, push);
395	INTON;
396}
397
398
399/*
400 * Like setinputfile, but takes an open file descriptor.  Call this with
401 * interrupts off.
402 */
403
404void
405setinputfd(fd, push)
406	int fd, push;
407{
408	(void)fcntl(fd, F_SETFD, FD_CLOEXEC);
409	if (push) {
410		pushfile();
411		parsefile->buf = ckmalloc(BUFSIZ);
412	}
413	if (parsefile->fd > 0)
414		close(parsefile->fd);
415	parsefile->fd = fd;
416	if (parsefile->buf == NULL)
417		parsefile->buf = ckmalloc(BUFSIZ);
418	parselleft = parsenleft = 0;
419	plinno = 1;
420}
421
422
423/*
424 * Like setinputfile, but takes input from a string.
425 */
426
427void
428setinputstring(string, push)
429	char *string;
430	int push;
431	{
432	INTOFF;
433	if (push)
434		pushfile();
435	parsenextc = string;
436	parselleft = parsenleft = strlen(string);
437	parsefile->buf = NULL;
438	plinno = 1;
439	INTON;
440}
441
442
443
444/*
445 * To handle the "." command, a stack of input files is used.  Pushfile
446 * adds a new entry to the stack and popfile restores the previous level.
447 */
448
449STATIC void
450pushfile() {
451	struct parsefile *pf;
452
453	parsefile->nleft = parsenleft;
454	parsefile->lleft = parselleft;
455	parsefile->nextc = parsenextc;
456	parsefile->linno = plinno;
457	pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
458	pf->prev = parsefile;
459	pf->fd = -1;
460	pf->strpush = NULL;
461	pf->basestrpush.prev = NULL;
462	parsefile = pf;
463}
464
465
466void
467popfile() {
468	struct parsefile *pf = parsefile;
469
470	INTOFF;
471	if (pf->fd >= 0)
472		close(pf->fd);
473	if (pf->buf)
474		ckfree(pf->buf);
475	while (pf->strpush)
476		popstring();
477	parsefile = pf->prev;
478	ckfree(pf);
479	parsenleft = parsefile->nleft;
480	parselleft = parsefile->lleft;
481	parsenextc = parsefile->nextc;
482	plinno = parsefile->linno;
483	INTON;
484}
485
486
487/*
488 * Return to top level.
489 */
490
491void
492popallfiles() {
493	while (parsefile != &basepf)
494		popfile();
495}
496
497
498
499/*
500 * Close the file(s) that the shell is reading commands from.  Called
501 * after a fork is done.
502 */
503
504void
505closescript() {
506	popallfiles();
507	if (parsefile->fd > 0) {
508		close(parsefile->fd);
509		parsefile->fd = 0;
510	}
511}
512