docbook2mdoc/docbook2mdoc.c - diff

Return to docbook2mdoc.c CVS log

Up to [cvsweb.bsd.lv] / docbook2mdoc

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.52 and 1.67

version 1.52, 2019/03/22 16:21:23

version 1.67, 2019/03/23 10:53:52

Line 51 struct parse {

struct node {

const char *name; /* docbook element name */

unsigned int flags;

enum nodeid node; /* docbook element to generate */

#define NODE_IGNTEXT 1 /* ignore all contained text */

};

TAILQ_HEAD(pnodeq, pnode);

Line 78 struct pnode {

Line 77 struct pnode {

static const char *attrkeys[ATTRKEY__MAX] = {

"choice",

"class",

"close",

"id",

"linkend",

"open",

"rep"

};

static const char *attrvals[ATTRVAL__MAX] = {

"monospaced",

"norepeat",

"opt",

"plain",

Line 92 static const char *attrvals[ATTRVAL__MAX] = {

Line 94 static const char *attrvals[ATTRVAL__MAX] = {

"req"

};

static const struct node nodes[NODE__MAX] = {

static const struct node nodes[] = {

{ NULL, 0 },

{ "acronym", NODE_ACRONYM },

{ "acronym", 0 },

{ "affiliation", NODE_AFFILIATION },

{ "affiliation", NODE_IGNTEXT },

{ "anchor", NODE_ANCHOR },

{ "anchor", NODE_IGNTEXT },

{ "application", NODE_APPLICATION },

{ "application", 0 },

{ "arg", NODE_ARG },

{ "arg", 0 },

{ "author", NODE_AUTHOR },

{ "author", NODE_IGNTEXT },

{ "authorgroup", NODE_AUTHORGROUP },

{ "authorgroup", NODE_IGNTEXT },

{ "blockquote", NODE_BLOCKQUOTE },

{ "blockquote", NODE_IGNTEXT },

{ "book", NODE_BOOK },

{ "book", NODE_IGNTEXT },

{ "bookinfo", NODE_BOOKINFO },

{ "bookinfo", NODE_IGNTEXT },

{ "caution", NODE_CAUTION },

{ "caution", NODE_IGNTEXT },

{ "chapter", NODE_SECTION },

{ "chapter", NODE_IGNTEXT },

{ "citerefentry", NODE_CITEREFENTRY },

{ "citerefentry", NODE_IGNTEXT },

{ "citetitle", NODE_CITETITLE },

{ "citetitle", 0 },

{ "cmdsynopsis", NODE_CMDSYNOPSIS },

{ "cmdsynopsis", NODE_IGNTEXT },

{ "code", NODE_CODE },

{ "code", 0 },

{ "colspec", NODE_COLSPEC },

{ "colspec", NODE_IGNTEXT },

{ "command", NODE_COMMAND },

{ "command", 0 },

{ "constant", NODE_CONSTANT },

{ "constant", 0 },

{ "copyright", NODE_COPYRIGHT },

{ "copyright", NODE_IGNTEXT },

{ "date", NODE_DATE },

{ "date", 0 },

{ "editor", NODE_EDITOR },

{ "editor", NODE_IGNTEXT },

{ "email", NODE_EMAIL },

{ "emphasis", 0 },

{ "emphasis", NODE_EMPHASIS },

{ "entry", 0 },

{ "entry", NODE_ENTRY },

{ "envar", 0 },

{ "envar", NODE_ENVAR },

{ "fieldsynopsis", NODE_IGNTEXT },

{ "fieldsynopsis", NODE_FIELDSYNOPSIS },

{ "filename", 0 },

{ "filename", NODE_FILENAME },

{ "firstname", 0 },

{ "firstname", NODE_FIRSTNAME },

{ "firstterm", 0 },

{ "firstterm", NODE_FIRSTTERM },

{ "footnote", 0 },

{ "footnote", NODE_FOOTNOTE },

{ "funcdef", 0 },

{ "funcdef", NODE_FUNCDEF },

{ "funcprototype", NODE_IGNTEXT },

{ "funcprototype", NODE_FUNCPROTOTYPE },

{ "funcsynopsis", NODE_IGNTEXT },

{ "funcsynopsis", NODE_FUNCSYNOPSIS },

{ "funcsynopsisinfo", 0 },

{ "funcsynopsisinfo", NODE_FUNCSYNOPSISINFO },

{ "function", 0 },

{ "function", NODE_FUNCTION },

{ "glossterm", 0 },

{ "glossterm", NODE_GLOSSTERM },

{ "group", NODE_IGNTEXT },

{ "group", NODE_GROUP },

{ "holder", NODE_IGNTEXT },

{ "holder", NODE_HOLDER },

{ "index", NODE_IGNTEXT },

{ "index", NODE_INDEX },

{ "indexterm", NODE_IGNTEXT },

{ "indexterm", NODE_INDEXTERM },

{ "info", NODE_IGNTEXT },

{ "info", NODE_INFO },

{ "informalequation", NODE_IGNTEXT },

{ "informalequation", NODE_INFORMALEQUATION },

{ "informaltable", NODE_IGNTEXT },

{ "informaltable", NODE_INFORMALTABLE },

{ "inlineequation", NODE_IGNTEXT },

{ "inlineequation", NODE_INLINEEQUATION },

{ "itemizedlist", NODE_IGNTEXT },

{ "itemizedlist", NODE_ITEMIZEDLIST },

{ "keysym", 0 },

{ "keysym", NODE_KEYSYM },

{ "legalnotice", NODE_IGNTEXT },

{ "legalnotice", NODE_LEGALNOTICE },

{ "link", 0 },

{ "link", NODE_LINK },

{ "listitem", NODE_IGNTEXT },

{ "listitem", NODE_LISTITEM },

{ "literal", 0 },

{ "literal", NODE_LITERAL },

{ "literallayout", 0 },

{ "literallayout", NODE_LITERALLAYOUT },

{ "manvolnum", 0 },

{ "manvolnum", NODE_MANVOLNUM },

{ "member", 0 },

{ "member", NODE_MEMBER },

{ "mml:math", NODE_IGNTEXT },

{ "mml:math", NODE_MML_MATH },

{ "mml:mfenced", 0 },

{ "mml:mfenced", NODE_MML_MFENCED },

{ "mml:mfrac", 0 },

{ "mml:mfrac", NODE_MML_MFRAC },

{ "mml:mi", 0 },

{ "mml:mi", NODE_MML_MI },

{ "mml:mn", 0 },

{ "mml:mn", NODE_MML_MN },

{ "mml:mo", 0 },

{ "mml:mo", NODE_MML_MO },

{ "mml:mrow", 0 },

{ "mml:mrow", NODE_MML_MROW },

{ "mml:msub", 0 },

{ "mml:msub", NODE_MML_MSUB },

{ "mml:msup", 0 },

{ "mml:msup", NODE_MML_MSUP },

{ "modifier", 0 },

{ "modifier", NODE_MODIFIER },

{ "note", NODE_IGNTEXT },

{ "note", NODE_NOTE },

{ "option", 0 },

{ "option", NODE_OPTION },

{ "orderedlist", NODE_IGNTEXT },

{ "orderedlist", NODE_ORDEREDLIST },

{ "orgname", 0 },

{ "orgname", NODE_ORGNAME },

{ "othername", 0 },

{ "othername", NODE_OTHERNAME },

{ "para", 0 },

{ "para", NODE_PARA },

{ "paramdef", 0 },

{ "paramdef", NODE_PARAMDEF },

{ "parameter", 0 },

{ "parameter", NODE_PARAMETER },

{ "part", NODE_IGNTEXT },

{ "part", NODE_SECTION },

{ "phrase", 0 },

{ "personname", NODE_PERSONNAME },

{ "preface", NODE_IGNTEXT },

{ "phrase", NODE_PHRASE },

{ "primary", 0 },

{ "preface", NODE_PREFACE },

{ "programlisting", 0 },

{ "primary", NODE_PRIMARY },

{ "prompt", 0 },

{ "programlisting", NODE_PROGRAMLISTING },

{ "quote", 0 },

{ "prompt", NODE_PROMPT },

{ "refclass", NODE_IGNTEXT },

{ "quote", NODE_QUOTE },

{ "refdescriptor", NODE_IGNTEXT },

{ "refclass", NODE_REFCLASS },

{ "refentry", NODE_IGNTEXT },

{ "refdescriptor", NODE_REFDESCRIPTOR },

{ "refentryinfo", NODE_IGNTEXT },

{ "refentry", NODE_REFENTRY },

{ "refentrytitle", 0 },

{ "refentryinfo", NODE_REFENTRYINFO },

{ "refmeta", NODE_IGNTEXT },

{ "refentrytitle", NODE_REFENTRYTITLE },

{ "refmetainfo", NODE_IGNTEXT },

{ "refmeta", NODE_REFMETA },

{ "refmiscinfo", NODE_IGNTEXT },

{ "refmetainfo", NODE_REFMETAINFO },

{ "refname", 0 },

{ "refmiscinfo", NODE_REFMISCINFO },

{ "refnamediv", NODE_IGNTEXT },

{ "refname", NODE_REFNAME },

{ "refpurpose", 0 },

{ "refnamediv", NODE_REFNAMEDIV },

{ "refsect1", NODE_IGNTEXT },

{ "refpurpose", NODE_REFPURPOSE },

{ "refsect2", NODE_IGNTEXT },

{ "refsect1", NODE_SECTION },

{ "refsect3", NODE_IGNTEXT },

{ "refsect2", NODE_SECTION },

{ "refsection", NODE_IGNTEXT },

{ "refsect3", NODE_SECTION },

{ "refsynopsisdiv", NODE_IGNTEXT },

{ "refsection", NODE_SECTION },

{ "releaseinfo", 0 },

{ "refsynopsisdiv", NODE_REFSYNOPSISDIV },

{ "replaceable", 0 },

{ "releaseinfo", NODE_RELEASEINFO },

{ "row", NODE_IGNTEXT },

{ "replaceable", NODE_REPLACEABLE },

{ "sbr", NODE_IGNTEXT },

{ "row", NODE_ROW },

{ "screen", NODE_IGNTEXT },

{ "sbr", NODE_SBR },

{ "secondary", 0 },

{ "screen", NODE_SCREEN },

{ "sect1", NODE_IGNTEXT },

{ "secondary", NODE_SECONDARY },

{ "sect2", NODE_IGNTEXT },

{ "sect1", NODE_SECTION },

{ "section", NODE_IGNTEXT },

{ "sect2", NODE_SECTION },

{ "sgmltag", 0 },

{ "section", NODE_SECTION },

{ "simplelist", NODE_IGNTEXT },

{ "sgmltag", NODE_SGMLTAG },

{ "spanspec", NODE_IGNTEXT },

{ "simplelist", NODE_SIMPLELIST },

{ "structname", 0 },

{ "spanspec", NODE_SPANSPEC },

{ "subtitle", 0 },

{ "structname", NODE_STRUCTNAME },

{ "surname", 0 },

{ "subtitle", NODE_SUBTITLE },

{ "synopsis", 0 },

{ "surname", NODE_SURNAME },

{ "table", NODE_IGNTEXT },

{ "synopsis", NODE_SYNOPSIS },

{ "tbody", NODE_IGNTEXT },

{ "table", NODE_TABLE },

{ "term", 0 },

{ "tbody", NODE_TBODY },

{ NULL, 0 },

{ "term", NODE_TERM },

{ "tfoot", NODE_IGNTEXT },

{ "tfoot", NODE_TFOOT },

{ "tgroup", NODE_IGNTEXT },

{ "tgroup", NODE_TGROUP },

{ "thead", NODE_IGNTEXT },

{ "thead", NODE_THEAD },

{ "tip", NODE_IGNTEXT },

{ "tip", NODE_TIP },

{ "title", 0 },

{ "title", NODE_TITLE },

{ "trademark", 0 },

{ "trademark", NODE_TRADEMARK },

{ "type", 0 },

{ "type", NODE_TYPE },

{ "ulink", 0 },

{ "ulink", NODE_ULINK },

{ "userinput", 0 },

{ "userinput", NODE_USERINPUT },

{ "variablelist", NODE_IGNTEXT },

{ "variablelist", NODE_VARIABLELIST },

{ "varlistentry", NODE_IGNTEXT },

{ "varlistentry", NODE_VARLISTENTRY },

{ "varname", 0 },

{ "varname", NODE_VARNAME },

{ "warning", NODE_IGNTEXT },

{ "warning", NODE_WARNING },

{ "wordasword", 0 },

{ "wordasword", NODE_WORDASWORD },

{ "year", NODE_IGNTEXT },

{ "year", NODE_YEAR },

{ NULL, NODE__MAX }

};

static int warn = 0;

Line 244 xml_char(void *arg, const XML_Char *p, int sz)

Line 247 xml_char(void *arg, const XML_Char *p, int sz)

int i;

/* Stopped or no tree yet. */

if (ps->stop || NODE_ROOT == ps->node)

if (ps->stop || ps->node == NODE_ROOT)

return;

/* Not supposed to be collecting text. */

assert(ps->cur != NULL);

assert(NULL != ps->cur);

if (NODE_IGNTEXT & nodes[ps->node].flags)

return;

* Are we in the midst of processing text?

Line 259 xml_char(void *arg, const XML_Char *p, int sz)

* However, don't do so unless we have some non-whitespace to

* process: strip out all leading whitespace to be sure.

if (NODE_TEXT != ps->node) {

if (ps->node != NODE_TEXT) {

for (i = 0; i < sz; i++)

if ( ! isspace((unsigned char)p[i]))

break;

Line 268 xml_char(void *arg, const XML_Char *p, int sz)

p += i;

sz -= i;

dat = calloc(1, sizeof(struct pnode));

if (NULL == dat) {

if (dat == NULL) {

perror(NULL);

exit(EXIT_FAILURE);

exit(1);

}

dat->node = ps->node = NODE_TEXT;

Line 279 xml_char(void *arg, const XML_Char *p, int sz)

TAILQ_INIT(&dat->attrq);

TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);

ps->cur = dat;

assert(NULL != ps->root);

assert(ps->root != NULL);

}

/* Append to current buffer. */

assert(sz >= 0);

ps->cur->b = realloc(ps->cur->b,

ps->cur->bsz + (size_t)sz);

if (NULL == ps->cur->b) {

if (ps->cur->b == NULL) {

perror(NULL);

exit(EXIT_FAILURE);

exit(1);

}

memcpy(ps->cur->b + ps->cur->bsz, p, sz);

ps->cur->bsz += (size_t)sz;

Line 298 xml_char(void *arg, const XML_Char *p, int sz)

static void

pnode_trim(struct pnode *pn)

{

assert(pn->node == NODE_TEXT);

assert(NODE_TEXT == pn->node);

for ( ; pn->bsz > 0; pn->bsz--)

if ( ! isspace((unsigned char)pn->b[pn->bsz - 1]))

break;

Line 323 static void

Line 322 static void

xml_elem_start(void *arg, const XML_Char *name, const XML_Char **atts)

{

struct parse *ps = arg;

enum nodeid node;

const struct node *node;

enum attrkey key;

enum attrval val;

struct pnode *dat;

Line 331 xml_elem_start(void *arg, const XML_Char *name, const

Line 330 xml_elem_start(void *arg, const XML_Char *name, const

const XML_Char **att;

/* FIXME: find a better way to ditch other namespaces. */

if (ps->stop || 0 == strcmp(name, "xi:include"))

if (ps->stop || strcmp(name, "xi:include") == 0)

return;

/* Close out text node, if applicable... */

if (NODE_TEXT == ps->node) {

if (ps->node == NODE_TEXT) {

assert(NULL != ps->cur);

pnode_trim(ps->cur);

ps->cur = ps->cur->parent;

assert(NULL != ps->cur);

ps->node = ps->cur->node;

}

for (node = 0; node < NODE__MAX; node++)

for (node = nodes; node->name != NULL; node++)

if (NULL == nodes[node].name)

if (strcmp(node->name, name) == 0)

continue;

else if (0 == strcmp(nodes[node].name, name))

break;

if (NODE__MAX == node && NODE_ROOT == ps->node) {

if (node->name == NULL) {

return;

if (ps->node == NODE_ROOT)

} else if (NODE__MAX == node) {

return;

fprintf(stderr, "%s:%zu:%zu: unknown node \"%s\"\n",

ps->fname, XML_GetCurrentLineNumber(ps->xml),

XML_GetCurrentColumnNumber(ps->xml), name);

ps->stop = 1;

return;

} else if (NODE_ROOT == ps->node && NULL != ps->root) {

} else if (ps->node == NODE_ROOT && ps->root != NULL) {

fprintf(stderr, "%s:%zu:%zu: multiple refentries\n",

ps->fname, XML_GetCurrentLineNumber(ps->xml),

XML_GetCurrentColumnNumber(ps->xml));

ps->stop = 1;

return;

} else if (NODE_ROOT == ps->node && NODE_REFENTRY != node &&

NODE_PART != node && NODE_BOOK != node) {

return;

}

if (NODE_INLINEEQUATION == node)

if (node->node == NODE_INLINEEQUATION)

ps->flags |= PARSE_EQN;

if (NULL == (dat = calloc(1, sizeof(struct pnode)))) {

if ((dat = calloc(1, sizeof(struct pnode))) == NULL) {

perror(NULL);

exit(EXIT_FAILURE);

exit(1);

}

dat->node = ps->node = node;

dat->node = ps->node = node->node;

dat->parent = ps->cur;

TAILQ_INIT(&dat->childq);

TAILQ_INIT(&dat->attrq);

if (NULL != ps->cur)

if (ps->cur != NULL)

TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);

ps->cur = dat;

if (NULL == ps->root)

if (ps->root == NULL)

ps->root = dat;

* Process attributes.

for (att = atts; NULL != *att; att += 2) {

for (att = atts; *att != NULL; att += 2) {

for (key = 0; key < ATTRKEY__MAX; key++)

if (0 == strcmp(*att, attrkeys[key]))

if (strcmp(*att, attrkeys[key]) == 0)

break;

if (ATTRKEY__MAX == key) {

if (key == ATTRKEY__MAX) {

if (warn)

fprintf(stderr, "%s:%zu:%zu: warning: "

"unknown attribute \"%s\"\n",

Line 406 xml_elem_start(void *arg, const XML_Char *name, const

Line 398 xml_elem_start(void *arg, const XML_Char *name, const

continue;

}

for (val = 0; val < ATTRVAL__MAX; val++)

if (0 == strcmp(*(att + 1), attrvals[val]))

if (strcmp(att[1], attrvals[val]) == 0)

break;

pattr = calloc(1, sizeof(struct pattr));

pattr->key = key;

pattr->val = val;

if (ATTRVAL__MAX == val)

if (val == ATTRVAL__MAX)

pattr->rawval = strdup(*(att + 1));

pattr->rawval = strdup(att[1]);

TAILQ_INSERT_TAIL(&dat->attrq, pattr, child);

}

Line 429 xml_elem_end(void *arg, const XML_Char *name)

Line 421 xml_elem_end(void *arg, const XML_Char *name)

struct parse *ps = arg;

/* FIXME: find a better way to ditch other namespaces. */

if (ps->stop || NODE_ROOT == ps->node)

if (ps->stop || ps->node == NODE_ROOT)

return;

else if (0 == strcmp(name, "xi:include"))

else if (strcmp(name, "xi:include") == 0)

return;

/* Close out text node, if applicable... */

if (NODE_TEXT == ps->node) {

if (ps->node == NODE_TEXT) {

assert(NULL != ps->cur);

pnode_trim(ps->cur);

ps->cur = ps->cur->parent;

assert(NULL != ps->cur);

ps->node = ps->cur->node;

}

if (NULL == (ps->cur = ps->cur->parent))

if ((ps->cur = ps->cur->parent) == NULL)

ps->node = NODE_ROOT;

else

ps->node = ps->cur->node;

Line 458 pnode_free(struct pnode *pn)

Line 448 pnode_free(struct pnode *pn)

struct pnode *pp;

struct pattr *ap;

if (NULL == pn)

if (pn == NULL)

return;

while (NULL != (pp = TAILQ_FIRST(&pn->childq))) {

while ((pp = TAILQ_FIRST(&pn->childq)) != NULL) {

TAILQ_REMOVE(&pn->childq, pp, child);

pnode_free(pp);

}

while (NULL != (ap = TAILQ_FIRST(&pn->attrq))) {

while ((ap = TAILQ_FIRST(&pn->attrq)) != NULL) {

TAILQ_REMOVE(&pn->attrq, ap, child);

free(ap->rawval);

free(ap);

Line 482 pnode_free(struct pnode *pn)

Line 472 pnode_free(struct pnode *pn)

static void

pnode_unlink(struct pnode *pn)

{

if (pn->parent != NULL)

if (NULL != pn->parent)

TAILQ_REMOVE(&pn->parent->childq, pn, child);

pnode_free(pn);

}

Line 500 pnode_unlinksub(struct pnode *pn)

Line 489 pnode_unlinksub(struct pnode *pn)

}

* Retrieve an enumeration attribute from a node.

* Return ATTRVAL__MAX if the node has no such attribute.

enum attrval

pnode_getattr(struct pnode *pn, enum attrkey key)

{

struct pattr *ap;

TAILQ_FOREACH(ap, &pn->attrq, child)

if (ap->key == key)

return ap->val;

return ATTRVAL__MAX;

}

* Retrieve an attribute string from a node.

* Return defval if the node has no such attribute.

const char *

pnode_getattr_raw(struct pnode *pn, enum attrkey key, const char *defval)

{

struct pattr *ap;

TAILQ_FOREACH(ap, &pn->attrq, child)

if (ap->key == key)

return ap->val == ATTRVAL__MAX ? ap->rawval :

attrvals[ap->val];

return defval;

}

* Reset the lookaside buffer.

static void

Line 518 static void

Line 538 static void

bufappend(struct parse *p, struct pnode *pn)

{

assert(NODE_TEXT == pn->node);

assert(pn->node == NODE_TEXT);

if (p->bsz + pn->bsz + 1 > p->mbsz) {

p->mbsz = p->bsz + pn->bsz + 1;

if (NULL == (p->b = realloc(p->b, p->mbsz))) {

if ((p->b = realloc(p->b, p->mbsz)) == NULL) {

perror(NULL);

exit(EXIT_FAILURE);

exit(1);

}

memcpy(p->b + p->bsz, pn->b, pn->bsz);

Line 542 bufappend_r(struct parse *p, struct pnode *pn)

Line 562 bufappend_r(struct parse *p, struct pnode *pn)

{

struct pnode *pp;

if (NODE_TEXT == pn->node)

if (pn->node == NODE_TEXT)

bufappend(p, pn);

TAILQ_FOREACH(pp, &pn->childq, child)

bufappend_r(p, pp);

Line 560 pnode_findfirst(struct pnode *pn, enum nodeid node)

Line 580 pnode_findfirst(struct pnode *pn, enum nodeid node)

TAILQ_FOREACH(pp, &pn->childq, child) {

res = pp->node == node ? pp :

pnode_findfirst(pp, node);

if (NULL != res)

if (res != NULL)

break;

}

return(res);

return res;

}

#define MACROLINE_NORM 0

Line 579 pnode_printmacrolinetext(struct parse *p, struct pnode

Line 599 pnode_printmacrolinetext(struct parse *p, struct pnode

{

char *cp;

if (0 == p->newln && ! (MACROLINE_NOWS & fl))

if (p->newln == 0 && (fl & MACROLINE_NOWS) == 0)

putchar(' ');

bufclear(p);

bufappend_r(p, pn);

/* Convert all space to spaces. */

for (cp = p->b; '\0' != *cp; cp++)

for (cp = p->b; *cp != '\0'; cp++)

if (isspace((unsigned char)*cp))

*cp = ' ';

for (cp = p->b; isspace((unsigned char)*cp); cp++)

/* Spin past whitespace (XXX: necessary?) */ ;

for ( ; '\0' != *cp; cp++) {

for ( ; *cp != '\0'; cp++) {

/* Escape us if we look like a macro. */

if ((cp == p->b || ' ' == *(cp - 1)) &&

if ((cp == p->b || cp[-1] == ' ') &&

isupper((unsigned char)*cp) &&

isupper((unsigned char)cp[0]) &&

'\0' != *(cp + 1) &&

islower((unsigned char)cp[1]) &&

islower((unsigned char)*(cp + 1)) &&

(cp[2] == '\0' || cp[2] == ' ' ||

('\0' == *(cp + 2) ||

(islower((unsigned char)cp[2]) &&

' ' == *(cp + 2) ||

(cp[3] == '\0' || cp[3] == ' '))))

(islower((unsigned char)*(cp + 2)) &&

('\0' == *(cp + 3) ||

' ' == *(cp + 3)))))

fputs("\\&", stdout);

if (MACROLINE_UPPER & fl)

if (fl & MACROLINE_UPPER)

putchar(toupper((unsigned char)*cp));

else

putchar(*cp);

/* If we're a character escape, escape us. */

if ('\\' == *cp)

if (*cp == '\\')

putchar('e');

}

Line 628 pnode_printmacrolinepart(struct parse *p, struct pnode

Line 645 pnode_printmacrolinepart(struct parse *p, struct pnode

static void

pnode_printmacroline(struct parse *p, struct pnode *pn)

{

assert(p->newln == 0);

assert(0 == p->newln);

pnode_printmacrolinetext(p, pn, 0);

putchar('\n');

p->newln = 1;

Line 668 pnode_printmclosepunct(struct parse *p, struct pnode *

Line 684 pnode_printmclosepunct(struct parse *p, struct pnode *

return;

/* No next node or it's not text. */

if (NULL == (pn = TAILQ_NEXT(pn, child))) {

if ((pn = TAILQ_NEXT(pn, child)) == NULL) {

pnode_printmclose(p, sv);

return;

} else if (NODE_TEXT != pn->node) {

} else if (pn->node != NODE_TEXT) {

pnode_printmclose(p, sv);

return;

}

/* Only do this for the comma/period. */

if (pn->bsz > 0 &&

(',' == pn->b[0] || '.' == pn->b[0]) &&

(pn->b[0] == ',' || pn->b[0] == '.') &&

(1 == pn->bsz || isspace((unsigned char)pn->b[1]))) {

(pn->bsz == 1 || isspace((unsigned char)pn->b[1]))) {

putchar(' ');

putchar(pn->b[0]);

pn->b++;

Line 690 pnode_printmclosepunct(struct parse *p, struct pnode *

Line 706 pnode_printmclosepunct(struct parse *p, struct pnode *

p->newln = 1;

}

static void

pnode_printpara(struct parse *p, struct pnode *pn)

{

struct pnode *pp;

assert(p->newln);

if ((pp = TAILQ_PREV(pn, pnodeq, child)) == NULL &&

(pp = pn->parent) == NULL)

return;

switch (pp->node) {

case NODE_ENTRY:

case NODE_LISTITEM:

return;

case NODE_PREFACE:

case NODE_SECTION:

if (p->level < 3)

return;

break;

default:

break;

}

puts(".Pp");

}

* If the SYNOPSIS macro has a superfluous title, kill it.

Line 699 pnode_printrefsynopsisdiv(struct parse *p, struct pnod

Line 740 pnode_printrefsynopsisdiv(struct parse *p, struct pnod

struct pnode *pp;

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TITLE == pp->node) {

if (pp->node == NODE_TITLE) {

pnode_unlink(pp);

return;

}

Line 715 pnode_printrefsect(struct parse *p, struct pnode *pn)

Line 756 pnode_printrefsect(struct parse *p, struct pnode *pn)

const char *title;

int flags, level;

if (pn->parent == NULL)

return;

level = ++p->level;

flags = 1 == level ? MACROLINE_UPPER : 0;

flags = level == 1 ? MACROLINE_UPPER : 0;

if (3 > level) {

if (level < 3) {

switch (pn->node) {

case (NODE_CAUTION):

case NODE_CAUTION:

case (NODE_NOTE):

case NODE_NOTE:

case (NODE_TIP):

case NODE_TIP:

case (NODE_WARNING):

case NODE_WARNING:

level = 3;

break;

default:

Line 731 pnode_printrefsect(struct parse *p, struct pnode *pn)

Line 775 pnode_printrefsect(struct parse *p, struct pnode *pn)

}

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TITLE == pp->node)

if (pp->node == NODE_TITLE)

break;

if (NULL == pp) {

if (pp == NULL) {

switch (pn->node) {

case (NODE_PREFACE):

case NODE_PREFACE:

title = "Preface";

break;

case (NODE_CAUTION):

case NODE_CAUTION:

title = "Caution";

break;

case (NODE_NOTE):

case NODE_NOTE:

title = "Note";

break;

case (NODE_TIP):

case NODE_TIP:

title = "Tip";

break;

case (NODE_WARNING):

case NODE_WARNING:

title = "Warning";

break;

default:

Line 758 pnode_printrefsect(struct parse *p, struct pnode *pn)

Line 802 pnode_printrefsect(struct parse *p, struct pnode *pn)

}

switch (level) {

case (1):

case 1:

fputs(".Sh", stdout);

break;

case (2):

case 2:

fputs(".Ss", stdout);

break;

default:

puts(".Pp");

pnode_printpara(p, pn);

fputs(".Sy", stdout);

break;

}

if (NULL != pp) {

if (pp != NULL) {

p->newln = 0;

pnode_printmacrolinetext(p, pp, flags);

pnode_printmclose(p, 1);

Line 789 pnode_printciterefentry(struct parse *p, struct pnode

Line 833 pnode_printciterefentry(struct parse *p, struct pnode

title = manvol = NULL;

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_MANVOLNUM == pp->node)

if (pp->node == NODE_MANVOLNUM)

manvol = pp;

else if (NODE_REFENTRYTITLE == pp->node)

else if (pp->node == NODE_REFENTRYTITLE)

title = pp;

if (NULL != title) {

if (title != NULL)

pnode_printmacrolinepart(p, title);

} else

else

fputs(" unknown ", stdout);

if (NULL == manvol) {

if (manvol == NULL) {

puts(" 1");

p->newln = 1;

} else

Line 814 pnode_printrefmeta(struct parse *p, struct pnode *pn)

Line 858 pnode_printrefmeta(struct parse *p, struct pnode *pn)

title = manvol = NULL;

assert(p->newln);

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_MANVOLNUM == pp->node)

if (pp->node == NODE_MANVOLNUM)

manvol = pp;

else if (NODE_REFENTRYTITLE == pp->node)

else if (pp->node == NODE_REFENTRYTITLE)

title = pp;

fputs(".Dt", stdout);

p->newln = 0;

if (NULL != title)

if (title != NULL)

pnode_printmacrolinetext(p, title, MACROLINE_UPPER);

else

fputs(" UNKNOWN ", stdout);

if (NULL == manvol) {

if (manvol == NULL) {

puts(" 1");

p->newln = 1;

} else

Line 842 pnode_printfuncdef(struct parse *p, struct pnode *pn)

Line 886 pnode_printfuncdef(struct parse *p, struct pnode *pn)

assert(p->newln);

ftype = func = NULL;

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TEXT == pp->node)

if (pp->node == NODE_TEXT)

ftype = pp;

else if (NODE_FUNCTION == pp->node)

else if (pp->node == NODE_FUNCTION)

func = pp;

if (NULL != ftype) {

if (ftype != NULL) {

fputs(".Ft", stdout);

p->newln = 0;

pnode_printmacroline(p, ftype);

}

if (NULL != func) {

if (func != NULL) {

fputs(".Fo", stdout);

p->newln = 0;

pnode_printmacroline(p, func);

Line 871 pnode_printparamdef(struct parse *p, struct pnode *pn)

Line 915 pnode_printparamdef(struct parse *p, struct pnode *pn)

assert(p->newln);

ptype = param = NULL;

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TEXT == pp->node)

if (pp->node == NODE_TEXT)

ptype = pp;

else if (NODE_PARAMETER == pp->node)

else if (pp->node == NODE_PARAMETER)

param = pp;

fputs(".Fa \"", stdout);

p->newln = 0;

if (NULL != ptype) {

if (ptype != NULL) {

pnode_printmacrolinetext(p, ptype, MACROLINE_NOWS);

putchar(' ');

}

if (NULL != param)

if (param != NULL)

pnode_printmacrolinepart(p, param);

puts("\"");

Line 900 static void

Line 944 static void

pnode_printmathfenced(struct parse *p, struct pnode *pn)

{

struct pnode *pp;

struct pattr *ap;

TAILQ_FOREACH(ap, &pn->attrq, child)

printf("left %s ", pnode_getattr_raw(pn, ATTRKEY_OPEN, "("));

if (ATTRKEY_OPEN == ap->key) {

printf("left %s ", ap->rawval);

break;

}

if (NULL == ap)

printf("left ( ");

pp = TAILQ_FIRST(&pn->childq);

pnode_print(p, pp);

while (NULL != (pp = TAILQ_NEXT(pp, child))) {

while ((pp = TAILQ_NEXT(pp, child)) != NULL) {

putchar(',');

pnode_print(p, pp);

}

TAILQ_FOREACH(ap, &pn->attrq, child)

printf("right %s ", pnode_getattr_raw(pn, ATTRKEY_CLOSE, ")"));

if (ATTRKEY_CLOSE == ap->key) {

printf("right %s ", ap->rawval);

break;

}

if (NULL == ap)

printf("right ) ");

}

Line 942 pnode_printmath(struct parse *p, struct pnode *pn)

Line 973 pnode_printmath(struct parse *p, struct pnode *pn)

pnode_print(p, pp);

switch (pn->node) {

case (NODE_MML_MSUP):

case NODE_MML_MSUP:

fputs(" sup ", stdout);

break;

case (NODE_MML_MFRAC):

case NODE_MML_MFRAC:

fputs(" over ", stdout);

break;

case (NODE_MML_MSUB):

case NODE_MML_MSUB:

fputs(" sub ", stdout);

break;

default:

Line 966 pnode_printfuncprototype(struct parse *p, struct pnode

Line 997 pnode_printfuncprototype(struct parse *p, struct pnode

assert(p->newln);

TAILQ_FOREACH(fdef, &pn->childq, child)

if (NODE_FUNCDEF == fdef->node)

if (fdef->node == NODE_FUNCDEF)

break;

if (NULL != fdef)

if (fdef != NULL)

pnode_printfuncdef(p, fdef);

else

puts(".Fo UNKNOWN");

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_PARAMDEF == pp->node)

if (pp->node == NODE_PARAMDEF)

pnode_printparamdef(p, pp);

puts(".Fc");

Line 999 pnode_printarg(struct parse *p, struct pnode *pn)

Line 1030 pnode_printarg(struct parse *p, struct pnode *pn)

isop = 1;

isrep = 0;

TAILQ_FOREACH(ap, &pn->attrq, child)

if (ATTRKEY_CHOICE == ap->key &&

if (ap->key == ATTRKEY_CHOICE &&

(ATTRVAL_PLAIN == ap->val ||

(ap->val == ATTRVAL_PLAIN || ap->val == ATTRVAL_REQ))

ATTRVAL_REQ == ap->val))

isop = 0;

else if (ATTRKEY_REP == ap->key &&

else if (ap->key == ATTRKEY_REP && ap->val == ATTRVAL_REPEAT)

(ATTRVAL_REPEAT == ap->val))

isrep = 1;

if (isop) {

Line 1013 pnode_printarg(struct parse *p, struct pnode *pn)

Line 1042 pnode_printarg(struct parse *p, struct pnode *pn)

}

TAILQ_FOREACH(pp, &pn->childq, child) {

if (NODE_TEXT == pp->node) {

if (pp->node == NODE_TEXT) {

pnode_printmopen(p);

fputs("Ar", stdout);

}

pnode_print(p, pp);

if (NODE_TEXT == pp->node && isrep)

if (isrep && pp->node == NODE_TEXT)

fputs("...", stdout);

}

Line 1032 pnode_printgroup(struct parse *p, struct pnode *pn)

Line 1061 pnode_printgroup(struct parse *p, struct pnode *pn)

isop = 1;

TAILQ_FOREACH(ap, &pn->attrq, child)

if (ATTRKEY_CHOICE == ap->key &&

if (ap->key == ATTRKEY_CHOICE &&

(ATTRVAL_PLAIN == ap->val ||

(ap->val == ATTRVAL_PLAIN || ap->val == ATTRVAL_REQ)) {

ATTRVAL_REQ == ap->val)) {

isop = 0;

break;

}

Line 1062 pnode_printgroup(struct parse *p, struct pnode *pn)

Line 1090 pnode_printgroup(struct parse *p, struct pnode *pn)

TAILQ_FOREACH(pp, &pn->childq, child) {

pnode_print(p, pp);

np = TAILQ_NEXT(pp, child);

while (NULL != np) {

while (np != NULL) {

if (pp->node != np->node)

break;

fputs(" |", stdout);

Line 1079 static void

Line 1107 static void

pnode_printprologue(struct parse *p, struct pnode *pn)

{

struct pnode *pp;

struct pattr *ap;

const char *name;

pp = NULL == p->root ? NULL :

pp = p->root == NULL ? NULL :

pnode_findfirst(p->root, NODE_REFMETA);

puts(".Dd $Mdocdate" "$");

if (NULL != pp) {

if (pp != NULL) {

pnode_printrefmeta(p, pp);

pnode_unlink(pp);

} else {

} else

name = "UNKNOWN";

printf(".Dt %s 1\n",

TAILQ_FOREACH(ap, &p->root->attrq, child) {

pnode_getattr_raw(p->root, ATTRKEY_ID, "UNKNOWN"));

if (ATTRKEY_ID == ap->key) {

name = ap->rawval;

break;

}

printf(".Dt %s 1\n", name);

}

puts(".Os");

if (PARSE_EQN & p->flags) {

if (p->flags & PARSE_EQN) {

puts(".EQ");

puts("delim $$");

puts(".EN");

Line 1123 pnode_printvarlistentry(struct parse *p, struct pnode

Line 1142 pnode_printvarlistentry(struct parse *p, struct pnode

p->newln = 0;

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TERM == pp->node) {

if (pp->node == NODE_TERM) {

if ( ! first)

putchar(',');

pnode_print(p, pp);

Line 1160 pnode_printtable(struct parse *p, struct pnode *pn)

Line 1179 pnode_printtable(struct parse *p, struct pnode *pn)

assert(p->newln);

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TITLE == pp->node) {

if (pp->node == NODE_TITLE) {

puts(".Pp");

pnode_printpara(p, pp);

pnode_print(p, pp);

pnode_unlink(pp);

}

assert(p->newln);

puts(".Bl -ohang");

while (NULL != (pp = pnode_findfirst(pn, NODE_ROW))) {

while ((pp = pnode_findfirst(pn, NODE_ROW)) != NULL) {

puts(".It Table Row");

pnode_printrow(p, pp);

pnode_printmclose(p, 1);

Line 1184 pnode_printlist(struct parse *p, struct pnode *pn)

Line 1203 pnode_printlist(struct parse *p, struct pnode *pn)

assert(p->newln);

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TITLE == pp->node) {

if (pp->node == NODE_TITLE) {

puts(".Pp");

pnode_printpara(p, pp);

pnode_print(p, pp);

pnode_unlink(pp);

}

assert(p->newln);

if (NODE_ORDEREDLIST == pn->node)

if (pn->node == NODE_ORDEREDLIST)

puts(".Bl -enum");

else

puts(".Bl -item");

puts(".Bl -bullet");

TAILQ_FOREACH(pp, &pn->childq, child) {

assert(p->newln);

Line 1213 pnode_printvariablelist(struct parse *p, struct pnode

Line 1232 pnode_printvariablelist(struct parse *p, struct pnode

assert(p->newln);

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_TITLE == pp->node) {

if (pp->node == NODE_TITLE) {

puts(".Pp");

pnode_printpara(p, pp);

pnode_print(p, pp);

pnode_unlink(pp);

}

Line 1222 pnode_printvariablelist(struct parse *p, struct pnode

Line 1241 pnode_printvariablelist(struct parse *p, struct pnode

assert(p->newln);

puts(".Bl -tag -width Ds");

TAILQ_FOREACH(pp, &pn->childq, child)

if (NODE_VARLISTENTRY != pp->node) {

if (pp->node != NODE_VARLISTENTRY) {

assert(p->newln);

fputs(".It", stdout);

pnode_printmacroline(p, pp);

Line 1244 static void

Line 1263 static void

pnode_print(struct parse *p, struct pnode *pn)

{

struct pnode *pp;

const char *ccp;

char *cp;

int last, sv;

if (NULL == pn)

if (pn == NULL)

return;

sv = p->newln;

/* XXX fprintf(stderr, "NODE %s\n", nodes[pn->node].name); */

switch (pn->node) {

case (NODE_APPLICATION):

case NODE_APPLICATION:

pnode_printmopen(p);

fputs("Nm", stdout);

break;

case (NODE_ANCHOR):

case NODE_ANCHOR:

/* Don't print anything! */

return;

case (NODE_ARG):

case NODE_ARG:

pnode_printarg(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_AUTHOR):

case NODE_AUTHOR:

pnode_printmopen(p);

fputs("An", stdout);

break;

case (NODE_AUTHORGROUP):

case NODE_AUTHORGROUP:

assert(p->newln);

puts(".An -split");

break;

case (NODE_BOOKINFO):

case NODE_BOOKINFO:

assert(p->newln);

puts(".Sh NAME");

break;

case (NODE_CITEREFENTRY):

case NODE_CITEREFENTRY:

pnode_printmopen(p);

fputs("Xr", stdout);

pnode_printciterefentry(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_CODE):

case NODE_CODE:

pnode_printmopen(p);

fputs("Li", stdout);

break;

case (NODE_COMMAND):

case NODE_COMMAND:

pnode_printmopen(p);

fputs("Nm", stdout);

break;

case (NODE_CONSTANT):

case NODE_CONSTANT:

pnode_printmopen(p);

fputs("Dv", stdout);

break;

case (NODE_EDITOR):

case NODE_EDITOR:

puts("editor: ");

pnode_printmopen(p);

fputs("An", stdout);

break;

case (NODE_EMPHASIS):

case NODE_EMAIL:

pnode_printmopen(p);

fputs("Aq Mt", stdout);

break;

case NODE_EMPHASIS:

case NODE_FIRSTTERM:

pnode_printmopen(p);

fputs("Em", stdout);

break;

case (NODE_ENVAR):

case NODE_ENVAR:

pnode_printmopen(p);

fputs("Ev", stdout);

break;

case (NODE_FILENAME):

case NODE_FILENAME:

pnode_printmopen(p);

fputs("Pa", stdout);

break;

case (NODE_FUNCTION):

case NODE_FUNCTION:

pnode_printmopen(p);

fputs("Fn", stdout);

break;

case (NODE_FUNCPROTOTYPE):

case NODE_FUNCPROTOTYPE:

assert(p->newln);

pnode_printfuncprototype(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_FUNCSYNOPSISINFO):

case NODE_FUNCSYNOPSISINFO:

pnode_printmopen(p);

fputs("Fd", stdout);

break;

case (NODE_INFORMALEQUATION):

case NODE_INDEXTERM:

return;

case NODE_INFORMALEQUATION:

if ( ! p->newln)

putchar('\n');

puts(".EQ");

p->newln = 0;

break;

case (NODE_INLINEEQUATION):

case NODE_INLINEEQUATION:

fputc('$', stdout);

p->newln = 0;

break;

case (NODE_ITEMIZEDLIST):

case NODE_ITEMIZEDLIST:

assert(p->newln);

pnode_printlist(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_GROUP):

case NODE_GROUP:

pnode_printgroup(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_LEGALNOTICE):

case NODE_KEYSYM:

pnode_printmopen(p);

fputs("Sy", stdout);

break;

case NODE_LEGALNOTICE:

assert(p->newln);

puts(".Sh LEGAL NOTICE");

break;

case (NODE_LITERAL):

case NODE_LINK:

ccp = pnode_getattr_raw(pn, ATTRKEY_LINKEND, NULL);

if (ccp == NULL)

break;

pnode_printmopen(p);

printf("Sx %s\n", ccp);

p->newln = 1;

return;

case NODE_LITERAL:

pnode_printmopen(p);

fputs("Li", stdout);

break;

case (NODE_MML_MFENCED):

case NODE_LITERALLAYOUT:

assert(p->newln);

printf(".Bd %s\n", pnode_getattr(pn, ATTRKEY_CLASS) ==

ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");

break;

case NODE_MML_MFENCED:

pnode_printmathfenced(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_MML_MROW):

case NODE_MML_MROW:

case (NODE_MML_MI):

case NODE_MML_MI:

case (NODE_MML_MN):

case NODE_MML_MN:

case (NODE_MML_MO):

case NODE_MML_MO:

if (TAILQ_EMPTY(&pn->childq))

break;

fputs(" { ", stdout);

break;

case (NODE_MML_MFRAC):

case NODE_MML_MFRAC:

case (NODE_MML_MSUB):

case NODE_MML_MSUB:

case (NODE_MML_MSUP):

case NODE_MML_MSUP:

pnode_printmath(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_OPTION):

case NODE_OPTION:

pnode_printmopen(p);

fputs("Fl", stdout);

break;

case (NODE_ORDEREDLIST):

case NODE_ORDEREDLIST:

assert(p->newln);

pnode_printlist(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_PARA):

case NODE_PARA:

assert(p->newln);

pnode_printpara(p, pn);

if (NULL != pn->parent &&

NODE_LISTITEM == pn->parent->node)

break;

puts(".Pp");

break;

case (NODE_PARAMETER):

case NODE_PARAMETER:

/* Suppress non-text children... */

pnode_printmopen(p);

fputs("Fa \"", stdout);

Line 1394 pnode_print(struct parse *p, struct pnode *pn)

Line 1433 pnode_print(struct parse *p, struct pnode *pn)

fputs("\"", stdout);

pnode_unlinksub(pn);

break;

case (NODE_QUOTE):

case NODE_QUOTE:

pnode_printmopen(p);

fputs("Qo", stdout);

break;

case (NODE_LITERALLAYOUT):

case NODE_PROGRAMLISTING:

/* FALLTHROUGH */

case NODE_SCREEN:

case (NODE_PROGRAMLISTING):

/* FALLTHROUGH */

case (NODE_SCREEN):

assert(p->newln);

puts(".Bd -literal");

break;

case (NODE_REFENTRYINFO):

case NODE_REFENTRYINFO:

/* Suppress. */

pnode_unlinksub(pn);

break;

case (NODE_REFMETA):

case NODE_REFMETA:

abort();

break;

case (NODE_REFNAME):

case NODE_REFNAME:

/* Suppress non-text children... */

pnode_printmopen(p);

fputs("Nm", stdout);

Line 1421 pnode_print(struct parse *p, struct pnode *pn)

Line 1457 pnode_print(struct parse *p, struct pnode *pn)

pnode_printmacrolinepart(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_REFNAMEDIV):

case NODE_REFNAMEDIV:

assert(p->newln);

puts(".Sh NAME");

break;

case (NODE_REFPURPOSE):

case NODE_REFPURPOSE:

assert(p->newln);

pnode_printmopen(p);

fputs("Nd", stdout);

break;

case (NODE_REFSYNOPSISDIV):

case NODE_REFSYNOPSISDIV:

assert(p->newln);

pnode_printrefsynopsisdiv(p, pn);

puts(".Sh SYNOPSIS");

break;

case (NODE_PREFACE):

case NODE_PREFACE:

case (NODE_REFSECT1):

case NODE_SECTION:

case (NODE_REFSECT2):

case NODE_NOTE:

case (NODE_REFSECT3):

case NODE_TIP:

case (NODE_REFSECTION):

case NODE_CAUTION:

case (NODE_CHAPTER):

case NODE_WARNING:

case (NODE_SECT1):

case (NODE_SECT2):

case (NODE_SECTION):

case (NODE_NOTE):

case (NODE_TIP):

case (NODE_CAUTION):

case (NODE_WARNING):

assert(p->newln);

pnode_printrefsect(p, pn);

break;

case (NODE_REPLACEABLE):

case NODE_REPLACEABLE:

pnode_printmopen(p);

fputs("Ar", stdout);

break;

case (NODE_SBR):

case NODE_SBR:

assert(p->newln);

puts(".br");

break;

case (NODE_SGMLTAG):

case NODE_SGMLTAG:

pnode_printmopen(p);

fputs("Li", stdout);

break;

case (NODE_STRUCTNAME):

case NODE_STRUCTNAME:

pnode_printmopen(p);

fputs("Vt", stdout);

break;

case (NODE_TABLE):

case NODE_TABLE:

/* FALLTHROUGH */

case NODE_INFORMALTABLE:

case (NODE_INFORMALTABLE):

assert(p->newln);

pnode_printtable(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_TEXT):

case NODE_TEXT:

if (0 == p->newln)

if (p->newln == 0)

putchar(' ');

bufclear(p);

bufappend(p, pn);

if (0 == p->bsz) {

if (p->bsz == 0) {

assert(pn->real != pn->b);

break;

}

Line 1500 pnode_print(struct parse *p, struct pnode *pn)

Line 1528 pnode_print(struct parse *p, struct pnode *pn)

* before the actual flags themselves.

* "Fl" does this for us, so remove it.

if (NULL != pn->parent &&

if (pn->parent != NULL &&

NODE_OPTION == pn->parent->node &&

pn->parent->node == NODE_OPTION &&

'-' == *cp)

*cp == '-')

cp++;

for (last = '\n'; '\0' != *cp; ) {

for (last = '\n'; *cp != '\0'; ) {

if ('\n' == last) {

if (last == '\n') {

/* Consume all whitespace. */

if (isspace((unsigned char)*cp)) {

while (isspace((unsigned char)*cp))

cp++;

continue;

} else if ('\'' == *cp || '.' == *cp)

} else if (*cp == '\'' || *cp == '.')

fputs("\\&", stdout);

}

putchar(last = *cp++);

/* If we're a character escape, escape us. */

if ('\\' == last)

if (last == '\\')

putchar('e');

}

p->newln = 0;

break;

case (NODE_TITLE):

case NODE_TITLE:

if (pn->parent->node == NODE_BOOKINFO) {

pnode_printmopen(p);

fputs("Nd", stdout);

}

break;

case (NODE_TYPE):

case NODE_TYPE:

pnode_printmopen(p);

fputs("Vt", stdout);

break;

case (NODE_USERINPUT):

case NODE_USERINPUT:

pnode_printmopen(p);

fputs("Li", stdout);

break;

case (NODE_VARIABLELIST):

case NODE_VARIABLELIST:

assert(p->newln);

pnode_printvariablelist(p, pn);

pnode_unlinksub(pn);

break;

case (NODE_VARLISTENTRY):

case NODE_VARLISTENTRY:

assert(p->newln);

pnode_printvarlistentry(p, pn);

break;

case (NODE_VARNAME):

case NODE_VARNAME:

pnode_printmopen(p);

fputs("Va", stdout);

break;

Line 1556 pnode_print(struct parse *p, struct pnode *pn)

Line 1584 pnode_print(struct parse *p, struct pnode *pn)

pnode_print(p, pp);

switch (pn->node) {

case (NODE_INFORMALEQUATION):

case NODE_INFORMALEQUATION:

if ( ! p->newln)

putchar('\n');

puts(".EN");

p->newln = 1;

break;

case (NODE_INLINEEQUATION):

case NODE_INLINEEQUATION:

fputs("$ ", stdout);

p->newln = sv;

break;

case (NODE_MML_MROW):

case NODE_MML_MROW:

case (NODE_MML_MI):

case NODE_MML_MI:

case (NODE_MML_MN):

case NODE_MML_MN:

case (NODE_MML_MO):

case NODE_MML_MO:

if (TAILQ_EMPTY(&pn->childq))

break;

fputs(" } ", stdout);

break;

case (NODE_APPLICATION):

case NODE_APPLICATION:

case (NODE_ARG):

case NODE_ARG:

case (NODE_AUTHOR):

case NODE_AUTHOR:

case (NODE_CITEREFENTRY):

case NODE_CITEREFENTRY:

case (NODE_CODE):

case NODE_CODE:

case (NODE_COMMAND):

case NODE_COMMAND:

case (NODE_CONSTANT):

case NODE_CONSTANT:

case (NODE_EDITOR):

case NODE_EDITOR:

case (NODE_EMPHASIS):

case NODE_EMAIL:

case (NODE_ENVAR):

case NODE_EMPHASIS:

case (NODE_FILENAME):

case NODE_ENVAR:

case (NODE_FUNCTION):

case NODE_FILENAME:

case (NODE_FUNCSYNOPSISINFO):

case NODE_FIRSTTERM:

case (NODE_LITERAL):

case NODE_FUNCTION:

case (NODE_OPTION):

case NODE_FUNCSYNOPSISINFO:

case (NODE_PARAMETER):

case NODE_KEYSYM:

case (NODE_REPLACEABLE):

case NODE_LITERAL:

case (NODE_REFPURPOSE):

case NODE_OPTION:

case (NODE_SGMLTAG):

case NODE_PARAMETER:

case (NODE_STRUCTNAME):

case NODE_REPLACEABLE:

case (NODE_TEXT):

case NODE_REFPURPOSE:

case (NODE_TYPE):

case NODE_SGMLTAG:

case (NODE_USERINPUT):

case NODE_STRUCTNAME:

case (NODE_VARNAME):

case NODE_TEXT:

case NODE_TYPE:

case NODE_USERINPUT:

case NODE_VARNAME:

pnode_printmclosepunct(p, pn, sv);

break;

case (NODE_QUOTE):

case NODE_QUOTE:

pnode_printmclose(p, sv);

sv = p->newln;

pnode_printmopen(p);

fputs("Qc", stdout);

pnode_printmclose(p, sv);

break;

case (NODE_REFNAME):

case NODE_REFNAME:

* If we're in the NAME macro and we have multiple

* <refname> macros in sequence, then print out a

* trailing comma before the newline.

if (NULL != pn->parent &&

if (pn->parent != NULL &&

NODE_REFNAMEDIV == pn->parent->node &&

pn->parent->node == NODE_REFNAMEDIV &&

NULL != TAILQ_NEXT(pn, child) &&

TAILQ_NEXT(pn, child) != NULL &&

NODE_REFNAME == TAILQ_NEXT(pn, child)->node)

TAILQ_NEXT(pn, child)->node == NODE_REFNAME)

fputs(" ,", stdout);

pnode_printmclose(p, sv);

break;

case (NODE_PREFACE):

case NODE_PREFACE:

case (NODE_REFSECT1):

case NODE_SECTION:

case (NODE_REFSECT2):

case NODE_NOTE:

case (NODE_REFSECT3):

case NODE_TIP:

case (NODE_REFSECTION):

case NODE_CAUTION:

case (NODE_CHAPTER):

case NODE_WARNING:

case (NODE_SECT1):

case (NODE_SECT2):

case (NODE_SECTION):

case (NODE_NOTE):

case (NODE_TIP):

case (NODE_CAUTION):

case (NODE_WARNING):

p->level--;

break;

case (NODE_LITERALLAYOUT):

case NODE_LITERALLAYOUT:

/* FALLTHROUGH */

case NODE_PROGRAMLISTING:

case (NODE_PROGRAMLISTING):

case NODE_SCREEN:

/* FALLTHROUGH */

case (NODE_SCREEN):

assert(p->newln);

puts(".Ed");

p->newln = 1;

break;

case (NODE_TITLE):

case NODE_TITLE:

if (pn->parent->node == NODE_BOOKINFO) {

pnode_printmclose(p, 1);

puts(".Sh AUTHORS");

Line 1678 readfile(XML_Parser xp, int fd,

Line 1700 readfile(XML_Parser xp, int fd,

XML_SetUserData(xp, &p);

while ((ssz = read(fd, b, bsz)) >= 0) {

if (0 == (rc = XML_Parse(xp, b, ssz, 0 == ssz)))

if ((rc = XML_Parse(xp, b, ssz, 0 == ssz)) == 0)

fprintf(stderr, "%s:%zu:%zu: %s\n", fn,

XML_GetCurrentLineNumber(xp),

XML_GetCurrentColumnNumber(xp),

Line 1695 readfile(XML_Parser xp, int fd,

Line 1717 readfile(XML_Parser xp, int fd,

pnode_print(&p, p.root);

pnode_free(p.root);

free(p.b);

return(0 != rc && ! p.stop);

return rc != 0 && p.stop == 0;

}

/* Read error has occured. */

perror(fn);

pnode_free(p.root);

free(p.b);

return(0);

return 0;

}

int

Line 1723 main(int argc, char *argv[])

Line 1745 main(int argc, char *argv[])

fname = "-";

xp = NULL;

buf = NULL;

rc = 0;

rc = 1;

while (-1 != (ch = getopt(argc, argv, "W")))

while ((ch = getopt(argc, argv, "W")) != -1)

switch (ch) {

case ('W'):

case 'W':

warn = 1;

break;

default:

Line 1744 main(int argc, char *argv[])

Line 1766 main(int argc, char *argv[])

fname = argv[0];

/* Read from stdin or a file. */

fd = 0 == strcmp(fname, "-") ?

fd = strcmp(fname, "-") == 0 ?

STDIN_FILENO : open(fname, O_RDONLY, 0);

Line 1753 main(int argc, char *argv[])

Line 1775 main(int argc, char *argv[])

* Create the parser context.

* Dive directly into the parse.

if (-1 == fd)

if (fd == -1)

perror(fname);

else if (NULL == (buf = malloc(4096)))

else if ((buf = malloc(4096)) == NULL)

perror(NULL);

else if (NULL == (xp = XML_ParserCreate(NULL)))

else if ((xp = XML_ParserCreate(NULL)) == NULL)

perror(NULL);

else if ( ! readfile(xp, fd, buf, 4096, fname))

else if (readfile(xp, fd, buf, 4096, fname))

rc = 1;

rc = 0;

XML_ParserFree(xp);

free(buf);

if (STDIN_FILENO != fd)

if (fd != STDIN_FILENO)

close(fd);

return(rc ? EXIT_SUCCESS : EXIT_FAILURE);

return rc;

usage:

fprintf(stderr, "usage: %s [-W] [input_filename]\n", progname);

return(EXIT_FAILURE);

return 1;

}

CVSweb