From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from localhost (fantadrom.bsd.lv [local]) by fantadrom.bsd.lv (OpenSMTPD) with ESMTPA id 5de815fb for ; Wed, 10 Apr 2019 09:23:08 -0500 (EST) Date: Wed, 10 Apr 2019 09:23:08 -0500 (EST) X-Mailinglist: mandoc-source Reply-To: source@mandoc.bsd.lv MIME-Version: 1.0 From: schwarze@mandoc.bsd.lv To: source@mandoc.bsd.lv Subject: docbook2mdoc: Consitently use for function arguments: struct parse *p, X-Mailer: activitymail 1.26, http://search.cpan.org/dist/activitymail/ Content-Type: text/plain; charset=utf-8 Message-ID: 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 * 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