MultiSource/Benchmarks/MallocBench/gawk/io.c

/*
 * io.c - routines for dealing with input and output and records
 */

/* 
 * Copyright (C) 1986, 1988, 1989 the Free Software Foundation, Inc.
 * 
 * This file is part of GAWK, the GNU implementation of the
 * AWK Progamming Language.
 * 
 * GAWK 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 1, or (at your option)
 * any later version.
 * 
 * GAWK 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 GAWK; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "gawk.h"
#ifndef O_RDONLY
#include <fcntl.h>
#endif
#include <signal.h>

extern FILE *popen();

static void do_file();
static IOBUF *nextfile();
static int get_a_record();
static int iop_close();
static IOBUF *iop_alloc();
static void close_one();
static int close_redir();
static IOBUF *gawk_popen();
static int gawk_pclose();

static struct redirect *red_head = NULL;
static int getline_redirect = 0;	/* "getline <file" being executed */

extern char *line_buf;
extern int output_is_tty;
extern NODE *ARGC_node;
extern NODE *ARGV_node;
extern NODE **fields_arr;

int field_num;

static IOBUF *
nextfile()
{
	static int i = 1;
	static int files = 0;
	static IOBUF *curfile = NULL;
	char *arg;
	char *cp;
	int fd = -1;

	if (curfile != NULL && curfile->cnt != EOF)
		return curfile;
	for (; i < (int) (ARGC_node->lnode->numbr); i++) {
		arg = (*assoc_lookup(ARGV_node, tmp_number((AWKNUM) i)))->stptr;
		if (*arg == '\0')
			continue;
		cp = strchr(arg, '=');
		if (cp != NULL) {
			*cp++ = '\0';
			variable(arg)->var_value = make_string(cp, strlen(cp));
			*--cp = '=';	/* restore original text of ARGV */
		} else {
			files++;
			if (STREQ(arg, "-"))
				fd = 0;
			else
				fd = devopen(arg, "r");
			if (fd == -1)
				fatal("cannot open file `%s' for reading (%s)",
					arg, strerror(errno));
				/* NOTREACHED */
			/* This is a kludge.  */
			deref = FILENAME_node->var_value;
			do_deref();
			FILENAME_node->var_value =
				make_string(arg, strlen(arg));
			FNR_node->var_value->numbr = 0.0;
			i++;
			break;
		}
	}
	if (files == 0) {
		files++;
		/* no args. -- use stdin */
		/* FILENAME is init'ed to "-" */
		/* FNR is init'ed to 0 */
		fd = 0;
	}
	if (fd == -1)
		return NULL;
	return curfile = iop_alloc(fd);
}

static IOBUF *
iop_alloc(fd)
int fd;
{
	IOBUF *iop;
	struct stat stb;

	/*
	 * System V doesn't have the file system block size in the
	 * stat structure. So we have to make some sort of reasonable
	 * guess. We use stdio's BUFSIZ, since that is what it was
	 * meant for in the first place.
	 */
#ifdef BLKSIZE_MISSING
#define	DEFBLKSIZE	BUFSIZ
#else
#define DEFBLKSIZE	(stb.st_blksize ? stb.st_blksize : BUFSIZ)
#endif

	if (fd == -1)
		return NULL;
	emalloc(iop, IOBUF *, sizeof(IOBUF), "nextfile");
	iop->flag = 0;
	if (isatty(fd)) {
		iop->flag |= IOP_IS_TTY;
		iop->size = BUFSIZ;
	} else if (fstat(fd, &stb) == -1)
		fatal("can't stat fd %d (%s)", fd, strerror(errno));
	else if (lseek(fd, 0L, 0) == -1)
		iop->size = DEFBLKSIZE;
	else
		iop->size = (stb.st_size < DEFBLKSIZE ?
				stb.st_size+1 : DEFBLKSIZE);
	errno = 0;
	iop->fd = fd;
	emalloc(iop->buf, char *, iop->size, "nextfile");
	iop->off = iop->buf;
	iop->cnt = 0;
	iop->secsiz = iop->size < BUFSIZ ? iop->size : BUFSIZ;
	emalloc(iop->secbuf, char *, iop->secsiz, "nextfile");
	return iop;
}

void
do_input()
{
	IOBUF *iop;
	extern int exiting;

	while ((iop = nextfile()) != NULL) {
		do_file(iop);
		if (exiting)
			break;
	}
}

