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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.101 and 1.109

version 1.101, 2019/04/10 14:22:37 version 1.109, 2019/04/12 10:34:48
Line 19 
Line 19 
 #include <ctype.h>  #include <ctype.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
   #include <string.h>
   
 #include "node.h"  #include "node.h"
 #include "macro.h"  #include "macro.h"
Line 36  pnode_printtext(struct format *f, struct pnode *n)
Line 37  pnode_printtext(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nn;          struct pnode    *nn;
         char            *cp;          char            *cp;
         char             last;          int              accept_arg;
   
         if (n->bsz == 0) {          cp = n->b;
                 assert(n->real < n->b);          accept_arg = f->flags & FMT_ARG;
                 return;          if (f->linestate == LINE_MACRO && !n->spc && !accept_arg) {
                   for (;;) {
                           if (*cp == '\0')
                                   return;
                           if (strchr("!),.:;?]", *cp) == NULL)
                                   break;
                           printf(" %c", *cp++);
                   }
                   if (isspace((unsigned char)*cp)) {
                           while (isspace((unsigned char)*cp))
                                   cp++;
                           macro_close(f);
                   } else {
                           fputs(" Ns", stdout);
                           f->flags &= FMT_IMPL;
                           accept_arg = 1;
                   }
         }          }
           if (f->linestate == LINE_MACRO && !accept_arg &&
               (f->flags & (FMT_CHILD | FMT_IMPL)) == 0)
                   macro_close(f);
   
         /*          /*
          * Text preceding a macro without intervening whitespace           * Text preceding a macro without intervening whitespace
Line 53  pnode_printtext(struct format *f, struct pnode *n)
Line 73  pnode_printtext(struct format *f, struct pnode *n)
             (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)) {              (nn->node != NODE_TEXT && nn->node != NODE_ESCAPE)) {
                 macro_open(f, "Pf");                  macro_open(f, "Pf");
                   accept_arg = 1;
                   f->flags |= FMT_CHILD;
                 nn->spc = 1;                  nn->spc = 1;
         }          }
   
         if (f->linestate == LINE_NEW) {          switch (f->linestate) {
                 last = '\n';          case LINE_NEW:
                 f->linestate = LINE_TEXT;                  break;
         } else {          case LINE_TEXT:
                 last = ' ';                  if (n->spc) {
                 if (n->spc || f->linestate == LINE_MACRO)                          if (n->node == NODE_TEXT)
                                   macro_close(f);
                           else
                                   putchar(' ');
                   }
                   break;
           case LINE_MACRO:
                   if (accept_arg)
                         putchar(' ');                          putchar(' ');
                   else
                           macro_close(f);
                   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 75  pnode_printtext(struct format *f, struct pnode *n)
Line 109  pnode_printtext(struct format *f, struct pnode *n)
          * because the arguments of .Fl macros do not need it.           * because the arguments of .Fl macros do not need it.
          */           */
   
         cp = n->b;  
         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 109  pnode_printpara(struct format *f, struct pnode *n)
Line 129  pnode_printpara(struct format *f, struct pnode *n)
         if ((np = TAILQ_PREV(n, pnodeq, child)) == NULL)          if ((np = TAILQ_PREV(n, pnodeq, child)) == NULL)
             np = n->parent;              np = n->parent;
   
           f->flags = 0;
   
         switch (np->node) {          switch (np->node) {
         case NODE_ENTRY:          case NODE_ENTRY:
         case NODE_GLOSSTERM:          case NODE_GLOSSTERM:
Line 387  pnode_printarg(struct format *f, struct pnode *n)
Line 409  pnode_printarg(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc;          struct pnode    *nc;
         struct pattr    *a;          struct pattr    *a;
         int              isop, isrep;          int              isop, isrep, was_impl;
   
         isop = 1;          isop = 1;
         isrep = 0;          isrep = was_impl = 0;
         TAILQ_FOREACH(a, &n->attrq, child) {          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))
Line 398  pnode_printarg(struct format *f, struct pnode *n)
Line 420  pnode_printarg(struct format *f, struct pnode *n)
                 else if (a->key == ATTRKEY_REP && a->val == ATTRVAL_REPEAT)                  else if (a->key == ATTRKEY_REP && a->val == ATTRVAL_REPEAT)
                         isrep = 1;                          isrep = 1;
         }          }
         if (isop)          if (isop) {
                 macro_open(f, "Op");                  if (f->flags & FMT_IMPL) {
                           was_impl = 1;
                           macro_open(f, "Oo");
                   } else {
                           macro_open(f, "Op");
                           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)
Line 408  pnode_printarg(struct format *f, struct pnode *n)
Line 437  pnode_printarg(struct format *f, struct pnode *n)
                 if (isrep && nc->node == NODE_TEXT)                  if (isrep && nc->node == NODE_TEXT)
                         macro_addarg(f, "...", ARG_SPACE);                          macro_addarg(f, "...", ARG_SPACE);
         }          }
           if (isop) {
                   if (was_impl)
                           macro_open(f, "Oc");
                   else
                           f->flags &= ~FMT_IMPL;
           }
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
Line 436  pnode_printgroup(struct format *f, struct pnode *n)
Line 471  pnode_printgroup(struct format *f, struct pnode *n)
                 macro_open(f, "Op");                  macro_open(f, "Op");
         else if (sv)          else if (sv)
                 macro_open(f, "No");                  macro_open(f, "No");
           f->flags |= FMT_IMPL;
   
         /*          /*
          * Keep on printing text separated by the vertical bar as long           * Keep on printing text separated by the vertical bar as long
Line 459  pnode_printgroup(struct format *f, struct pnode *n)
Line 495  pnode_printgroup(struct format *f, struct pnode *n)
         }          }
         if (sv)          if (sv)
                 macro_close(f);                  macro_close(f);
           f->flags &= ~FMT_IMPL;
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
Line 516  pnode_printauthor(struct format *f, struct pnode *n)
Line 553  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;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
Line 535  pnode_printauthor(struct format *f, struct pnode *n)
Line 573  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)
                                   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 601  pnode_printprologue(struct format *f, struct ptree *tr
Line 651  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");
         TAILQ_FOREACH(nc, &n->childq, child) {          f->flags |= FMT_IMPL;
           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 673  pnode_printtgroup2(struct format *f, struct pnode *n)
Line 735  pnode_printtgroup2(struct format *f, struct pnode *n)
         while ((nr = pnode_findfirst(n, NODE_ROW)) != NULL) {          while ((nr = pnode_findfirst(n, NODE_ROW)) != NULL) {
                 if ((ne = pnode_findfirst(n, NODE_ENTRY)) == NULL)                  if ((ne = pnode_findfirst(n, NODE_ENTRY)) == NULL)
                         break;                          break;
                 macro_close(f);  
                 macro_open(f, "It");                  macro_open(f, "It");
                   f->flags |= FMT_IMPL;
                 pnode_print(f, ne);                  pnode_print(f, ne);
                 macro_close(f);                  macro_close(f);
                 pnode_unlink(ne);                  pnode_unlink(ne);
Line 752  pnode_printvariablelist(struct format *f, struct pnode
Line 814  pnode_printvariablelist(struct format *f, struct pnode
 static void  static void
 pnode_print(struct format *f, struct pnode *n)  pnode_print(struct format *f, struct pnode *n)
 {  {
         struct pnode    *pp;          struct pnode    *nc, *nn;
         enum linestate   sv;          enum linestate   sv;
   
         if (n == NULL)          if (n == NULL)
                 return;                  return;
   
         f->spc = n->spc;  
         sv = f->linestate;          sv = f->linestate;
           if (n->spc)
                   f->flags &= ~FMT_NOSPC;
           else
                   f->flags |= FMT_NOSPC;
   
         switch (n->node) {          switch (n->node) {
         case NODE_APPLICATION:          case NODE_APPLICATION:
Line 851  pnode_print(struct format *f, struct pnode *n)
Line 916  pnode_print(struct format *f, struct pnode *n)
                 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 878  pnode_print(struct format *f, struct pnode *n)
Line 946  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:
Line 924  pnode_print(struct format *f, struct pnode *n)
Line 994  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 957  pnode_print(struct format *f, struct pnode *n)
Line 1024  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         }          }
   
         TAILQ_FOREACH(pp, &n->childq, child)          TAILQ_FOREACH(nc, &n->childq, child)
                 pnode_print(f, pp);                  pnode_print(f, nc);
   
         switch (n->node) {          switch (n->node) {
           case NODE_ESCAPE:
           case NODE_TERM:
           case NODE_TEXT:
                   /* Accept more arguments to the previous macro. */
                   return;
         case NODE_INFORMALEQUATION:          case NODE_INFORMALEQUATION:
                 macro_line(f, "EN");                  macro_line(f, "EN");
                 break;                  break;
