===================================================================
RCS file: /cvs/docbook2mdoc/parse.c,v
retrieving revision 1.29
retrieving revision 1.30
diff -u -p -r1.29 -r1.30
--- docbook2mdoc/parse.c	2019/04/09 15:23:51	1.29
+++ docbook2mdoc/parse.c	2019/04/10 14:22:37	1.30
@@ -1,4 +1,4 @@
-/* $Id: parse.c,v 1.29 2019/04/09 15:23:51 schwarze Exp $ */
+/* $Id: parse.c,v 1.30 2019/04/10 14:22:37 schwarze Exp $ */
 /*
  * Copyright (c) 2014 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2019 Ingo Schwarze <schwarze@openbsd.org>
@@ -322,47 +322,47 @@ warn_msg(struct parse *p, const char *fmt, ...)
  * Otherwise, create a new one as a child of the current node.
  */
 static void
-xml_char(struct parse *ps, const char *p, int sz)
+xml_char(struct parse *p, const char *word, int sz)
 {
-	struct pnode	*dat;
+	struct pnode	*n;
 	size_t		 newsz;
 
-	if (ps->del > 0)
+	if (p->del > 0)
 		return;
 
-	if (ps->cur == NULL) {
-		error_msg(ps, "discarding text before document: %.*s", sz, p);
+	if (p->cur == NULL) {
+		error_msg(p, "discarding text before document: %.*s", sz, word);
 		return;
 	}
 
-	if (ps->cur->node != NODE_TEXT) {
-		if ((dat = calloc(1, sizeof(*dat))) == NULL)
-			fatal(ps);
-		dat->node = NODE_TEXT;
-		dat->spc = (ps->flags & PFLAG_SPC) != 0;
-		dat->parent = ps->cur;
-		TAILQ_INIT(&dat->childq);
-		TAILQ_INIT(&dat->attrq);
-		TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);
-		ps->cur = dat;
+	if (p->cur->node != NODE_TEXT) {
+		if ((n = calloc(1, sizeof(*n))) == NULL)
+			fatal(p);
+		n->node = NODE_TEXT;
+		n->spc = (p->flags & PFLAG_SPC) != 0;
+		n->parent = p->cur;
+		TAILQ_INIT(&n->childq);
+		TAILQ_INIT(&n->attrq);
+		TAILQ_INSERT_TAIL(&p->cur->childq, n, child);
+		p->cur = n;
 	}
 
-	if (ps->tree->flags & TREE_CLOSED &&
-	    ps->cur->parent == ps->tree->root)
-		warn_msg(ps, "text after end of document: %.*s", sz, p);
+	if (p->tree->flags & TREE_CLOSED &&
+	    p->cur->parent == p->tree->root)
+		warn_msg(p, "text after end of document: %.*s", sz, word);
 
 	/* Append to the current text node. */
 
 	assert(sz >= 0);
-	newsz = ps->cur->bsz + (ps->cur->bsz && (ps->flags & PFLAG_SPC)) + sz;
-	if ((ps->cur->b = realloc(ps->cur->b, newsz + 1)) == NULL)
-		fatal(ps);
-	if (ps->cur->bsz && (ps->flags & PFLAG_SPC))
-		ps->cur->b[ps->cur->bsz++] = ' ';
-	memcpy(ps->cur->b + ps->cur->bsz, p, sz);
-	ps->cur->b[ps->cur->bsz = newsz] = '\0';
-	ps->cur->real = ps->cur->b;
-	ps->flags &= ~PFLAG_SPC;
+	newsz = p->cur->bsz + (p->cur->bsz && (p->flags & PFLAG_SPC)) + sz;
+	if ((p->cur->b = realloc(p->cur->b, newsz + 1)) == NULL)
+		fatal(p);
+	if (p->cur->bsz && (p->flags & PFLAG_SPC))
+		p->cur->b[p->cur->bsz++] = ' ';
+	memcpy(p->cur->b + p->cur->bsz, word, sz);
+	p->cur->b[p->cur->bsz = newsz] = '\0';
+	p->cur->real = p->cur->b;
+	p->flags &= ~PFLAG_SPC;
 }
 
 /*
@@ -386,7 +386,7 @@ static void
 xml_entity(struct parse *p, const char *name)
 {
 	const struct entity	*entity;
-	struct pnode		*dat;
+	struct pnode		*n;
 	const char		*ccp;
 	char			*cp;
 	enum pstate		 pstate;
@@ -410,18 +410,18 @@ xml_entity(struct parse *p, const char *name)
 
 	if (entity->roff == NULL) {
 		if (p->doctype != NULL) {
-			TAILQ_FOREACH(dat, &p->doctype->childq, child) {
-				if ((ccp = pnode_getattr_raw(dat,
+			TAILQ_FOREACH(n, &p->doctype->childq, child) {
+				if ((ccp = pnode_getattr_raw(n,
 				     ATTRKEY_NAME, NULL)) == NULL ||
 				    strcmp(ccp, name) != 0)
 					continue;
-				if ((ccp = pnode_getattr_raw(dat,
+				if ((ccp = pnode_getattr_raw(n,
 				    ATTRKEY_SYSTEM, NULL)) != NULL) {
 					parse_file(p, -1, ccp);
 					p->flags &= ~PFLAG_SPC;
 					return;
 				}
-				if ((ccp = pnode_getattr_raw(dat,
+				if ((ccp = pnode_getattr_raw(n,
 				     ATTRKEY_DEFINITION, NULL)) == NULL)
 					continue;
 				if ((cp = strdup(ccp)) == NULL)
@@ -438,16 +438,16 @@ xml_entity(struct parse *p, const char *name)
 	}
 
 	/* Create, append, and close out an entity node. */
-	if ((dat = calloc(1, sizeof(*dat))) == NULL ||
-	    (dat->b = dat->real = strdup(entity->roff)) == NULL)
+	if ((n = calloc(1, sizeof(*n))) == NULL ||
+	    (n->b = n->real = strdup(entity->roff)) == NULL)
 		fatal(p);
-	dat->node = NODE_ESCAPE;
-	dat->bsz = strlen(dat->b);
-	dat->spc = (p->flags & PFLAG_SPC) != 0;
-	dat->parent = p->cur;
-	TAILQ_INIT(&dat->childq);
-	TAILQ_INIT(&dat->attrq);
-	TAILQ_INSERT_TAIL(&p->cur->childq, dat, child);
+	n->node = NODE_ESCAPE;
+	n->bsz = strlen(n->b);
+	n->spc = (p->flags & PFLAG_SPC) != 0;
+	n->parent = p->cur;
+	TAILQ_INIT(&n->childq);
+	TAILQ_INIT(&n->attrq);
+	TAILQ_INSERT_TAIL(&p->cur->childq, n, child);
 	p->flags &= ~PFLAG_SPC;
 }
 
