485 lines
11 KiB
C
485 lines
11 KiB
C
/* $NetBSD: input.c,v 1.15 1995/06/07 16:28:03 cgd 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
|
|
* 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
|
|
#if 0
|
|
static char sccsid[] = "@(#)input.c 8.2 (Berkeley) 5/4/95";
|
|
#else
|
|
static char rcsid[] = "$NetBSD: input.c,v 1.15 1995/06/07 16:28:03 cgd Exp $";
|
|
#endif
|
|
#endif /* not lint */
|
|
|
|
#include <stdio.h> /* defines BUFSIZ */
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
/*
|
|
* This file implements the input routines used by the parser.
|
|
*/
|
|
|
|
#include "shell.h"
|
|
#include "redir.h"
|
|
#include "syntax.h"
|
|
#include "input.h"
|
|
#include "output.h"
|
|
#include "options.h"
|
|
#include "memalloc.h"
|
|
#include "error.h"
|
|
#include "alias.h"
|
|
#include "parser.h"
|
|
#include "myhistedit.h"
|
|
|
|
#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
|
|
|
|
MKINIT
|
|
struct strpush {
|
|
struct strpush *prev; /* preceding string on stack */
|
|
char *prevstring;
|
|
int prevnleft;
|
|
struct alias *ap; /* if push was associated with an alias */
|
|
};
|
|
|
|
/*
|
|
* The parsefile structure pointed to by the global variable parsefile
|
|
* contains information about the current file being read.
|
|
*/
|
|
|
|
MKINIT
|
|
struct parsefile {
|
|
struct parsefile *prev; /* preceding file on stack */
|
|
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 */
|
|
char *buf; /* input buffer */
|
|
struct strpush *strpush; /* for pushing strings at this level */
|
|
struct strpush basestrpush; /* so pushing one is fast */
|
|
};
|
|
|
|
|
|
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 */
|
|
int init_editline = 0; /* editline library initialized? */
|
|
int whichprompt; /* 1 == PS1, 2 == PS2 */
|
|
|
|
EditLine *el; /* cookie for editline package */
|
|
|
|
STATIC void pushfile __P((void));
|
|
|
|
#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;
|
|
int len;
|
|
{
|
|
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, pop it;
|
|
* 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;
|
|
register int something;
|
|
extern EditLine *el;
|
|
|
|
if (parsefile->strpush) {
|
|
popstring();
|
|
if (--parsenleft >= 0)
|
|
return (*parsenextc++);
|
|
}
|
|
if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
|
|
return PEOF;
|
|
flushout(&output);
|
|
flushout(&errout);
|
|
retry:
|
|
p = parsenextc = parsefile->buf;
|
|
if (parsefile->fd == 0 && el) {
|
|
const char *rl_cp;
|
|
int len;
|
|
|
|
rl_cp = el_gets(el, &len);
|
|
if (rl_cp == NULL) {
|
|
i = 0;
|
|
goto eof;
|
|
}
|
|
strcpy(p, rl_cp); /* XXX - BUFSIZE should redesign so not necessary */
|
|
i = len;
|
|
|
|
} else {
|
|
i = read(parsefile->fd, p, BUFSIZ - 1);
|
|
}
|
|
eof:
|
|
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; /* we're returning one char in this call */
|
|
|
|
/* delete nul characters */
|
|
something = 0;
|
|
for (;;) {
|
|
if (*p == '\0')
|
|
break;
|
|
if (*p != ' ' && *p != '\t' && *p != '\n')
|
|
something = 1;
|
|
p++;
|
|
if (--i <= 0) {
|
|
*p = '\0';
|
|
goto done; /* no nul characters */
|
|
}
|
|
}
|
|
/*
|
|
* remove nuls
|
|
*/
|
|
q = p++;
|
|
while (--i > 0) {
|
|
if (*p != '\0')
|
|
*q++ = *p;
|
|
p++;
|
|
}
|
|
*q = '\0';
|
|
if (q == parsefile->buf)
|
|
goto retry; /* buffer contained nothing but nuls */
|
|
parsenleft = q - parsefile->buf - 1;
|
|
|
|
done:
|
|
if (parsefile->fd == 0 && hist && something) {
|
|
INTOFF;
|
|
history(hist, whichprompt == 1 ? H_ENTER : H_ADD,
|
|
parsefile->buf);
|
|
INTON;
|
|
}
|
|
if (vflag) {
|
|
/*
|
|
* This isn't right. Most shells coordinate it with
|
|
* reading a line at a time. I honestly don't know if its
|
|
* worth it.
|
|
*/
|
|
i = parsenleft + 1;
|
|
p = parsefile->buf;
|
|
for (; i--; p++)
|
|
out2c(*p)
|
|
flushout(out2);
|
|
}
|
|
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 at this current parsefile level.
|
|
* We handle aliases this way.
|
|
*/
|
|
void
|
|
pushstring(s, len, ap)
|
|
char *s;
|
|
int len;
|
|
void *ap;
|
|
{
|
|
struct strpush *sp;
|
|
|
|
INTOFF;
|
|
/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
|
|
if (parsefile->strpush) {
|
|
sp = ckmalloc(sizeof (struct strpush));
|
|
sp->prev = parsefile->strpush;
|
|
parsefile->strpush = sp;
|
|
} else
|
|
sp = parsefile->strpush = &(parsefile->basestrpush);
|
|
sp->prevstring = parsenextc;
|
|
sp->prevnleft = parsenleft;
|
|
sp->ap = (struct alias *)ap;
|
|
if (ap)
|
|
((struct alias *)ap)->flag |= ALIASINUSE;
|
|
parsenextc = s;
|
|
parsenleft = len;
|
|
INTON;
|
|
}
|
|
|
|
void
|
|
popstring()
|
|
{
|
|
struct strpush *sp = parsefile->strpush;
|
|
|
|
INTOFF;
|
|
parsenextc = sp->prevstring;
|
|
parsenleft = sp->prevnleft;
|
|
/*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);
|
|
INTON;
|
|
}
|
|
|
|
/*
|
|
* 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 push;
|
|
{
|
|
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)
|
|
int 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;
|
|
int push;
|
|
{
|
|
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;
|
|
pf->strpush = NULL;
|
|
pf->basestrpush.prev = NULL;
|
|
parsefile = pf;
|
|
}
|
|
|
|
|
|
void
|
|
popfile() {
|
|
struct parsefile *pf = parsefile;
|
|
|
|
INTOFF;
|
|
if (pf->fd >= 0)
|
|
close(pf->fd);
|
|
if (pf->buf)
|
|
ckfree(pf->buf);
|
|
while (pf->strpush)
|
|
popstring();
|
|
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;
|
|
}
|
|
}
|