===================================================================
RCS file: /cvs/mandoc/eqn.c,v
retrieving revision 1.58
retrieving revision 1.63
diff -u -p -r1.58 -r1.63
--- mandoc/eqn.c	2015/03/04 12:19:49	1.58
+++ mandoc/eqn.c	2017/06/20 17:24:35	1.63
@@ -1,4 +1,4 @@
-/*	$Id: eqn.c,v 1.58 2015/03/04 12:19:49 schwarze Exp $ */
+/*	$Id: eqn.c,v 1.63 2017/06/20 17:24:35 schwarze Exp $ */
 /*
  * Copyright (c) 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
@@ -302,10 +302,10 @@ eqn_read(struct eqn_node **epp, int ln,
 		while (' ' == *p || '\t' == *p)
 			p++;
 		if ('\0' == *p)
-			return(er);
+			return er;
 		mandoc_vmsg(MANDOCERR_ARG_SKIP, ep->parse,
 		    ln, pos, "EN %s", p);
-		return(er);
+		return er;
 	}
 
 	/*
@@ -324,7 +324,7 @@ eqn_read(struct eqn_node **epp, int ln,
 	ep->sz += sz;
 	strlcat(ep->data, p + pos, ep->sz + 1);
 	strlcat(ep->data, " ", ep->sz + 1);
-	return(ROFF_IGN);
+	return ROFF_IGN;
 }
 
 struct eqn_node *
@@ -339,7 +339,7 @@ eqn_alloc(int pos, int line, struct mparse *parse)
 	p->eqn.pos = pos;
 	p->gsize = EQN_DEFSIZE;
 
-	return(p);
+	return p;
 }
 
 /*
@@ -353,9 +353,9 @@ eqn_def_find(struct eqn_node *ep, const char *key, siz
 	for (i = 0; i < (int)ep->defsz; i++)
 		if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key,
 		    ep->defs[i].keysz, key, sz))
-			return(&ep->defs[i]);
+			return &ep->defs[i];
 
-	return(NULL);
+	return NULL;
 }
 
 /*
@@ -366,15 +366,19 @@ eqn_def_find(struct eqn_node *ep, const char *key, siz
 static const char *
 eqn_next(struct eqn_node *ep, char quote, size_t *sz, int repl)
 {
+	static size_t	 last_len;
+	static int	 lim;
+
 	char		*start, *next;
-	int		 q, diff, lim;
+	int		 q, diff;
 	size_t		 ssz, dummy;
 	struct eqn_def	*def;
 
 	if (NULL == sz)
 		sz = &dummy;
 
-	lim = 0;
+	if (ep->cur >= last_len)
+		lim = 0;
 	ep->rew = ep->cur;
 again:
 	/* Prevent self-definitions. */
@@ -382,7 +386,7 @@ again:
 	if (lim >= EQN_NEST_MAX) {
 		mandoc_msg(MANDOCERR_ROFFLOOP, ep->parse,
 		    ep->eqn.ln, ep->eqn.pos, NULL);
-		return(NULL);
+		return NULL;
 	}
 
 	ep->cur = ep->rew;
@@ -390,7 +394,7 @@ again:
 	q = 0;
 
 	if ('\0' == *start)
-		return(NULL);
+		return NULL;
 
 	if (quote == *start) {
 		ep->cur++;
@@ -432,7 +436,7 @@ again:
 	/* Quotes aren't expanded for values. */
 
 	if (q || ! repl)
-		return(start);
+		return start;
 
 	if (NULL != (def = eqn_def_find(ep, start, *sz))) {
 		diff = def->valsz - *sz;
@@ -448,10 +452,12 @@ again:
 		memmove(start + *sz + diff, start + *sz,
 		    (strlen(start) - *sz) + 1);
 		memcpy(start, def->val, def->valsz);
+		last_len = start - ep->data + def->valsz;
+		lim++;
 		goto again;
 	}
 
-	return(start);
+	return start;
 }
 
 /*
@@ -462,7 +468,7 @@ static const char *
 eqn_nexttok(struct eqn_node *ep, size_t *sz)
 {
 
-	return(eqn_next(ep, '"', sz, 1));
+	return eqn_next(ep, '"', sz, 1);
 }
 
 /*
@@ -472,7 +478,7 @@ static const char *
 eqn_nextrawtok(struct eqn_node *ep, size_t *sz)
 {
 
-	return(eqn_next(ep, '"', sz, 0));
+	return eqn_next(ep, '"', sz, 0);
 }
 
 /*
@@ -498,12 +504,12 @@ eqn_tok_parse(struct eqn_node *ep, char **p)
 	quoted = ep->data[ep->cur] == '"';
 
 	if (NULL == (start = eqn_nexttok(ep, &sz)))
-		return(EQN_TOK_EOF);
+		return EQN_TOK_EOF;
 
 	if (quoted) {
 		if (p != NULL)
 			*p = mandoc_strndup(start, sz);
-		return(EQN_TOK__MAX);
+		return EQN_TOK__MAX;
 	}
 
 	for (i = 0; i < EQN_TOK__MAX; i++) {
@@ -516,7 +522,7 @@ eqn_tok_parse(struct eqn_node *ep, char **p)
 	if (i == EQN_TOK__MAX && NULL != p)
 		*p = mandoc_strndup(start, sz);
 
-	return(i);
+	return i;
 }
 
 static void
@@ -557,7 +563,7 @@ eqn_box_alloc(struct eqn_node *ep, struct eqn_box *par
 		parent->first = bp;
 
 	parent->last = bp;
-	return(bp);
+	return bp;
 }
 
 /*
@@ -587,7 +593,7 @@ eqn_box_makebinary(struct eqn_node *ep,
 	newb->first = newb->last = b;
 	newb->first->next = NULL;
 	b->parent = newb;
-	return(newb);
+	return newb;
 }
 
 /*
@@ -712,46 +718,46 @@ eqn_parse(struct eqn_node *ep, struct eqn_box *parent)
 	 */
 
 	if (ep->data == NULL)
