BSD 4_4_Lite2 development

[unix-history] / usr / src / contrib / rc-1.4 / heredoc.c

/* heredoc.c: heredoc slurping is done here */

#include "rc.h"

struct Hq {
	Node *doc;
	char *name;
	Hq *n;
	bool quoted;
} *hq;

static bool dead = FALSE;

/*
 * read in a heredocument. A clever trick: skip over any partially matched end-of-file
 * marker storing only the number of characters matched. If the whole marker is matched,
 * return from readheredoc(). If only part of the marker is matched, copy that part into
 * the heredocument.
 *
 * BUG: if the eof string contains a newline, the state can get confused, and the
 * heredoc may continue past where it should.  on the other hand, /bin/sh seems to
 * never get out of its readheredoc() when the heredoc string contains a newline
 */

static char *readheredoc(char *eof) {
	int c;
	char *t, *buf, *bufend;
	unsigned char *s;
	size_t bufsize;
	t = buf = nalloc(bufsize = 512);
	bufend = &buf[bufsize];
	dead = FALSE;
#define	RESIZE(extra) { \
		char *nbuf; \
		bufsize = bufsize * 2 + extra; \
		nbuf = nalloc(bufsize); \
		memcpy(nbuf, buf, (size_t) (t - buf)); \
		t = nbuf + (t - buf); \
		buf = nbuf; \
		bufend = &buf[bufsize]; \
	}
	for (;;) {
		print_prompt2();
		for (s = (unsigned char *) eof; (c = gchar()) == *s; s++)
			;
		if (*s == '\0' && (c == '\n' || c == EOF)) {
			*t++ = '\0';
			return buf;
		}
		if (s != (unsigned char *) eof) {
			size_t len = s - (unsigned char *) eof;
			if (t + len >= bufend)
				RESIZE(len);
			memcpy(t, eof, len);
			t += len;
		}
		for (;; c = gchar()) {
			if (c == EOF) {
				yyerror("heredoc incomplete");
				dead = TRUE;
				return NULL;
			}
			if (t + 1 >= bufend)
				RESIZE(0);
			*t++ = c;
			if (c == '\n')
				break;
		}
	}
}

/* parseheredoc -- turn a heredoc with variable references into a node chain */

static Node *parseheredoc(char *s) {
	int c = *s;
	Node *result = NULL;
	while (TRUE) {
		Node *node;
		switch (c) {
		default: {
			char *begin = s;
			while ((c = *s++) != '\0' && c != '$')
				;
			*--s = '\0';
			node = mk(nQword, begin, NULL);
			break;
		}
		case '$': {
			char *begin = ++s, *var;
			c = *s++;
			if (c == '$') {
				node = mk(nQword, "$", NULL);
				c = *s;
			} else {
				size_t len = 0;
				do
					len++;
				while (!dnw[c = *(unsigned char *) s++]);
				if (c == '^')
					c = *s;
				else
					s--;
				var = nalloc(len + 1);
				var[len] = '\0';
				memcpy(var, begin, len);
				node = mk(nFlat, mk(nWord, var, NULL));
			}
			break;
		}
		case '\0':
			return result;
		}
		result = (result == NULL) ? node : mk(nConcat, result, node);
	}
}

/* read in heredocs when yyparse hits a newline. called from yyparse */

extern int heredoc(int end) {
	Hq *here;
	if ((here = hq) != NULL) {
		hq = NULL;
		if (end) {
			yyerror("heredoc incomplete");
			return FALSE;
		}
		do {
			Node *n = here->doc;
			char *s = readheredoc(here->name);
			if (dead)
				return FALSE;
			n->u[2].p = here->quoted ? mk(nQword, s, NULL) : parseheredoc(s);
			n->u[0].i = rHerestring;
		} while ((here = here->n) != NULL);
	}
	return TRUE;
}

/* queue pending heredocs into a queue. called from yyparse */

extern int qdoc(Node *name, Node *n) {
	Hq *new, **prev;
	if (name->type != nWord && name->type != nQword) {
		yyerror("eof-marker not a single literal word");
		flushu();
		return FALSE;
	}
	for (prev = &hq; (new = *prev) != NULL; prev = &new->n)
		;
	*prev = new = nnew(Hq);
	new->name = name->u[0].s;
	new->quoted = (name->type == nQword);
	new->doc = n;
	new->n = NULL;
	return TRUE;
}