The upcoming .while request will have to re-execute roff(7) lines

parsed earlier, so they will have to be saved for reuse - but the
read.c preparser does not know yet whether a line contains a .while
request before passing it to the roff parser.  To cope with that,
save all parsed lines for now.  Even shortens the code by 20 lines.

1 files changed, 68 insertions, 71 deletions

diff --git a/read.c b/read.c
index 12901bd3..374ad9d4 100644
--- a/read.c
+++ b/read.c
@@ -1,4 +1,4 @@
-/*	$Id: read.c,v 1.197 2018/08/23 14:29:38 schwarze Exp $ */
+/*	$Id: read.c,v 1.198 2018/08/23 19:33:27 schwarze Exp $ */
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010-2018 Ingo Schwarze <schwarze@openbsd.org>
@@ -48,7 +48,7 @@ struct	mparse {
 	char		 *sodest; /* filename pointed to by .so */
 	const char	 *file; /* filename of current input file */
 	struct buf	 *primary; /* buffer currently being parsed */
-	struct buf	 *secondary; /* preprocessed copy of input */
+	struct buf	 *secondary; /* copy of top level input */
 	const char	 *os_s; /* default operating system */
 	mandocmsg	  mmsg; /* warning/error message handler */
 	enum mandoclevel  file_status; /* status of current parse */
@@ -61,6 +61,7 @@ struct	mparse {
 };
 
 static	void	  choose_parser(struct mparse *);
+static	void	  free_buf_list(struct buf *);
 static	void	  resize_buf(struct buf *, size_t);
 static	enum rofferr mparse_buf_r(struct mparse *, struct buf, size_t, int);
 static	int	  read_whole_file(struct mparse *, const char *, int,
@@ -290,6 +291,19 @@ resize_buf(struct buf *buf, size_t initial)
 }
 
 static void
+free_buf_list(struct buf *buf)
+{
+	struct buf *tmp;
+
+	while (buf != NULL) {
+		tmp = buf;
+		buf = tmp->next;
+		free(tmp->buf);
+		free(tmp);
+	}
+}
+
+static void
 choose_parser(struct mparse *curp)
 {
 	char		*cp, *ep;
@@ -346,19 +360,23 @@ static enum rofferr
 mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
 {
 	struct buf	 ln;
+	struct buf	*firstln, *lastln, *thisln;
 	const char	*save_file;
 	char		*cp;
 	size_t		 pos; /* byte number in the ln buffer */
-	enum rofferr	 line_result, sub_result;
+	enum rofferr	 line_result, result;
 	int		 of;
 	int		 lnn; /* line number in the real file */
 	int		 fd;
 	unsigned char	 c;
 
-	memset(&ln, 0, sizeof(ln));
-
+	ln.sz = 256;
+	ln.buf = mandoc_malloc(ln.sz);
+	ln.next = NULL;
+	firstln = NULL;
 	lnn = curp->line;
 	pos = 0;
+	result = ROFF_CONT;
 
 	while (i < blk.sz) {
 		if (0 == pos && '\0' == blk.buf[i])
@@ -393,10 +411,10 @@ mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
 
 			/*
 			 * Make sure we have space for the worst
-			 * case of 11 bytes: "\\[u10ffff]\0"
+			 * case of 12 bytes: "\\[u10ffff]\n\0"
 			 */
 
-			if (pos + 11 > ln.sz)
+			if (pos + 12 > ln.sz)
 				resize_buf(&ln, 256);
 
 			/*
@@ -432,13 +450,32 @@ mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
 
 			ln.buf[pos++] = blk.buf[i++];
 		}
+		ln.buf[pos] = '\0';
+
+		/*
+		 * Maintain a lookaside buffer of all lines.
+		 * parsed from this input source.
+		 */
+
+		thisln = mandoc_malloc(sizeof(*thisln));
+		thisln->buf = mandoc_strdup(ln.buf);
+		thisln->sz = strlen(ln.buf) + 1;
+		thisln->next = NULL;
+		if (firstln == NULL) {
+			firstln = lastln = thisln;
+			if (curp->secondary == NULL)
+				curp->secondary = firstln;
+		} else {
+			lastln->next = thisln;
+			lastln = thisln;
+		}
 
-		if (pos + 1 >= ln.sz)
-			resize_buf(&ln, 256);
+		/* XXX Ugly hack to mark the end of the input. */
 
-		if (i == blk.sz || blk.buf[i] == '\0')
+		if (i == blk.sz || blk.buf[i] == '\0') {
 			ln.buf[pos++] = '\n';
-		ln.buf[pos] = '\0';
+			ln.buf[pos] = '\0';
+		}
 
 		/*
 		 * A significant amount of complexity is contained by
@@ -450,27 +487,6 @@ mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
 		 */
 
 		of = 0;
-
-		/*
-		 * Maintain a lookaside buffer of all parsed lines.  We
-		 * only do this if mparse_keep() has been invoked (the
-		 * buffer may be accessed with mparse_getkeep()).
-		 */
-
-		if (curp->secondary) {
-			curp->secondary->buf = mandoc_realloc(
-			    curp->secondary->buf,
-			    curp->secondary->sz + pos + 2);
-			memcpy(curp->secondary->buf +
-			    curp->secondary->sz,
-			    ln.buf, pos);
-			curp->secondary->sz += pos;
-			curp->secondary->buf
-				[curp->secondary->sz] = '\n';
-			curp->secondary->sz++;
-			curp->secondary->buf
-				[curp->secondary->sz] = '\0';
-		}
 rerun:
 		line_result = roff_parseln(curp->roff, curp->line, &ln, &of);
 
@@ -478,30 +494,29 @@ rerun:
 		case ROFF_REPARSE:
 		case ROFF_USERCALL:
 			if (++curp->reparse_count > REPARSE_LIMIT) {
-				sub_result = ROFF_IGN;
+				result = ROFF_IGN;
 				mandoc_msg(MANDOCERR_ROFFLOOP, curp,
 				    curp->line, pos, NULL);
 			} else {
-				sub_result = mparse_buf_r(curp, ln, of, 0);
+				result = mparse_buf_r(curp, ln, of, 0);
 				if (line_result == ROFF_USERCALL) {
-					if (sub_result == ROFF_USERRET)
-						sub_result = ROFF_CONT;
+					if (result == ROFF_USERRET)
+						result = ROFF_CONT;
 					roff_userret(curp->roff);
 				}
-				if (start || sub_result == ROFF_CONT) {
+				if (start || result == ROFF_CONT) {
 					pos = 0;
 					continue;
 				}
 			}
-			free(ln.buf);
-			return sub_result;
+			goto out;
 		case ROFF_USERRET:
 			if (start) {
 				pos = 0;
 				continue;
 			}
-			free(ln.buf);
-			return ROFF_USERRET;
+			result = ROFF_USERRET;
+			goto out;
 		case ROFF_APPEND:
 			pos = strlen(ln.buf);
 			continue;
@@ -514,16 +529,8 @@ rerun:
 			if ( ! (curp->options & MPARSE_SO) &&
 			    (i >= blk.sz || blk.buf[i] == '\0')) {
 				curp->sodest = mandoc_strdup(ln.buf + of);
-				free(ln.buf);
-				return ROFF_CONT;
+				goto out;
 			}
-			/*
-			 * We remove `so' clauses from our lookaside
-			 * buffer because we're going to descend into
-			 * the file recursively.
-			 */
-			if (curp->secondary)
-				curp->secondary->sz -= pos + 1;
 			save_file = curp->file;
 			if ((fd = mparse_open(curp, ln.buf + of)) != -1) {
 				mparse_readfd(curp, fd, ln.buf + of);
@@ -565,9 +572,11 @@ rerun:
 
 		pos = 0;
 	}
-
+out:
 	free(ln.buf);
-	return ROFF_CONT;
+	if (firstln != curp->secondary)
+		free_buf_list(firstln);
+	return result;
 }
 
 static int
@@ -837,13 +846,12 @@ mparse_reset(struct mparse *curp)
 {
 	roff_reset(curp->roff);
 	roff_man_reset(curp->man);
+	free_buf_list(curp->secondary);
+	curp->secondary = NULL;
 
 	free(curp->sodest);
 	curp->sodest = NULL;
 
-	if (curp->secondary)
-		curp->secondary->sz = 0;
-
 	curp->file_status = MANDOCLEVEL_OK;
 	curp->gzip = 0;
 }
@@ -851,15 +859,11 @@ mparse_reset(struct mparse *curp)
 void
 mparse_free(struct mparse *curp)
 {
-
 	roffhash_free(curp->man->mdocmac);
 	roffhash_free(curp->man->manmac);
 	roff_man_free(curp->man);
 	roff_free(curp->roff);
-	if (curp->secondary)
-		free(curp->secondary->buf);
-
-	free(curp->secondary);
+	free_buf_list(curp->secondary);
 	free(curp->sodest);
 	free(curp);
 }
@@ -932,17 +936,10 @@ mparse_strlevel(enum mandoclevel lvl)
 }
 
 void
-mparse_keep(struct mparse *p)
-{
-
-	assert(NULL == p->secondary);
-	p->secondary = mandoc_calloc(1, sizeof(struct buf));
-}
-
-const char *
-mparse_getkeep(const struct mparse *p)
+mparse_copy(const struct mparse *p)
 {
+	struct buf	*buf;
 
-	assert(p->secondary);
-	return p->secondary->sz ? p->secondary->buf : NULL;
+	for (buf = p->secondary; buf != NULL; buf = buf->next)
+		puts(buf->buf);
 }