===================================================================
RCS file: /cvs/mandoc/mdoc.c,v
retrieving revision 1.242
retrieving revision 1.254
diff -u -p -r1.242 -r1.254
--- mandoc/mdoc.c	2015/04/18 16:06:40	1.242
+++ mandoc/mdoc.c	2015/10/12 00:08:15	1.254
@@ -1,4 +1,4 @@
-/*	$Id: mdoc.c,v 1.242 2015/04/18 16:06:40 schwarze Exp $ */
+/*	$Id: mdoc.c,v 1.254 2015/10/12 00:08:15 schwarze Exp $ */
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010, 2012-2015 Ingo Schwarze <schwarze@openbsd.org>
@@ -32,9 +32,11 @@
 #include "roff.h"
 #include "mdoc.h"
 #include "libmandoc.h"
+#include "roff_int.h"
 #include "libmdoc.h"
 
 const	char *const __mdoc_macronames[MDOC_MAX + 1] = {
+	"text",
 	"Ap",		"Dd",		"Dt",		"Os",
 	"Sh",		"Ss",		"Pp",		"D1",
 	"Dl",		"Bd",		"Ed",		"Bl",
@@ -65,8 +67,8 @@ const	char *const __mdoc_macronames[MDOC_MAX + 1] = {
 	"Lk",		"Mt",		"Brq",		"Bro",
 	"Brc",		"%C",		"Es",		"En",
 	"Dx",		"%Q",		"br",		"sp",
-	"%U",		"Ta",		"ll",		"text",
-	};
+	"%U",		"Ta",		"ll",
+};
 
 const	char *const __mdoc_argnames[MDOC_ARG_MAX] = {
 	"split",		"nosplit",		"ragged",
@@ -80,149 +82,14 @@ const	char *const __mdoc_argnames[MDOC_ARG_MAX] = {
 	"symbolic",		"nested",		"centered"
 	};
 
-const	char * const *mdoc_macronames = __mdoc_macronames;
+const	char * const *mdoc_macronames = __mdoc_macronames + 1;
 const	char * const *mdoc_argnames = __mdoc_argnames;
 
-static	void		  mdoc_node_free(struct roff_node *);
-static	void		  mdoc_node_unlink(struct roff_man *,
-				struct roff_node *);
-static	void		  mdoc_free1(struct roff_man *);
-static	void		  mdoc_alloc1(struct roff_man *);
-static	struct roff_node *node_alloc(struct roff_man *, int, int,
-				int, enum roff_type);
-static	void		  node_append(struct roff_man *, struct roff_node *);
 static	int		  mdoc_ptext(struct roff_man *, int, char *, int);
 static	int		  mdoc_pmacro(struct roff_man *, int, char *, int);
 
 
-const struct roff_node *
-mdoc_node(const struct roff_man *mdoc)
-{
-
-	return(mdoc->first);
-}
-
-const struct roff_meta *
-mdoc_meta(const struct roff_man *mdoc)
-{
-
-	return(&mdoc->meta);
-}
-
 /*
- * Frees volatile resources (parse tree, meta-data, fields).
- */
-static void
-mdoc_free1(struct roff_man *mdoc)
-{
-
-	if (mdoc->first)
-		mdoc_node_delete(mdoc, mdoc->first);
-	free(mdoc->meta.msec);
-	free(mdoc->meta.vol);
-	free(mdoc->meta.arch);
-	free(mdoc->meta.date);
-	free(mdoc->meta.title);
-	free(mdoc->meta.os);
-	free(mdoc->meta.name);
-}
-
-/*
- * Allocate all volatile resources (parse tree, meta-data, fields).
- */
-static void
-mdoc_alloc1(struct roff_man *mdoc)
-{
-
-	memset(&mdoc->meta, 0, sizeof(mdoc->meta));
-	mdoc->flags = 0;
-	mdoc->lastnamed = mdoc->lastsec = SEC_NONE;
-	mdoc->last = mandoc_calloc(1, sizeof(*mdoc->last));
-	mdoc->first = mdoc->last;
-	mdoc->last->type = ROFFT_ROOT;
-	mdoc->last->tok = MDOC_MAX;
-	mdoc->next = ROFF_NEXT_CHILD;
-}
-
-/*
- * Free up volatile resources (see mdoc_free1()) then re-initialises the
- * data with mdoc_alloc1().  After invocation, parse data has been reset
- * and the parser is ready for re-invocation on a new tree; however,
- * cross-parse non-volatile data is kept intact.
- */
-void
-mdoc_reset(struct roff_man *mdoc)
-{
-
-	mdoc_free1(mdoc);
-	mdoc_alloc1(mdoc);
-}
-
-/*
- * Completely free up all volatile and non-volatile parse resources.
- * After invocation, the pointer is no longer usable.
- */
-void
-mdoc_free(struct roff_man *mdoc)
-{
-
-	mdoc_free1(mdoc);
-	free(mdoc);
-}
-
-/*
- * Allocate volatile and non-volatile parse resources.
- */
-struct roff_man *
-mdoc_alloc(struct roff *roff, struct mparse *parse,
-	const char *defos, int quick)
-{
-	struct roff_man	*p;
-
-	p = mandoc_calloc(1, sizeof(*p));
-
-	p->parse = parse;
-	p->defos = defos;
-	p->quick = quick;
-	p->roff = roff;
-
-	mdoc_hash_init();
-	mdoc_alloc1(p);
-	return(p);
-}
-
-void
-mdoc_endparse(struct roff_man *mdoc)
-{
-
-	mdoc_macroend(mdoc);
-}
-
-void
-mdoc_addeqn(struct roff_man *mdoc, const struct eqn *ep)
-{
-	struct roff_node *n;
-
-	n = node_alloc(mdoc, ep->ln, ep->pos, MDOC_MAX, ROFFT_EQN);
-	n->eqn = ep;
-	if (ep->ln > mdoc->last->line)
-		n->flags |= MDOC_LINE;
-	node_append(mdoc, n);
-	mdoc->next = ROFF_NEXT_SIBLING;
-}
-
-void
-mdoc_addspan(struct roff_man *mdoc, const struct tbl_span *sp)
-{
-	struct roff_node *n;
-
-	n = node_alloc(mdoc, sp->line, 0, MDOC_MAX, ROFFT_TBL);
-	n->span = sp;
-	node_append(mdoc, n);
-	mdoc->next = ROFF_NEXT_SIBLING;
-}
-
-/*
  * Main parse routine.  Parses a single line -- really just hands off to
  * the macro (mdoc_pmacro()) or text parser (mdoc_ptext()).
  */
@@ -244,15 +111,15 @@ mdoc_parseln(struct roff_man *mdoc, int ln, char *buf,
 	else
 		mdoc->flags &= ~MDOC_SYNOPSIS;
 
-	return(roff_getcontrol(mdoc->roff, buf, &offs) ?
+	return roff_getcontrol(mdoc->roff, buf, &offs) ?
 	    mdoc_pmacro(mdoc, ln, buf, offs) :
-	    mdoc_ptext(mdoc, ln, buf, offs));
+	    mdoc_ptext(mdoc, ln, buf, offs);
 }
 
 void
 mdoc_macro(MACRO_PROT_ARGS)
 {
-	assert(tok < MDOC_MAX);
+	assert(tok > TOKEN_NONE && tok < MDOC_MAX);
 
 	if (mdoc->flags & MDOC_PBODY) {
 		if (tok == MDOC_Dt) {
@@ -275,146 +142,17 @@ mdoc_macro(MACRO_PROT_ARGS)
 	(*mdoc_macros[tok].fp)(mdoc, tok, line, ppos, pos, buf);
 }
 
-
-static void
-node_append(struct roff_man *mdoc, struct roff_node *p)
-{
-
-	assert(mdoc->last);
-	assert(mdoc->first);
-	assert(p->type != ROFFT_ROOT);
-
-	switch (mdoc->next) {
-	case ROFF_NEXT_SIBLING:
-		mdoc->last->next = p;
-		p->prev = mdoc->last;
-		p->parent = mdoc->last->parent;
-		break;
-	case ROFF_NEXT_CHILD:
-		mdoc->last->child = p;
-		p->parent = mdoc->last;
-		break;
-	default:
-		abort();
-		/* NOTREACHED */
-	}
-
-	p->parent->nchild++;
-
-	/*
-	 * Copy over the normalised-data pointer of our parent.  Not
-	 * everybody has one, but copying a null pointer is fine.
-	 */
-
-	switch (p->type) {
-	case ROFFT_BODY:
-		if (ENDBODY_NOT != p->end)
-			break;
-		/* FALLTHROUGH */
-	case ROFFT_TAIL:
-		/* FALLTHROUGH */
-	case ROFFT_HEAD:
-		p->norm = p->parent->norm;
-		break;
-	default:
-		break;
-	}
-
-	mdoc_valid_pre(mdoc, p);
-
-	switch (p->type) {
-	case ROFFT_HEAD:
-		assert(p->parent->type == ROFFT_BLOCK);
-		p->parent->head = p;
-		break;
-	case ROFFT_TAIL:
-		assert(p->parent->type == ROFFT_BLOCK);
-		p->parent->tail = p;
-		break;
-	case ROFFT_BODY:
-		if (p->end)
-			break;
-		assert(p->parent->type == ROFFT_BLOCK);
-		p->parent->body = p;
-		break;
-	default:
-		break;
-	}
-
-	mdoc->last = p;
-
-	switch (p->type) {
-	case ROFFT_TBL:
-		/* FALLTHROUGH */
-	case ROFFT_TEXT:
-		mdoc_valid_post(mdoc);
-		break;
-	default:
-		break;
-	}
-}
-
-static struct roff_node *
-node_alloc(struct roff_man *mdoc, int line, int pos,
-	int tok, enum roff_type type)
-{
-	struct roff_node *p;
-
-	p = mandoc_calloc(1, sizeof(*p));
-	p->sec = mdoc->lastsec;
-	p->line = line;
-	p->pos = pos;
-	p->tok = tok;
-	p->type = type;
-
-	/* Flag analysis. */
-
-	if (MDOC_SYNOPSIS & mdoc->flags)
-		p->flags |= MDOC_SYNPRETTY;
-	else
-		p->flags &= ~MDOC_SYNPRETTY;
-	if (MDOC_NEWLINE & mdoc->flags)
-		p->flags |= MDOC_LINE;
-	mdoc->flags &= ~MDOC_NEWLINE;
-
-	return(p);
-}
-
 void
 mdoc_tail_alloc(struct roff_man *mdoc, int line, int pos, int tok)
 {
 	struct roff_node *p;
 
-	p = node_alloc(mdoc, line, pos, tok, ROFFT_TAIL);
-	node_append(mdoc, p);
+	p = roff_node_alloc(mdoc, line, pos, ROFFT_TAIL, tok);
+	roff_node_append(mdoc, p);
 	mdoc->next = ROFF_NEXT_CHILD;
 }
 
 struct roff_node *
-mdoc_head_alloc(struct roff_man *mdoc, int line, int pos, int tok)
-{
-	struct roff_node *p;
-
-	assert(mdoc->first);
-	assert(mdoc->last);
-	p = node_alloc(mdoc, line, pos, tok, ROFFT_HEAD);
-	node_append(mdoc, p);
-	mdoc->next = ROFF_NEXT_CHILD;
-	return(p);
-}
-
-struct roff_node *
-mdoc_body_alloc(struct roff_man *mdoc, int line, int pos, int tok)
-{
-	struct roff_node *p;
-
-	p = node_alloc(mdoc, line, pos, tok, ROFFT_BODY);
-	node_append(mdoc, p);
-	mdoc->next = ROFF_NEXT_CHILD;
-	return(p);
-}
-
-struct roff_node *
 mdoc_endbody_alloc(struct roff_man *mdoc, int line, int pos, int tok,
 		struct roff_node *body, enum mdoc_endbody end)
 {
@@ -422,13 +160,13 @@ mdoc_endbody_alloc(struct roff_man *mdoc, int line, in
 
 	body->flags |= MDOC_ENDED;
 	body->parent->flags |= MDOC_ENDED;
-	p = node_alloc(mdoc, line, pos, tok, ROFFT_BODY);
+	p = roff_node_alloc(mdoc, line, pos, ROFFT_BODY, tok);
 	p->body = body;
 	p->norm = body->norm;
 	p->end = end;
-	node_append(mdoc, p);
+	roff_node_append(mdoc, p);
 	mdoc->next = ROFF_NEXT_SIBLING;
-	return(p);
+	return p;
 }
 
 struct roff_node *
@@ -437,29 +175,25 @@ mdoc_block_alloc(struct roff_man *mdoc, int line, int 
 {
 	struct roff_node *p;
 
-	p = node_alloc(mdoc, line, pos, tok, ROFFT_BLOCK);
+	p = roff_node_alloc(mdoc, line, pos, ROFFT_BLOCK, tok);
 	p->args = args;
 	if (p->args)
 		(args->refcnt)++;
 
 	switch (tok) {
 	case MDOC_Bd:
-		/* FALLTHROUGH */
 	case MDOC_Bf:
-		/* FALLTHROUGH */
 	case MDOC_Bl:
-		/* FALLTHROUGH */
 	case MDOC_En:
-		/* FALLTHROUGH */
 	case MDOC_Rs:
 		p->norm = mandoc_calloc(1, sizeof(union mdoc_data));
 		break;
 	default:
 		break;
 	}
-	node_append(mdoc, p);
+	roff_node_append(mdoc, p);
 	mdoc->next = ROFF_NEXT_CHILD;
-	return(p);
+	return p;
 }
 
 void
@@ -468,7 +202,7 @@ mdoc_elem_alloc(struct roff_man *mdoc, int line, int p
 {
 	struct roff_node *p;
 
-	p = node_alloc(mdoc, line, pos, tok, ROFFT_ELEM);
+	p = roff_node_alloc(mdoc, line, pos, ROFFT_ELEM, tok);
 	p->args = args;
 	if (p->args)
 		(args->refcnt)++;
@@ -480,106 +214,16 @@ mdoc_elem_alloc(struct roff_man *mdoc, int line, int p
 	default:
 		break;
 	}
-	node_append(mdoc, p);
+	roff_node_append(mdoc, p);
 	mdoc->next = ROFF_NEXT_CHILD;
 }
 
 void
-mdoc_word_alloc(struct roff_man *mdoc, int line, int pos, const char *p)
-{
-	struct roff_node *n;
-
-	n = node_alloc(mdoc, line, pos, MDOC_MAX, ROFFT_TEXT);
-	n->string = roff_strdup(mdoc->roff, p);
-	node_append(mdoc, n);
-	mdoc->next = ROFF_NEXT_SIBLING;
-}
-
-void
-mdoc_word_append(struct roff_man *mdoc, const char *p)
-{
-	struct roff_node	*n;
-	char			*addstr, *newstr;
-
-	n = mdoc->last;
-	addstr = roff_strdup(mdoc->roff, p);
-	mandoc_asprintf(&newstr, "%s %s", n->string, addstr);
-	free(addstr);
-	free(n->string);
-	n->string = newstr;
-	mdoc->next = ROFF_NEXT_SIBLING;
-}
-
-static void
-mdoc_node_free(struct roff_node *p)
-{
-
-	if (p->type == ROFFT_BLOCK || p->type == ROFFT_ELEM)
-		free(p->norm);
-	if (p->string)
-		free(p->string);
-	if (p->args)
-		mdoc_argv_free(p->args);
-	free(p);
-}
-
-static void
-mdoc_node_unlink(struct roff_man *mdoc, struct roff_node *n)
-{
-
-	/* Adjust siblings. */
-
-	if (n->prev)
-		n->prev->next = n->next;
-	if (n->next)
-		n->next->prev = n->prev;
-
-	/* Adjust parent. */
-
-	if (n->parent) {
-		n->parent->nchild--;
-		if (n->parent->child == n)
-			n->parent->child = n->prev ? n->prev : n->next;
-		if (n->parent->last == n)
-			n->parent->last = n->prev ? n->prev : NULL;
-	}
-
-	/* Adjust parse point, if applicable. */
-
-	if (mdoc && mdoc->last == n) {
-		if (n->prev) {
-			mdoc->last = n->prev;
-			mdoc->next = ROFF_NEXT_SIBLING;
-		} else {
-			mdoc->last = n->parent;
-			mdoc->next = ROFF_NEXT_CHILD;
-		}
-	}
-
-	if (mdoc && mdoc->first == n)
-		mdoc->first = NULL;
-}
-
-void
-mdoc_node_delete(struct roff_man *mdoc, struct roff_node *p)
-{
-
-	while (p->child) {
-		assert(p->nchild);
-		mdoc_node_delete(mdoc, p->child);
-	}
-	assert(0 == p->nchild);
-
-	mdoc_node_unlink(mdoc, p);
-	mdoc_node_free(p);
-}
-
-void
 mdoc_node_relink(struct roff_man *mdoc, struct roff_node *p)
 {
 
-	mdoc_node_unlink(mdoc, p);
-	node_append(mdoc, p);
+	roff_node_unlink(mdoc, p);
+	roff_node_append(mdoc, p);
 }
 
 /*
@@ -607,7 +251,7 @@ mdoc_ptext(struct roff_man *mdoc, int line, char *buf,
 		/* `Bl' is open without any children. */
 		mdoc->flags |= MDOC_FREECOL;
 		mdoc_macro(mdoc, MDOC_It, line, offs, &offs, buf);
-		return(1);
+		return 1;
 	}
 
 	if (n->tok == MDOC_It && n->type == ROFFT_BLOCK &&
@@ -617,7 +261,7 @@ mdoc_ptext(struct roff_man *mdoc, int line, char *buf,
 		/* `Bl' has block-level `It' children. */
 		mdoc->flags |= MDOC_FREECOL;
 		mdoc_macro(mdoc, MDOC_It, line, offs, &offs, buf);
-		return(1);
+		return 1;
 	}
 
 	/*
@@ -674,16 +318,16 @@ mdoc_ptext(struct roff_man *mdoc, int line, char *buf,
 		 * blank lines aren't allowed, but enough manuals assume this
 		 * behaviour that we want to work around it.
 		 */
-		mdoc_elem_alloc(mdoc, line, offs, MDOC_sp, NULL);
+		roff_elem_alloc(mdoc, line, offs, MDOC_sp);
 		mdoc->next = ROFF_NEXT_SIBLING;
 		mdoc_valid_post(mdoc);
-		return(1);
+		return 1;
 	}
 
-	mdoc_word_alloc(mdoc, line, offs, buf+offs);
+	roff_word_alloc(mdoc, line, offs, buf+offs);
 
 	if (mdoc->flags & MDOC_LITERAL)
-		return(1);
+		return 1;
 
 	/*
 	 * End-of-sentence check.  If the last character is an unescaped
@@ -695,7 +339,7 @@ mdoc_ptext(struct roff_man *mdoc, int line, char *buf,
 
 	if (mandoc_eos(buf+offs, (size_t)(end-buf-offs)))
 		mdoc->last->flags |= MDOC_EOS;
-	return(1);
+	return 1;
 }
 
 /*
@@ -724,12 +368,12 @@ mdoc_pmacro(struct roff_man *mdoc, int ln, char *buf, 
 
 	mac[i] = '\0';
 
-	tok = (i > 1 && i < 4) ? mdoc_hash_find(mac) : MDOC_MAX;
+	tok = (i > 1 && i < 4) ? mdoc_hash_find(mac) : TOKEN_NONE;
 
-	if (tok == MDOC_MAX) {
+	if (tok == TOKEN_NONE) {
 		mandoc_msg(MANDOCERR_MACRO, mdoc->parse,
 		    ln, sv, buf + sv - 1);
-		return(1);
+		return 1;
 	}
 
 	/* Skip a leading escape sequence or tab. */
@@ -768,7 +412,7 @@ mdoc_pmacro(struct roff_man *mdoc, int ln, char *buf, 
 
 	if (NULL == mdoc->last || MDOC_It == tok || MDOC_El == tok) {
 		mdoc_macro(mdoc, tok, ln, sv, &offs, buf);
-		return(1);
+		return 1;
 	}
 
 	n = mdoc->last;
@@ -783,7 +427,7 @@ mdoc_pmacro(struct roff_man *mdoc, int ln, char *buf, 
 	    n->end == ENDBODY_NOT && n->norm->Bl.type == LIST_column) {
 		mdoc->flags |= MDOC_FREECOL;
 		mdoc_macro(mdoc, MDOC_It, ln, sv, &sv, buf);
-		return(1);
+		return 1;
 	}
 
 	/*
@@ -798,7 +442,7 @@ mdoc_pmacro(struct roff_man *mdoc, int ln, char *buf, 
 	    LIST_column == n->parent->norm->Bl.type) {
 		mdoc->flags |= MDOC_FREECOL;
 		mdoc_macro(mdoc, MDOC_It, ln, sv, &sv, buf);
-		return(1);
+		return 1;
 	}
 
 	/* Normal processing of a macro. */
@@ -809,9 +453,9 @@ mdoc_pmacro(struct roff_man *mdoc, int ln, char *buf, 
 
 	if (mdoc->quick && MDOC_Sh == tok &&
 	    SEC_NAME != mdoc->last->sec)
-		return(2);
+		return 2;
 
-	return(1);
+	return 1;
 }
 
 enum mdelim
@@ -819,82 +463,35 @@ mdoc_isdelim(const char *p)
 {
 
 	if ('\0' == p[0])
-		return(DELIM_NONE);
+		return DELIM_NONE;
 
 	if ('\0' == p[1])
 		switch (p[0]) {
 		case '(':
-			/* FALLTHROUGH */
 		case '[':
-			return(DELIM_OPEN);
+			return DELIM_OPEN;
 		case '|':
-			return(DELIM_MIDDLE);
+			return DELIM_MIDDLE;
 		case '.':
-			/* FALLTHROUGH */
 		case ',':
-			/* FALLTHROUGH */
 		case ';':
-			/* FALLTHROUGH */
 		case ':':
-			/* FALLTHROUGH */
 		case '?':
-			/* FALLTHROUGH */
 		case '!':
-			/* FALLTHROUGH */
 		case ')':
-			/* FALLTHROUGH */
 		case ']':
-			return(DELIM_CLOSE);
+			return DELIM_CLOSE;
 		default:
-			return(DELIM_NONE);
+			return DELIM_NONE;
 		}
 
 	if ('\\' != p[0])
-		return(DELIM_NONE);
+		return DELIM_NONE;
 
 	if (0 == strcmp(p + 1, "."))
-		return(DELIM_CLOSE);
+		return DELIM_CLOSE;
 	if (0 == strcmp(p + 1, "fR|\\fP"))
-		return(DELIM_MIDDLE);
+		return DELIM_MIDDLE;
 
-	return(DELIM_NONE);
-}
-
-void
-mdoc_deroff(char **dest, const struct roff_node *n)
-{
-	char	*cp;
-	size_t	 sz;
-
-	if (n->type != ROFFT_TEXT) {
-		for (n = n->child; n; n = n->next)
-			mdoc_deroff(dest, n);
-		return;
-	}
-
-	/* Skip leading whitespace. */
-
-	for (cp = n->string; '\0' != *cp; cp++)
-		if (0 == isspace((unsigned char)*cp))
-			break;
-
-	/* Skip trailing whitespace. */
-
-	for (sz = strlen(cp); sz; sz--)
-		if (0 == isspace((unsigned char)cp[sz-1]))
-			break;
-
-	/* Skip empty strings. */
-
-	if (0 == sz)
-		return;
-
-	if (NULL == *dest) {
-		*dest = mandoc_strndup(cp, sz);
-		return;
-	}
-
-	mandoc_asprintf(&cp, "%s %*s", *dest, (int)sz, cp);
-	free(*dest);
-	*dest = cp;
+	return DELIM_NONE;
 }