static int
iop_close(iop)
IOBUF *iop;
{
	int ret;

	ret = close(iop->fd);
	if (ret == -1)
		warning("close of fd %d failed (%s)", iop->fd, strerror(errno));
	free(iop->buf);
	free(iop->secbuf);
	free((char *)iop);
	return ret == -1 ? 1 : 0;
}

/*
 * This reads in a record from the input file
 */
static int
inrec(iop)
IOBUF *iop;
{
	int cnt;
	int retval = 0;

	cnt = get_a_record(&line_buf, iop);
	if (cnt == EOF) {
		cnt = 0;
		retval = 1;
	} else {
		if (!getline_redirect) {
			assign_number(&NR_node->var_value,
			    NR_node->var_value->numbr + 1.0);
			assign_number(&FNR_node->var_value,
			    FNR_node->var_value->numbr + 1.0);
		}
	}
	set_record(line_buf, cnt);

	return retval;
}

static void
do_file(iop)
IOBUF *iop;
{
	/* This is where it spends all its time.  The infamous MAIN LOOP */
	if (inrec(iop) == 0)
		while (interpret(expression_value) && inrec(iop) == 0)
			;
	(void) iop_close(iop);
}

int
get_rs()
{
	register NODE *tmp;

	tmp = force_string(RS_node->var_value);
	if (tmp->stlen == 0)
		return 0;
	return *(tmp->stptr);
}

/* Redirection for printf and print commands */
struct redirect *
redirect(tree, errflg)
NODE *tree;
int *errflg;
{
	register NODE *tmp;
	register struct redirect *rp;
	register char *str;
	int tflag = 0;
	int outflag = 0;
	char *direction = "to";
	char *mode;
	int fd;

	switch (tree->type) {
	case Node_redirect_append:
		tflag = RED_APPEND;
	case Node_redirect_output:
		outflag = (RED_FILE|RED_WRITE);
		tflag |= outflag;
		break;
	case Node_redirect_pipe:
		tflag = (RED_PIPE|RED_WRITE);
		break;
	case Node_redirect_pipein:
		tflag = (RED_PIPE|RED_READ);
		break;
	case Node_redirect_input:
		tflag = (RED_FILE|RED_READ);
		break;
	default:
		fatal ("invalid tree type %d in redirect()", tree->type);
		break;
	}
	tmp = force_string(tree_eval(tree->subnode));
	str = tmp->stptr;
	for (rp = red_head; rp != NULL; rp = rp->next)
		if (STREQ(rp->value, str)
		    && ((rp->flag & ~RED_NOBUF) == tflag
			|| (outflag
			    && (rp->flag & (RED_FILE|RED_WRITE)) == outflag)))
			break;
	if (rp == NULL) {
		emalloc(rp, struct redirect *, sizeof(struct redirect),
			"redirect");
		emalloc(str, char *, tmp->stlen+1, "redirect");
		memcpy(str, tmp->stptr, tmp->stlen+1);
		rp->value = str;
		rp->flag = tflag;
		rp->offset = 0;
		rp->fp = NULL;
		rp->iop = NULL;
		/* maintain list in most-recently-used first order */
		if (red_head)
			red_head->prev = rp;
		rp->prev = NULL;
		rp->next = red_head;
		red_head = rp;
	}
	while (rp->fp == NULL && rp->iop == NULL) {
		mode = NULL;
		errno = 0;
		switch (tree->type) {
		case Node_redirect_output:
			mode = "w";
			break;
		case Node_redirect_append:
			mode = "a";
			break;
		case Node_redirect_pipe:
			if ((rp->fp = popen(str, "w")) == NULL)
				fatal("can't open pipe (\"%s\") for output (%s)",
					str, strerror(errno));
			rp->flag |= RED_NOBUF;
			break;
		case Node_redirect_pipein:
			direction = "from";
			if (gawk_popen(str, rp) == NULL)
				fatal("can't open pipe (\"%s\") for input (%s)",
					str, strerror(errno));
			break;
		case Node_redirect_input:
			direction = "from";
			rp->iop = iop_alloc(devopen(str, "r"));
			break;
		default:
			cant_happen();
		}
		if (mode != NULL) {
			fd = devopen(str, mode);
			if (fd != -1) {
				rp->fp = fdopen(fd, mode);
				if (isatty(fd))
					rp->flag |= RED_NOBUF;
			}
		}
		if (rp->fp == NULL && rp->iop == NULL) {
			/* too many files open -- close one and try again */
			if (errno == ENFILE || errno == EMFILE)
				close_one();
			else {
				/*
				 * Some other reason for failure.
				 *
				 * On redirection of input from a file,
				 * just return an error, so e.g. getline
				 * can return -1.  For output to file,
				 * complain. The shell will complain on
				 * a bad command to a pipe.
				 */
				*errflg = 1;
				if (tree->type == Node_redirect_output
				    || tree->type == Node_redirect_append)
					fatal("can't redirect %s `%s' (%s)",
					    direction, str, strerror(errno));
				else
					return NULL;
			}
		}
	}
	if (rp->offset != 0)	/* this file was previously open */
		if (fseek(rp->fp, rp->offset, 0) == -1)
			fatal("can't seek to %ld on `%s' (%s)",
				rp->offset, str, strerror(errno));
	free_temp(tmp);
	return rp;
}

