===================================================================
RCS file: /cvs/mandoc/roff.c,v
retrieving revision 1.75
retrieving revision 1.78
diff -u -p -r1.75 -r1.78
--- mandoc/roff.c	2010/05/16 13:49:23	1.75
+++ mandoc/roff.c	2010/05/16 22:28:33	1.78
@@ -1,4 +1,4 @@
-/*	$Id: roff.c,v 1.75 2010/05/16 13:49:23 kristaps Exp $ */
+/*	$Id: roff.c,v 1.78 2010/05/16 22:28:33 kristaps Exp $ */
 /*
  * Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -28,7 +28,7 @@
 
 #define	ROFF_CTL(c) \
 	('.' == (c) || '\'' == (c))
-#ifdef	ROFF_DEBUG
+#if	0
 #define	ROFF_MDEBUG(p, str) \
 	fprintf(stderr, "%s: %s (%d:%d)\n", (str), \
 		roffs[(p)->last->tok].name, \
@@ -39,13 +39,14 @@
 
 enum	rofft {
 	ROFF_if,
+	ROFF_ig,
+	ROFF_cblock,
 	ROFF_ccond,
 #if 0
 	ROFF_am,
 	ROFF_ami,
 	ROFF_de,
 	ROFF_dei,
-	ROFF_ig,
 	ROFF_close,
 #endif
 	ROFF_MAX
@@ -80,31 +81,26 @@ typedef	enum rofferr (*roffproc)(ROFF_ARGS);
 struct	roffmac {
 	const char	*name; /* macro name */
 	roffproc	 proc;
+	roffproc	 text;
 };
 
 static	enum rofferr	 roff_if(ROFF_ARGS);
+static	enum rofferr	 roff_if_text(ROFF_ARGS);
+static	enum rofferr	 roff_ig(ROFF_ARGS);
+static	enum rofferr	 roff_ig_text(ROFF_ARGS);
+static	enum rofferr	 roff_cblock(ROFF_ARGS);
 static	enum rofferr	 roff_ccond(ROFF_ARGS);
-#if 0
-static	enum rofferr	 roff_new_close(ROFF_ARGS);
-static	enum rofferr	 roff_new_ig(ROFF_ARGS);
-static	enum rofferr	 roff_sub_ig(ROFF_ARGS);
-#endif
 
 const	struct roffmac	 roffs[ROFF_MAX] = {
-	{ "if", roff_if },
-	{ "\\}", roff_ccond },
-#if 0
-	{ "am", roff_sub_ig, roff_new_ig },
-	{ "ami", roff_sub_ig, roff_new_ig },
-	{ "de", roff_sub_ig, roff_new_ig },
-	{ "dei", roff_sub_ig, roff_new_ig },
-	{ "ig", roff_sub_ig, roff_new_ig },
-	{ ".", NULL, roff_new_close },
-#endif
+	{ "if", roff_if, roff_if_text },
+	{ "ig", roff_ig, roff_ig_text },
+	{ ".", roff_cblock, NULL },
+	{ "\\}", roff_ccond, NULL },
 };
 
 static	void		 roff_free1(struct roff *);
 static	enum rofft	 roff_hash_find(const char *);
+static	void		 roffnode_cleanscope(struct roff *);
 static	int		 roffnode_push(struct roff *, 
 				enum rofft, int, int);
 static	void		 roffnode_pop(struct roff *);