-		return(ROFF_IGN);
+		return ROFF_IGN;
 
 next_tok:
 	tok = eqn_tok_parse(ep, &p);
 
 this_tok:
 	switch (tok) {
-	case (EQN_TOK_UNDEF):
+	case EQN_TOK_UNDEF:
 		eqn_undef(ep);
 		break;
-	case (EQN_TOK_NDEFINE):
-	case (EQN_TOK_DEFINE):
+	case EQN_TOK_NDEFINE:
+	case EQN_TOK_DEFINE:
 		eqn_def(ep);
 		break;
-	case (EQN_TOK_TDEFINE):
+	case EQN_TOK_TDEFINE:
 		if (eqn_nextrawtok(ep, NULL) == NULL ||
 		    eqn_next(ep, ep->data[(int)ep->cur], NULL, 0) == NULL)
 			mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
 			    ep->eqn.ln, ep->eqn.pos, "tdefine");
 		break;
-	case (EQN_TOK_DELIM):
+	case EQN_TOK_DELIM:
 		eqn_delim(ep);
 		break;
-	case (EQN_TOK_GFONT):
+	case EQN_TOK_GFONT:
 		if (eqn_nextrawtok(ep, NULL) == NULL)
 			mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
 			    ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
 		break;
-	case (EQN_TOK_MARK):
-	case (EQN_TOK_LINEUP):
+	case EQN_TOK_MARK:
+	case EQN_TOK_LINEUP:
 		/* Ignore these. */
 		break;
