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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.103 and 1.115

version 1.103, 2019/04/11 04:23:22 version 1.115, 2019/04/12 21:37:07
Line 38  pnode_printtext(struct format *f, struct pnode *n)
Line 38  pnode_printtext(struct format *f, struct pnode *n)
         struct pnode    *nn;          struct pnode    *nn;
         char            *cp;          char            *cp;
         int              accept_arg;          int              accept_arg;
         char             last;  
   
         cp = n->b;          cp = n->b;
         accept_arg = f->flags & FMT_ARG;          accept_arg = f->flags & FMT_ARG;
         if (f->linestate == LINE_MACRO && n->spc == 0 && !accept_arg) {          if (f->linestate == LINE_MACRO && !n->spc && !accept_arg) {
                 for (;;) {                  for (;;) {
                         if (*cp == '\0')                          if (*cp == '\0')
                                 return;                                  return;
Line 71  pnode_printtext(struct format *f, struct pnode *n)
Line 70  pnode_printtext(struct format *f, struct pnode *n)
          */           */
   
         if (f->linestate != LINE_MACRO &&          if (f->linestate != LINE_MACRO &&
             (nn = TAILQ_NEXT(n, child)) != NULL && nn->spc == 0 &&              (nn = TAILQ_NEXT(n, child)) != NULL && nn->spc == 0) {
             (nn->node != NODE_TEXT && nn->node != NODE_ESCAPE)) {                  switch (pnode_class(nn->node)) {
                 macro_open(f, "Pf");                  case CLASS_LINE:
                 accept_arg = 1;                  case CLASS_ENCL:
                 f->flags |= FMT_CHILD;                          macro_open(f, "Pf");
                 nn->spc = 1;                          accept_arg = 1;
                           f->flags |= FMT_CHILD;
                           nn->spc = 1;
                           break;
                   default:
                           break;
                   }
         }          }
   
         switch (f->linestate) {          switch (f->linestate) {
           case LINE_NEW:
                   break;
         case LINE_TEXT:          case LINE_TEXT:
                 if (n->spc)                  if (n->spc) {
                         putchar(' ');                          if (n->node == NODE_TEXT)
                 last = ' ';                                  macro_close(f);
                           else
                                   putchar(' ');
                   }
                 break;                  break;
         case LINE_MACRO:          case LINE_MACRO:
                 if (accept_arg) {                  if (accept_arg)
                         putchar(' ');                          putchar(' ');
                         last = ' ';                  else
                         break;                          macro_close(f);
                 }  
                 macro_close(f);  
                 /* FALLTHROUGH */  
         case LINE_NEW:  
                 f->linestate = LINE_TEXT;  
                 last = '\n';  
                 break;                  break;
         }          }
   
         if (n->node == NODE_ESCAPE) {          if (n->node == NODE_ESCAPE) {
                 fputs(n->b, stdout);                  fputs(n->b, stdout);
                   if (f->linestate == LINE_NEW)
                           f->linestate = LINE_TEXT;
                 return;                  return;
         }          }
   
Line 112  pnode_printtext(struct format *f, struct pnode *n)
Line 118  pnode_printtext(struct format *f, struct pnode *n)
         if (n->parent != NULL && n->parent->node == NODE_OPTION && *cp == '-')          if (n->parent != NULL && n->parent->node == NODE_OPTION && *cp == '-')
                 cp++;                  cp++;
   
         /*          if (f->linestate == LINE_MACRO)
          * Print the text, skipping whitespace on new lines,                  macro_addarg(f, cp, 0);
          * escaping control characters on new lines,          else
          * and escaping backslashes.                  print_text(f, cp, 0);
          */  
   
         for (; *cp != '\0'; cp++) {  
                 if (last == '\n') {  
                         if (isspace((unsigned char)*cp))  
                                 continue;  
                         if (*cp == '\'' || *cp == '.')  
                                 fputs("\\&", stdout);  
                 }  
                 putchar(last = *cp);  
                 if (last == '\\')  
                         putchar('e');  
         }  
 }  }
   
 static void  static void
Line 163  pnode_printpara(struct format *f, struct pnode *n)
Line 156  pnode_printpara(struct format *f, struct pnode *n)
         macro_line(f, "Pp");          macro_line(f, "Pp");
 }  }
   
   static void
   pnode_printrefnamediv(struct format *f, struct pnode *n)
   {
           struct pnode    *nc, *nn;
           int              comma;
   
           macro_line(f, "Sh NAME");
           comma = 0;
           TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                   if (nc->node != NODE_REFNAME)
                           continue;
                   if (comma)
                           macro_addarg(f, ",", ARG_SPACE);
                   macro_open(f, "Nm");
                   macro_addnode(f, nc, ARG_SPACE);
                   pnode_unlink(nc);
                   comma = 1;
           }
           macro_close(f);
   }
   
 /*  /*
  * If the SYNOPSIS macro has a superfluous title, kill it.   * If the SYNOPSIS macro has a superfluous title, kill it.
  */   */
