[BACK]Return to docbook2mdoc.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / docbook2mdoc

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.2 and 1.3

version 1.2, 2014/03/28 02:06:29 version 1.3, 2014/03/28 02:46:40
Line 33  enum nodeid {
Line 33  enum nodeid {
         /* 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");
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
CVSweb