@@ -455,22 +455,22 @@ xml_entity(struct parse *p, const char *name)
  * Begin an element.
  */
 static void
-xml_elem_start(struct parse *ps, const char *name)
+xml_elem_start(struct parse *p, const char *name)
 {
 	const struct element	*elem;
-	struct pnode		*dat;
+	struct pnode		*n;
 
 	/*
 	 * An ancestor is excluded from the tree;
 	 * keep track of the number of levels excluded.
 	 */
-	if (ps->del > 0) {
+	if (p->del > 0) {
 		if (*name != '!' && *name != '?')
-			ps->del++;
+			p->del++;
 		return;
 	}
 
-	pnode_closetext(ps);
+	pnode_closetext(p);
 
 	for (elem = elements; elem->name != NULL; elem++)
 		if (strcmp(elem->name, name) == 0)
@@ -479,43 +479,43 @@ xml_elem_start(struct parse *ps, const char *name)
 	if (elem->name == NULL) {
 		if (*name == '!' || *name == '?')
 			return;
-		error_msg(ps, "unknown element <%s>", name);
+		error_msg(p, "unknown element <%s>", name);
 	}
 
-	ps->ncur = elem->node;
+	p->ncur = elem->node;
 
-	switch (ps->ncur) {
+	switch (p->ncur) {
 	case NODE_DELETE_WARN:
-		warn_msg(ps, "skipping element <%s>", name);
+		warn_msg(p, "skipping element <%s>", name);
 		/* FALLTHROUGH */
 	case NODE_DELETE:
-		ps->del = 1;
+		p->del = 1;
 		/* FALLTHROUGH */
 	case NODE_IGNORE:
 		return;
 	case NODE_INLINEEQUATION:
-		ps->tree->flags |= TREE_EQN;
+		p->tree->flags |= TREE_EQN;
 		break;
 	default:
 		break;
 	}
 
-	if (ps->tree->flags & TREE_CLOSED && ps->cur->parent == NULL)
-		warn_msg(ps, "element after end of document: <%s>", name);
+	if (p->tree->flags & TREE_CLOSED && p->cur->parent == NULL)
+		warn_msg(p, "element after end of document: <%s>", name);
 
-	if ((dat = calloc(1, sizeof(*dat))) == NULL)
-		fatal(ps);
+	if ((n = calloc(1, sizeof(*n))) == NULL)
+		fatal(p);
 
 	/*
 	 * Nodes that begin a new macro or request line or start by
 	 * printing text always want whitespace before themselves.
 	 */
 
-	switch (dat->node = elem->node) {
+	switch (n->node = elem->node) {
 	case NODE_DOCTYPE:
 	case NODE_ENTITY:
 	case NODE_SBR:
-		ps->flags |= PFLAG_EEND;
+		p->flags |= PFLAG_EEND;
 		/* FALLTHROUGH */
 	case NODE_APPENDIX:
 	case NODE_AUTHORGROUP:
@@ -549,82 +549,82 @@ xml_elem_start(struct parse *ps, const char *name)
 	case NODE_VARIABLELIST:
 	case NODE_VARLISTENTRY:
 	case NODE_WARNING:
-		dat->spc = 1;
+		n->spc = 1;
 		break;
 	default:
-		dat->spc = (ps->flags & PFLAG_SPC) != 0;
+		n->spc = (p->flags & PFLAG_SPC) != 0;
 		break;
 	}
-	dat->parent = ps->cur;
-	TAILQ_INIT(&dat->childq);
-	TAILQ_INIT(&dat->attrq);
+	n->parent = p->cur;
+	TAILQ_INIT(&n->childq);
+	TAILQ_INIT(&n->attrq);
 
-	if (ps->cur != NULL)
-		TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);
+	if (p->cur != NULL)
+		TAILQ_INSERT_TAIL(&p->cur->childq, n, child);
 
-	ps->cur = dat;
-	if (dat->node == NODE_DOCTYPE) {
-		if (ps->doctype == NULL)
-			ps->doctype = dat;
+	p->cur = n;
+	if (n->node == NODE_DOCTYPE) {
+		if (p->doctype == NULL)
+			p->doctype = n;
 		else
-			error_msg(ps, "duplicate doctype");
-	} else if (dat->parent == NULL && ps->tree->root == NULL)
-		ps->tree->root = dat;
+			error_msg(p, "duplicate doctype");
+	} else if (n->parent == NULL && p->tree->root == NULL)
+		p->tree->root = n;
 }
 
 static void
-xml_attrkey(struct parse *ps, const char *name)
+xml_attrkey(struct parse *p, const char *name)
 {
-	struct pattr	*attr;
+	struct pattr	*a;
 	const char	*value;
 	enum attrkey	 key;
 
-	if (ps->del > 0 || ps->ncur == NODE_IGNORE || *name == '\0')
+	if (p->del > 0 || p->ncur == NODE_IGNORE || *name == '\0')
 		return;
 
-	if ((ps->ncur == NODE_DOCTYPE || ps->ncur == NODE_ENTITY) &&
-	    TAILQ_FIRST(&ps->cur->attrq) == NULL) {
+	if ((p->ncur == NODE_DOCTYPE || p->ncur == NODE_ENTITY) &&
+	    TAILQ_FIRST(&p->cur->attrq) == NULL) {
 		value = name;
 		name = "NAME";
 	} else
 		value = NULL;
 
 	if ((key = attrkey_parse(name)) == ATTRKEY__MAX) {
-		ps->flags &= ~PFLAG_ATTR;
+		p->flags &= ~PFLAG_ATTR;
 		return;
 	}
-	if ((attr = calloc(1, sizeof(*attr))) == NULL)
-		fatal(ps);
+	if ((a = calloc(1, sizeof(*a))) == NULL)
+		fatal(p);
 
-	attr->key = key;
-	attr->val = ATTRVAL__MAX;
+	a->key = key;
+	a->val = ATTRVAL__MAX;
 	if (value == NULL) {
-		attr->rawval = NULL;
-		ps->flags |= PFLAG_ATTR;
+		a->rawval = NULL;
+		p->flags |= PFLAG_ATTR;
 	} else {
-		if ((attr->rawval = strdup(value)) == NULL)
-			fatal(ps);
-		ps->flags &= ~PFLAG_ATTR;
+		if ((a->rawval = strdup(value)) == NULL)
+			fatal(p);
+		p->flags &= ~PFLAG_ATTR;
 	}
-	TAILQ_INSERT_TAIL(&ps->cur->attrq, attr, child);
-	if (ps->ncur == NODE_ENTITY && key == ATTRKEY_NAME)
-		xml_attrkey(ps, "DEFINITION");
+	TAILQ_INSERT_TAIL(&p->cur->attrq, a, child);
+	if (p->ncur == NODE_ENTITY && key == ATTRKEY_NAME)
+		xml_attrkey(p, "DEFINITION");
 }
 
 static void
-xml_attrval(struct parse *ps, const char *name)
+xml_attrval(struct parse *p, const char *name)
 {
-	struct pattr	*attr;
+	struct pattr	*a;
 
-	if (ps->del > 0 || ps->ncur == NODE_IGNORE ||
-	    (ps->flags & PFLAG_ATTR) == 0)
+	if (p->del > 0 || p->ncur == NODE_IGNORE ||
+	    (p->flags & PFLAG_ATTR) == 0)
 		return;
-	if ((attr = TAILQ_LAST(&ps->cur->attrq, pattrq)) == NULL)
+	if ((a = TAILQ_LAST(&p->cur->attrq, pattrq)) == NULL)
 		return;
-	if ((attr->val = attrval_parse(name)) == ATTRVAL__MAX &&
-	    (attr->rawval = strdup(name)) == NULL)
-		fatal(ps);
-	ps->flags &= ~PFLAG_ATTR;
+	if ((a->val = attrval_parse(name)) == ATTRVAL__MAX &&
+	    (a->rawval = strdup(name)) == NULL)
+		fatal(p);
+	p->flags &= ~PFLAG_ATTR;
 }
 
 /*