Line 184  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 256  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 567  pnode_printauthor(struct format *f, struct pnode *n)
Line 593  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 586  pnode_printauthor(struct format *f, struct pnode *n)
Line 613  pnode_printauthor(struct format *f, struct pnode *n)
 static void  static void
 pnode_printlink(struct format *f, struct pnode *n)  pnode_printlink(struct format *f, struct pnode *n)
 {  {
           struct pnode    *nc;
         const char      *uri, *text;          const char      *uri, *text;
   
         uri = pnode_getattr_raw(n, ATTRKEY_LINKEND, NULL);          uri = pnode_getattr_raw(n, ATTRKEY_LINKEND, NULL);
         if (uri != NULL) {          if (uri != NULL) {
                 if (TAILQ_FIRST(&n->childq) != NULL) {                  if (TAILQ_FIRST(&n->childq) != NULL) {
                         print_textnode(f, n);                          TAILQ_FOREACH(nc, &n->childq, child)
                                   pnode_print(f, nc);
                         text = "";                          text = "";
                 } else {                  } else if ((text = pnode_getattr_raw(n,
                         text = pnode_getattr_raw(n, ATTRKEY_ENDTERM, NULL);                      ATTRKEY_ENDTERM, NULL)) != NULL) {
                         if (text != NULL)                          if (f->linestate == LINE_MACRO && f->flags & FMT_ARG)
                                   macro_addarg(f, text, ARG_SPACE);
                           else
                                 print_text(f, text, ARG_SPACE);                                  print_text(f, text, ARG_SPACE);
                 }                  }
                 if (text != NULL) {                  if (text != NULL) {
                         macro_open(f, "Pq");                          if (f->flags & FMT_IMPL)
                         f->flags |= FMT_CHILD;                                  macro_open(f, "Po");
                           else {
                                   macro_open(f, "Pq");
                                   f->flags |= FMT_CHILD;
                           }
                 }                  }
                 macro_open(f, "Sx");                  macro_open(f, "Sx");
                 macro_addarg(f, uri, ARG_SPACE);                  macro_addarg(f, uri, ARG_SPACE);
                   if (text != NULL && f->flags & FMT_IMPL)
                           macro_open(f, "Pc");
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
                 return;                  return;
         }          }
Line 639  pnode_printprologue(struct format *f, struct ptree *tr
Line 676  pnode_printprologue(struct format *f, struct ptree *tr
         } else          } else
                 pnode_printrefmeta(f, refmeta);                  pnode_printrefmeta(f, refmeta);
         macro_line(f, "Os");          macro_line(f, "Os");
   
         if (tree->flags & TREE_EQN) {  
                 macro_line(f, "EQ");  
                 print_text(f, "delim $$", 0);  
                 macro_line(f, "EN");  
         }  
 }  }
   
 /*  /*
Line 654  pnode_printprologue(struct format *f, struct ptree *tr
Line 685  pnode_printprologue(struct format *f, struct ptree *tr
 static void  static void
 pnode_printvarlistentry(struct format *f, struct pnode *n)  pnode_printvarlistentry(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc;          struct pnode    *nc, *nn;
         int              first = 1;          int              first = 1;
   
         macro_close(f);  
         macro_open(f, "It");          macro_open(f, "It");
         f->flags |= FMT_IMPL;          f->flags |= FMT_IMPL;
         TAILQ_FOREACH(nc, &n->childq, child) {          TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                 if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)                  if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)
                         continue;                          continue;
                 if ( ! first)                  if (first == 0) {
                         macro_addarg(f, ",", 0);                          switch (f->linestate) {
                           case LINE_NEW:
                                   break;
                           case LINE_TEXT:
                                   print_text(f, ",", 0);
                                   break;
                           case LINE_MACRO:
                                   macro_addarg(f, ",", 0);
                                   break;
                           }
                   }
                 pnode_print(f, nc);                  pnode_print(f, nc);
                   pnode_unlink(nc);
                 first = 0;                  first = 0;
         }          }
         macro_close(f);          macro_close(f);
         TAILQ_FOREACH(nc, &n->childq, child)          while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {
                 if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)                  pnode_print(f, nc);
                         pnode_print(f, nc);                  pnode_unlink(nc);
         pnode_unlinksub(n);          }
           macro_close(f);
 }  }
   
 static void  static void
Line 807  static void
Line 849  static void
 pnode_print(struct format *f, struct pnode *n)  pnode_print(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc, *nn;          struct pnode    *nc, *nn;
         enum linestate   sv;          int              was_impl;
   
         if (n == NULL)          if (n == NULL)
                 return;                  return;
   
         sv = f->linestate;          was_impl = f->flags & FMT_IMPL;
         if (n->spc)          if (n->spc)
                 f->flags &= ~FMT_NOSPC;                  f->flags &= ~FMT_NOSPC;
         else          else
Line 851  pnode_print(struct format *f, struct pnode *n)
Line 893  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_EDITOR:          case NODE_EDITOR:
                 print_text(f, "editor:", ARG_SPACE);                  print_text(f, "editor:", ARG_SPACE);
                 sv = LINE_TEXT;  
                 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 881  pnode_print(struct format *f, struct pnode *n)
Line 927  pnode_print(struct format *f, struct pnode *n)
                 macro_open(f, "Fd");                  macro_open(f, "Fd");
                 break;                  break;
         case NODE_INFORMALEQUATION:          case NODE_INFORMALEQUATION:
                   macro_line(f, "Bd -ragged -offset indent");
                   /* FALLTHROUGH */
           case NODE_INLINEEQUATION:
                 macro_line(f, "EQ");                  macro_line(f, "EQ");
                 break;                  break;
         case NODE_INLINEEQUATION:  
                 if (f->linestate == LINE_NEW)  
                         f->linestate = LINE_TEXT;  
                 putchar('$');  
                 break;  
         case NODE_ITEMIZEDLIST:          case NODE_ITEMIZEDLIST:
                 pnode_printlist(f, n);                  pnode_printlist(f, n);
                 break;                  break;
