version 1.38, 2014/04/30 12:54:26 |
version 1.42, 2014/10/12 15:48:42 |
|
|
|
|
static const char *attrkeys[ATTRKEY__MAX] = { |
static const char *attrkeys[ATTRKEY__MAX] = { |
"choice", |
"choice", |
|
"close", |
"id", |
"id", |
|
"open", |
"rep" |
"rep" |
}; |
}; |
|
|
Line 96 static const struct node nodes[NODE__MAX] = { |
|
Line 98 static const struct node nodes[NODE__MAX] = { |
|
{ "citerefentry", NODE_IGNTEXT }, |
{ "citerefentry", NODE_IGNTEXT }, |
{ "cmdsynopsis", NODE_IGNTEXT }, |
{ "cmdsynopsis", NODE_IGNTEXT }, |
{ "code", 0 }, |
{ "code", 0 }, |
|
{ "colspec", NODE_IGNTEXT }, |
{ "command", 0 }, |
{ "command", 0 }, |
{ "constant", 0 }, |
{ "constant", 0 }, |
{ "copyright", NODE_IGNTEXT }, |
{ "copyright", NODE_IGNTEXT }, |
Line 103 static const struct node nodes[NODE__MAX] = { |
|
Line 106 static const struct node nodes[NODE__MAX] = { |
|
{ "emphasis", 0 }, |
{ "emphasis", 0 }, |
{ "entry", 0 }, |
{ "entry", 0 }, |
{ "envar", 0 }, |
{ "envar", 0 }, |
|
{ "fieldsynopsis", NODE_IGNTEXT }, |
{ "filename", 0 }, |
{ "filename", 0 }, |
{ "funcdef", 0 }, |
{ "funcdef", 0 }, |
{ "funcprototype", NODE_IGNTEXT }, |
{ "funcprototype", NODE_IGNTEXT }, |
Line 112 static const struct node nodes[NODE__MAX] = { |
|
Line 116 static const struct node nodes[NODE__MAX] = { |
|
{ "group", NODE_IGNTEXT }, |
{ "group", NODE_IGNTEXT }, |
{ "holder", NODE_IGNTEXT }, |
{ "holder", NODE_IGNTEXT }, |
{ "info", NODE_IGNTEXT }, |
{ "info", NODE_IGNTEXT }, |
|
{ "informalequation", NODE_IGNTEXT }, |
{ "informaltable", NODE_IGNTEXT }, |
{ "informaltable", NODE_IGNTEXT }, |
|
{ "inlineequation", NODE_IGNTEXT }, |
{ "itemizedlist", NODE_IGNTEXT }, |
{ "itemizedlist", NODE_IGNTEXT }, |
{ "link", 0 }, |
{ "link", 0 }, |
{ "listitem", NODE_IGNTEXT }, |
{ "listitem", NODE_IGNTEXT }, |
{ "literal", 0 }, |
{ "literal", 0 }, |
{ "manvolnum", 0 }, |
{ "manvolnum", 0 }, |
|
{ "mml:math", NODE_IGNTEXT }, |
|
{ "mml:mfenced", 0 }, |
|
{ "mml:mfrac", 0 }, |
|
{ "mml:mi", 0 }, |
|
{ "mml:mn", 0 }, |
|
{ "mml:mo", 0 }, |
|
{ "mml:mrow", 0 }, |
|
{ "mml:msub", 0 }, |
|
{ "mml:msup", 0 }, |
|
{ "modifier", 0 }, |
{ "note", NODE_IGNTEXT }, |
{ "note", NODE_IGNTEXT }, |
{ "option", 0 }, |
{ "option", 0 }, |
{ "orderedlist", NODE_IGNTEXT }, |
{ "orderedlist", NODE_IGNTEXT }, |
Line 160 static const struct node nodes[NODE__MAX] = { |
|
Line 176 static const struct node nodes[NODE__MAX] = { |
|
{ "tip", NODE_IGNTEXT }, |
{ "tip", NODE_IGNTEXT }, |
{ "title", 0 }, |
{ "title", 0 }, |
{ "trademark", 0 }, |
{ "trademark", 0 }, |
|
{ "type", 0 }, |
{ "ulink", 0 }, |
{ "ulink", 0 }, |
{ "userinput", 0 }, |
{ "userinput", 0 }, |
{ "variablelist", NODE_IGNTEXT }, |
{ "variablelist", NODE_IGNTEXT }, |
Line 847 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
Line 864 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
p->newln = 1; |
p->newln = 1; |
} |
} |
|
|
|
/* |
|
* The <mml:mfenced> node is a little peculiar. |
|
* First, it can have arbitrary open and closing tokens, which default |
|
* to parentheses. |
|
* Second, >1 arguments are separated by commas. |
|
*/ |
static void |
static void |
|
pnode_printmathfenced(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp; |
|
struct pattr *ap; |
|
|
|
TAILQ_FOREACH(ap, &pn->attrq, child) |
|
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))) { |
|
putchar(','); |
|
pnode_print(p, pp); |
|
} |
|
|
|
TAILQ_FOREACH(ap, &pn->attrq, child) |
|
if (ATTRKEY_CLOSE == ap->key) { |
|
printf("right %s ", ap->rawval); |
|
break; |
|
} |
|
if (NULL == ap) |
|
printf("right ) "); |
|
} |
|
|
|
/* |
|
* These math nodes require special handling because they have infix |
|
* syntax, instead of the usual prefix or prefix. |
|
* So we need to break up the first and second child node with a |
|
* particular eqn(7) word. |
|
*/ |
|
static void |
|
pnode_printmath(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp; |
|
|
|
pp = TAILQ_FIRST(&pn->childq); |
|
pnode_print(p, pp); |
|
|
|
switch (pn->node) { |
|
case (NODE_MML_MSUP): |
|
fputs(" sup ", stdout); |
|
break; |
|
case (NODE_MML_MFRAC): |
|
fputs(" over ", stdout); |
|
break; |
|
case (NODE_MML_MSUB): |
|
fputs(" sub ", stdout); |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
pp = TAILQ_NEXT(pp, child); |
|
pnode_print(p, pp); |
|
} |
|
|
|
static void |
pnode_printfuncprototype(struct parse *p, struct pnode *pn) |
pnode_printfuncprototype(struct parse *p, struct pnode *pn) |
{ |
{ |
struct pnode *pp, *fdef; |
struct pnode *pp, *fdef; |
Line 982 pnode_printprologue(struct parse *p, struct pnode *pn) |
|
Line 1068 pnode_printprologue(struct parse *p, struct pnode *pn) |
|
} |
} |
} |
} |
|
|
|
/* |
|
* We can have multiple <term> elements within a <varlistentry>, which |
|
* we should comma-separate as list headers. |
|
*/ |
static void |
static void |
pnode_printvarlistentry(struct parse *p, struct pnode *pn) |
pnode_printvarlistentry(struct parse *p, struct pnode *pn) |
{ |
{ |
struct pnode *pp; |
struct pnode *pp; |
|
int first = 1; |
|
|
assert(p->newln); |
assert(p->newln); |
|
fputs(".It", stdout); |
|
p->newln = 0; |
|
|
TAILQ_FOREACH(pp, &pn->childq, child) |
TAILQ_FOREACH(pp, &pn->childq, child) |
if (NODE_TERM == pp->node) { |
if (NODE_TERM == pp->node) { |
assert(p->newln); |
if ( ! first) |
fputs(".It", stdout); |
putchar(','); |
p->newln = 0; |
|
pnode_print(p, pp); |
pnode_print(p, pp); |
pnode_unlink(pp); |
pnode_unlink(pp); |
pnode_printmclose(p, 1); |
first = 0; |
return; |
} else |
} |
break; |
|
|
puts(".It"); |
putchar('\n'); |
p->newln = 1; |
p->newln = 1; |
} |
} |
|
|
Line 1187 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1280 pnode_print(struct parse *p, struct pnode *pn) |
|
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Li", stdout); |
fputs("Li", stdout); |
break; |
break; |
|
case (NODE_MML_MATH): |
|
if ( ! p->newln) |
|
putchar('\n'); |
|
puts(".EQ"); |
|
p->newln = 0; |
|
break; |
|
case (NODE_MML_MFENCED): |
|
pnode_printmathfenced(p, pn); |
|
pnode_unlinksub(pn); |
|
break; |
|
case (NODE_MML_MROW): |
|
case (NODE_MML_MI): |
|
case (NODE_MML_MN): |
|
case (NODE_MML_MO): |
|
putchar('{'); |
|
break; |
|
case (NODE_MML_MFRAC): |
|
case (NODE_MML_MSUB): |
|
case (NODE_MML_MSUP): |
|
pnode_printmath(p, pn); |
|
pnode_unlinksub(pn); |
|
break; |
case (NODE_OPTION): |
case (NODE_OPTION): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Fl", stdout); |
fputs("Fl", stdout); |
Line 1338 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1453 pnode_print(struct parse *p, struct pnode *pn) |
|
} |
} |
p->newln = 0; |
p->newln = 0; |
break; |
break; |
|
case (NODE_TYPE): |
|
pnode_printmopen(p); |
|
fputs("Vt", stdout); |
|
break; |
case (NODE_USERINPUT): |
case (NODE_USERINPUT): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Li", stdout); |
fputs("Li", stdout); |
Line 1363 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1482 pnode_print(struct parse *p, struct pnode *pn) |
|
pnode_print(p, pp); |
pnode_print(p, pp); |
|
|
switch (pn->node) { |
switch (pn->node) { |
|
case (NODE_MML_MATH): |
|
if ( ! p->newln) |
|
putchar('\n'); |
|
puts(".EN"); |
|
p->newln = 1; |
|
break; |
|
case (NODE_MML_MROW): |
|
case (NODE_MML_MI): |
|
case (NODE_MML_MN): |
|
case (NODE_MML_MO): |
|
putchar('}'); |
|
break; |
case (NODE_APPLICATION): |
case (NODE_APPLICATION): |
case (NODE_ARG): |
case (NODE_ARG): |
case (NODE_CITEREFENTRY): |
case (NODE_CITEREFENTRY): |
Line 1382 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1513 pnode_print(struct parse *p, struct pnode *pn) |
|
case (NODE_SGMLTAG): |
case (NODE_SGMLTAG): |
case (NODE_STRUCTNAME): |
case (NODE_STRUCTNAME): |
case (NODE_TEXT): |
case (NODE_TEXT): |
|
case (NODE_TYPE): |
case (NODE_USERINPUT): |
case (NODE_USERINPUT): |
case (NODE_VARNAME): |
case (NODE_VARNAME): |
pnode_printmclosepunct(p, pn, sv); |
pnode_printmclosepunct(p, pn, sv); |