===================================================================
RCS file: /cvs/mandoc/tbl_layout.c,v
retrieving revision 1.13
retrieving revision 1.38
diff -u -p -r1.13 -r1.38
--- mandoc/tbl_layout.c	2011/01/09 05:38:23	1.13
+++ mandoc/tbl_layout.c	2015/02/10 11:03:13	1.38
@@ -1,6 +1,7 @@
-/*	$Id: tbl_layout.c,v 1.13 2011/01/09 05:38:23 joerg Exp $ */
+/*	$Id: tbl_layout.c,v 1.38 2015/02/10 11:03:13 schwarze Exp $ */
 /*
- * Copyright (c) 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2012, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -14,13 +15,17 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
-#include <assert.h>
+#include "config.h"
+
+#include <sys/types.h>
+
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 #include "mandoc.h"
+#include "mandoc_aux.h"
 #include "libmandoc.h"
 #include "libroff.h"
 
@@ -29,15 +34,7 @@ struct	tbl_phrase {
 	enum tbl_cellt	 key;
 };
 
-/*
- * FIXME: we can make this parse a lot nicer by, when an error is
- * encountered in a layout key, bailing to the next key (i.e. to the
- * next whitespace then continuing).
- */
-
-#define	KEYS_MAX	 11
-
-static	const struct tbl_phrase keys[KEYS_MAX] = {
+static	const struct tbl_phrase keys[] = {
 	{ 'c',		 TBL_CELL_CENTRE },
 	{ 'r',		 TBL_CELL_RIGHT },
 	{ 'l',		 TBL_CELL_LEFT },
@@ -47,49 +44,34 @@ static	const struct tbl_phrase keys[KEYS_MAX] = {
 	{ '^',		 TBL_CELL_DOWN },
 	{ '-',		 TBL_CELL_HORIZ },
 	{ '_',		 TBL_CELL_HORIZ },
-	{ '=',		 TBL_CELL_DHORIZ },
-	{ '|',		 TBL_CELL_VERT }
+	{ '=',		 TBL_CELL_DHORIZ }
 };
 
-static	int		 mods(struct tbl_node *, struct tbl_cell *, 
+#define KEYS_MAX ((int)(sizeof(keys)/sizeof(keys[0])))
+
+static	void		 mods(struct tbl_node *, struct tbl_cell *,
 				int, const char *, int *);
-static	int		 cell(struct tbl_node *, struct tbl_row *, 
+static	void		 cell(struct tbl_node *, struct tbl_row *,
 				int, const char *, int *);
-static	void		 row(struct tbl_node *, int, const char *, int *);
-static	struct tbl_cell *cell_alloc(struct tbl_node *, 
-				struct tbl_row *, enum tbl_cellt);
-static	void		 head_adjust(const struct tbl_cell *, 
-				struct tbl_head *);
+static	struct tbl_cell *cell_alloc(struct tbl_node *, struct tbl_row *,
+				enum tbl_cellt);
 
-static int
-mods(struct tbl_node *tbl, struct tbl_cell *cp, 
+
+static void
+mods(struct tbl_node *tbl, struct tbl_cell *cp,
 		int ln, const char *p, int *pos)
 {
-	char		 buf[5];
-	int		 i;
+	char		*endptr;
 
 mod:
-	/* 
-	 * XXX: since, at least for now, modifiers are non-conflicting
-	 * (are separable by value, regardless of position), we let
-	 * modifiers come in any order.  The existing tbl doesn't let
-	 * this happen.
-	 */
-	switch (p[*pos]) {
-	case ('\0'):
-		/* FALLTHROUGH */
-	case (' '):
-		/* FALLTHROUGH */
-	case ('\t'):
-		/* FALLTHROUGH */
-	case (','):
-		/* FALLTHROUGH */
-	case ('.'):
-		return(1);
-	default:
-		break;
-	}
+	while (p[*pos] == ' ' || p[*pos] == '\t')
+		(*pos)++;
 
+	/* Row delimiters and cell specifiers end modifier lists. */
+
+	if (strchr(".,-=^_ACLNRSaclnrs", p[*pos]) != NULL)
+		return;
+
 	/* Throw away parenthesised expression. */
 
 	if ('(' == p[*pos]) {
@@ -100,309 +82,277 @@ mod:
 			(*pos)++;
 			goto mod;
 		}
-		TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
-		return(0);
+		mandoc_msg(MANDOCERR_TBLLAYOUT_PAR, tbl->parse,
+		    ln, *pos, NULL);
+		return;
 	}
 
 	/* Parse numerical spacing from modifier string. */
 
 	if (isdigit((unsigned char)p[*pos])) {
-		for (i = 0; i < 4; i++) {
-			if ( ! isdigit((unsigned char)p[*pos + i]))
-				break;
-			buf[i] = p[*pos + i];
-		}
-		buf[i] = '\0';
-
-		/* No greater than 4 digits. */
-
-		if (4 == i) {
-			TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
-			return(0);
-		}
-
-		*pos += i;
-		cp->spacing = atoi(buf);
-
+		cp->spacing = strtoull(p + *pos, &endptr, 10);
+		*pos = endptr - p;
 		goto mod;
-		/* NOTREACHED */
-	} 
+	}
 
-	/* TODO: GNU has many more extensions. */
-
 	switch (tolower((unsigned char)p[(*pos)++])) {
-	case ('z'):
-		cp->flags |= TBL_CELL_WIGN;
+	case 'b':
+		cp->flags |= TBL_CELL_BOLD;
 		goto mod;
-	case ('u'):
-		cp->flags |= TBL_CELL_UP;
+	case 'd':
+		cp->flags |= TBL_CELL_BALIGN;
 		goto mod;
-	case ('e'):
+	case 'e':
 		cp->flags |= TBL_CELL_EQUAL;
 		goto mod;
-	case ('t'):
+	case 'f':
+		break;
+	case 'i':
+		cp->flags |= TBL_CELL_ITALIC;
+		goto mod;
+	case 'm':
+		mandoc_msg(MANDOCERR_TBLLAYOUT_MOD, tbl->parse,
+		    ln, *pos, "m");
+		goto mod;
+	case 'p':
+		/* FALLTHROUGH */
+	case 'v':
+		if (p[*pos] == '-' || p[*pos] == '+')
+			(*pos)++;
+		while (isdigit((unsigned char)p[*pos]))
+			(*pos)++;
+		goto mod;
+	case 't':
 		cp->flags |= TBL_CELL_TALIGN;
 		goto mod;
-	case ('d'):
-		cp->flags |= TBL_CELL_BALIGN;
+	case 'u':
+		cp->flags |= TBL_CELL_UP;
 		goto mod;
-	case ('w'):  /* XXX for now, ignore minimal column width */
+	case 'w':  /* XXX for now, ignore minimal column width */
 		goto mod;
-	case ('f'):
-		break;
-	case ('b'):
-		/* FALLTHROUGH */
-	case ('i'):
-		(*pos)--;
-		break;
+	case 'x':
+		cp->flags |= TBL_CELL_WMAX;
+		goto mod;
+	case 'z':
+		cp->flags |= TBL_CELL_WIGN;
+		goto mod;
+	case '|':
+		if (cp->vert < 2)
+			cp->vert++;
+		else
+			mandoc_msg(MANDOCERR_TBLLAYOUT_VERT,
+			    tbl->parse, ln, *pos - 1, NULL);
+		goto mod;
 	default:
-		TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
-		return(0);
+		mandoc_vmsg(MANDOCERR_TBLLAYOUT_CHAR, tbl->parse,
+		    ln, *pos - 1, "%c", p[*pos - 1]);
+		goto mod;
 	}
 
-	switch (tolower((unsigned char)p[(*pos)++])) {
-	case ('b'):
+	/* Ignore parenthised font names for now. */
+
+	if (p[*pos] == '(')
+		goto mod;
+
+	/* Support only one-character font-names for now. */
+
+	if (p[*pos] == '\0' || (p[*pos + 1] != ' ' && p[*pos + 1] != '.')) {
+		mandoc_vmsg(MANDOCERR_FT_BAD, tbl->parse,
+		    ln, *pos, "TS %s", p + *pos - 1);
+		if (p[*pos] != '\0')
+			(*pos)++;
+		if (p[*pos] != '\0')
+			(*pos)++;
+		goto mod;
+	}
+
+	switch (p[(*pos)++]) {
+	case '3':
+		/* FALLTHROUGH */
+	case 'B':
 		cp->flags |= TBL_CELL_BOLD;
 		goto mod;
-	case ('i'):
+	case '2':
+		/* FALLTHROUGH */
+	case 'I':
 		cp->flags |= TBL_CELL_ITALIC;
 		goto mod;
+	case '1':
+		/* FALLTHROUGH */
+	case 'R':
+		goto mod;
 	default:
-		break;
+		mandoc_vmsg(MANDOCERR_FT_BAD, tbl->parse,
+		    ln, *pos - 1, "TS f%c", p[*pos - 1]);
+		goto mod;
 	}
-
-	TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
-	return(0);
 }
 
-static int
-cell(struct tbl_node *tbl, struct tbl_row *rp, 
+static void
+cell(struct tbl_node *tbl, struct tbl_row *rp,
 		int ln, const char *p, int *pos)
 {
 	int		 i;
 	enum tbl_cellt	 c;
 
-	/* Parse the column position (`r', `R', `|', ...). */
+	/* Handle leading vertical lines */
 
+	while (p[*pos] == ' ' || p[*pos] == '\t' || p[*pos] == '|') {
+		if (p[*pos] == '|') {
+			if (rp->vert < 2)
+				rp->vert++;
+			else
+				mandoc_msg(MANDOCERR_TBLLAYOUT_VERT,
+				    tbl->parse, ln, *pos, NULL);
+		}
+		(*pos)++;
+	}
+
+again:
+	while (p[*pos] == ' ' || p[*pos] == '\t')
+		(*pos)++;
+
+	if (p[*pos] == '.' || p[*pos] == '\0')
+		return;
+
+	/* Parse the column position (`c', `l', `r', ...). */
+
 	for (i = 0; i < KEYS_MAX; i++)
 		if (tolower((unsigned char)p[*pos]) == keys[i].name)
 			break;
 
-	if (KEYS_MAX == i) {
-		TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
-		return(0);
+	if (i == KEYS_MAX) {
+		mandoc_vmsg(MANDOCERR_TBLLAYOUT_CHAR, tbl->parse,
+		    ln, *pos, "%c", p[*pos]);
+		(*pos)++;
+		goto again;
 	}
-
 	c = keys[i].key;
 
-	/*
-	 * If a span cell is found first, raise a warning and abort the
-	 * parse.  FIXME: recover from this somehow?
-	 */
+	/* Special cases of spanners. */
 
-	if (NULL == rp->first && TBL_CELL_SPAN == c) {
-		TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
-		return(0);
-	}
+	if (c == TBL_CELL_SPAN) {
+		if (rp->last == NULL)
+			mandoc_msg(MANDOCERR_TBLLAYOUT_SPAN,
+			    tbl->parse, ln, *pos, NULL);
+		else if (rp->last->pos == TBL_CELL_HORIZ ||
+		    rp->last->pos == TBL_CELL_DHORIZ)
+			c = rp->last->pos;
+	} else if (c == TBL_CELL_DOWN && rp == tbl->first_row)
+		mandoc_msg(MANDOCERR_TBLLAYOUT_DOWN,
+		    tbl->parse, ln, *pos, NULL);
 
 	(*pos)++;
 
-	/* Extra check for the double-vertical. */
-
-	if (TBL_CELL_VERT == c && '|' == p[*pos]) {
-		(*pos)++;
-		c = TBL_CELL_DVERT;
-	} 
-	
-	/* Disallow adjacent spacers. */
-
-	if (rp->last && (TBL_CELL_VERT == c || TBL_CELL_DVERT == c) &&
-			(TBL_CELL_VERT == rp->last->pos || 
-			 TBL_CELL_DVERT == rp->last->pos)) {
-		TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
-		return(0);
-	}
-
 	/* Allocate cell then parse its modifiers. */
 
-	return(mods(tbl, cell_alloc(tbl, rp, c), ln, p, pos));
+	mods(tbl, cell_alloc(tbl, rp, c), ln, p, pos);
 }
 
-
-static void
-row(struct tbl_node *tbl, int ln, const char *p, int *pos)
+void
+tbl_layout(struct tbl_node *tbl, int ln, const char *p, int pos)
 {
 	struct tbl_row	*rp;
 
-row:	/*
-	 * EBNF describing this section:
-	 *
-	 * row		::= row_list [:space:]* [.]?[\n]
-	 * row_list	::= [:space:]* row_elem row_tail
-	 * row_tail	::= [:space:]*[,] row_list |
-	 *                  epsilon
-	 * row_elem	::= [\t\ ]*[:alpha:]+
-	 */
+	rp = NULL;
+	for (;;) {
+		/* Skip whitespace before and after each cell. */
 
-	rp = mandoc_calloc(1, sizeof(struct tbl_row));
-	if (tbl->last_row) {
-		tbl->last_row->next = rp;
-		tbl->last_row = rp;
-	} else
-		tbl->last_row = tbl->first_row = rp;
+		while (p[pos] == ' ' || p[pos] == '\t')
+			pos++;
 
-cell:
-	while (isspace((unsigned char)p[*pos]))
-		(*pos)++;
+		switch (p[pos]) {
+		case ',':  /* Next row on this input line. */
+			pos++;
+			rp = NULL;
+			continue;
+		case '\0':  /* Next row on next input line. */
+			return;
+		case '.':  /* End of layout. */
+			pos++;
+			tbl->part = TBL_PART_DATA;
 
-	/* Safely exit layout context. */
+			/*
+			 * When the layout is completely empty,
+			 * default to one left-justified column.
+			 */
 
-	if ('.' == p[*pos]) {
-		tbl->part = TBL_PART_DATA;
-		if (NULL == tbl->first_row) 
-			TBL_MSG(tbl, MANDOCERR_TBLNOLAYOUT, ln, *pos);
-		(*pos)++;
-		return;
-	}
+			if (tbl->first_row == NULL) {
+				tbl->first_row = tbl->last_row =
+				    mandoc_calloc(1, sizeof(*rp));
+			}
+			if (tbl->first_row->first == NULL) {
+				mandoc_msg(MANDOCERR_TBLLAYOUT_NONE,
+				    tbl->parse, ln, pos, NULL);
+				cell_alloc(tbl, tbl->first_row,
+				    TBL_CELL_LEFT);
+				return;
+			}
 
-	/* End (and possibly restart) a row. */
+			/*
+			 * Search for the widest line
+			 * along the left and right margins.
+			 */
 
-	if (',' == p[*pos]) {
-		(*pos)++;
-		goto row;
-	} else if ('\0' == p[*pos])
-		return;
+			for (rp = tbl->first_row; rp; rp = rp->next) {
+				if (tbl->opts.lvert < rp->vert)
+					tbl->opts.lvert = rp->vert;
+				if (rp->last != NULL &&
+				    rp->last->col + 1 == tbl->opts.cols &&
+				    tbl->opts.rvert < rp->last->vert)
+					tbl->opts.rvert = rp->last->vert;
 
-	if ( ! cell(tbl, rp, ln, p, pos))
-		return;
+				/* If the last line is empty, drop it. */
 
-	goto cell;
-	/* NOTREACHED */
-}
+				if (rp->next != NULL &&
+				    rp->next->first == NULL) {
+					free(rp->next);
+					rp->next = NULL;
+				}
+			}
+			return;
+		default:  /* Cell. */
+			break;
+		}
 
-int
-tbl_layout(struct tbl_node *tbl, int ln, const char *p)
-{
-	int		 pos;
+		/*
+		 * If the last line had at least one cell,
+		 * start a new one; otherwise, continue it.
+		 */
 
-	pos = 0;
-	row(tbl, ln, p, &pos);
-
-	/* Always succeed. */
-	return(1);
+		if (rp == NULL) {
+			if (tbl->last_row == NULL ||
+			    tbl->last_row->first != NULL) {
+				rp = mandoc_calloc(1, sizeof(*rp));
+				if (tbl->last_row)
+					tbl->last_row->next = rp;
+				else
+					tbl->first_row = rp;
+				tbl->last_row = rp;
+			} else
+				rp = tbl->last_row;
+		}
+		cell(tbl, rp, ln, p, &pos);
+	}
 }
 
 static struct tbl_cell *
 cell_alloc(struct tbl_node *tbl, struct tbl_row *rp, enum tbl_cellt pos)
 {
 	struct tbl_cell	*p, *pp;
-	struct tbl_head	*h, *hp;
 
-	p = mandoc_calloc(1, sizeof(struct tbl_cell));
-
-	if (NULL != (pp = rp->last)) {
-		rp->last->next = p;
-		rp->last = p;
-	} else
-		rp->last = rp->first = p;
-
+	p = mandoc_calloc(1, sizeof(*p));
 	p->pos = pos;
 
-	/*
-	 * This is a little bit complicated.  Here we determine the
-	 * header the corresponds to a cell.  We add headers dynamically
-	 * when need be or re-use them, otherwise.  As an example, given
-	 * the following:
-	 *
-	 * 	1  c || l 
-	 * 	2  | c | l
-	 * 	3  l l
-	 * 	3  || c | l |.
-	 *
-	 * We first add the new headers (as there are none) in (1); then
-	 * in (2) we insert the first spanner (as it doesn't match up
-	 * with the header); then we re-use the prior data headers,
-	 * skipping over the spanners; then we re-use everything and add
-	 * a last spanner.  Note that VERT headers are made into DVERT
-	 * ones.
-	 */
-
-	h = pp ? pp->head->next : tbl->first_head;
-
-	if (h) {
-		/* Re-use data header. */
-		if (TBL_HEAD_DATA == h->pos && 
-				(TBL_CELL_VERT != p->pos &&
-				 TBL_CELL_DVERT != p->pos)) {
-			p->head = h;
-			return(p);
-		}
-
-		/* Re-use spanner header. */
-		if (TBL_HEAD_DATA != h->pos && 
-				(TBL_CELL_VERT == p->pos ||
-				 TBL_CELL_DVERT == p->pos)) {
-			head_adjust(p, h);
-			p->head = h;
-			return(p);
-		}
-
-		/* Right-shift headers with a new spanner. */
-		if (TBL_HEAD_DATA == h->pos && 
-				(TBL_CELL_VERT == p->pos ||
-				 TBL_CELL_DVERT == p->pos)) {
-			hp = mandoc_calloc(1, sizeof(struct tbl_head));
-			hp->ident = tbl->opts.cols++;
-			hp->prev = h->prev;
-			if (h->prev)
-				h->prev->next = hp;
-			if (h == tbl->first_head)
-				tbl->first_head = hp;
-			h->prev = hp;
-			hp->next = h;
-			head_adjust(p, hp);
-			p->head = hp;
-			return(p);
-		}
-
-		if (NULL != (h = h->next)) {
-			head_adjust(p, h);
-			p->head = h;
-			return(p);
-		}
-
-		/* Fall through to default case... */
-	}
-
-	hp = mandoc_calloc(1, sizeof(struct tbl_head));
-	hp->ident = tbl->opts.cols++;
-
-	if (tbl->last_head) {
-		hp->prev = tbl->last_head;
-		tbl->last_head->next = hp;
-		tbl->last_head = hp;
+	if ((pp = rp->last) != NULL) {
+		pp->next = p;
+		p->col = pp->col + 1;
 	} else
-		tbl->last_head = tbl->first_head = hp;
+		rp->first = p;
+	rp->last = p;
 
-	head_adjust(p, hp);
-	p->head = hp;
+	if (tbl->opts.cols <= p->col)
+		tbl->opts.cols = p->col + 1;
+
 	return(p);
 }
-
-static void
-head_adjust(const struct tbl_cell *cell, struct tbl_head *head)
-{
-	if (TBL_CELL_VERT != cell->pos &&
-			TBL_CELL_DVERT != cell->pos) {
-		head->pos = TBL_HEAD_DATA;
-		return;
-	}
-
-	if (TBL_CELL_VERT == cell->pos)
-		if (TBL_HEAD_DVERT != head->pos)
-			head->pos = TBL_HEAD_VERT;
-
-	if (TBL_CELL_DVERT == cell->pos)
-		head->pos = TBL_HEAD_DVERT;
-}
-