===================================================================
RCS file: /cvs/mandoc/main.c,v
retrieving revision 1.71
retrieving revision 1.76
diff -u -p -r1.71 -r1.76
--- mandoc/main.c	2010/05/15 18:35:14	1.71
+++ mandoc/main.c	2010/05/16 10:59:36	1.76
@@ -1,4 +1,4 @@
-/*	$Id: main.c,v 1.71 2010/05/15 18:35:14 kristaps Exp $ */
+/*	$Id: main.c,v 1.76 2010/05/16 10:59:36 kristaps Exp $ */
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -386,7 +386,7 @@ static void
 fdesc(struct curparse *curp)
 {
 	struct buf	 ln, blk;
-	int		 i, pos, lnn, lnn_start, with_mmap;
+	int		 i, pos, lnn, lnn_start, with_mmap, of;
 	enum rofferr	 re;
 	struct man	*man;
 	struct mdoc	*mdoc;
@@ -467,22 +467,42 @@ fdesc(struct curparse *curp)
 				goto bailout;
 		ln.buf[pos] = '\0';
 
-		re = roff_parseln(roff, lnn_start, &ln.buf, &ln.sz);
+		/*
+		 * A significant amount of complexity is contained by
+		 * the roff preprocessor.  It's line-oriented but can be
+		 * expressed on one line, so we need at times to
+		 * readjust our starting point and re-run it.  The roff
+		 * preprocessor can also readjust the buffers with new
+		 * data, so we pass them in wholesale.
+		 */
+
+		of = 0;
+		do {
+			re = roff_parseln(roff, lnn_start, 
+					&ln.buf, &ln.sz, of, &of);
+		} while (ROFF_RERUN == re);
+
 		if (ROFF_IGN == re)
 			continue;
 		else if (ROFF_ERR == re)
 			goto bailout;
 
-		/* If unset, assign parser in pset(). */
+		/*
+		 * If input parsers have not been allocated, do so now.
+		 * We keep these instanced betwen parsers, but set them
+		 * locally per parse routine since we can use different
+		 * parsers with each one.
+		 */
 
-		if ( ! (man || mdoc) && ! pset(ln.buf, pos, curp, &man, &mdoc))
-			goto bailout;
+		if ( ! (man || mdoc))
+			if ( ! pset(ln.buf + of, pos - of, curp, &man, &mdoc))
+				goto bailout;
 
-		/* Pass down into parsers. */
+		/* Lastly, push down into the parsers themselves. */
 
-		if (man && ! man_parseln(man, lnn_start, ln.buf))
+		if (man && ! man_parseln(man, lnn_start, ln.buf, of))
 			goto bailout;
-		if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf))
+		if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf, of))
 			goto bailout;
 	}
 
@@ -493,6 +513,8 @@ fdesc(struct curparse *curp)
 		goto bailout;
 	}
 
+	/* Clean up the parse routine ASTs. */
+
 	if (mdoc && ! mdoc_endparse(mdoc))
 		goto bailout;
 	if (man && ! man_endparse(man))
@@ -574,7 +596,7 @@ pset(const char *buf, int pos, struct curparse *curp,
 	 * default to -man, which is more lenient.
 	 */
 
-	if (buf[0] == '.') {
+	if ('.' == buf[0] || '\'' == buf[0]) {
 		for (i = 1; buf[i]; i++)
 			if (' ' != buf[i] && '\t' != buf[i])
 				break;
@@ -773,6 +795,14 @@ mwarn(void *arg, int line, int col, const char *msg)
 	return(1);
 }
 
+static	const char * const	mandocerrs[MANDOCERR_MAX] = {
+	"ok",
+	"multi-line scope open on exit",
+	"request for scope closure when no matching scope is open",
+	"line arguments will be lost",
+	"memory exhausted"
+};
+
 /*
  * XXX: this is experimental code that will eventually become the
  * generic means of covering all warnings and errors!
@@ -781,11 +811,18 @@ mwarn(void *arg, int line, int col, const char *msg)
 static int
 mmsg(enum mandocerr t, void *arg, int ln, int col, const char *msg)
 {
+#if 0
 	struct curparse *cp;
 
 	cp = (struct curparse *)arg;
 
-	fprintf(stderr, "%s:%d:%d: %s\n", cp->file, ln, col + 1, msg);
+	fprintf(stderr, "%s:%d:%d: %s", cp->file, 
+			ln, col + 1, mandocerrs[t]);
 
+	if (msg)
+		fprintf(stderr, ": %s", msg);
+
+	fputc('\n', stderr);
+#endif
 	return(1);
 }