Line 901  pnode_print(struct format *f, struct pnode *n)
Line 945  pnode_print(struct format *f, struct pnode *n)
                 pnode_printlink(f, n);                  pnode_printlink(f, n);
                 break;                  break;
         case NODE_LITERAL:          case NODE_LITERAL:
                 macro_open(f, "Ql");                  if (was_impl)
                           macro_open(f, "So");
                   else {
                           macro_open(f, "Ql");
                           f->flags |= FMT_IMPL;
                   }
                 break;                  break;
         case NODE_LITERALLAYOUT:          case NODE_LITERALLAYOUT:
                 macro_close(f);                  macro_close(f);
                 macro_argline(f, "Bd", pnode_getattr(n, ATTRKEY_CLASS) ==                  macro_argline(f, "Bd", pnode_getattr(n, ATTRKEY_CLASS) ==
                     ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");                      ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");
                 break;                  break;
           case NODE_MARKUP:
                   macro_open(f, "Ic");
                   break;
         case NODE_MML_MFENCED:          case NODE_MML_MFENCED:
                 pnode_printmathfenced(f, n);                  pnode_printmathfenced(f, n);
                 break;                  break;
Line 935  pnode_print(struct format *f, struct pnode *n)
Line 987  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_PARAMDEF:          case NODE_PARAMDEF:
         case NODE_PARAMETER:          case NODE_PARAMETER:
                 macro_nodeline(f, "Fa", n, ARG_SINGLE);                  /* More often, these appear inside NODE_FUNCPROTOTYPE. */
                   macro_open(f, "Fa");
                   macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
                 break;                  break;
         case NODE_QUOTE:          case NODE_QUOTE:
                 macro_open(f, "Qo");                  if (was_impl)
                           macro_open(f, "Do");
                   else {
                           macro_open(f, "Dq");
                           f->flags |= FMT_IMPL;
                   }
                 break;                  break;
         case NODE_PROGRAMLISTING:          case NODE_PROGRAMLISTING:
         case NODE_SCREEN:          case NODE_SCREEN:
Line 951  pnode_print(struct format *f, struct pnode *n)
Line 1010  pnode_print(struct format *f, struct pnode *n)
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
                 break;                  break;
         case NODE_REFNAME:          case NODE_REFNAME:
                 /* Suppress non-text children... */                  /* More often, these appear inside NODE_REFNAMEDIV. */
                 macro_open(f, "Nm");                  macro_open(f, "Nm");
                 macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);  
                 pnode_unlinksub(n);  
                 break;                  break;
         case NODE_REFNAMEDIV:          case NODE_REFNAMEDIV:
                 macro_line(f, "Sh NAME");                  pnode_printrefnamediv(f, n);
                 break;                  break;
         case NODE_REFPURPOSE:          case NODE_REFPURPOSE:
                 macro_open(f, "Nd");                  macro_open(f, "Nd");
