version 1.12, 2014/03/29 22:44:06 |
version 1.13, 2014/03/30 11:48:10 |
|
|
#include <string.h> |
#include <string.h> |
#include <unistd.h> |
#include <unistd.h> |
|
|
/* |
#include "extern.h" |
* All recognised node types. |
|
*/ |
|
enum nodeid { |
|
NODE_ROOT = 0, /* Must comes first. */ |
|
/* Alpha-ordered hereafter. */ |
|
NODE_ARG, |
|
NODE_CITEREFENTRY, |
|
NODE_CMDSYNOPSIS, |
|
NODE_CODE, |
|
NODE_COMMAND, |
|
NODE_FUNCDEF, |
|
NODE_FUNCPROTOTYPE, |
|
NODE_FUNCSYNOPSIS, |
|
NODE_FUNCSYNOPSISINFO, |
|
NODE_FUNCTION, |
|
NODE_MANVOLNUM, |
|
NODE_OPTION, |
|
NODE_PARA, |
|
NODE_PARAMDEF, |
|
NODE_PARAMETER, |
|
NODE_PROGRAMLISTING, |
|
NODE_REFCLASS, |
|
NODE_REFDESCRIPTOR, |
|
NODE_REFENTRY, |
|
NODE_REFENTRYTITLE, |
|
NODE_REFMETA, |
|
NODE_REFMISCINFO, |
|
NODE_REFNAME, |
|
NODE_REFNAMEDIV, |
|
NODE_REFPURPOSE, |
|
NODE_REFSECT1, |
|
NODE_REFSYNOPSISDIV, |
|
NODE_STRUCTNAME, |
|
NODE_SYNOPSIS, |
|
NODE_TEXT, |
|
NODE_TITLE, |
|
NODE__MAX |
|
}; |
|
|
|
/* |
/* |
* All recognised attribute keys. |
|
*/ |
|
enum attrkey { |
|
/* Alpha-order... */ |
|
ATTRKEY_CHOICE = 0, |
|
ATTRKEY_ID, |
|
ATTRKEY_REP, |
|
ATTRKEY__MAX |
|
}; |
|
|
|
/* |
|
* All [explicitly] recognised attribute values. |
|
* If an attribute has ATTRVAL__MAX, it could be a free-form. |
|
*/ |
|
enum attrval { |
|
/* Alpha-order... */ |
|
ATTRVAL_NOREPEAT, |
|
ATTRVAL_OPT, |
|
ATTRVAL_PLAIN, |
|
ATTRVAL_REPEAT, |
|
ATTRVAL_REQ, |
|
ATTRVAL__MAX |
|
}; |
|
|
|
/* |
|
* Global parse state. |
* Global parse state. |
* Keep this as simple and small as possible. |
* Keep this as simple and small as possible. |
*/ |
*/ |
Line 155 static const struct node nodes[NODE__MAX] = { |
|
Line 92 static const struct node nodes[NODE__MAX] = { |
|
{ "cmdsynopsis", NODE_IGNTEXT }, |
{ "cmdsynopsis", NODE_IGNTEXT }, |
{ "code", 0 }, |
{ "code", 0 }, |
{ "command", 0 }, |
{ "command", 0 }, |
|
{ "emphasis", 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 }, |
|
{ "listitem", NODE_IGNTEXT }, |
{ "manvolnum", 0 }, |
{ "manvolnum", 0 }, |
{ "option", 0 }, |
{ "option", 0 }, |
{ "para", 0 }, |
{ "para", 0 }, |
Line 177 static const struct node nodes[NODE__MAX] = { |
|
Line 116 static const struct node nodes[NODE__MAX] = { |
|
{ "refpurpose", 0 }, |
{ "refpurpose", 0 }, |
{ "refsect1", 0 }, |
{ "refsect1", 0 }, |
{ "refsynopsisdiv", NODE_IGNTEXT }, |
{ "refsynopsisdiv", NODE_IGNTEXT }, |
|
{ "replaceable", 0 }, |
{ "structname", 0 }, |
{ "structname", 0 }, |
{ "synopsis", 0 }, |
{ "synopsis", 0 }, |
|
{ "term", 0 }, |
{ NULL, 0 }, |
{ NULL, 0 }, |
{ "title", 0 }, |
{ "title", 0 }, |
|
{ "variablelist", NODE_IGNTEXT }, |
|
{ "varlistentry", NODE_IGNTEXT }, |
}; |
}; |
|
|
static void |
static void |
pnode_print(struct parse *p, struct pnode *pn); |
pnode_print(struct parse *p, struct pnode *pn); |
|
|
static int |
|
isattrkey(enum nodeid node, enum attrkey key) |
|
{ |
|
|
|
switch (key) { |
|
case (ATTRKEY_CHOICE): |
|
return(node == NODE_ARG); |
|
case (ATTRKEY_ID): |
|
/* Common to all. */ |
|
return(1); |
|
case (ATTRKEY_REP): |
|
return(node == NODE_ARG); |
|
default: |
|
break; |
|
} |
|
abort(); |
|
return(0); |
|
} |
|
|
|
static int |
|
isattrval(enum attrkey key, enum attrval val) |
|
{ |
|
|
|
switch (val) { |
|
case (ATTRVAL_OPT): |
|
case (ATTRVAL_PLAIN): |
|
case (ATTRVAL_REQ): |
|
return(key == ATTRKEY_CHOICE); |
|
case (ATTRVAL_REPEAT): |
|
case (ATTRVAL_NOREPEAT): |
|
return(key == ATTRKEY_REP); |
|
default: |
|
break; |
|
} |
|
abort(); |
|
return(0); |
|
} |
|
|
|
/* |
/* |
* Look up whether "parent" is a valid parent for "node". |
|
* This is sucked directly from the DocBook specification: look at the |
|
* "children" and "parent" sections of each node. |
|
*/ |
|
static int |
|
isparent(enum nodeid node, enum nodeid parent) |
|
{ |
|
|
|
switch (node) { |
|
case (NODE_ROOT): |
|
return(0); |
|
case (NODE_ARG): |
|
switch (parent) { |
|
case (NODE_ARG): |
|
case (NODE_CMDSYNOPSIS): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_CITEREFENTRY): |
|
switch (parent) { |
|
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_PARA): |
|
case (NODE_PROGRAMLISTING): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_CMDSYNOPSIS): |
|
switch (parent) { |
|
case (NODE_PARA): |
|
case (NODE_REFSECT1): |
|
case (NODE_REFSYNOPSISDIV): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_CODE): |
|
switch (parent) { |
|
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_PARA): |
|
case (NODE_PROGRAMLISTING): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_COMMAND): |
|
switch (parent) { |
|
case (NODE_CMDSYNOPSIS): |
|
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_PARA): |
|
case (NODE_PROGRAMLISTING): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_FUNCDEF): |
|
return(NODE_FUNCPROTOTYPE == parent); |
|
case (NODE_FUNCPROTOTYPE): |
|
return(NODE_FUNCSYNOPSIS == parent); |
|
case (NODE_FUNCSYNOPSIS): |
|
switch (parent) { |
|
case (NODE_PARA): |
|
case (NODE_REFSECT1): |
|
case (NODE_REFSYNOPSISDIV): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_FUNCSYNOPSISINFO): |
|
return(NODE_FUNCSYNOPSIS == parent); |
|
case (NODE_FUNCTION): |
|
switch (parent) { |
|
case (NODE_CODE): |
|
case (NODE_FUNCDEF): |
|
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_PARA): |
|
case (NODE_PROGRAMLISTING): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_MANVOLNUM): |
|
switch (parent) { |
|
case (NODE_CITEREFENTRY): |
|
case (NODE_REFMETA): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_OPTION): |
|
switch (parent) { |
|
case (NODE_ARG): |
|
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_PARA): |
|
case (NODE_PROGRAMLISTING): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_PARA): |
|
switch (parent) { |
|
case (NODE_REFSECT1): |
|
case (NODE_REFSYNOPSISDIV): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_PARAMDEF): |
|
return(NODE_FUNCPROTOTYPE == parent); |
|
case (NODE_PARAMETER): |
|
switch (parent) { |
|
case (NODE_CODE): |
|
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_PARA): |
|
case (NODE_PARAMDEF): |
|
case (NODE_PROGRAMLISTING): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_PROGRAMLISTING): |
|
switch (parent) { |
|
case (NODE_PARA): |
|
case (NODE_REFSECT1): |
|
case (NODE_REFSYNOPSISDIV): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_REFCLASS): |
|
return(parent == NODE_REFNAMEDIV); |
|
case (NODE_REFDESCRIPTOR): |
|
return(parent == NODE_REFNAMEDIV); |
|
case (NODE_REFENTRY): |
|
return(parent == NODE_ROOT); |
|
case (NODE_REFENTRYTITLE): |
|
switch (parent) { |
|
case (NODE_CITEREFENTRY): |
|
case (NODE_REFMETA): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
case (NODE_REFMETA): |
|
return(parent == NODE_REFENTRY); |
|
case (NODE_REFMISCINFO): |
|
return(parent == NODE_REFMETA); |
|
case (NODE_REFNAME): |
|
return(parent == NODE_REFNAMEDIV); |
|
case (NODE_REFNAMEDIV): |
|
return(parent == NODE_REFENTRY); |
|
case (NODE_REFPURPOSE): |
|
return(parent == NODE_REFNAMEDIV); |
|
case (NODE_REFSECT1): |
|
return(parent == NODE_REFENTRY); |
|
case (NODE_REFSYNOPSISDIV): |
|
return(parent == NODE_REFENTRY); |
|
case (NODE_STRUCTNAME): |
|
switch (parent) { |
|
case (NODE_CODE): |
|
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_FUNCTION): |
|
case (NODE_OPTION): |
|
case (NODE_PARA): |
|
case (NODE_PARAMETER): |
|
case (NODE_PROGRAMLISTING): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_SYNOPSIS): |
|
switch (parent) { |
|
case (NODE_REFSYNOPSISDIV): |
|
case (NODE_REFSECT1): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_TITLE): |
|
switch (parent) { |
|
case (NODE_REFSECT1): |
|
case (NODE_REFSYNOPSISDIV): |
|
return(1); |
|
default: |
|
break; |
|
} |
|
return(0); |
|
case (NODE_TEXT): |
|
return(1); |
|
case (NODE__MAX): |
|
break; |
|
} |
|
|
|
abort(); |
|
return(0); |
|
} |
|
|
|
/* |
|
* Process a stream of characters. |
* Process a stream of characters. |
* We store text as nodes in and of themselves. |
* We store text as nodes in and of themselves. |
* If a text node is already open, append to it. |
* If a text node is already open, append to it. |
Line 613 xml_elem_start(void *arg, const XML_Char *name, const |
|
Line 263 xml_elem_start(void *arg, const XML_Char *name, const |
|
} else if (NODE_ROOT == ps->node && NODE_REFENTRY != node) { |
} else if (NODE_ROOT == ps->node && NODE_REFENTRY != node) { |
return; |
return; |
} else if ( ! isparent(node, ps->node)) { |
} else if ( ! isparent(node, ps->node)) { |
fprintf(stderr, "%s:%zu:%zu: bad parent \"%s\"\n", |
fprintf(stderr, "%s:%zu:%zu: bad parent \"%s\" " |
|
"of node \"%s\"\n", |
ps->fname, XML_GetCurrentLineNumber(ps->xml), |
ps->fname, XML_GetCurrentLineNumber(ps->xml), |
XML_GetCurrentColumnNumber(ps->xml), |
XML_GetCurrentColumnNumber(ps->xml), |
NULL == nodes[ps->node].name ? |
NULL == nodes[ps->node].name ? |
"(none)" : nodes[ps->node].name); |
"(none)" : nodes[ps->node].name, |
|
NULL == nodes[node].name ? |
|
"(none)" : nodes[node].name); |
ps->stop = 1; |
ps->stop = 1; |
return; |
return; |
} |
} |
Line 820 pnode_printmacrolinetext(struct parse *p, struct pnode |
|
Line 473 pnode_printmacrolinetext(struct parse *p, struct pnode |
|
{ |
{ |
char *cp; |
char *cp; |
|
|
|
if (0 == p->newln) |
|
putchar(' '); |
|
|
bufclear(p); |
bufclear(p); |
bufappend_r(p, pn); |
bufappend_r(p, pn); |
|
|
|
|
pnode_printmacroline(struct parse *p, struct pnode *pn) |
pnode_printmacroline(struct parse *p, struct pnode *pn) |
{ |
{ |
|
|
|
assert(0 == p->newln); |
pnode_printmacrolinetext(p, pn, 0); |
pnode_printmacrolinetext(p, pn, 0); |
putchar('\n'); |
putchar('\n'); |
|
p->newln = 1; |
} |
} |
|
|
static void |
static void |
Line 918 pnode_printrefsect(struct parse *p, struct pnode *pn) |
|
Line 576 pnode_printrefsect(struct parse *p, struct pnode *pn) |
|
if (NODE_TITLE == pp->node) |
if (NODE_TITLE == pp->node) |
break; |
break; |
|
|
fputs(".Sh ", stdout); |
fputs(".Sh", stdout); |
|
p->newln = 0; |
|
|
if (NULL != pp) { |
if (NULL != pp) { |
pnode_printmacroline(p, pp); |
pnode_printmacroline(p, pp); |
pnode_unlink(pp); |
pnode_unlink(pp); |
} else |
} else { |
puts("UNKNOWN"); |
puts("UNKNOWN"); |
|
p->newln = 1; |
|
} |
} |
} |
|
|
/* |
/* |
Line 936 pnode_printciterefentry(struct parse *p, struct pnode |
|
Line 597 pnode_printciterefentry(struct parse *p, struct pnode |
|
struct pnode *pp, *title, *manvol; |
struct pnode *pp, *title, *manvol; |
|
|
title = manvol = NULL; |
title = manvol = NULL; |
|
assert(p->newln); |
TAILQ_FOREACH(pp, &pn->childq, child) |
TAILQ_FOREACH(pp, &pn->childq, child) |
if (NODE_MANVOLNUM == pp->node) |
if (NODE_MANVOLNUM == pp->node) |
manvol = pp; |
manvol = pp; |
else if (NODE_REFENTRYTITLE == pp->node) |
else if (NODE_REFENTRYTITLE == pp->node) |
title = pp; |
title = pp; |
|
|
fputs(".Xr ", stdout); |
fputs(".Xr", stdout); |
|
p->newln = 0; |
|
|
if (NULL != title) { |
if (NULL != title) { |
pnode_printmacrolinepart(p, title); |
pnode_printmacrolinepart(p, title); |
putchar(' '); |
|
} else |
} else |
fputs("unknown ", stdout); |
fputs(" unknown ", stdout); |
|
|
if (NULL != manvol) |
if (NULL == manvol) { |
|
puts(" 1"); |
|
p->newln = 1; |
|
} else |
pnode_printmacroline(p, manvol); |
pnode_printmacroline(p, manvol); |
else |
|
puts("1"); |
|
} |
} |
|
|
static void |
static void |
Line 962 pnode_printrefmeta(struct parse *p, struct pnode *pn) |
|
Line 625 pnode_printrefmeta(struct parse *p, struct pnode *pn) |
|
struct pnode *pp, *title, *manvol; |
struct pnode *pp, *title, *manvol; |
|
|
title = manvol = NULL; |
title = manvol = NULL; |
|
assert(p->newln); |
TAILQ_FOREACH(pp, &pn->childq, child) |
TAILQ_FOREACH(pp, &pn->childq, child) |
if (NODE_MANVOLNUM == pp->node) |
if (NODE_MANVOLNUM == pp->node) |
manvol = pp; |
manvol = pp; |
Line 969 pnode_printrefmeta(struct parse *p, struct pnode *pn) |
|
Line 633 pnode_printrefmeta(struct parse *p, struct pnode *pn) |
|
title = pp; |
title = pp; |
|
|
puts(".Dd $Mdocdate" "$"); |
puts(".Dd $Mdocdate" "$"); |
fputs(".Dt ", stdout); |
fputs(".Dt", stdout); |
|
p->newln = 0; |
|
|
if (NULL != title) { |
if (NULL != title) |
/* FIXME: uppercase. */ |
|
pnode_printmacrolinetext(p, title, MACROLINE_UPPER); |
pnode_printmacrolinetext(p, title, MACROLINE_UPPER); |
putchar(' '); |
else |
} else |
fputs(" UNKNOWN ", stdout); |
fputs("UNKNOWN ", stdout); |
|
|
|
if (NULL != manvol) |
if (NULL == manvol) { |
|
puts(" 1"); |
|
p->newln = 1; |
|
} else |
pnode_printmacroline(p, manvol); |
pnode_printmacroline(p, manvol); |
else |
|
puts("1"); |
|
|
|
puts(".Os"); |
puts(".Os"); |
} |
} |
Line 991 pnode_printfuncdef(struct parse *p, struct pnode *pn) |
|
Line 655 pnode_printfuncdef(struct parse *p, struct pnode *pn) |
|
{ |
{ |
struct pnode *pp, *ftype, *func; |
struct pnode *pp, *ftype, *func; |
|
|
|
assert(p->newln); |
ftype = func = NULL; |
ftype = func = NULL; |
TAILQ_FOREACH(pp, &pn->childq, child) |
TAILQ_FOREACH(pp, &pn->childq, child) |
if (NODE_TEXT == pp->node) |
if (NODE_TEXT == pp->node) |
Line 999 pnode_printfuncdef(struct parse *p, struct pnode *pn) |
|
Line 664 pnode_printfuncdef(struct parse *p, struct pnode *pn) |
|
func = pp; |
func = pp; |
|
|
if (NULL != ftype) { |
if (NULL != ftype) { |
fputs(".Ft ", stdout); |
fputs(".Ft", stdout); |
|
p->newln = 0; |
pnode_printmacroline(p, ftype); |
pnode_printmacroline(p, ftype); |
} |
} |
|
|
if (NULL != func) { |
if (NULL != func) { |
fputs(".Fo ", stdout); |
fputs(".Fo", stdout); |
|
p->newln = 0; |
pnode_printmacroline(p, func); |
pnode_printmacroline(p, func); |
} else |
} else { |
puts(".Fo UNKNOWN"); |
puts(".Fo UNKNOWN"); |
|
p->newln = 1; |
|
} |
} |
} |
|
|
static void |
static void |
Line 1015 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
Line 684 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
{ |
{ |
struct pnode *pp, *ptype, *param; |
struct pnode *pp, *ptype, *param; |
|
|
|
assert(p->newln); |
ptype = param = NULL; |
ptype = param = NULL; |
TAILQ_FOREACH(pp, &pn->childq, child) |
TAILQ_FOREACH(pp, &pn->childq, child) |
if (NODE_TEXT == pp->node) |
if (NODE_TEXT == pp->node) |
Line 1023 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
Line 693 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
param = pp; |
param = pp; |
|
|
fputs(".Fa \"", stdout); |
fputs(".Fa \"", stdout); |
|
p->newln = 0; |
if (NULL != ptype) { |
if (NULL != ptype) { |
pnode_printmacrolinepart(p, ptype); |
pnode_printmacrolinepart(p, ptype); |
putchar(' '); |
putchar(' '); |
Line 1032 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
Line 703 pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
pnode_printmacrolinepart(p, param); |
pnode_printmacrolinepart(p, param); |
|
|
puts("\""); |
puts("\""); |
|
p->newln = 1; |
} |
} |
|
|
static void |
static void |
Line 1039 pnode_printfuncprototype(struct parse *p, struct pnode |
|
Line 711 pnode_printfuncprototype(struct parse *p, struct pnode |
|
{ |
{ |
struct pnode *pp, *fdef; |
struct pnode *pp, *fdef; |
|
|
|
assert(p->newln); |
TAILQ_FOREACH(fdef, &pn->childq, child) |
TAILQ_FOREACH(fdef, &pn->childq, child) |
if (NODE_FUNCDEF == fdef->node) |
if (NODE_FUNCDEF == fdef->node) |
break; |
break; |
Line 1053 pnode_printfuncprototype(struct parse *p, struct pnode |
|
Line 726 pnode_printfuncprototype(struct parse *p, struct pnode |
|
pnode_printparamdef(p, pp); |
pnode_printparamdef(p, pp); |
|
|
puts(".Fc"); |
puts(".Fc"); |
|
p->newln = 1; |
} |
} |
|
|
/* |
/* |
Line 1082 pnode_printarg(struct parse *p, struct pnode *pn) |
|
Line 756 pnode_printarg(struct parse *p, struct pnode *pn) |
|
|
|
if (isop) { |
if (isop) { |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Op ", stdout); |
fputs("Op", stdout); |
} |
} |
|
|
TAILQ_FOREACH(pp, &pn->childq, child) { |
TAILQ_FOREACH(pp, &pn->childq, child) { |
if (NODE_TEXT == pp->node) { |
if (NODE_TEXT == pp->node) { |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Ar ", stdout); |
fputs("Ar", stdout); |
} |
} |
pnode_print(p, pp); |
pnode_print(p, pp); |
if (NODE_TEXT == pp->node && isrep) |
if (NODE_TEXT == pp->node && isrep) |
Line 1134 pnode_printprologue(struct parse *p, struct pnode *pn) |
|
Line 808 pnode_printprologue(struct parse *p, struct pnode *pn) |
|
} |
} |
} |
} |
|
|
|
static void |
|
pnode_printvarlistentry(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp; |
|
|
|
assert(p->newln); |
|
TAILQ_FOREACH(pp, &pn->childq, child) |
|
if (NODE_TERM == pp->node) { |
|
fputs(".It", stdout); |
|
p->newln = 0; |
|
pnode_print(p, pp); |
|
pnode_unlink(pp); |
|
putchar('\n'); |
|
p->newln = 1; |
|
return; |
|
} |
|
|
|
puts(".It"); |
|
p->newln = 1; |
|
} |
|
|
|
static void |
|
pnode_printvariablelist(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 -tag -width Ds"); |
|
TAILQ_FOREACH(pp, &pn->childq, child) |
|
if (NODE_VARLISTENTRY != pp->node) { |
|
assert(p->newln); |
|
fputs(".It", stdout); |
|
pnode_printmacroline(p, pp); |
|
} else { |
|
assert(p->newln); |
|
pnode_print(p, pp); |
|
} |
|
assert(p->newln); |
|
puts(".El"); |
|
} |
|
|
/* |
/* |
* 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. |
Line 1163 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 886 pnode_print(struct parse *p, struct pnode *pn) |
|
break; |
break; |
case (NODE_CODE): |
case (NODE_CODE): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Li ", stdout); |
fputs("Li", stdout); |
break; |
break; |
case (NODE_COMMAND): |
case (NODE_COMMAND): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Nm ", stdout); |
fputs("Nm", stdout); |
break; |
break; |
|
case (NODE_EMPHASIS): |
|
pnode_printmopen(p); |
|
fputs("Em", stdout); |
|
break; |
case (NODE_FUNCTION): |
case (NODE_FUNCTION): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Fn ", stdout); |
fputs("Fn", stdout); |
break; |
break; |
case (NODE_FUNCPROTOTYPE): |
case (NODE_FUNCPROTOTYPE): |
assert(p->newln); |
assert(p->newln); |
Line 1180 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 907 pnode_print(struct parse *p, struct pnode *pn) |
|
break; |
break; |
case (NODE_FUNCSYNOPSISINFO): |
case (NODE_FUNCSYNOPSISINFO): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Fd ", stdout); |
fputs("Fd", stdout); |
break; |
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_PARA): |
case (NODE_PARA): |
assert(p->newln); |
assert(p->newln); |
|
if (NULL != pn->parent && |
|
NODE_LISTITEM == pn->parent->node) |
|
break; |
puts(".Pp"); |
puts(".Pp"); |
break; |
break; |
case (NODE_PARAMETER): |
case (NODE_PARAMETER): |
Line 1208 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 939 pnode_print(struct parse *p, struct pnode *pn) |
|
case (NODE_REFNAME): |
case (NODE_REFNAME): |
/* Suppress non-text children... */ |
/* Suppress non-text children... */ |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Nm ", stdout); |
fputs("Nm", stdout); |
|
p->newln = 0; |
pnode_printmacrolinepart(p, pn); |
pnode_printmacrolinepart(p, pn); |
pnode_unlinksub(pn); |
pnode_unlinksub(pn); |
break; |
break; |
Line 1218 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 950 pnode_print(struct parse *p, struct pnode *pn) |
|
break; |
break; |
case (NODE_REFPURPOSE): |
case (NODE_REFPURPOSE): |
assert(p->newln); |
assert(p->newln); |
fputs(".Nd ", stdout); |
pnode_printmopen(p); |
|
fputs("Nd", stdout); |
break; |
break; |
case (NODE_REFSYNOPSISDIV): |
case (NODE_REFSYNOPSISDIV): |
assert(p->newln); |
assert(p->newln); |
Line 1229 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 962 pnode_print(struct parse *p, struct pnode *pn) |
|
assert(p->newln); |
assert(p->newln); |
pnode_printrefsect(p, pn); |
pnode_printrefsect(p, pn); |
break; |
break; |
|
case (NODE_REPLACEABLE): |
|
pnode_printmopen(p); |
|
fputs("Ar", stdout); |
|
break; |
case (NODE_STRUCTNAME): |
case (NODE_STRUCTNAME): |
pnode_printmopen(p); |
pnode_printmopen(p); |
fputs("Vt ", stdout); |
fputs("Vt", stdout); |
break; |
break; |
case (NODE_TEXT): |
case (NODE_TEXT): |
|
if (0 == p->newln) |
|
putchar(' '); |
bufclear(p); |
bufclear(p); |
bufappend(p, pn); |
bufappend(p, pn); |
/* |
/* |
Line 1260 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 999 pnode_print(struct parse *p, struct pnode *pn) |
|
} |
} |
p->newln = 0; |
p->newln = 0; |
break; |
break; |
|
case (NODE_VARIABLELIST): |
|
assert(p->newln); |
|
pnode_printvariablelist(p, pn); |
|
pnode_unlinksub(pn); |
|
break; |
|
case (NODE_VARLISTENTRY): |
|
assert(p->newln); |
|
pnode_printvarlistentry(p, pn); |
|
break; |
default: |
default: |
break; |
break; |
} |
} |
Line 1271 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 1019 pnode_print(struct parse *p, struct pnode *pn) |
|
case (NODE_ARG): |
case (NODE_ARG): |
case (NODE_CODE): |
case (NODE_CODE): |
case (NODE_COMMAND): |
case (NODE_COMMAND): |
|
case (NODE_EMPHASIS): |
case (NODE_FUNCTION): |
case (NODE_FUNCTION): |
case (NODE_FUNCSYNOPSISINFO): |
case (NODE_FUNCSYNOPSISINFO): |
case (NODE_OPTION): |
case (NODE_OPTION): |
case (NODE_PARAMETER): |
case (NODE_PARAMETER): |
|
case (NODE_REPLACEABLE): |
|
case (NODE_REFPURPOSE): |
case (NODE_STRUCTNAME): |
case (NODE_STRUCTNAME): |
case (NODE_TEXT): |
case (NODE_TEXT): |
pnode_printmclose(p, sv); |
pnode_printmclose(p, sv); |