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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.114 and 1.117

version 1.114, 2019/04/12 19:14:50 version 1.117, 2019/04/13 15:13:31
Line 198  pnode_printrefsynopsisdiv(struct format *f, struct pno
Line 198  pnode_printrefsynopsisdiv(struct format *f, struct pno
 static void  static void
 pnode_printrefsect(struct format *f, struct pnode *n)  pnode_printrefsect(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc;          struct pnode    *nc, *ncc;
         const char      *title;          const char      *title;
         int              flags, level;          int              flags, level;
   
Line 270  pnode_printrefsect(struct format *f, struct pnode *n)
Line 270  pnode_printrefsect(struct format *f, struct pnode *n)
                 break;                  break;
         }          }
   
         if (nc != NULL) {          if (nc != NULL)
                 macro_addnode(f, nc, flags);                  macro_addnode(f, nc, flags);
                 pnode_unlink(nc);          else
         } else  
                 macro_addarg(f, title, flags | ARG_QUOTED);                  macro_addarg(f, title, flags | ARG_QUOTED);
         macro_close(f);          macro_close(f);
   
           /*
            * DocBook has no equivalent for -split mode,
            * so just switch the default in the AUTHORS section.
            */
   
           if (nc != NULL) {
                   ncc = TAILQ_FIRST(&nc->childq);
                   if (ncc != NULL && ncc->node == NODE_TEXT &&
                       strcasecmp(ncc->b, "AUTHORS") == 0)
                           macro_line(f, "An -nosplit");
                   pnode_unlink(nc);
           }
 }  }
   
 /*  /*
Line 306  pnode_printciterefentry(struct format *f, struct pnode
Line 318  pnode_printciterefentry(struct format *f, struct pnode
 }  }
   
 static void  static void
 pnode_printrefmeta(struct format *f, struct pnode *n)  
 {  
         struct pnode    *nc, *title, *manvol;  
   
         title = manvol = NULL;  
         TAILQ_FOREACH(nc, &n->childq, child) {  
                 if (nc->node == NODE_MANVOLNUM)  
                         manvol = nc;  
                 else if (nc->node == NODE_REFENTRYTITLE)  
                         title = nc;  
         }  
         macro_close(f);  
         macro_open(f, "Dt");  
         if (title == NULL)  
                 macro_addarg(f, "UNKNOWN", ARG_SPACE);  
         else  
                 macro_addnode(f, title, ARG_SPACE | ARG_SINGLE | ARG_UPPER);  
         if (manvol == NULL)  
                 macro_addarg(f, "1", ARG_SPACE);  
         else  
                 macro_addnode(f, manvol, ARG_SPACE | ARG_SINGLE);  
         macro_close(f);  
         pnode_unlink(n);  
 }  
   
 static void  
 pnode_printfuncdef(struct format *f, struct pnode *n)  pnode_printfuncdef(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc;          struct pnode    *nc;
Line 456  pnode_printarg(struct format *f, struct pnode *n)
Line 442  pnode_printarg(struct format *f, struct pnode *n)
                         f->flags |= FMT_IMPL;                          f->flags |= FMT_IMPL;
                 }                  }
         }          }
   
         TAILQ_FOREACH(nc, &n->childq, child) {          TAILQ_FOREACH(nc, &n->childq, child) {
                 if (nc->node == NODE_TEXT)                  if (nc->node == NODE_TEXT)
                         macro_open(f, "Ar");                          macro_open(f, "Ar");
                 pnode_print(f, nc);                  pnode_print(f, nc);
                 if (isrep && nc->node == NODE_TEXT)  
                         macro_addarg(f, "...", ARG_SPACE);  
         }          }
           if (isrep && f->linestate == LINE_MACRO)
                   macro_addarg(f, "...", ARG_SPACE);
         if (isop) {          if (isop) {
                 if (was_impl)                  if (was_impl)
                         macro_open(f, "Oc");                          macro_open(f, "Oc");
Line 476  pnode_printarg(struct format *f, struct pnode *n)
Line 461  pnode_printarg(struct format *f, struct pnode *n)
 static void  static void
 pnode_printgroup(struct format *f, struct pnode *n)  pnode_printgroup(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc, *nn;          struct pnode    *nc;
         struct pattr    *a;          struct pattr    *a;
         int              isop, sv;          int              bar, isop, isrep, was_impl;
   
         isop = 1;          isop = 1;
         TAILQ_FOREACH(a, &n->attrq, child)          isrep = was_impl = 0;
           TAILQ_FOREACH(a, &n->attrq, child) {
                 if (a->key == ATTRKEY_CHOICE &&                  if (a->key == ATTRKEY_CHOICE &&
                     (a->val == ATTRVAL_PLAIN || a->val == ATTRVAL_REQ)) {                      (a->val == ATTRVAL_PLAIN || a->val == ATTRVAL_REQ))
                         isop = 0;                          isop = 0;
                         break;                  else if (a->key == ATTRKEY_REP && a->val == ATTRVAL_REPEAT)
                           isrep = 1;
           }
           if (isop) {
                   if (f->flags & FMT_IMPL) {
                           was_impl = 1;
                           macro_open(f, "Oo");
                   } else {
                           macro_open(f, "Op");
                           f->flags |= FMT_IMPL;
                 }                  }
           } else if (isrep) {
         /*                  if (f->flags & FMT_IMPL) {
          * Make sure we're on a macro line.                          was_impl = 1;
          * This will prevent pnode_print() for putting us on a                          macro_open(f, "Bro");
          * subsequent line.                  } else {
          */                          macro_open(f, "Brq");
         sv = f->linestate == LINE_NEW;                          f->flags |= FMT_IMPL;
         if (isop)                  }
                 macro_open(f, "Op");          }
         else if (sv)          bar = 0;
                 macro_open(f, "No");  
         f->flags |= FMT_IMPL;  
   
         /*  
          * 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(nc, &n->childq, child) {          TAILQ_FOREACH(nc, &n->childq, child) {
                 pnode_print(f, nc);                  if (bar && f->linestate == LINE_MACRO)
                 nn = TAILQ_NEXT(nc, child);  
                 while (nn != NULL) {  
                         if (nc->node != nn->node)  
                                 break;  
                         macro_addarg(f, "|", ARG_SPACE);                          macro_addarg(f, "|", ARG_SPACE);
                         macro_addnode(f, nn, ARG_SPACE);                  pnode_print(f, nc);
                         nc = nn;                  bar = 1;
                         nn = TAILQ_NEXT(nn, child);  
                 }  
         }          }
         if (sv)          if (isop) {
                 macro_close(f);                  if (was_impl)
         f->flags &= ~FMT_IMPL;                          macro_open(f, "Oc");
                   else
                           f->flags &= ~FMT_IMPL;
           } else if (isrep) {
                   if (was_impl)
                           macro_open(f, "Brc");
                   else
                           f->flags &= ~FMT_IMPL;
           }
           if (isrep && f->linestate == LINE_MACRO)
                   macro_addarg(f, "...", ARG_SPACE);
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
Line 581  pnode_printauthor(struct format *f, struct pnode *n)
Line 569  pnode_printauthor(struct format *f, struct pnode *n)
   
         if ((nc = pnode_findfirst(n, NODE_EMAIL)) != NULL) {          if ((nc = pnode_findfirst(n, NODE_EMAIL)) != NULL) {
                 f->flags |= FMT_CHILD;                  f->flags |= FMT_CHILD;
                 pnode_print(f, nc);                  macro_open(f, "Aq Mt");
                   macro_addnode(f, nc, ARG_SPACE);
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
   
Line 645  pnode_printlink(struct format *f, struct pnode *n)
Line 634  pnode_printlink(struct format *f, struct pnode *n)
 }  }
   
 static void  static void
 pnode_printprologue(struct format *f, struct ptree *tree)  pnode_printprologue(struct format *f, struct pnode *root)
 {  {
         struct pnode    *refmeta;          struct pnode    *date, *refmeta, *name, *vol, *descr, *nc;
           const char      *sname;
   
         refmeta = tree->root == NULL ? NULL :          /* Collect information. */
             pnode_findfirst(tree->root, NODE_REFMETA);  
   
         macro_line(f, "Dd $Mdocdate" "$");          if ((date = pnode_takefirst(root, NODE_PUBDATE)) == NULL)
         if (refmeta == NULL) {                  date = pnode_takefirst(root, NODE_DATE);
                 macro_open(f, "Dt");  
                 macro_addarg(f,          name = vol = NULL;
                     pnode_getattr_raw(tree->root, ATTRKEY_ID, "UNKNOWN"),          if ((refmeta = pnode_takefirst(root, NODE_REFMETA)) != NULL) {
                     ARG_SPACE | ARG_SINGLE | ARG_UPPER);                  TAILQ_FOREACH(nc, &refmeta->childq, child) {
                 macro_addarg(f, "1", ARG_SPACE);                          switch (nc->node) {
                 macro_close(f);                          case NODE_REFENTRYTITLE:
                                   name = nc;
                                   break;
                           case NODE_MANVOLNUM:
                                   vol = nc;
                                   break;
                           default:
                                   break;
                           }
                   }
           }
   
           if (pnode_findfirst(root, NODE_REFNAMEDIV) == NULL &&
               ((nc = pnode_findfirst(root, NODE_BOOKINFO)) != NULL ||
                (nc = pnode_findfirst(root, NODE_REFENTRYINFO)) != NULL))
                   descr = pnode_takefirst(nc, NODE_TITLE);
           else
                   descr = NULL;
   
           /* Print prologue. */
   
           if (date == NULL)
                   macro_line(f, "Dd $Mdocdate" "$");
           else
                   macro_nodeline(f, "Dd", date, 0);
   
           macro_open(f, "Dt");
           if (name == NULL) {
                   sname = pnode_getattr_raw(root, ATTRKEY_ID, "UNKNOWN");
                   macro_addarg(f, sname, ARG_SPACE | ARG_SINGLE | ARG_UPPER);
         } else          } else
                 pnode_printrefmeta(f, refmeta);                  macro_addnode(f, name, ARG_SPACE | ARG_SINGLE | ARG_UPPER);
           if (vol == NULL)
                   macro_addarg(f, "1", ARG_SPACE);
           else
                   macro_addnode(f, vol, ARG_SPACE | ARG_SINGLE);
   
         macro_line(f, "Os");          macro_line(f, "Os");
   
           if (descr != NULL) {
                   macro_line(f, "Sh NAME");
                   if (name == NULL)
                           macro_argline(f, "Nm", sname);
                   else
                           macro_nodeline(f, "Nm", name, ARG_SINGLE);
                   macro_nodeline(f, "Nd", descr, 0);
           }
   
           /* Clean up. */
   
           pnode_unlink(date);
           pnode_unlink(refmeta);
           pnode_unlink(descr);
 }  }
   
 /*  /*
Line 863  pnode_print(struct format *f, struct pnode *n)
Line 901  pnode_print(struct format *f, struct pnode *n)
         case NODE_BLOCKQUOTE:          case NODE_BLOCKQUOTE:
                 macro_line(f, "Bd -ragged -offset indent");                  macro_line(f, "Bd -ragged -offset indent");
                 break;                  break;
         case NODE_BOOKINFO:  
                 macro_line(f, "Sh NAME");  
                 break;  
         case NODE_CITEREFENTRY:          case NODE_CITEREFENTRY:
                 pnode_printciterefentry(f, n);                  pnode_printciterefentry(f, n);
                 break;                  break;
Line 883  pnode_print(struct format *f, struct pnode *n)
Line 918  pnode_print(struct format *f, struct pnode *n)
                 macro_open(f, "An");                  macro_open(f, "An");
                 break;                  break;
         case NODE_EMAIL:          case NODE_EMAIL:
                 macro_open(f, "Aq Mt");                  if (was_impl)
                           macro_open(f, "Ao Mt");
                   else {
                           macro_open(f, "Aq Mt");
                           f->flags |= FMT_IMPL;
                   }
                 break;                  break;
         case NODE_EMPHASIS:          case NODE_EMPHASIS:
         case NODE_FIRSTTERM:          case NODE_FIRSTTERM:
Line 1028  pnode_print(struct format *f, struct pnode *n)
Line 1068  pnode_print(struct format *f, struct pnode *n)
                 pnode_printtgroup(f, n);                  pnode_printtgroup(f, n);
                 break;                  break;
         case NODE_TITLE:          case NODE_TITLE:
                 if (n->parent != NULL &&  
                     n->parent->node == NODE_BOOKINFO) {  
                         macro_open(f, "Nd");  
                         break;  
                 }  
                 pnode_printpara(f, n);                  pnode_printpara(f, n);
                 macro_nodeline(f, "Sy", n, 0);                  macro_nodeline(f, "Sy", n, 0);
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
Line 1054  pnode_print(struct format *f, struct pnode *n)
Line 1089  pnode_print(struct format *f, struct pnode *n)
                 pnode_print(f, nc);                  pnode_print(f, nc);
   
         switch (n->node) {          switch (n->node) {
           case NODE_EMAIL:
                   if (was_impl) {
                           f->flags &= ~FMT_NOSPC;
                           macro_open(f, "Ac");
                   } else
                           f->flags &= ~FMT_IMPL;
                   break;
         case NODE_ESCAPE:          case NODE_ESCAPE:
         case NODE_TERM:          case NODE_TERM:
         case NODE_TEXT:          case NODE_TEXT:
Line 1067  pnode_print(struct format *f, struct pnode *n)
Line 1109  pnode_print(struct format *f, struct pnode *n)
                 macro_line(f, "EN");                  macro_line(f, "EN");
                 break;                  break;
         case NODE_LITERAL:          case NODE_LITERAL:
                 if (was_impl)                  if (was_impl) {
                           f->flags &= ~FMT_NOSPC;
                         macro_open(f, "Sc");                          macro_open(f, "Sc");
                 else                  } else
                         f->flags &= ~FMT_IMPL;                          f->flags &= ~FMT_IMPL;
                 break;                  break;
         case NODE_MEMBER:          case NODE_MEMBER:
Line 1099  pnode_print(struct format *f, struct pnode *n)
Line 1142  pnode_print(struct format *f, struct pnode *n)
                 fputs(" } ", stdout);                  fputs(" } ", stdout);
                 break;                  break;
         case NODE_QUOTE:          case NODE_QUOTE:
                 if (was_impl)                  if (was_impl) {
                           f->flags &= ~FMT_NOSPC;
                         macro_open(f, "Dc");                          macro_open(f, "Dc");
                 else                  } else
                         f->flags &= ~FMT_IMPL;                          f->flags &= ~FMT_IMPL;
                 break;                  break;
         case NODE_PREFACE:          case NODE_PREFACE:
Line 1121  pnode_print(struct format *f, struct pnode *n)
Line 1165  pnode_print(struct format *f, struct pnode *n)
         case NODE_SYNOPSIS:          case NODE_SYNOPSIS:
                 macro_line(f, "Ed");                  macro_line(f, "Ed");
                 break;                  break;
         case NODE_TITLE:  
                 if (n->parent != NULL &&  
                     n->parent->node == NODE_BOOKINFO)  
                         macro_line(f, "Sh AUTHORS");  
                 break;  
         default:          default:
                 break;                  break;
         }          }
Line 1139  ptree_print_mdoc(struct ptree *tree)
Line 1178  ptree_print_mdoc(struct ptree *tree)
   
         formatter.level = 0;          formatter.level = 0;
         formatter.linestate = LINE_NEW;          formatter.linestate = LINE_NEW;
         pnode_printprologue(&formatter, tree);          pnode_printprologue(&formatter, tree->root);
         pnode_print(&formatter, tree->root);          pnode_print(&formatter, tree->root);
         if (formatter.linestate != LINE_NEW)          if (formatter.linestate != LINE_NEW)
                 putchar('\n');                  putchar('\n');
Legend:
Removed from v.1.114  
changed lines
  Added in v.1.117
CVSweb