Line 981  pnode_print(struct format *f, struct pnode *n)
Line 1038  pnode_print(struct format *f, struct pnode *n)
         case NODE_SBR:          case NODE_SBR:
                 macro_line(f, "br");                  macro_line(f, "br");
                 break;                  break;
         case NODE_SGMLTAG:  
                 macro_open(f, "Ic");  
                 break;  
         case NODE_TEXT:          case NODE_TEXT:
         case NODE_ESCAPE:          case NODE_ESCAPE:
                 pnode_printtext(f, n);                  pnode_printtext(f, n);
Line 1018  pnode_print(struct format *f, struct pnode *n)
Line 1072  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 1025  pnode_print(struct format *f, struct pnode *n)
Line 1086  pnode_print(struct format *f, struct pnode *n)
                 return;                  return;
         case NODE_INFORMALEQUATION:          case NODE_INFORMALEQUATION:
                 macro_line(f, "EN");                  macro_line(f, "EN");
                   macro_line(f, "Ed");
                 break;                  break;
         case NODE_INLINEEQUATION:          case NODE_INLINEEQUATION:
                 fputs("$ ", stdout);                  macro_line(f, "EN");
                 f->linestate = sv;  
                 break;                  break;
           case NODE_LITERAL:
                   if (was_impl) {
                           f->flags &= ~FMT_NOSPC;
                           macro_open(f, "Sc");
                   } else
                           f->flags &= ~FMT_IMPL;
                   break;
         case NODE_MEMBER:          case NODE_MEMBER:
                 if ((nn = TAILQ_NEXT(n, child)) != NULL &&                  if ((nn = TAILQ_NEXT(n, child)) != NULL &&
                     nn->node != NODE_MEMBER)                      nn->node != NODE_MEMBER)
Line 1057  pnode_print(struct format *f, struct pnode *n)
Line 1125  pnode_print(struct format *f, struct pnode *n)
                 fputs(" } ", stdout);                  fputs(" } ", stdout);
                 break;                  break;
         case NODE_QUOTE:          case NODE_QUOTE:
                 if (sv == LINE_NEW)                  if (was_impl) {
                         macro_close(f);                          f->flags &= ~FMT_NOSPC;
                 sv = f->linestate;                          macro_open(f, "Dc");
                 macro_open(f, "Qc");                  } else
                 if (sv == LINE_NEW)                          f->flags &= ~FMT_IMPL;
                         macro_close(f);  
                 break;                  break;
         case NODE_REFNAME:  
                 /*  
                  * If we're in the NAME macro and we have multiple  
                  * <refname> macros in sequence, then print out a  
                  * trailing comma before the newline.  
                  */  
                 if (n->parent != NULL &&  
                     n->parent->node == NODE_REFNAMEDIV &&  
                     TAILQ_NEXT(n, child) != NULL &&  
                     TAILQ_NEXT(n, child)->node == NODE_REFNAME)  
                         macro_addarg(f, ",", ARG_SPACE);  
                 if (sv == LINE_NEW)  
                         macro_close(f);  
                 break;  
         case NODE_PREFACE:          case NODE_PREFACE:
         case NODE_SECTION:          case NODE_SECTION:
         case NODE_APPENDIX:          case NODE_APPENDIX:
Line 1107  pnode_print(struct format *f, struct pnode *n)
Line 1160  pnode_print(struct format *f, struct pnode *n)
 }  }
   
 void  void
 ptree_print(struct ptree *tree)  ptree_print_mdoc(struct ptree *tree)
 {  {
         struct format    formatter;          struct format    formatter;
   
Legend:
Removed from v.1.103  
changed lines
  Added in v.1.115
CVSweb