static void
close_one()
{
	register struct redirect *rp;
	register struct redirect *rplast = NULL;

	/* go to end of list first, to pick up least recently used entry */
	for (rp = red_head; rp != NULL; rp = rp->next)
		rplast = rp;
	/* now work back up through the list */
	for (rp = rplast; rp != NULL; rp = rp->prev)
		if (rp->fp && (rp->flag & RED_FILE)) {
			rp->offset = ftell(rp->fp);
			if (fclose(rp->fp))
				warning("close of \"%s\" failed (%s).",
					rp->value, strerror(errno));
			rp->fp = NULL;
			break;
		}
	if (rp == NULL)
		/* surely this is the only reason ??? */
		fatal("too many pipes or input files open"); 
}

NODE *
do_close(tree)
NODE *tree;
{
	NODE *tmp;
	register struct redirect *rp;

	tmp = force_string(tree_eval(tree->subnode));
	for (rp = red_head; rp != NULL; rp = rp->next) {
		if (STREQ(rp->value, tmp->stptr))
			break;
	}
	free_temp(tmp);
	if (rp == NULL) /* no match */
		return tmp_number((AWKNUM) 0.0);
	fflush(stdout);	/* synchronize regular output */
	return tmp_number((AWKNUM)close_redir(rp));
}

static int
close_redir(rp)
register struct redirect *rp;
{
	int status = 0;

	if ((rp->flag & (RED_PIPE|RED_WRITE)) == (RED_PIPE|RED_WRITE))
		status = pclose(rp->fp);
	else if (rp->fp)
		status = fclose(rp->fp);
	else if (rp->iop) {
		if (rp->flag & RED_PIPE)
			status = gawk_pclose(rp);
		else
			status = iop_close(rp->iop);

	}
	/* SVR4 awk checks and warns about status of close */
	if (status)
		warning("failure status (%d) on %s close of \"%s\" (%s).",
			status,
			(rp->flag & RED_PIPE) ? "pipe" :
			"file", rp->value, strerror(errno));
	if (rp->next)
		rp->next->prev = rp->prev;
	if (rp->prev)
		rp->prev->next = rp->next;
	else
		red_head = rp->next;
	free(rp->value);
	free((char *)rp);
	return status;
}

int
flush_io ()
{
	register struct redirect *rp;
	int status = 0;

	errno = 0;
	if (fflush(stdout)) {
		warning("error writing standard output (%s).", strerror(errno));
		status++;
	}
	errno = 0;
	if (fflush(stderr)) {
		warning("error writing standard error (%s).", strerror(errno));
		status++;
	}
	for (rp = red_head; rp != NULL; rp = rp->next)
		/* flush both files and pipes, what the heck */
		if ((rp->flag & RED_WRITE) && rp->fp != NULL)
			if (fflush(rp->fp)) {
				warning("%s flush of \"%s\" failed (%s).",
				    (rp->flag  & RED_PIPE) ? "pipe" :
				    "file", rp->value, strerror(errno));
				status++;
			}
	return status;
}

int
close_io ()
{
	register struct redirect *rp;
	int status = 0;

	for (rp = red_head; rp != NULL; rp = rp->next)
		if (close_redir(rp))
			status++;
	return status;
}