-	case (EQN_TOK_DYAD):
-	case (EQN_TOK_VEC):
-	case (EQN_TOK_UNDER):
-	case (EQN_TOK_BAR):
-	case (EQN_TOK_TILDE):
-	case (EQN_TOK_HAT):
-	case (EQN_TOK_DOT):
-	case (EQN_TOK_DOTDOT):
+	case EQN_TOK_DYAD:
+	case EQN_TOK_VEC:
+	case EQN_TOK_UNDER:
+	case EQN_TOK_BAR:
+	case EQN_TOK_TILDE:
+	case EQN_TOK_HAT:
+	case EQN_TOK_DOT:
+	case EQN_TOK_DOTDOT:
 		if (parent->last == NULL) {
 			mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
 			    ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
@@ -763,28 +769,28 @@ this_tok:
 		parent->type = EQN_LISTONE;
 		parent->expectargs = 1;
 		switch (tok) {
-		case (EQN_TOK_DOTDOT):
+		case EQN_TOK_DOTDOT:
 			strlcpy(sym, "\\[ad]", sizeof(sym));
 			break;
-		case (EQN_TOK_VEC):
+		case EQN_TOK_VEC:
 			strlcpy(sym, "\\[->]", sizeof(sym));
 			break;
-		case (EQN_TOK_DYAD):
+		case EQN_TOK_DYAD:
 			strlcpy(sym, "\\[<>]", sizeof(sym));
 			break;
-		case (EQN_TOK_TILDE):
+		case EQN_TOK_TILDE:
 			strlcpy(sym, "\\[a~]", sizeof(sym));
 			break;
-		case (EQN_TOK_UNDER):
+		case EQN_TOK_UNDER:
 			strlcpy(sym, "\\[ul]", sizeof(sym));
 			break;
-		case (EQN_TOK_BAR):
+		case EQN_TOK_BAR:
 			strlcpy(sym, "\\[rl]", sizeof(sym));
 			break;
-		case (EQN_TOK_DOT):
+		case EQN_TOK_DOT:
 			strlcpy(sym, "\\[a.]", sizeof(sym));
 			break;
-		case (EQN_TOK_HAT):
+		case EQN_TOK_HAT:
 			strlcpy(sym, "\\[ha]", sizeof(sym));
 			break;
 		default:
@@ -792,16 +798,16 @@ this_tok:
 		}
 
 		switch (tok) {
-		case (EQN_TOK_DOTDOT):
-		case (EQN_TOK_VEC):
-		case (EQN_TOK_DYAD):
-		case (EQN_TOK_TILDE):
-		case (EQN_TOK_BAR):
-		case (EQN_TOK_DOT):
-		case (EQN_TOK_HAT):
+		case EQN_TOK_DOTDOT:
+		case EQN_TOK_VEC:
+		case EQN_TOK_DYAD:
+		case EQN_TOK_TILDE:
+		case EQN_TOK_BAR:
+		case EQN_TOK_DOT:
+		case EQN_TOK_HAT:
 			parent->top = mandoc_strdup(sym);
 			break;
-		case (EQN_TOK_UNDER):
+		case EQN_TOK_UNDER:
 			parent->bottom = mandoc_strdup(sym);
 			break;
 		default:
@@ -809,10 +815,10 @@ this_tok:
 		}
 		parent = parent->parent;
 		break;
-	case (EQN_TOK_FWD):
-	case (EQN_TOK_BACK):
-	case (EQN_TOK_DOWN):
-	case (EQN_TOK_UP):
+	case EQN_TOK_FWD:
+	case EQN_TOK_BACK:
+	case EQN_TOK_DOWN:
+	case EQN_TOK_UP:
 		subtok = eqn_tok_parse(ep, NULL);
 		if (subtok != EQN_TOK__MAX) {
 			mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
@@ -821,10 +827,10 @@ this_tok:
 			goto this_tok;
 		}
 		break;
-	case (EQN_TOK_FAT):
-	case (EQN_TOK_ROMAN):
-	case (EQN_TOK_ITALIC):
-	case (EQN_TOK_BOLD):
+	case EQN_TOK_FAT:
+	case EQN_TOK_ROMAN:
+	case EQN_TOK_ITALIC:
+	case EQN_TOK_BOLD:
 		while (parent->args == parent->expectargs)
 			parent = parent->parent;
 		/*
@@ -836,24 +842,24 @@ this_tok:
 		parent->type = EQN_LISTONE;
 		parent->expectargs = 1;
 		switch (tok) {
-		case (EQN_TOK_FAT):
+		case EQN_TOK_FAT:
 			parent->font = EQNFONT_FAT;
 			break;
-		case (EQN_TOK_ROMAN):
+		case EQN_TOK_ROMAN:
 			parent->font = EQNFONT_ROMAN;
 			break;
-		case (EQN_TOK_ITALIC):
+		case EQN_TOK_ITALIC:
 			parent->font = EQNFONT_ITALIC;
 			break;
-		case (EQN_TOK_BOLD):
+		case EQN_TOK_BOLD:
 			parent->font = EQNFONT_BOLD;
 			break;
 		default:
 			abort();
 		}
 		break;
-	case (EQN_TOK_SIZE):
-	case (EQN_TOK_GSIZE):
+	case EQN_TOK_SIZE:
+	case EQN_TOK_GSIZE:
 		/* Accept two values: integral size and a single. */
 		if (NULL == (start = eqn_nexttok(ep, &sz))) {
 			mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
@@ -875,10 +881,10 @@ this_tok:
 		parent->expectargs = 1;
 		parent->size = size;
 		break;
-	case (EQN_TOK_FROM):
-	case (EQN_TOK_TO):
-	case (EQN_TOK_SUB):
-	case (EQN_TOK_SUP):
+	case EQN_TOK_FROM:
+	case EQN_TOK_TO:
+	case EQN_TOK_SUB:
+	case EQN_TOK_SUP:
 		/*
 		 * We have a left-right-associative expression.
 		 * Repivot under a positional node, open a child scope
@@ -903,16 +909,16 @@ this_tok:
 			break;
 		}
 		switch (tok) {
-		case (EQN_TOK_FROM):
+		case EQN_TOK_FROM:
 			pos = EQNPOS_FROM;
 			break;
-		case (EQN_TOK_TO):
+		case EQN_TOK_TO:
 			pos = EQNPOS_TO;
 			break;
-		case (EQN_TOK_SUP):
+		case EQN_TOK_SUP:
 			pos = EQNPOS_SUP;
 			break;
-		case (EQN_TOK_SUB):
+		case EQN_TOK_SUB:
 			pos = EQNPOS_SUB;
 			break;
 		default:
@@ -920,7 +926,7 @@ this_tok:
 		}
 		parent = eqn_box_makebinary(ep, pos, parent);
 		break;
-	case (EQN_TOK_SQRT):
+	case EQN_TOK_SQRT:
 		while (parent->args == parent->expectargs)
 			parent = parent->parent;
 		/*
@@ -933,7 +939,7 @@ this_tok:
 		parent->pos = EQNPOS_SQRT;
 		parent->expectargs = 1;
 		break;
-	case (EQN_TOK_OVER):
+	case EQN_TOK_OVER:
 		/*
 		 * We have a right-left-associative fraction.
 		 * Close out anything that's currently open, then
@@ -950,8 +956,8 @@ this_tok:
 			parent = parent->parent;
 		parent = eqn_box_makebinary(ep, EQNPOS_OVER, parent);
 		break;
-	case (EQN_TOK_RIGHT):
-	case (EQN_TOK_BRACE_CLOSE):
+	case EQN_TOK_RIGHT:
+	case EQN_TOK_BRACE_CLOSE:
 		/*
 		 * Close out the existing brace.
 		 * FIXME: this is a shitty sentinel: we should really
@@ -986,7 +992,7 @@ this_tok:
 				parent->right = mandoc_strndup(start, sz);
 		}
 		parent = parent->parent;
-		if (EQN_TOK_BRACE_CLOSE == tok && parent &&
+		if (tok == EQN_TOK_BRACE_CLOSE &&
 		    (parent->type == EQN_PILE ||
 		     parent->type == EQN_MATRIX))
 			parent = parent->parent;
@@ -995,8 +1001,8 @@ this_tok:
 		    parent->args == parent->expectargs)
 			parent = parent->parent;
 		break;
-	case (EQN_TOK_BRACE_OPEN):
-	case (EQN_TOK_LEFT):
+	case EQN_TOK_BRACE_OPEN:
+	case EQN_TOK_LEFT:
 		/*
 		 * If we already have something in the stack and we're
 		 * in an expression, then rewind til we're not any more
@@ -1023,20 +1029,20 @@ this_tok:
 				parent->left = mandoc_strndup(start, sz);
 		}
 		break;
-	case (EQN_TOK_PILE):
-	case (EQN_TOK_LPILE):
-	case (EQN_TOK_RPILE):
-	case (EQN_TOK_CPILE):
-	case (EQN_TOK_CCOL):
-	case (EQN_TOK_LCOL):
-	case (EQN_TOK_RCOL):
+	case EQN_TOK_PILE:
+	case EQN_TOK_LPILE:
+	case EQN_TOK_RPILE:
+	case EQN_TOK_CPILE:
+	case EQN_TOK_CCOL:
+	case EQN_TOK_LCOL:
+	case EQN_TOK_RCOL:
 		while (parent->args == parent->expectargs)
 			parent = parent->parent;
 		parent = eqn_box_alloc(ep, parent);
 		parent->type = EQN_PILE;
 		parent->expectargs = 1;
 		break;
-	case (EQN_TOK_ABOVE):
+	case EQN_TOK_ABOVE:
 		for (cur = parent; cur != NULL; cur = cur->parent)
 			if (cur->type == EQN_PILE)
 				break;
@@ -1048,19 +1054,19 @@ this_tok:
 		parent = eqn_box_alloc(ep, cur);
 		parent->type = EQN_LIST;
 		break;
-	case (EQN_TOK_MATRIX):
+	case EQN_TOK_MATRIX:
 		while (parent->args == parent->expectargs)
 			parent = parent->parent;
 		parent = eqn_box_alloc(ep, parent);
 		parent->type = EQN_MATRIX;
 		parent->expectargs = 1;
 		break;
-	case (EQN_TOK_EOF):
+	case EQN_TOK_EOF:
 		/*
 		 * End of file!
 		 * TODO: make sure we're not in an open subexpression.
 		 */
-		return(ROFF_EQN);
+		return ROFF_EQN;
 	default:
 		assert(tok == EQN_TOK__MAX);
 		assert(NULL != p);
@@ -1104,7 +1110,7 @@ eqn_end(struct eqn_node **epp)
 
 	ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
 	ep->eqn.root->expectargs = UINT_MAX;
-	return(eqn_parse(ep, ep->eqn.root));
+	return eqn_parse(ep, ep->eqn.root);
 }
 
 void