Line 969  pnode_print(struct format *f, struct pnode *n)
Line 1041  pnode_print(struct format *f, struct pnode *n)
                 f->linestate = sv;                  f->linestate = sv;
                 break;                  break;
         case NODE_MEMBER:          case NODE_MEMBER:
                 if ((pp = TAILQ_NEXT(n, child)) != NULL &&                  if ((nn = TAILQ_NEXT(n, child)) != NULL &&
                     pp->node != NODE_MEMBER)                      nn->node != NODE_MEMBER)
                         pp = NULL;                          nn = NULL;
                 switch (f->linestate) {                  switch (f->linestate) {
                 case LINE_TEXT:                  case LINE_TEXT:
                         if (pp != NULL)                          if (nn != NULL)
                                 print_text(f, ",", 0);                                  print_text(f, ",", 0);
                         break;                          break;
                 case LINE_MACRO:                  case LINE_MACRO:
                         if (pp != NULL)                          if (nn != NULL)
                                 macro_addarg(f, ",", ARG_SPACE);                                  macro_addarg(f, ",", ARG_SPACE);
                         macro_close(f);                          macro_close(f);
                         break;                          break;
Line 994  pnode_print(struct format *f, struct pnode *n)
Line 1066  pnode_print(struct format *f, struct pnode *n)
                         break;                          break;
                 fputs(" } ", stdout);                  fputs(" } ", stdout);
                 break;                  break;
         case NODE_APPLICATION:  
         case NODE_ARG:  
         case NODE_AUTHOR:  
         case NODE_CITEREFENTRY:  
         case NODE_CITETITLE:  
         case NODE_COMMAND:  
         case NODE_CONSTANT:  
         case NODE_EDITOR:  
         case NODE_EMAIL:  
         case NODE_EMPHASIS:  
         case NODE_ENVAR:  
         case NODE_ERRORNAME:  
         case NODE_FILENAME:  
         case NODE_FIRSTTERM:  
         case NODE_FUNCTION:  
         case NODE_FUNCSYNOPSISINFO:  
         case NODE_KEYSYM:  
         case NODE_LINK:  
         case NODE_LITERAL:  
         case NODE_OPTION:  
         case NODE_PARAMETER:  
         case NODE_REPLACEABLE:  
         case NODE_REFPURPOSE:  
         case NODE_SGMLTAG:  
         case NODE_TYPE:  
         case NODE_VARNAME:  
                 if (sv != LINE_MACRO && f->linestate == LINE_MACRO &&  
                     (n->parent == NULL || n->parent->node != NODE_MEMBER))  
                         macro_closepunct(f, n);  
                 break;  
         case NODE_QUOTE:          case NODE_QUOTE:
                 if (sv == LINE_NEW)                  if (sv == LINE_NEW)
                         macro_close(f);                          macro_close(f);
Line 1071  pnode_print(struct format *f, struct pnode *n)
Line 1113  pnode_print(struct format *f, struct pnode *n)
         default:          default:
                 break;                  break;
         }          }
           f->flags &= ~FMT_ARG;
 }  }
   
 void  void
Legend:
Removed from v.1.101  
changed lines
  Added in v.1.109
CVSweb