/* devopen --- handle /dev/std{in,out,err}, /dev/fd/N, regular files */
int
devopen (name, mode)
char *name, *mode;
{
	int openfd = -1;
	FILE *fdopen ();
	char *cp;
	int flag = 0;

	switch(mode[0]) {
	case 'r':
		flag = O_RDONLY;
		break;

	case 'w':
		flag = O_WRONLY|O_CREAT|O_TRUNC;
		break;

	case 'a':
		flag = O_WRONLY|O_APPEND|O_CREAT;
		break;
	default:
		cant_happen();
	}

#if defined(STRICT) || defined(NO_DEV_FD)
	return (open (name, flag, 0666));
#else
	if (strict)
		return (open (name, flag, 0666));

	if (!STREQN (name, "/dev/", 5))
		return (open (name, flag, 0666));
	else
		cp = name + 5;
		
	/* XXX - first three tests ignore mode */
	if (STREQ(cp, "stdin"))
		return (0);
	else if (STREQ(cp, "stdout"))
		return (1);
	else if (STREQ(cp, "stderr"))
		return (2);
	else if (STREQN(cp, "fd/", 3)) {
		cp += 3;
		if (sscanf (cp, "%d", & openfd) == 1 && openfd >= 0)
			/* got something */
			return openfd;
		else
			return -1;
	} else
		return (open (name, flag, 0666));
#endif
}

#ifndef MSDOS
static IOBUF *
gawk_popen(cmd, rp)
char *cmd;
struct redirect *rp;
{
	int p[2];
	register int pid;

	rp->pid = -1;
	rp->iop = NULL;
	if (pipe(p) < 0)
		return NULL;
	if ((pid = fork()) == 0) {
		close(p[0]);
		dup2(p[1], 1);
		close(p[1]);
		execl("/bin/sh", "sh", "-c", cmd, 0);
		_exit(127);
	}
	if (pid == -1)
		return NULL;
	rp->pid = pid;
	close(p[1]);
	return (rp->iop = iop_alloc(p[0]));
}

static int
gawk_pclose(rp)
struct redirect *rp;
{
	SIGTYPE (*hstat)(), (*istat)(), (*qstat)();
	int pid;
	int status;
	struct redirect *redp;

	iop_close(rp->iop);
	if (rp->pid == -1)
		return rp->status;
	hstat = signal(SIGHUP, SIG_IGN);
	istat = signal(SIGINT, SIG_IGN);
	qstat = signal(SIGQUIT, SIG_IGN);
	for (;;) {
		pid = wait(&status);
		if (pid == -1 && errno == ECHILD)
			break;
		else if (pid == rp->pid) {
			rp->pid = -1;
			rp->status = status;
			break;
		} else {
			for (redp = red_head; redp != NULL; redp = redp->next)
				if (pid == redp->pid) {
					redp->pid = -1;
					redp->status = status;
					break;
				}
		}
	}
	signal(SIGHUP, hstat);
	signal(SIGINT, istat);
	signal(SIGQUIT, qstat);
	return(rp->status);
}
#else
static
struct {
	char *command;
	char *name;
} pipes[_NFILE];

static IOBUF *
gawk_popen(cmd, rp)
char *cmd;
struct redirect *rp;
{
	extern char *strdup(const char *);
	int current;
	char *name;
	static char cmdbuf[256];

	/* get a name to use.  */
	if ((name = tempnam(".", "pip")) == NULL)
		return NULL;
	sprintf(cmdbuf,"%s > %s", cmd, name);
	system(cmdbuf);
	if ((current = open(name,O_RDONLY)) == -1)
		return NULL;
	pipes[current].name = name;
	pipes[current].command = strdup(cmd);
	return (rp->iop = iop_alloc(current));
}

static int
gawk_pclose(rp)
struct redirect *rp;
{
	int cur = rp->iop->fd;
	int rval;

	rval = iop_close(rp->iop);

	/* check for an open file  */
	if (pipes[cur].name == NULL)
		return -1;
	unlink(pipes[cur].name);
	free(pipes[cur].name);
	pipes[cur].name = NULL;
	free(pipes[cur].command);
	return rval;
}
#endif

#define	DO_END_OF_BUF	len = bp - iop->off;\
			used = last - start;\
			while (len + used > iop->secsiz) {\
				iop->secsiz *= 2;\
				erealloc(iop->secbuf,char *,iop->secsiz,"get");\
			}\
			last = iop->secbuf + used;\
			start = iop->secbuf;\
			memcpy(last, iop->off, len);\
			last += len;\
			iop->cnt = read(iop->fd, iop->buf, iop->size);\
			if (iop->cnt < 0)\
				return iop->cnt;\
			end_data = iop->buf + iop->cnt;\
			iop->off = bp = iop->buf;

