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