version 1.13, 2014/03/30 11:48:10 |
version 1.25, 2014/04/02 07:48:34 |
Line 87 static const char *attrvals[ATTRVAL__MAX] = { |
|
Line 87 static const char *attrvals[ATTRVAL__MAX] = { |
|
|
|
static const struct node nodes[NODE__MAX] = { |
static const struct node nodes[NODE__MAX] = { |
{ NULL, 0 }, |
{ NULL, 0 }, |
|
{ "acronym", 0 }, |
{ "arg", 0 }, |
{ "arg", 0 }, |
{ "citerefentry", NODE_IGNTEXT }, |
{ "citerefentry", NODE_IGNTEXT }, |
{ "cmdsynopsis", NODE_IGNTEXT }, |
{ "cmdsynopsis", NODE_IGNTEXT }, |
{ "code", 0 }, |
{ "code", 0 }, |
{ "command", 0 }, |
{ "command", 0 }, |
|
{ "date", 0 }, |
{ "emphasis", 0 }, |
{ "emphasis", 0 }, |
|
{ "entry", 0 }, |
|
{ "envar", 0 }, |
|
{ "filename", 0 }, |
{ "funcdef", 0 }, |
{ "funcdef", 0 }, |
{ "funcprototype", NODE_IGNTEXT }, |
{ "funcprototype", NODE_IGNTEXT }, |
{ "funcsynopsis", NODE_IGNTEXT }, |
{ "funcsynopsis", NODE_IGNTEXT }, |
{ "funcsynopsisinfo", 0 }, |
{ "funcsynopsisinfo", 0 }, |
{ "function", 0 }, |
{ "function", 0 }, |
|
{ "itemizedlist", NODE_IGNTEXT }, |
|
{ "group", NODE_IGNTEXT }, |
|
{ "link", 0 }, |
{ "listitem", NODE_IGNTEXT }, |
{ "listitem", NODE_IGNTEXT }, |
|
{ "literal", 0 }, |
{ "manvolnum", 0 }, |
{ "manvolnum", 0 }, |
{ "option", 0 }, |
{ "option", 0 }, |
|
{ "orderedlist", NODE_IGNTEXT }, |
{ "para", 0 }, |
{ "para", 0 }, |
{ "paramdef", 0 }, |
{ "paramdef", 0 }, |
{ "parameter", 0 }, |
{ "parameter", 0 }, |
{ "programlisting", 0 }, |
{ "programlisting", 0 }, |
|
{ "prompt", 0 }, |
{ "refclass", NODE_IGNTEXT }, |
{ "refclass", NODE_IGNTEXT }, |
{ "refdescriptor", NODE_IGNTEXT }, |
{ "refdescriptor", NODE_IGNTEXT }, |
{ "refentry", NODE_IGNTEXT }, |
{ "refentry", NODE_IGNTEXT }, |
|
{ "refentryinfo", NODE_IGNTEXT }, |
{ "refentrytitle", 0 }, |
{ "refentrytitle", 0 }, |
{ "refmeta", NODE_IGNTEXT }, |
{ "refmeta", NODE_IGNTEXT }, |
{ "refmiscinfo", NODE_IGNTEXT }, |
{ "refmiscinfo", NODE_IGNTEXT }, |
{ "refname", 0 }, |
{ "refname", 0 }, |
{ "refnamediv", NODE_IGNTEXT }, |
{ "refnamediv", NODE_IGNTEXT }, |
{ "refpurpose", 0 }, |
{ "refpurpose", 0 }, |
{ "refsect1", 0 }, |
{ "refsect1", NODE_IGNTEXT }, |
|
{ "refsect2", NODE_IGNTEXT }, |
{ "refsynopsisdiv", NODE_IGNTEXT }, |
{ "refsynopsisdiv", NODE_IGNTEXT }, |
{ "replaceable", 0 }, |
{ "replaceable", 0 }, |
|
{ "row", NODE_IGNTEXT }, |
|
{ "sbr", NODE_IGNTEXT }, |
|
{ "screen", NODE_IGNTEXT }, |
{ "structname", 0 }, |
{ "structname", 0 }, |
{ "synopsis", 0 }, |
{ "synopsis", 0 }, |
|
{ "table", NODE_IGNTEXT }, |
|
{ "tbody", NODE_IGNTEXT }, |
{ "term", 0 }, |
{ "term", 0 }, |
{ NULL, 0 }, |
{ NULL, 0 }, |
|
{ "tfoot", NODE_IGNTEXT }, |
|
{ "tgroup", NODE_IGNTEXT }, |
|
{ "thead", NODE_IGNTEXT }, |
{ "title", 0 }, |
{ "title", 0 }, |
|
{ "ulink", 0 }, |
|
{ "userinput", 0 }, |
{ "variablelist", NODE_IGNTEXT }, |
{ "variablelist", NODE_IGNTEXT }, |
{ "varlistentry", NODE_IGNTEXT }, |
{ "varlistentry", NODE_IGNTEXT }, |
}; |
}; |
Line 462 bufappend_r(struct parse *p, struct pnode *pn) |
|
Line 485 bufappend_r(struct parse *p, struct pnode *pn) |
|
bufappend_r(p, pp); |
bufappend_r(p, pp); |
} |
} |
|
|
|
/* |
|
* Recursively search and return the first instance of "node". |
|
*/ |
|
static struct pnode * |
|
pnode_findfirst(struct pnode *pn, enum nodeid node) |
|
{ |
|
struct pnode *pp, *res; |
|
|
|
res = NULL; |
|
TAILQ_FOREACH(pp, &pn->childq, child) { |
|
res = pp->node == node ? pp : |
|
pnode_findfirst(pp, node); |
|
if (NULL != res) |
|
break; |
|
} |
|
|
|
return(res); |
|
} |
|
|
#define MACROLINE_NORM 0 |
#define MACROLINE_NORM 0 |
#define MACROLINE_UPPER 1 |
#define MACROLINE_UPPER 1 |
/* |
/* |
Line 576 pnode_printrefsect(struct parse *p, struct pnode *pn) |
|
Line 618 pnode_printrefsect(struct parse *p, struct pnode *pn) |
|
if (NODE_TITLE == pp->node) |
if (NODE_TITLE == pp->node) |
break; |
break; |
|
|
fputs(".Sh", stdout); |
if (NODE_REFSECT1 == pn->node) |
|
fputs(".Sh", stdout); |
|
else |
|
fputs(".Ss", stdout); |
|
|
p->newln = 0; |
p->newln = 0; |
|
|
if (NULL != pp) { |
if (NULL != pp) { |
pnode_printmacroline(p, pp); |
pnode_printmacrolinetext(p, pp, |
|
NODE_REFSECT1 == pn->node ? |
|
MACROLINE_UPPER : 0); |
|
pnode_printmclose(p, 1); |
pnode_unlink(pp); |
pnode_unlink(pp); |
} else { |
} else { |
puts("UNKNOWN"); |
puts("UNKNOWN"); |
Line 770 pnode_printarg(struct parse *p, struct pnode *pn) |
|
Line 819 pnode_printarg(struct parse *p, struct pnode *pn) |
|
} |
} |
} |
} |
|
|
/* |
static void |
* Recursively search and return the first instance of "node". |
pnode_printgroup(struct parse *p, struct pnode *pn) |
*/ |
|
static struct pnode * |
|
pnode_findfirst(struct pnode *pn, enum nodeid node) |
|
{ |
{ |
struct pnode *pp, *res; |
struct pnode *pp, *np; |
|
struct pattr *ap; |
|
int isop, sv; |
|
|
res = NULL; |
isop = 1; |
TAILQ_FOREACH(pp, &pn->childq, child) { |
TAILQ_FOREACH(ap, &pn->attrq, child) |
res = pp->node == node ? pp : |
if (ATTRKEY_CHOICE == ap->key && |
pnode_findfirst(pp, node); |
(ATTRVAL_PLAIN == ap->val || |
if (NULL != res) |
ATTRVAL_REQ == ap->val)) { |
|
isop = 0; |
break; |
break; |
|
} |
|
|
|
/* |
|
* Make sure we're on a macro line. |
|
* This will prevent pnode_print() for putting us on a |
|
* subsequent line. |
|
*/ |
|
sv = p->newln; |
|
pnode_printmopen(p); |
|
if (isop) |
|
fputs("Op", stdout); |
|
else if (sv) |
|
fputs("No", stdout); |
|
|
|
/* |
|
* Keep on printing text separated by the vertical bar as long |
|
* as we're within the same origin node as the group. |
|
* This is kind of a nightmare. |
|
* Eh, DocBook... |
|
* 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 (NULL != np) { |
|
if (pp->node != np->node) |
|
break; |
|
fputs(" |", stdout); |
|
pnode_printmacrolinepart(p, np); |
|
pp = np; |
|
np = TAILQ_NEXT(np, child); |
|
} |
} |
} |
|
|
return(res); |
pnode_printmclose(p, sv); |
} |
} |
|
|
static void |
static void |
Line 820 pnode_printvarlistentry(struct parse *p, struct pnode |
|
Line 902 pnode_printvarlistentry(struct parse *p, struct pnode |
|
p->newln = 0; |
p->newln = 0; |
pnode_print(p, pp); |
pnode_print(p, pp); |
pnode_unlink(pp); |
pnode_unlink(pp); |
putchar('\n'); |
pnode_printmclose(p, 1); |
p->newln = 1; |
|
return; |
return; |
} |
} |
|
|
Line 830 pnode_printvarlistentry(struct parse *p, struct pnode |
|
Line 911 pnode_printvarlistentry(struct parse *p, struct pnode |
|
} |
} |
|
|
static void |
static void |
|
pnode_printrow(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp; |
|
|
|
puts(".Bl -dash -compact"); |
|
|
|
TAILQ_FOREACH(pp, &pn->childq, child) { |
|
assert(p->newln); |
|
puts(".It"); |
|
pnode_print(p, pp); |
|
pnode_printmclose(p, 1); |
|
} |
|
assert(p->newln); |
|
puts(".El"); |
|
} |
|
|
|
static void |
|
pnode_printtable(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp; |
|
|
|
assert(p->newln); |
|
TAILQ_FOREACH(pp, &pn->childq, child) |
|
if (NODE_TITLE == pp->node) { |
|
puts(".Pp"); |
|
pnode_print(p, pp); |
|
pnode_unlink(pp); |
|
} |
|
assert(p->newln); |
|
puts(".Bl -ohang"); |
|
while (NULL != (pp = pnode_findfirst(pn, NODE_ROW))) { |
|
puts(".It Table Row"); |
|
pnode_printrow(p, pp); |
|
pnode_printmclose(p, 1); |
|
pnode_unlink(pp); |
|
} |
|
assert(p->newln); |
|
puts(".El"); |
|
} |
|
|
|
static void |
|
pnode_printlist(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp; |
|
|
|
assert(p->newln); |
|
TAILQ_FOREACH(pp, &pn->childq, child) |
|
if (NODE_TITLE == pp->node) { |
|
puts(".Pp"); |
|
pnode_print(p, pp); |
|
pnode_unlink(pp); |
|
} |
|
assert(p->newln); |
|
|
|
if (NODE_ORDEREDLIST == pn->node) |
|
puts(".Bl -enum"); |
|
else |
|
puts(".Bl -item"); |
|
|
|
TAILQ_FOREACH(pp, &pn->childq, child) { |
|
assert(p->newln); |
|
puts(".It"); |
|
pnode_print(p, pp); |
|
pnode_printmclose(p, 1); |
|
} |
|
assert(p->newln); |
|
puts(".El"); |
|
} |
|
|
|
static void |
pnode_printvariablelist(struct parse *p, struct pnode *pn) |
pnode_printvariablelist(struct parse *p, struct pnode *pn) |
{ |
{ |
struct pnode *pp; |
struct pnode *pp; |
Line 860 pnode_printvariablelist(struct parse *p, struct pnode |
|
Line 1011 pnode_printvariablelist(struct parse *p, struct pnode |
|
/* |
/* |
* Print a parsed node (or ignore it--whatever). |
* Print a parsed node (or ignore it--whatever). |
* This is a recursive function. |
* This is a recursive function. |
* FIXME: macro line continuation? |
* FIXME: if we're in a literal context (<screen> or <programlisting> or |
|
* whatever), don't print inline macros. |
*/ |
*/ |
static void |
static void |
pnode_print(struct parse *p, struct pnode *pn) |
pnode_print(struct parse *p, struct pnode *pn) |
Line 896 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1048 pnode_print(struct parse *p, struct pnode *pn) |
|
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Em", stdout); |
fputs("Em", stdout); |
break; |
break; |
|
case (NODE_ENVAR): |
|
pnode_printmopen(p); |
|
fputs("Ev", stdout); |
|
break; |
|
case (NODE_FILENAME): |
|
pnode_printmopen(p); |
|
fputs("Pa", stdout); |
|
break; |
case (NODE_FUNCTION): |
case (NODE_FUNCTION): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Fn", stdout); |
fputs("Fn", stdout); |
Line 909 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1069 pnode_print(struct parse *p, struct pnode *pn) |
|
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Fd", stdout); |
fputs("Fd", stdout); |
break; |
break; |
|
case (NODE_ITEMIZEDLIST): |
|
assert(p->newln); |
|
pnode_printlist(p, pn); |
|
pnode_unlinksub(pn); |
|
break; |
|
case (NODE_GROUP): |
|
pnode_printgroup(p, pn); |
|
pnode_unlinksub(pn); |
|
break; |
|
case (NODE_LITERAL): |
|
pnode_printmopen(p); |
|
fputs("Li", stdout); |
|
break; |
case (NODE_OPTION): |
case (NODE_OPTION): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Fl", stdout); |
fputs("Fl", stdout); |
/* FIXME: bogus leading '-'? */ |
|
break; |
break; |
|
case (NODE_ORDEREDLIST): |
|
assert(p->newln); |
|
pnode_printlist(p, pn); |
|
pnode_unlinksub(pn); |
|
break; |
case (NODE_PARA): |
case (NODE_PARA): |
assert(p->newln); |
assert(p->newln); |
if (NULL != pn->parent && |
if (NULL != pn->parent && |
Line 930 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1107 pnode_print(struct parse *p, struct pnode *pn) |
|
pnode_unlinksub(pn); |
pnode_unlinksub(pn); |
break; |
break; |
case (NODE_PROGRAMLISTING): |
case (NODE_PROGRAMLISTING): |
|
/* FALLTHROUGH */ |
|
case (NODE_SCREEN): |
assert(p->newln); |
assert(p->newln); |
puts(".Bd -literal"); |
puts(".Bd -literal"); |
break; |
break; |
|
case (NODE_REFENTRYINFO): |
|
/* Suppress. */ |
|
pnode_unlinksub(pn); |
|
break; |
case (NODE_REFMETA): |
case (NODE_REFMETA): |
abort(); |
abort(); |
break; |
break; |
Line 959 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1142 pnode_print(struct parse *p, struct pnode *pn) |
|
puts(".Sh SYNOPSIS"); |
puts(".Sh SYNOPSIS"); |
break; |
break; |
case (NODE_REFSECT1): |
case (NODE_REFSECT1): |
|
/* FALLTHROUGH */ |
|
case (NODE_REFSECT2): |
assert(p->newln); |
assert(p->newln); |
pnode_printrefsect(p, pn); |
pnode_printrefsect(p, pn); |
break; |
break; |
Line 966 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1151 pnode_print(struct parse *p, struct pnode *pn) |
|
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Ar", stdout); |
fputs("Ar", stdout); |
break; |
break; |
|
case (NODE_SBR): |
|
assert(p->newln); |
|
puts(".br"); |
|
break; |
case (NODE_STRUCTNAME): |
case (NODE_STRUCTNAME): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Vt", stdout); |
fputs("Vt", stdout); |
break; |
break; |
|
case (NODE_TABLE): |
|
assert(p->newln); |
|
pnode_printtable(p, pn); |
|
pnode_unlinksub(pn); |
|
break; |
case (NODE_TEXT): |
case (NODE_TEXT): |
if (0 == p->newln) |
if (0 == p->newln) |
putchar(' '); |
putchar(' '); |
Line 982 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1176 pnode_print(struct parse *p, struct pnode *pn) |
|
* Remember to escape control characters and escapes. |
* Remember to escape control characters and escapes. |
*/ |
*/ |
assert(p->bsz); |
assert(p->bsz); |
for (last = '\n', cp = p->b; '\0' != *cp; ) { |
cp = p->b; |
|
/* |
|
* There's often a superfluous "-" in its <option> tags |
|
* before the actual flags themselves. |
|
* "Fl" does this for us, so remove it. |
|
*/ |
|
if (NULL != pn->parent && |
|
NODE_OPTION == pn->parent->node && |
|
'-' == *cp) |
|
cp++; |
|
for (last = '\n'; '\0' != *cp; ) { |
if ('\n' == last) { |
if ('\n' == last) { |
/* Consume all whitespace. */ |
/* Consume all whitespace. */ |
if (isspace((int)*cp)) { |
if (isspace((int)*cp)) { |
Line 1008 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1212 pnode_print(struct parse *p, struct pnode *pn) |
|
assert(p->newln); |
assert(p->newln); |
pnode_printvarlistentry(p, pn); |
pnode_printvarlistentry(p, pn); |
break; |
break; |
|
case (NODE_USERINPUT): |
|
pnode_printmopen(p); |
|
fputs("Li", stdout); |
|
break; |
default: |
default: |
break; |
break; |
} |
} |
Line 1020 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1228 pnode_print(struct parse *p, struct pnode *pn) |
|
case (NODE_CODE): |
case (NODE_CODE): |
case (NODE_COMMAND): |
case (NODE_COMMAND): |
case (NODE_EMPHASIS): |
case (NODE_EMPHASIS): |
|
case (NODE_ENVAR): |
|
case (NODE_FILENAME): |
case (NODE_FUNCTION): |
case (NODE_FUNCTION): |
case (NODE_FUNCSYNOPSISINFO): |
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_LITERAL): |
case (NODE_OPTION): |
case (NODE_OPTION): |
case (NODE_PARAMETER): |
case (NODE_PARAMETER): |
case (NODE_REPLACEABLE): |
case (NODE_REPLACEABLE): |
case (NODE_REFPURPOSE): |
case (NODE_REFPURPOSE): |
case (NODE_STRUCTNAME): |
case (NODE_STRUCTNAME): |
case (NODE_TEXT): |
case (NODE_TEXT): |
|
case (NODE_USERINPUT): |
pnode_printmclose(p, sv); |
pnode_printmclose(p, sv); |
break; |
break; |
case (NODE_REFNAME): |
case (NODE_REFNAME): |
Line 1044 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1256 pnode_print(struct parse *p, struct pnode *pn) |
|
pnode_printmclose(p, sv); |
pnode_printmclose(p, sv); |
break; |
break; |
case (NODE_PROGRAMLISTING): |
case (NODE_PROGRAMLISTING): |
|
/* FALLTHROUGH */ |
|
case (NODE_SCREEN): |
assert(p->newln); |
assert(p->newln); |
puts(".Ed"); |
puts(".Ed"); |
p->newln = 1; |
p->newln = 1; |