#define	DO_END_OF_DATA	iop->cnt = read(iop->fd, end_data, end_buf - end_data);\
			if (iop->cnt < 0)\
				return iop->cnt;\
			end_data += iop->cnt;\
			if (iop->cnt == 0)\
				break;\
			iop->cnt = end_data - iop->buf;

static int
get_a_record(res, iop)
char **res;
IOBUF *iop;
{
	register char *end_data;
	register char *end_buf;
	char *start;
	register char *bp;
	register char *last;
	int len, used;
	register char rs = get_rs();

	if (iop->cnt < 0)
		return iop->cnt;
	if ((iop->flag & IOP_IS_TTY) && output_is_tty)
		fflush(stdout);
	end_data = iop->buf + iop->cnt;
	if (iop->off >= end_data) {
		iop->cnt = read(iop->fd, iop->buf, iop->size);
		if (iop->cnt <= 0)
			return iop->cnt = EOF;
		end_data = iop->buf + iop->cnt;
		iop->off = iop->buf;
	}
	last = start = bp = iop->off;
	end_buf = iop->buf + iop->size;
	if (rs == 0) {
		while (!(*bp == '\n' && bp != iop->buf && bp[-1] == '\n')) {
			if (++bp == end_buf) {
				DO_END_OF_BUF
			}
			if (bp == end_data) {
				DO_END_OF_DATA
			}
		}
		if (*bp == '\n' && bp != iop->off && bp[-1] == '\n') {
			int tmp = 0;

			/* allow for more than two newlines */
			while (*bp == '\n') {
				tmp++;
				if (++bp == end_buf) {
					DO_END_OF_BUF
				}
				if (bp == end_data) {
					DO_END_OF_DATA
				}
			}
			iop->off = bp;
			bp -= 1 + tmp;
		} else if (bp != iop->buf && bp[-1] != '\n') {
			warning("record not terminated");
			iop->off = bp + 2;
		} else {
			bp--;
			iop->off = bp + 2;
		}
	} else {
		while (*bp++ != rs) {
			if (bp == end_buf) {
				DO_END_OF_BUF
			}
			if (bp == end_data) {
				DO_END_OF_DATA
			}
		}
		if (*--bp != rs) {
			warning("record not terminated");
			bp++;
		}
		iop->off = bp + 1;
	}
	if (start == iop->secbuf) {
		len = bp - iop->buf;
		if (len > 0) {
			used = last - start;
			while (len + used > iop->secsiz) {
				iop->secsiz *= 2;
				erealloc(iop->secbuf,char *,iop->secsiz,"get2");
			}
			last = iop->secbuf + used;
			start = iop->secbuf;
			memcpy(last, iop->buf, len);
			last += len;
		}
	} else
		last = bp;
	*last = '\0';
	*res = start;
	return last - start;
}

NODE *
do_getline(tree)
NODE *tree;
{
	struct redirect *rp;
	IOBUF *iop;
	int cnt;
	NODE **lhs;
	int redir_error = 0;

	if (tree->rnode == NULL) {	 /* no redirection */
		iop = nextfile();
		if (iop == NULL)		/* end of input */
			return tmp_number((AWKNUM) 0.0);
	} else {
		rp = redirect(tree->rnode, &redir_error);
		if (rp == NULL && redir_error)	/* failed redirect */
			return tmp_number((AWKNUM) -1.0);
		iop = rp->iop;
		getline_redirect++;
	}
	if (tree->lnode == NULL) {	/* no optional var. -- read in $0 */
		if (inrec(iop) != 0) {
			getline_redirect = 0;
			return tmp_number((AWKNUM) 0.0);
		}
	} else {			/* read in a named variable */
		char *s = NULL;

		lhs = get_lhs(tree->lnode, 1);
		cnt = get_a_record(&s, iop);
		if (!getline_redirect) {
			assign_number(&NR_node->var_value,
			    NR_node->var_value->numbr + 1.0);
			assign_number(&FNR_node->var_value,
			    FNR_node->var_value->numbr + 1.0);
		}
		if (cnt == EOF) {
			getline_redirect = 0;
			free(s);
			return tmp_number((AWKNUM) 0.0);
		}
		*lhs = make_string(s, strlen(s));
		do_deref();
		/* we may have to regenerate $0 here! */
		if (field_num == 0)
			set_record(fields_arr[0]->stptr, fields_arr[0]->stlen);
		field_num = -1;
	}
	getline_redirect = 0;
	return tmp_number((AWKNUM) 1.0);
}