@@ -219,30 +215,72 @@ roff_parseln(struct roff *r, int ln, 
 		char **bufp, size_t *szp, int pos, int *offs)
 {
 	enum rofft	 t;
-	int		 ppos;
+	int		 ppos, i, j, wtf;
 
-	/* Return when in free text without a context. */
-
 	if (r->last && ! ROFF_CTL((*bufp)[pos])) {
-		/* XXX: this assumes we're just discarding. */
-		while (r->last) {
-			if (r->last->endspan-- < 0)
-				break;
-			ROFF_MDEBUG(r, "closing implicit scope");
-			roffnode_pop(r);
-		}
-		return(ROFF_IGN);
+		/*
+		 * If a scope is open and we're not a macro, pass it
+		 * through our text detector and continue as quickly as
+		 * possible.
+		 */
+		t = r->last->tok;
+		assert(roffs[t].text);
+		return((*roffs[t].text)
+				(r, t, bufp, szp, ln, pos, pos, offs));
 	} else if ( ! ROFF_CTL((*bufp)[pos]))
+		/*
+		 * Don't do anything if we're free-form text.
+		 */
 		return(ROFF_CONT);
 
-	/* There's nothing on the stack: make us anew. */
+	/* A macro-ish line with a possibly-open macro context. */
 
+	wtf = 0;
+
+	if (r->last && r->last->end) {
+		/*
+		 * We have a scope open that has a custom end-macro
+		 * handler.  Try to match it against the input.
+		 */
+		i = pos + 1;
+		while (' ' == (*bufp)[i] || '\t' == (*bufp)[i])
+			i++;
+
+		for (j = 0; r->last->end[j]; j++, i++)
+			if ((*bufp)[i] != r->last->end[j])
+				break;
+
+		if ('\0' == r->last->end[j] && 
+				('\0' == (*bufp)[i] ||
+				 ' ' == (*bufp)[i] ||
+				 '\t' == (*bufp)[i])) {
+			roffnode_pop(r);
+			roffnode_cleanscope(r);
+			wtf = 1;
+		}
+	}
+
 	ppos = pos;
-	if (ROFF_MAX == (t = roff_parse(*bufp, &pos)))
-		return(ROFF_CONT);
+	if (ROFF_MAX == (t = roff_parse(*bufp, &pos))) {
+		/* 
+		 * This is some of groff's stranger behaviours.  If we
+		 * encountered a custom end-scope tag and that tag also
+		 * happens to be a "real" macro, then we need to try
+		 * interpreting it again as a real macro.  If it's not,
+		 * then return ignore.  Else continue.
+		 */
+		if (wtf)
+			return(ROFF_IGN);
+		else if (NULL == r->last)
+			return(ROFF_CONT);
 
+		/* FIXME: this assumes that we ignore!? */
+		return(ROFF_IGN);
+	}
+
 	assert(roffs[t].proc);
-	return((*roffs[t].proc)(r, t, bufp, szp, ln, ppos, pos, offs));
+	return((*roffs[t].proc)
+			(r, t, bufp, szp, ln, ppos, pos, offs));
 }
 
 
@@ -298,85 +336,158 @@ roff_parse(const char *buf, int *pos)
 }
 
 
-#if 0
 /* ARGSUSED */
 static enum rofferr
-roff_sub_ig(ROFF_ARGS)
+roff_cblock(ROFF_ARGS)
 {
-	int		 i, j;
 
-	/* Ignore free-text lines. */
+	if (NULL == r->last) {
+		if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))
+			return(ROFF_ERR);
+		return(ROFF_IGN);
+	}
 
-	if ('.' != (*bufp)[ppos] && '\'' != (*bufp)[ppos])
+	if (ROFF_ig != r->last->tok) {
+		if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))
+			return(ROFF_ERR);
 		return(ROFF_IGN);
+	}
 
-	if (r->last->end) {
-		i = ppos + 1;
+	if ((*bufp)[pos])
+		if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))
+			return(ROFF_ERR);
 
-		while ((*bufp)[i] && ' ' == (*bufp)[i])
-			i++;
+	ROFF_MDEBUG(r, "closing ignore block");
+	roffnode_pop(r);
+	roffnode_cleanscope(r);
+	return(ROFF_IGN);
 
-		for (j = 0; r->last->end[j]; i++, j++)
-			if ((*bufp)[i] != r->last->end[j])
-				return(ROFF_IGN);
+}
 
-		if (r->last->end[j])
-			return(ROFF_IGN);
-		if ((*bufp)[i] && ' ' != (*bufp)[i])
-			return(ROFF_IGN);
 
