version 1.2, 2014/03/28 02:06:29 |
version 1.3, 2014/03/28 02:46:40 |
|
|
/* Alpha-ordered hereafter. */ |
/* Alpha-ordered hereafter. */ |
NODE_CITEREFENTRY, |
NODE_CITEREFENTRY, |
NODE_CODE, |
NODE_CODE, |
|
NODE_FUNCDEF, |
|
NODE_FUNCPROTOTYPE, |
NODE_FUNCSYNOPSIS, |
NODE_FUNCSYNOPSIS, |
NODE_FUNCSYNOPSISINFO, |
NODE_FUNCSYNOPSISINFO, |
|
NODE_FUNCTION, |
NODE_MANVOLNUM, |
NODE_MANVOLNUM, |
NODE_PARA, |
NODE_PARA, |
|
NODE_PARAMDEF, |
|
NODE_PARAMETER, |
NODE_PROGRAMLISTING, |
NODE_PROGRAMLISTING, |
NODE_REFCLASS, |
NODE_REFCLASS, |
NODE_REFDESCRIPTOR, |
NODE_REFDESCRIPTOR, |
Line 90 static const struct node nodes[NODE__MAX] = { |
|
Line 95 static const struct node nodes[NODE__MAX] = { |
|
{ NULL, 0 }, |
{ NULL, 0 }, |
{ "citerefentry", NODE_IGNTEXT }, |
{ "citerefentry", NODE_IGNTEXT }, |
{ "code", 0 }, |
{ "code", 0 }, |
|
{ "funcdef", 0 }, |
|
{ "funcprototype", NODE_IGNTEXT }, |
{ "funcsynopsis", NODE_IGNTEXT }, |
{ "funcsynopsis", NODE_IGNTEXT }, |
{ "funcsynopsisinfo", 0 }, |
{ "funcsynopsisinfo", 0 }, |
|
{ "function", 0 }, |
{ "manvolnum", 0 }, |
{ "manvolnum", 0 }, |
{ "para", 0 }, |
{ "para", 0 }, |
|
{ "paramdef", 0 }, |
|
{ "parameter", 0 }, |
{ "programlisting", 0 }, |
{ "programlisting", 0 }, |
{ "refclass", NODE_IGNTEXT }, |
{ "refclass", NODE_IGNTEXT }, |
{ "refdescriptor", NODE_IGNTEXT }, |
{ "refdescriptor", NODE_IGNTEXT }, |
Line 153 isparent(enum nodeid node, enum nodeid parent) |
|
Line 163 isparent(enum nodeid node, enum nodeid parent) |
|
break; |
break; |
} |
} |
return(0); |
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_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): |
case (NODE_MANVOLNUM): |
switch (parent) { |
switch (parent) { |
case (NODE_CITEREFENTRY): |
case (NODE_CITEREFENTRY): |
Line 162 isparent(enum nodeid node, enum nodeid parent) |
|
Line 205 isparent(enum nodeid node, enum nodeid parent) |
|
break; |
break; |
} |
} |
return(0); |
return(0); |
case (NODE_FUNCSYNOPSIS): |
case (NODE_PARA): |
switch (parent) { |
switch (parent) { |
case (NODE_PARA): |
|
case (NODE_REFSECT1): |
case (NODE_REFSECT1): |
case (NODE_REFSYNOPSISDIV): |
case (NODE_REFSYNOPSISDIV): |
return(1); |
return(1); |
Line 172 isparent(enum nodeid node, enum nodeid parent) |
|
Line 214 isparent(enum nodeid node, enum nodeid parent) |
|
break; |
break; |
} |
} |
return(0); |
return(0); |
case (NODE_FUNCSYNOPSISINFO): |
case (NODE_PARAMDEF): |
return(NODE_FUNCSYNOPSIS == parent); |
return(NODE_FUNCPROTOTYPE == parent); |
case (NODE_PARA): |
case (NODE_PARAMETER): |
switch (parent) { |
switch (parent) { |
case (NODE_REFSECT1): |
case (NODE_CODE): |
case (NODE_REFSYNOPSISDIV): |
case (NODE_FUNCSYNOPSISINFO): |
|
case (NODE_PARA): |
|
case (NODE_PARAMDEF): |
|
case (NODE_REFDESCRIPTOR): |
|
case (NODE_REFENTRYTITLE): |
|
case (NODE_REFNAME): |
|
case (NODE_REFPURPOSE): |
|
case (NODE_SYNOPSIS): |
|
case (NODE_TITLE): |
return(1); |
return(1); |
default: |
default: |
break; |
break; |
Line 446 bufappend(struct parse *p, struct pnode *pn) |
|
Line 496 bufappend(struct parse *p, struct pnode *pn) |
|
p->b[p->bsz] = '\0'; |
p->b[p->bsz] = '\0'; |
} |
} |
|
|
|
static void |
|
bufappend_r(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp; |
|
|
|
if (NODE_TEXT == pn->node) |
|
bufappend(p, pn); |
|
TAILQ_FOREACH(pp, &pn->childq, child) |
|
bufappend_r(p, pp); |
|
} |
|
|
/* |
/* |
* Print text presumably on a macro line. |
* Print text presumably on a macro line. |
* Ignore any child macros. |
* Ignore any child macros. |
Line 454 bufappend(struct parse *p, struct pnode *pn) |
|
Line 515 bufappend(struct parse *p, struct pnode *pn) |
|
static void |
static void |
pnode_printmacrolinepart(struct parse *p, struct pnode *pn) |
pnode_printmacrolinepart(struct parse *p, struct pnode *pn) |
{ |
{ |
struct pnode *pp; |
|
char *cp; |
char *cp; |
|
|
bufclear(p); |
bufclear(p); |
while (NULL != (pp = TAILQ_FIRST(&pn->childq))) { |
bufappend_r(p, pn); |
if (NODE_TEXT == pp->node) |
|
bufappend(p, pp); |
|
pnode_unlink(pp); |
|
} |
|
|
|
/* Convert all space to spaces. */ |
/* Convert all space to spaces. */ |
for (cp = p->b; '\0' != *cp; cp++) |
for (cp = p->b; '\0' != *cp; cp++) |
Line 576 pnode_printrefmeta(struct parse *p, struct pnode *pn) |
|
Line 632 pnode_printrefmeta(struct parse *p, struct pnode *pn) |
|
puts(".Os"); |
puts(".Os"); |
} |
} |
|
|
|
static void |
|
pnode_printfuncdef(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp, *ftype, *func; |
|
|
|
ftype = func = NULL; |
|
TAILQ_FOREACH(pp, &pn->childq, child) |
|
if (NODE_TEXT == pp->node) |
|
ftype = pp; |
|
else if (NODE_FUNCTION == pp->node) |
|
func = pp; |
|
|
|
if (NULL != ftype) { |
|
fputs(".Ft ", stdout); |
|
pnode_printmacroline(p, ftype); |
|
} |
|
|
|
if (NULL != func) { |
|
fputs(".Fo ", stdout); |
|
pnode_printmacroline(p, func); |
|
} else |
|
puts(".Fo UNKNOWN"); |
|
} |
|
|
|
static void |
|
pnode_printparamdef(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp, *ptype, *param; |
|
|
|
ptype = param = NULL; |
|
TAILQ_FOREACH(pp, &pn->childq, child) |
|
if (NODE_TEXT == pp->node) |
|
ptype = pp; |
|
else if (NODE_PARAMETER == pp->node) |
|
param = pp; |
|
|
|
fputs(".Fa \"", stdout); |
|
if (NULL != ptype) { |
|
pnode_printmacrolinepart(p, ptype); |
|
putchar(' '); |
|
} |
|
|
|
if (NULL != param) |
|
pnode_printmacrolinepart(p, param); |
|
else |
|
fputs("UNKNOWN", stdout); |
|
|
|
puts("\""); |
|
} |
|
|
|
static void |
|
pnode_printfuncprototype(struct parse *p, struct pnode *pn) |
|
{ |
|
struct pnode *pp, *fdef; |
|
|
|
TAILQ_FOREACH(fdef, &pn->childq, child) |
|
if (NODE_FUNCDEF == fdef->node) |
|
break; |
|
|
|
if (NULL != fdef) { |
|
pnode_printfuncdef(p, fdef); |
|
pnode_unlink(fdef); |
|
} else |
|
puts(".Fo UNKNOWN"); |
|
|
|
TAILQ_FOREACH(pp, &pn->childq, child) { |
|
if (NODE_PARAMDEF == pp->node) |
|
pnode_printparamdef(p, pp); |
|
pnode_unlink(pp); |
|
} |
|
|
|
puts(".Fc"); |
|
} |
|
|
/* |
/* |
* 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 602 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 732 pnode_print(struct parse *p, struct pnode *pn) |
|
fputs(".Li ", stdout); |
fputs(".Li ", stdout); |
pnode_printmacroline(p, pn); |
pnode_printmacroline(p, pn); |
break; |
break; |
|
case (NODE_FUNCTION): |
|
fputs(".Fn ", stdout); |
|
pnode_printmacroline(p, pn); |
|
break; |
|
case (NODE_FUNCPROTOTYPE): |
|
pnode_printfuncprototype(p, pn); |
|
break; |
case (NODE_FUNCSYNOPSISINFO): |
case (NODE_FUNCSYNOPSISINFO): |
fputs(".Fd ", stdout); |
fputs(".Fd ", stdout); |
pnode_printmacroline(p, pn); |
pnode_printmacroline(p, pn); |
Line 609 pnode_print(struct parse *p, struct pnode *pn) |
|
Line 746 pnode_print(struct parse *p, struct pnode *pn) |
|
case (NODE_PARA): |
case (NODE_PARA): |
/* FIXME: not always. */ |
/* FIXME: not always. */ |
puts(".Pp"); |
puts(".Pp"); |
|
break; |
|
case (NODE_PARAMETER): |
|
fputs(".Fa \"", stdout); |
|
pnode_printmacrolinepart(p, pn); |
|
puts("\""); |
break; |
break; |
case (NODE_PROGRAMLISTING): |
case (NODE_PROGRAMLISTING): |
puts(".Bd -literal"); |
puts(".Bd -literal"); |