* docbook2mdoc: Consitently use for function arguments: struct parse *p,
@ 2019-04-10 14:23 schwarze
0 siblings, 0 replies; only message in thread
From: schwarze @ 2019-04-10 14:23 UTC (permalink / raw)
To: source
Log Message:
-----------
Consitently use for function arguments:
struct parse *p, struct format *f, struct pnode *n, struct pattr *a
Consistently use struct pnode *nc, *nn, *np
for child, next, and previous nodes, respectively.
I admit this makes commit history a bit harder to inspect,
but i think seeing at once what variables mean is worth it.
Modified Files:
--------------
docbook2mdoc:
docbook2mdoc.c
macro.c
node.c
parse.c
Revision Data
-------------
Index: node.c
===================================================================
RCS file: /home/cvs/mdocml/docbook2mdoc/node.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -Lnode.c -Lnode.c -u -p -r1.6 -r1.7
--- node.c
+++ node.c
@@ -78,48 +78,48 @@ attrval_parse(const char *name)
* Recursively free a node (NULL is ok).
*/
static void
-pnode_free(struct pnode *pn)
+pnode_free(struct pnode *n)
{
- struct pnode *pch;
- struct pattr *ap;
+ struct pnode *nc;
+ struct pattr *a;
- if (pn == NULL)
+ if (n == NULL)
return;
- while ((pch = TAILQ_FIRST(&pn->childq)) != NULL) {
- TAILQ_REMOVE(&pn->childq, pch, child);
- pnode_free(pch);
+ while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {
+ TAILQ_REMOVE(&n->childq, nc, child);
+ pnode_free(nc);
}
- while ((ap = TAILQ_FIRST(&pn->attrq)) != NULL) {
- TAILQ_REMOVE(&pn->attrq, ap, child);
- free(ap->rawval);
- free(ap);
+ while ((a = TAILQ_FIRST(&n->attrq)) != NULL) {
+ TAILQ_REMOVE(&n->attrq, a, child);
+ free(a->rawval);
+ free(a);
}
- free(pn->real);
- free(pn);
+ free(n->real);
+ free(n);
}
/*
* Unlink a node from its parent and pnode_free() it.
*/
void
-pnode_unlink(struct pnode *pn)
+pnode_unlink(struct pnode *n)
{
- if (pn == NULL)
+ if (n == NULL)
return;
- if (pn->parent != NULL)
- TAILQ_REMOVE(&pn->parent->childq, pn, child);
- pnode_free(pn);
+ if (n->parent != NULL)
+ TAILQ_REMOVE(&n->parent->childq, n, child);
+ pnode_free(n);
}
/*
* Unlink all children of a node and pnode_free() them.
*/
void
-pnode_unlinksub(struct pnode *pn)
+pnode_unlinksub(struct pnode *n)
{
- while (TAILQ_EMPTY(&pn->childq) == 0)
- pnode_unlink(TAILQ_FIRST(&pn->childq));
+ while (TAILQ_EMPTY(&n->childq) == 0)
+ pnode_unlink(TAILQ_FIRST(&n->childq));
}
/*
@@ -127,15 +127,15 @@ pnode_unlinksub(struct pnode *pn)
* Return ATTRVAL__MAX if the node has no such attribute.
*/
enum attrval
-pnode_getattr(struct pnode *pn, enum attrkey key)
+pnode_getattr(struct pnode *n, enum attrkey key)
{
- struct pattr *ap;
+ struct pattr *a;
- if (pn == NULL)
+ if (n == NULL)
return ATTRVAL__MAX;
- TAILQ_FOREACH(ap, &pn->attrq, child)
- if (ap->key == key)
- return ap->val;
+ TAILQ_FOREACH(a, &n->attrq, child)
+ if (a->key == key)
+ return a->val;
return ATTRVAL__MAX;
}
@@ -144,16 +144,16 @@ pnode_getattr(struct pnode *pn, enum att
* Return defval if the node has no such attribute.
*/
const char *
-pnode_getattr_raw(struct pnode *pn, enum attrkey key, const char *defval)
+pnode_getattr_raw(struct pnode *n, enum attrkey key, const char *defval)
{
- struct pattr *ap;
+ struct pattr *a;
- if (pn == NULL)
+ if (n == NULL)
return defval;
- TAILQ_FOREACH(ap, &pn->attrq, child)
- if (ap->key == key)
- return ap->val != ATTRVAL__MAX ? attrvals[ap->val] :
- ap->rawval != NULL ? ap->rawval : defval;
+ TAILQ_FOREACH(a, &n->attrq, child)
+ if (a->key == key)
+ return a->val != ATTRVAL__MAX ? attrvals[a->val] :
+ a->rawval != NULL ? a->rawval : defval;
return defval;
}
@@ -161,14 +161,14 @@ pnode_getattr_raw(struct pnode *pn, enum
* Recursively search and return the first instance of "node".
*/
struct pnode *
-pnode_findfirst(struct pnode *pn, enum nodeid node)
+pnode_findfirst(struct pnode *n, enum nodeid node)
{
- struct pnode *pch, *res;
+ struct pnode *nc, *res;
- if (pn->node == node)
- return pn;
- TAILQ_FOREACH(pch, &pn->childq, child)
- if ((res = pnode_findfirst(pch, node)) != NULL)
+ if (n->node == node)
+ return n;
+ TAILQ_FOREACH(nc, &n->childq, child)
+ if ((res = pnode_findfirst(nc, node)) != NULL)
return res;
return NULL;
}
Index: parse.c
===================================================================
RCS file: /home/cvs/mdocml/docbook2mdoc/parse.c,v
retrieving revision 1.29
retrieving revision 1.30
diff -Lparse.c -Lparse.c -u -p -r1.29 -r1.30
--- parse.c
+++ parse.c
@@ -322,47 +322,47 @@ warn_msg(struct parse *p, const char *fm
* 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 *
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 *
}
/* 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 *
* 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 c
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 c
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);
-
- if (ps->cur != NULL)
- TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);
-
- ps->cur = dat;
- if (dat->node == NODE_DOCTYPE) {
- if (ps->doctype == NULL)
- ps->doctype = dat;
+ n->parent = p->cur;
+ TAILQ_INIT(&n->childq);
+ TAILQ_INIT(&n->attrq);
+
+ if (p->cur != NULL)
+ TAILQ_INSERT_TAIL(&p->cur->childq, n, child);
+
+ 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;
- }
- TAILQ_INSERT_TAIL(&ps->cur->attrq, attr, child);
- if (ps->ncur == NODE_ENTITY && key == ATTRKEY_NAME)
- xml_attrkey(ps, "DEFINITION");
+ if ((a->rawval = strdup(value)) == NULL)
+ fatal(p);
+ p->flags &= ~PFLAG_ATTR;
+ }
+ 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;
}
/*
Index: docbook2mdoc.c
===================================================================
RCS file: /home/cvs/mdocml/docbook2mdoc/docbook2mdoc.c,v
retrieving revision 1.100
retrieving revision 1.101
diff -Ldocbook2mdoc.c -Ldocbook2mdoc.c -u -p -r1.100 -r1.101
--- docbook2mdoc.c
+++ docbook2mdoc.c
@@ -99,17 +99,17 @@ pnode_printtext(struct format *f, struct
}
static void
-pnode_printpara(struct format *p, struct pnode *pn)
+pnode_printpara(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *np;
- if (pn->parent == NULL)
+ if (n->parent == NULL)
return;
- if ((pp = TAILQ_PREV(pn, pnodeq, child)) == NULL)
- pp = pn->parent;
+ if ((np = TAILQ_PREV(n, pnodeq, child)) == NULL)
+ np = n->parent;
- switch (pp->node) {
+ switch (np->node) {
case NODE_ENTRY:
case NODE_GLOSSTERM:
case NODE_LISTITEM:
@@ -119,49 +119,49 @@ pnode_printpara(struct format *p, struct
case NODE_LEGALNOTICE:
case NODE_PREFACE:
case NODE_SECTION:
- if (p->level < 3)
+ if (f->level < 3)
return;
break;
default:
break;
}
- macro_line(p, "Pp");
+ macro_line(f, "Pp");
}
/*
* If the SYNOPSIS macro has a superfluous title, kill it.
*/
static void
-pnode_printrefsynopsisdiv(struct format *p, struct pnode *pn)
+pnode_printrefsynopsisdiv(struct format *f, struct pnode *n)
{
- struct pnode *pp, *pq;
+ struct pnode *nc, *nn;
- TAILQ_FOREACH_SAFE(pp, &pn->childq, child, pq)
- if (pp->node == NODE_TITLE)
- pnode_unlink(pp);
+ TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn)
+ if (nc->node == NODE_TITLE)
+ pnode_unlink(nc);
- macro_line(p, "Sh SYNOPSIS");
+ macro_line(f, "Sh SYNOPSIS");
}
/*
* Start a hopefully-named `Sh' section.
*/
static void
-pnode_printrefsect(struct format *p, struct pnode *pn)
+pnode_printrefsect(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *nc;
const char *title;
int flags, level;
- if (pn->parent == NULL)
+ if (n->parent == NULL)
return;
- level = ++p->level;
+ level = ++f->level;
flags = ARG_SPACE;
if (level == 1)
flags |= ARG_UPPER;
if (level < 3) {
- switch (pn->node) {
+ switch (n->node) {
case NODE_CAUTION:
case NODE_NOTE:
case NODE_TIP:
@@ -173,12 +173,12 @@ pnode_printrefsect(struct format *p, str
}
}
- TAILQ_FOREACH(pp, &pn->childq, child)
- if (pp->node == NODE_TITLE)
+ TAILQ_FOREACH(nc, &n->childq, child)
+ if (nc->node == NODE_TITLE)
break;
- if (pp == NULL) {
- switch (pn->node) {
+ if (nc == NULL) {
+ switch (n->node) {
case NODE_PREFACE:
title = "Preface";
break;
@@ -208,78 +208,78 @@ pnode_printrefsect(struct format *p, str
switch (level) {
case 1:
- macro_close(p);
- macro_open(p, "Sh");
+ macro_close(f);
+ macro_open(f, "Sh");
break;
case 2:
- macro_close(p);
- macro_open(p, "Ss");
+ macro_close(f);
+ macro_open(f, "Ss");
break;
default:
- pnode_printpara(p, pn);
- macro_open(p, "Sy");
+ pnode_printpara(f, n);
+ macro_open(f, "Sy");
break;
}
- if (pp != NULL) {
- macro_addnode(p, pp, flags);
- pnode_unlink(pp);
+ if (nc != NULL) {
+ macro_addnode(f, nc, flags);
+ pnode_unlink(nc);
} else
- macro_addarg(p, title, flags | ARG_QUOTED);
- macro_close(p);
+ macro_addarg(f, title, flags | ARG_QUOTED);
+ macro_close(f);
}
/*
* Start a reference, extracting the title and volume.
*/
static void
-pnode_printciterefentry(struct format *p, struct pnode *pn)
+pnode_printciterefentry(struct format *f, struct pnode *n)
{
- struct pnode *pp, *title, *manvol;
+ struct pnode *nc, *title, *manvol;
title = manvol = NULL;
- TAILQ_FOREACH(pp, &pn->childq, child) {
- if (pp->node == NODE_MANVOLNUM)
- manvol = pp;
- else if (pp->node == NODE_REFENTRYTITLE)
- title = pp;
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ if (nc->node == NODE_MANVOLNUM)
+ manvol = nc;
+ else if (nc->node == NODE_REFENTRYTITLE)
+ title = nc;
}
- macro_open(p, "Xr");
+ macro_open(f, "Xr");
if (title == NULL)
- macro_addarg(p, "unknown", ARG_SPACE);
+ macro_addarg(f, "unknown", ARG_SPACE);
else
- macro_addnode(p, title, ARG_SPACE | ARG_SINGLE);
+ macro_addnode(f, title, ARG_SPACE | ARG_SINGLE);
if (manvol == NULL)
- macro_addarg(p, "1", ARG_SPACE);
+ macro_addarg(f, "1", ARG_SPACE);
else
- macro_addnode(p, manvol, ARG_SPACE | ARG_SINGLE);
- pnode_unlinksub(pn);
+ macro_addnode(f, manvol, ARG_SPACE | ARG_SINGLE);
+ pnode_unlinksub(n);
}
static void
-pnode_printrefmeta(struct format *p, struct pnode *pn)
+pnode_printrefmeta(struct format *f, struct pnode *n)
{
- struct pnode *pp, *title, *manvol;
+ struct pnode *nc, *title, *manvol;
title = manvol = NULL;
- TAILQ_FOREACH(pp, &pn->childq, child) {
- if (pp->node == NODE_MANVOLNUM)
- manvol = pp;
- else if (pp->node == NODE_REFENTRYTITLE)
- title = pp;
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ if (nc->node == NODE_MANVOLNUM)
+ manvol = nc;
+ else if (nc->node == NODE_REFENTRYTITLE)
+ title = nc;
}
- macro_close(p);
- macro_open(p, "Dt");
+ macro_close(f);
+ macro_open(f, "Dt");
if (title == NULL)
- macro_addarg(p, "UNKNOWN", ARG_SPACE);
+ macro_addarg(f, "UNKNOWN", ARG_SPACE);
else
- macro_addnode(p, title, ARG_SPACE | ARG_SINGLE | ARG_UPPER);
+ macro_addnode(f, title, ARG_SPACE | ARG_SINGLE | ARG_UPPER);
if (manvol == NULL)
- macro_addarg(p, "1", ARG_SPACE);
+ macro_addarg(f, "1", ARG_SPACE);
else
- macro_addnode(p, manvol, ARG_SPACE | ARG_SINGLE);
- macro_close(p);
- pnode_unlink(pn);
+ macro_addnode(f, manvol, ARG_SPACE | ARG_SINGLE);
+ macro_close(f);
+ pnode_unlink(n);
}
static void
@@ -303,21 +303,21 @@ pnode_printfuncdef(struct format *f, str
* Second, >1 arguments are separated by commas.
*/
static void
-pnode_printmathfenced(struct format *p, struct pnode *pn)
+pnode_printmathfenced(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *nc;
- printf("left %s ", pnode_getattr_raw(pn, ATTRKEY_OPEN, "("));
+ printf("left %s ", pnode_getattr_raw(n, ATTRKEY_OPEN, "("));
- pp = TAILQ_FIRST(&pn->childq);
- pnode_print(p, pp);
+ nc = TAILQ_FIRST(&n->childq);
+ pnode_print(f, nc);
- while ((pp = TAILQ_NEXT(pp, child)) != NULL) {
+ while ((nc = TAILQ_NEXT(nc, child)) != NULL) {
putchar(',');
- pnode_print(p, pp);
+ pnode_print(f, nc);
}
- printf("right %s ", pnode_getattr_raw(pn, ATTRKEY_CLOSE, ")"));
- pnode_unlinksub(pn);
+ printf("right %s ", pnode_getattr_raw(n, ATTRKEY_CLOSE, ")"));
+ pnode_unlinksub(n);
}
/*
@@ -327,14 +327,14 @@ pnode_printmathfenced(struct format *p,
* particular eqn(7) word.
*/
static void
-pnode_printmath(struct format *p, struct pnode *pn)
+pnode_printmath(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *nc;
- pp = TAILQ_FIRST(&pn->childq);
- pnode_print(p, pp);
+ nc = TAILQ_FIRST(&n->childq);
+ pnode_print(f, nc);
- switch (pn->node) {
+ switch (n->node) {
case NODE_MML_MSUP:
fputs(" sup ", stdout);
break;
@@ -348,31 +348,31 @@ pnode_printmath(struct format *p, struct
break;
}
- pp = TAILQ_NEXT(pp, child);
- pnode_print(p, pp);
- pnode_unlinksub(pn);
+ nc = TAILQ_NEXT(nc, child);
+ pnode_print(f, nc);
+ pnode_unlinksub(n);
}
static void
-pnode_printfuncprototype(struct format *p, struct pnode *pn)
+pnode_printfuncprototype(struct format *f, struct pnode *n)
{
- struct pnode *pp, *fdef;
+ struct pnode *nc, *fdef;
- TAILQ_FOREACH(fdef, &pn->childq, child)
+ TAILQ_FOREACH(fdef, &n->childq, child)
if (fdef->node == NODE_FUNCDEF)
break;
if (fdef != NULL) {
- pnode_printfuncdef(p, fdef);
+ pnode_printfuncdef(f, fdef);
pnode_unlink(fdef);
} else
- macro_line(p, "Fo UNKNOWN");
+ macro_line(f, "Fo UNKNOWN");
- TAILQ_FOREACH(pp, &pn->childq, child)
- macro_nodeline(p, "Fa", pp, ARG_SINGLE);
+ TAILQ_FOREACH(nc, &n->childq, child)
+ macro_nodeline(f, "Fa", nc, ARG_SINGLE);
- macro_line(p, "Fc");
- pnode_unlinksub(pn);
+ macro_line(f, "Fc");
+ pnode_unlinksub(n);
}
/*
@@ -383,45 +383,45 @@ pnode_printfuncprototype(struct format *
* ellipsis following an argument) and optionality.
*/
static void
-pnode_printarg(struct format *p, struct pnode *pn)
+pnode_printarg(struct format *f, struct pnode *n)
{
- struct pnode *pp;
- struct pattr *ap;
+ struct pnode *nc;
+ struct pattr *a;
int isop, isrep;
isop = 1;
isrep = 0;
- TAILQ_FOREACH(ap, &pn->attrq, child) {
- if (ap->key == ATTRKEY_CHOICE &&
- (ap->val == ATTRVAL_PLAIN || ap->val == ATTRVAL_REQ))
+ TAILQ_FOREACH(a, &n->attrq, child) {
+ if (a->key == ATTRKEY_CHOICE &&
+ (a->val == ATTRVAL_PLAIN || a->val == ATTRVAL_REQ))
isop = 0;
- else if (ap->key == ATTRKEY_REP && ap->val == ATTRVAL_REPEAT)
+ else if (a->key == ATTRKEY_REP && a->val == ATTRVAL_REPEAT)
isrep = 1;
}
if (isop)
- macro_open(p, "Op");
+ macro_open(f, "Op");
- TAILQ_FOREACH(pp, &pn->childq, child) {
- if (pp->node == NODE_TEXT)
- macro_open(p, "Ar");
- pnode_print(p, pp);
- if (isrep && pp->node == NODE_TEXT)
- macro_addarg(p, "...", ARG_SPACE);
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ if (nc->node == NODE_TEXT)
+ macro_open(f, "Ar");
+ pnode_print(f, nc);
+ if (isrep && nc->node == NODE_TEXT)
+ macro_addarg(f, "...", ARG_SPACE);
}
- pnode_unlinksub(pn);
+ pnode_unlinksub(n);
}
static void
-pnode_printgroup(struct format *p, struct pnode *pn)
+pnode_printgroup(struct format *f, struct pnode *n)
{
- struct pnode *pp, *np;
- struct pattr *ap;
+ struct pnode *nc, *nn;
+ struct pattr *a;
int isop, sv;
isop = 1;
- TAILQ_FOREACH(ap, &pn->attrq, child)
- if (ap->key == ATTRKEY_CHOICE &&
- (ap->val == ATTRVAL_PLAIN || ap->val == ATTRVAL_REQ)) {
+ TAILQ_FOREACH(a, &n->attrq, child)
+ if (a->key == ATTRKEY_CHOICE &&
+ (a->val == ATTRVAL_PLAIN || a->val == ATTRVAL_REQ)) {
isop = 0;
break;
}
@@ -431,11 +431,11 @@ pnode_printgroup(struct format *p, struc
* This will prevent pnode_print() for putting us on a
* subsequent line.
*/
- sv = p->linestate == LINE_NEW;
+ sv = f->linestate == LINE_NEW;
if (isop)
- macro_open(p, "Op");
+ macro_open(f, "Op");
else if (sv)
- macro_open(p, "No");
+ macro_open(f, "No");
/*
* Keep on printing text separated by the vertical bar as long
@@ -445,27 +445,27 @@ pnode_printgroup(struct format *p, struc
* FIXME: if there's a "Fl", we don't cut off the leading "-"
* like we do in pnode_print().
*/
- TAILQ_FOREACH(pp, &pn->childq, child) {
- pnode_print(p, pp);
- np = TAILQ_NEXT(pp, child);
- while (np != NULL) {
- if (pp->node != np->node)
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ pnode_print(f, nc);
+ nn = TAILQ_NEXT(nc, child);
+ while (nn != NULL) {
+ if (nc->node != nn->node)
break;
- macro_addarg(p, "|", ARG_SPACE);
- macro_addnode(p, np, ARG_SPACE);
- pp = np;
- np = TAILQ_NEXT(np, child);
+ macro_addarg(f, "|", ARG_SPACE);
+ macro_addnode(f, nn, ARG_SPACE);
+ nc = nn;
+ nn = TAILQ_NEXT(nn, child);
}
}
if (sv)
- macro_close(p);
- pnode_unlinksub(pn);
+ macro_close(f);
+ pnode_unlinksub(n);
}
static void
pnode_printauthor(struct format *f, struct pnode *n)
{
- struct pnode *nc, *ncn;
+ struct pnode *nc, *nn;
int have_contrib, have_name;
/*
@@ -474,7 +474,7 @@ pnode_printauthor(struct format *f, stru
*/
have_contrib = have_name = 0;
- TAILQ_FOREACH_SAFE(nc, &n->childq, child, ncn) {
+ TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
switch (nc->node) {
case NODE_CONTRIB:
if (have_contrib)
@@ -503,7 +503,7 @@ pnode_printauthor(struct format *f, stru
*/
macro_open(f, "An");
- TAILQ_FOREACH_SAFE(nc, &n->childq, child, ncn) {
+ TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
if (nc->node == NODE_PERSONNAME || have_name == 0) {
macro_addnode(f, nc, ARG_SPACE);
pnode_unlink(nc);
@@ -568,29 +568,29 @@ pnode_printlink(struct format *f, struct
}
static void
-pnode_printprologue(struct format *p, struct ptree *tree)
+pnode_printprologue(struct format *f, struct ptree *tree)
{
struct pnode *refmeta;
refmeta = tree->root == NULL ? NULL :
pnode_findfirst(tree->root, NODE_REFMETA);
- macro_line(p, "Dd $Mdocdate" "$");
+ macro_line(f, "Dd $Mdocdate" "$");
if (refmeta == NULL) {
- macro_open(p, "Dt");
- macro_addarg(p,
+ macro_open(f, "Dt");
+ macro_addarg(f,
pnode_getattr_raw(tree->root, ATTRKEY_ID, "UNKNOWN"),
ARG_SPACE | ARG_SINGLE | ARG_UPPER);
- macro_addarg(p, "1", ARG_SPACE);
- macro_close(p);
+ macro_addarg(f, "1", ARG_SPACE);
+ macro_close(f);
} else
- pnode_printrefmeta(p, refmeta);
- macro_line(p, "Os");
+ pnode_printrefmeta(f, refmeta);
+ macro_line(f, "Os");
if (tree->flags & TREE_EQN) {
- macro_line(p, "EQ");
- print_text(p, "delim $$", 0);
- macro_line(p, "EN");
+ macro_line(f, "EQ");
+ print_text(f, "delim $$", 0);
+ macro_line(f, "EN");
}
}
@@ -599,54 +599,54 @@ pnode_printprologue(struct format *p, st
* we should comma-separate as list headers.
*/
static void
-pnode_printvarlistentry(struct format *p, struct pnode *pn)
+pnode_printvarlistentry(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *nc;
int first = 1;
- macro_close(p);
- macro_open(p, "It");
- TAILQ_FOREACH(pp, &pn->childq, child) {
- if (pp->node != NODE_TERM && pp->node != NODE_GLOSSTERM)
+ macro_close(f);
+ macro_open(f, "It");
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)
continue;
if ( ! first)
- macro_addarg(p, ",", 0);
- pnode_print(p, pp);
+ macro_addarg(f, ",", 0);
+ pnode_print(f, nc);
first = 0;
}
- macro_close(p);
- TAILQ_FOREACH(pp, &pn->childq, child)
- if (pp->node != NODE_TERM && pp->node != NODE_GLOSSTERM)
- pnode_print(p, pp);
- pnode_unlinksub(pn);
+ macro_close(f);
+ TAILQ_FOREACH(nc, &n->childq, child)
+ if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)
+ pnode_print(f, nc);
+ pnode_unlinksub(n);
}
static void
-pnode_printtitle(struct format *p, struct pnode *pn)
+pnode_printtitle(struct format *f, struct pnode *n)
{
- struct pnode *pp, *pq;
+ struct pnode *nc, *nn;
- TAILQ_FOREACH_SAFE(pp, &pn->childq, child, pq) {
- if (pp->node == NODE_TITLE) {
- pnode_printpara(p, pp);
- pnode_print(p, pp);
- pnode_unlink(pp);
+ TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
+ if (nc->node == NODE_TITLE) {
+ pnode_printpara(f, nc);
+ pnode_print(f, nc);
+ pnode_unlink(nc);
}
}
}
static void
-pnode_printrow(struct format *p, struct pnode *pn)
+pnode_printrow(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *nc;
- macro_line(p, "Bl -dash -compact");
- TAILQ_FOREACH(pp, &pn->childq, child) {
- macro_line(p, "It");
- pnode_print(p, pp);
+ macro_line(f, "Bl -dash -compact");
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ macro_line(f, "It");
+ pnode_print(f, nc);
}
- macro_line(p, "El");
- pnode_unlink(pn);
+ macro_line(f, "El");
+ pnode_unlink(n);
}
static void
@@ -711,36 +711,36 @@ pnode_printtgroup(struct format *f, stru
}
static void
-pnode_printlist(struct format *p, struct pnode *pn)
+pnode_printlist(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *nc;
- pnode_printtitle(p, pn);
- macro_argline(p, "Bl",
- pn->node == NODE_ORDEREDLIST ? "-enum" : "-bullet");
- TAILQ_FOREACH(pp, &pn->childq, child) {
- macro_line(p, "It");
- pnode_print(p, pp);
+ pnode_printtitle(f, n);
+ macro_argline(f, "Bl",
+ n->node == NODE_ORDEREDLIST ? "-enum" : "-bullet");
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ macro_line(f, "It");
+ pnode_print(f, nc);
}
- macro_line(p, "El");
- pnode_unlinksub(pn);
+ macro_line(f, "El");
+ pnode_unlinksub(n);
}
static void
-pnode_printvariablelist(struct format *p, struct pnode *pn)
+pnode_printvariablelist(struct format *f, struct pnode *n)
{
- struct pnode *pp;
+ struct pnode *nc;
- pnode_printtitle(p, pn);
- macro_line(p, "Bl -tag -width Ds");
- TAILQ_FOREACH(pp, &pn->childq, child) {
- if (pp->node == NODE_VARLISTENTRY)
- pnode_printvarlistentry(p, pp);
+ pnode_printtitle(f, n);
+ macro_line(f, "Bl -tag -width Ds");
+ TAILQ_FOREACH(nc, &n->childq, child) {
+ if (nc->node == NODE_VARLISTENTRY)
+ pnode_printvarlistentry(f, nc);
else
- macro_nodeline(p, "It", pp, 0);
+ macro_nodeline(f, "It", nc, 0);
}
- macro_line(p, "El");
- pnode_unlinksub(pn);
+ macro_line(f, "El");
+ pnode_unlinksub(n);
}
/*
@@ -750,163 +750,163 @@ pnode_printvariablelist(struct format *p
* whatever), don't print inline macros.
*/
static void
-pnode_print(struct format *p, struct pnode *pn)
+pnode_print(struct format *f, struct pnode *n)
{
struct pnode *pp;
enum linestate sv;
- if (pn == NULL)
+ if (n == NULL)
return;
- p->spc = pn->spc;
- sv = p->linestate;
+ f->spc = n->spc;
+ sv = f->linestate;
- switch (pn->node) {
+ switch (n->node) {
case NODE_APPLICATION:
- macro_open(p, "Nm");
+ macro_open(f, "Nm");
break;
case NODE_ARG:
- pnode_printarg(p, pn);
+ pnode_printarg(f, n);
break;
case NODE_AUTHOR:
- pnode_printauthor(p, pn);
+ pnode_printauthor(f, n);
break;
case NODE_AUTHORGROUP:
- macro_line(p, "An -split");
+ macro_line(f, "An -split");
break;
case NODE_BLOCKQUOTE:
- macro_line(p, "Bd -ragged -offset indent");
+ macro_line(f, "Bd -ragged -offset indent");
break;
case NODE_BOOKINFO:
- macro_line(p, "Sh NAME");
+ macro_line(f, "Sh NAME");
break;
case NODE_CITEREFENTRY:
- pnode_printciterefentry(p, pn);
+ pnode_printciterefentry(f, n);
break;
case NODE_CITETITLE:
- macro_open(p, "%T");
+ macro_open(f, "%T");
break;
case NODE_COMMAND:
- macro_open(p, "Nm");
+ macro_open(f, "Nm");
break;
case NODE_CONSTANT:
- macro_open(p, "Dv");
+ macro_open(f, "Dv");
break;
case NODE_EDITOR:
- print_text(p, "editor:", ARG_SPACE);
+ print_text(f, "editor:", ARG_SPACE);
sv = LINE_TEXT;
- macro_open(p, "An");
+ macro_open(f, "An");
break;
case NODE_EMAIL:
- macro_open(p, "Aq Mt");
+ macro_open(f, "Aq Mt");
break;
case NODE_EMPHASIS:
case NODE_FIRSTTERM:
case NODE_GLOSSTERM:
- macro_open(p, "Em");
+ macro_open(f, "Em");
break;
case NODE_ENVAR:
- macro_open(p, "Ev");
+ macro_open(f, "Ev");
break;
case NODE_ERRORNAME:
- macro_open(p, "Er");
+ macro_open(f, "Er");
break;
case NODE_FILENAME:
- macro_open(p, "Pa");
+ macro_open(f, "Pa");
break;
case NODE_FUNCTION:
- macro_open(p, "Fn");
+ macro_open(f, "Fn");
break;
case NODE_FUNCPROTOTYPE:
- pnode_printfuncprototype(p, pn);
+ pnode_printfuncprototype(f, n);
break;
case NODE_FUNCSYNOPSISINFO:
- macro_open(p, "Fd");
+ macro_open(f, "Fd");
break;
case NODE_INFORMALEQUATION:
- macro_line(p, "EQ");
+ macro_line(f, "EQ");
break;
case NODE_INLINEEQUATION:
- if (p->linestate == LINE_NEW)
- p->linestate = LINE_TEXT;
+ if (f->linestate == LINE_NEW)
+ f->linestate = LINE_TEXT;
putchar('$');
break;
case NODE_ITEMIZEDLIST:
- pnode_printlist(p, pn);
+ pnode_printlist(f, n);
break;
case NODE_GROUP:
- pnode_printgroup(p, pn);
+ pnode_printgroup(f, n);
break;
case NODE_KEYSYM:
- macro_open(p, "Sy");
+ macro_open(f, "Sy");
break;
case NODE_LINK:
- pnode_printlink(p, pn);
+ pnode_printlink(f, n);
break;
case NODE_LITERAL:
- macro_open(p, "Ql");
+ macro_open(f, "Ql");
break;
case NODE_LITERALLAYOUT:
- macro_close(p);
- macro_argline(p, "Bd", pnode_getattr(pn, ATTRKEY_CLASS) ==
+ macro_close(f);
+ macro_argline(f, "Bd", pnode_getattr(n, ATTRKEY_CLASS) ==
ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");
break;
case NODE_MML_MFENCED:
- pnode_printmathfenced(p, pn);
+ pnode_printmathfenced(f, n);
break;
case NODE_MML_MROW:
case NODE_MML_MI:
case NODE_MML_MN:
case NODE_MML_MO:
- if (TAILQ_EMPTY(&pn->childq))
+ if (TAILQ_EMPTY(&n->childq))
break;
fputs(" { ", stdout);
break;
case NODE_MML_MFRAC:
case NODE_MML_MSUB:
case NODE_MML_MSUP:
- pnode_printmath(p, pn);
+ pnode_printmath(f, n);
break;
case NODE_OPTION:
- macro_open(p, "Fl");
+ macro_open(f, "Fl");
break;
case NODE_ORDEREDLIST:
- pnode_printlist(p, pn);
+ pnode_printlist(f, n);
break;
case NODE_PARA:
- pnode_printpara(p, pn);
+ pnode_printpara(f, n);
break;
case NODE_PARAMDEF:
case NODE_PARAMETER:
- macro_nodeline(p, "Fa", pn, ARG_SINGLE);
- pnode_unlinksub(pn);
+ macro_nodeline(f, "Fa", n, ARG_SINGLE);
+ pnode_unlinksub(n);
break;
case NODE_QUOTE:
- macro_open(p, "Qo");
+ macro_open(f, "Qo");
break;
case NODE_PROGRAMLISTING:
case NODE_SCREEN:
case NODE_SYNOPSIS:
- macro_line(p, "Bd -literal");
+ macro_line(f, "Bd -literal");
break;
case NODE_REFENTRYINFO:
/* Suppress. */
- pnode_unlinksub(pn);
+ pnode_unlinksub(n);
break;
case NODE_REFNAME:
/* Suppress non-text children... */
- macro_open(p, "Nm");
- macro_addnode(p, pn, ARG_SPACE | ARG_SINGLE);
- pnode_unlinksub(pn);
+ macro_open(f, "Nm");
+ macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);
+ pnode_unlinksub(n);
break;
case NODE_REFNAMEDIV:
- macro_line(p, "Sh NAME");
+ macro_line(f, "Sh NAME");
break;
case NODE_REFPURPOSE:
- macro_open(p, "Nd");
+ macro_open(f, "Nd");
break;
case NODE_REFSYNOPSISDIV:
- pnode_printrefsynopsisdiv(p, pn);
+ pnode_printrefsynopsisdiv(f, n);
break;
case NODE_PREFACE:
case NODE_SECTION:
@@ -916,71 +916,71 @@ pnode_print(struct format *p, struct pno
case NODE_TIP:
case NODE_CAUTION:
case NODE_WARNING:
- pnode_printrefsect(p, pn);
+ pnode_printrefsect(f, n);
break;
case NODE_REPLACEABLE:
- macro_open(p, "Ar");
+ macro_open(f, "Ar");
break;
case NODE_SBR:
- macro_line(p, "br");
+ macro_line(f, "br");
break;
case NODE_SGMLTAG:
- macro_open(p, "Ic");
+ macro_open(f, "Ic");
break;
case NODE_TEXT:
case NODE_ESCAPE:
- pnode_printtext(p, pn);
+ pnode_printtext(f, n);
break;
case NODE_TGROUP:
- pnode_printtgroup(p, pn);
+ pnode_printtgroup(f, n);
break;
case NODE_TITLE:
- if (pn->parent != NULL &&
- pn->parent->node == NODE_BOOKINFO) {
- macro_open(p, "Nd");
+ if (n->parent != NULL &&
+ n->parent->node == NODE_BOOKINFO) {
+ macro_open(f, "Nd");
break;
}
- pnode_printpara(p, pn);
- macro_nodeline(p, "Sy", pn, 0);
- pnode_unlinksub(pn);
+ pnode_printpara(f, n);
+ macro_nodeline(f, "Sy", n, 0);
+ pnode_unlinksub(n);
break;
case NODE_TYPE:
- macro_open(p, "Vt");
+ macro_open(f, "Vt");
break;
case NODE_VARIABLELIST:
- pnode_printvariablelist(p, pn);
+ pnode_printvariablelist(f, n);
break;
case NODE_VARNAME:
- macro_open(p, "Va");
+ macro_open(f, "Va");
break;
default:
break;
}
- TAILQ_FOREACH(pp, &pn->childq, child)
- pnode_print(p, pp);
+ TAILQ_FOREACH(pp, &n->childq, child)
+ pnode_print(f, pp);
- switch (pn->node) {
+ switch (n->node) {
case NODE_INFORMALEQUATION:
- macro_line(p, "EN");
+ macro_line(f, "EN");
break;
case NODE_INLINEEQUATION:
fputs("$ ", stdout);
- p->linestate = sv;
+ f->linestate = sv;
break;
case NODE_MEMBER:
- if ((pp = TAILQ_NEXT(pn, child)) != NULL &&
+ if ((pp = TAILQ_NEXT(n, child)) != NULL &&
pp->node != NODE_MEMBER)
pp = NULL;
- switch (p->linestate) {
+ switch (f->linestate) {
case LINE_TEXT:
if (pp != NULL)
- print_text(p, ",", 0);
+ print_text(f, ",", 0);
break;
case LINE_MACRO:
if (pp != NULL)
- macro_addarg(p, ",", ARG_SPACE);
- macro_close(p);
+ macro_addarg(f, ",", ARG_SPACE);
+ macro_close(f);
break;
case LINE_NEW:
break;
@@ -990,7 +990,7 @@ pnode_print(struct format *p, struct pno
case NODE_MML_MI:
case NODE_MML_MN:
case NODE_MML_MO:
- if (TAILQ_EMPTY(&pn->childq))
+ if (TAILQ_EMPTY(&n->childq))
break;
fputs(" } ", stdout);
break;
@@ -1020,17 +1020,17 @@ pnode_print(struct format *p, struct pno
case NODE_SGMLTAG:
case NODE_TYPE:
case NODE_VARNAME:
- if (sv != LINE_MACRO && p->linestate == LINE_MACRO &&
- (pn->parent == NULL || pn->parent->node != NODE_MEMBER))
- macro_closepunct(p, pn);
+ if (sv != LINE_MACRO && f->linestate == LINE_MACRO &&
+ (n->parent == NULL || n->parent->node != NODE_MEMBER))
+ macro_closepunct(f, n);
break;
case NODE_QUOTE:
if (sv == LINE_NEW)
- macro_close(p);
- sv = p->linestate;
- macro_open(p, "Qc");
+ macro_close(f);
+ sv = f->linestate;
+ macro_open(f, "Qc");
if (sv == LINE_NEW)
- macro_close(p);
+ macro_close(f);
break;
case NODE_REFNAME:
/*
@@ -1038,13 +1038,13 @@ pnode_print(struct format *p, struct pno
* <refname> macros in sequence, then print out a
* trailing comma before the newline.
*/
- if (pn->parent != NULL &&
- pn->parent->node == NODE_REFNAMEDIV &&
- TAILQ_NEXT(pn, child) != NULL &&
- TAILQ_NEXT(pn, child)->node == NODE_REFNAME)
- macro_addarg(p, ",", ARG_SPACE);
+ if (n->parent != NULL &&
+ n->parent->node == NODE_REFNAMEDIV &&
+ TAILQ_NEXT(n, child) != NULL &&
+ TAILQ_NEXT(n, child)->node == NODE_REFNAME)
+ macro_addarg(f, ",", ARG_SPACE);
if (sv == LINE_NEW)
- macro_close(p);
+ macro_close(f);
break;
case NODE_PREFACE:
case NODE_SECTION:
@@ -1054,19 +1054,19 @@ pnode_print(struct format *p, struct pno
case NODE_TIP:
case NODE_CAUTION:
case NODE_WARNING:
- p->level--;
+ f->level--;
break;
case NODE_BLOCKQUOTE:
case NODE_LITERALLAYOUT:
case NODE_PROGRAMLISTING:
case NODE_SCREEN:
case NODE_SYNOPSIS:
- macro_line(p, "Ed");
+ macro_line(f, "Ed");
break;
case NODE_TITLE:
- if (pn->parent != NULL &&
- pn->parent->node == NODE_BOOKINFO)
- macro_line(p, "Sh AUTHORS");
+ if (n->parent != NULL &&
+ n->parent->node == NODE_BOOKINFO)
+ macro_line(f, "Sh AUTHORS");
break;
default:
break;
Index: macro.c
===================================================================
RCS file: /home/cvs/mdocml/docbook2mdoc/macro.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -Lmacro.c -Lmacro.c -u -p -r1.7 -r1.8
--- macro.c
+++ macro.c
@@ -203,7 +203,7 @@ macro_argline(struct format *f, const ch
* Recursively append text from the children of a node to a macro line.
*/
void
-macro_addnode(struct format *f, struct pnode *pn, int flags)
+macro_addnode(struct format *f, struct pnode *n, int flags)
{
struct pnode *nc;
int quote_now;
@@ -215,12 +215,12 @@ macro_addnode(struct format *f, struct p
* that text, letting macro_addarg() decide about quoting.
*/
- while ((nc = TAILQ_FIRST(&pn->childq)) != NULL &&
+ while ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
TAILQ_NEXT(nc, child) == NULL)
- pn = nc;
+ n = nc;
- if (pn->node == NODE_TEXT || pn->node == NODE_ESCAPE) {
- macro_addarg(f, pn->b, flags);
+ if (n->node == NODE_TEXT || n->node == NODE_ESCAPE) {
+ macro_addarg(f, n->b, flags);
return;
}
@@ -258,10 +258,10 @@ macro_addnode(struct format *f, struct p
}
void
-macro_nodeline(struct format *f, const char *name, struct pnode *pn, int flags)
+macro_nodeline(struct format *f, const char *name, struct pnode *n, int flags)
{
macro_open(f, name);
- macro_addnode(f, pn, ARG_SPACE | flags);
+ macro_addnode(f, n, ARG_SPACE | flags);
macro_close(f);
}
--
To unsubscribe send an email to source+unsubscribe@mandoc.bsd.lv
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2019-04-10 14:23 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-04-10 14:23 docbook2mdoc: Consitently use for function arguments: struct parse *p, schwarze
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).