-		while (' ' == (*bufp)[i])
-			i++;
+static void
+roffnode_cleanscope(struct roff *r)
+{
 
-	} else if (ROFF_close != roff_parse(*bufp, &i))
+	while (r->last) {
+		if (--r->last->endspan < 0)
+			break;
+		ROFF_MDEBUG(r, "closing implicit scope");
+		roffnode_pop(r);
+	}
+}
+
+
+/* ARGSUSED */
+static enum rofferr
+roff_ccond(ROFF_ARGS)
+{
+
+	if (NULL == r->last) {
+		if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))
+			return(ROFF_ERR);
 		return(ROFF_IGN);
+	}
 
-	roffnode_pop(r);
+	if (ROFF_if != r->last->tok) {
+		if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))
+			return(ROFF_ERR);
+		return(ROFF_IGN);
+	}
 
-	if ('\0' == (*bufp)[i])
+	if (r->last->endspan > -1) {
+		if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))
+			return(ROFF_ERR);
 		return(ROFF_IGN);
-	if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, i, NULL))
-		return(ROFF_ERR);
+	}
 
+	if ((*bufp)[pos])
+		if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))
+			return(ROFF_ERR);
+
+	ROFF_MDEBUG(r, "closing explicit scope");
+	roffnode_pop(r);
+	roffnode_cleanscope(r);
 	return(ROFF_IGN);
 }
 
 
 /* ARGSUSED */
 static enum rofferr
-roff_new_close(ROFF_ARGS)
+roff_ig(ROFF_ARGS)
 {
+	int		sv;
+	size_t		sz;
 
-	if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))
+	if ( ! roffnode_push(r, tok, ln, ppos))
 		return(ROFF_ERR);
 
+	if ('\0' == (*bufp)[pos]) {
+		ROFF_MDEBUG(r, "opening ignore block");
+		return(ROFF_IGN);
+	}
+
+	sv = pos;
+	while ((*bufp)[pos] && ' ' != (*bufp)[pos] && 
+			'\t' != (*bufp)[pos])
+		pos++;
+
+	/*
+	 * Note: groff does NOT like escape characters in the input.
+	 * Instead of detecting this, we're just going to let it fly and
+	 * to hell with it.
+	 */
+
+	assert(pos > sv);
+	sz = (size_t)(pos - sv);
+
+	r->last->end = malloc(sz + 1);
+
+	if (NULL == r->last->end) {
+		(*r->msg)(MANDOCERR_MEM, r->data, ln, pos, NULL);
+		return(ROFF_ERR);
+	}
+
+	memcpy(r->last->end, *bufp + sv, sz);
+	r->last->end[(int)sz] = '\0';
+
+	ROFF_MDEBUG(r, "opening explicit ignore block");
+
+	if ((*bufp)[pos])
+		if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))
+			return(ROFF_ERR);
+
 	return(ROFF_IGN);
 }
-#endif
 
 
 /* ARGSUSED */
 static enum rofferr
-roff_ccond(ROFF_ARGS)
+roff_ig_text(ROFF_ARGS)
 {
 
-	if (NULL == r->last || ROFF_if != r->last->tok || r->last->endspan > -1) {
-		if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))
-			return(ROFF_ERR);
-		return(ROFF_IGN);
-	}
+	return(ROFF_IGN);
+}
 
-	ROFF_MDEBUG(r, "closing explicit scope");
-	roffnode_pop(r);
 
-	while (r->last) {
-		if (--r->last->endspan < 0)
-			break;
+/* ARGSUSED */
+static enum rofferr
+roff_if_text(ROFF_ARGS)
+{
+	char		*ep, *st;
 
-		ROFF_MDEBUG(r, "closing implicit scope");
+	st = &(*bufp)[pos];
+	if (NULL == (ep = strstr(st, "\\}"))) {
+		roffnode_cleanscope(r);
+		return(ROFF_IGN);
+	}
+
+	if (ep > st && '\\' != *(ep - 1)) {
+		ROFF_MDEBUG(r, "closing explicit scope (in-line)");
 		roffnode_pop(r);
 	}
 
+	roffnode_cleanscope(r);
 	return(ROFF_IGN);
 }
 
@@ -385,6 +496,7 @@ roff_ccond(ROFF_ARGS)
 static enum rofferr
 roff_if(ROFF_ARGS)
 {
+	int		 sv;
 
 	/*
 	 * Read ahead past the conditional.
@@ -393,14 +505,29 @@ roff_if(ROFF_ARGS)
 	 * It's good enough for now, however.
 	 */
 
-	if ( ! roffnode_push(r, tok, ln, ppos))
-		return(ROFF_ERR);
-
 	while ((*bufp)[pos] && ' ' != (*bufp)[pos])
 		pos++;
+
+	sv = pos;
 	while (' ' == (*bufp)[pos])
 		pos++;
 
+	/*
+	 * Roff is weird.  If we have just white-space after the
+	 * conditional, it's considered the BODY and we exit without
+	 * really doing anything.  Warn about this.  It's probably
+	 * wrong.
+	 */
+
+	if ('\0' == (*bufp)[pos] && sv != pos) {
+		if ( ! (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL))
+			return(ROFF_ERR);
+		return(ROFF_IGN);
+	}
+
+	if ( ! roffnode_push(r, tok, ln, ppos))
+		return(ROFF_ERR);
+
 	/* Don't evaluate: just assume NO. */
 
 	r->last->endspan = 1;
@@ -412,67 +539,16 @@ roff_if(ROFF_ARGS)
 	} else
 		ROFF_MDEBUG(r, "opening implicit scope");
 
-	if ('\0' == (*bufp)[pos])
-		return(ROFF_IGN);
-
-	*offs = pos;
-	return(ROFF_RERUN);
-}
-
-
-#if 0
-static enum rofferr
-roff_new_ig(ROFF_ARGS)
-{
-	int		 i;
-
-	if ( ! roffnode_push(r, tok, ln, ppos))
-		return(ROFF_ERR);
-	
 	/*
-	 * Other macros (not `ig') using this routine have additional
-	 * crap here that we discard. 
+	 * If there are no arguments on the line, the next-line scope is
+	 * assumed.
 	 */
 
-	if (ROFF_ig != tok) {
-		while ((*bufp)[ppos] && ' ' != (*bufp)[ppos])
-			ppos++;
-		while (' ' == (*bufp)[ppos])
-			ppos++;
-	}
-
-	i = (int)ppos;
-
-	while ((*bufp)[i] && ' ' != (*bufp)[i])
-		i++;
-
-	if (i == (int)ppos)
+	if ('\0' == (*bufp)[pos])
 		return(ROFF_IGN);
 
-	if ((*bufp)[i])
-		if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, i, NULL))
-			return(ROFF_ERR);
+	/* Otherwise re-run the roff parser after recalculating. */
 
-	/*
-	 * If the macro has arguments, the first argument (up to the
-	 * next whitespace) is interpreted as an argument marking the
-	 * macro close.  Thus, `.ig foo' will close at `.foo'.
-	 *
-	 * NOTE: the closing macro `.foo' in the above case is not
-	 * allowed to have leading spaces with old groff!  Thus `.foo'
-	 * != `. foo'.  Oh yeah, everything after the `.foo' is lost.
-	 * Merry fucking Christmas.
-	 */
-
-	r->last->end = malloc((size_t)(i - ppos) + 1);
-	if (NULL == r->last->end) {
-		(*r->msg)(MANDOCERR_MEM, r->data, ln, ppos, NULL);
-		return(ROFF_ERR);
-	}
-
-	memcpy(r->last->end, &(*bufp)[ppos], (size_t)(i - ppos));
-	r->last->end[i - ppos] = '\0';
-
-	return(ROFF_IGN);
+	*offs = pos;
+	return(ROFF_RERUN);
 }
-#endif