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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.89 and 1.96

version 1.89, 2019/04/03 16:52:51 version 1.96, 2019/04/07 17:00:56
Line 32  static void  pnode_print(struct format *, struct pnode
Line 32  static void  pnode_print(struct format *, struct pnode
   
   
 static void  static void
   pnode_printtext(struct format *f, struct pnode *n)
   {
           struct pnode    *nn;
           char            *cp;
           char             last;
   
           if (n->bsz == 0) {
                   assert(n->real < n->b);
                   return;
           }
   
           /*
            * Text preceding a macro without intervening whitespace
            * requires a .Pf macro.
            * Set the spacing flag to avoid a redundant .Ns macro.
            */
   
           if (f->linestate != LINE_MACRO &&
               (nn = TAILQ_NEXT(n, child)) != NULL && nn->spc == 0 &&
               (nn->node != NODE_TEXT && nn->node != NODE_ESCAPE)) {
                   macro_open(f, "Pf");
                   nn->spc = 1;
           }
   
           if (f->linestate == LINE_NEW) {
                   last = '\n';
                   f->linestate = LINE_TEXT;
           } else {
                   last = ' ';
                   if (n->spc || f->linestate == LINE_MACRO)
                           putchar(' ');
           }
   
           if (n->node == NODE_ESCAPE) {
                   fputs(n->b, stdout);
                   return;
           }
   
           /*
            * Remove the prefix '-' from <option> elements
            * because the arguments of .Fl macros do not need it.
            */
   
           cp = n->b;
           if (n->parent != NULL && n->parent->node == NODE_OPTION && *cp == '-')
                   cp++;
   
           /*
            * Print the text, skipping whitespace on new lines,
            * escaping control characters on new lines,
            * and escaping backslashes.
            */
   
           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
 pnode_printpara(struct format *p, struct pnode *pn)  pnode_printpara(struct format *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
Line 129  pnode_printrefsect(struct format *p, struct pnode *pn)
Line 196  pnode_printrefsect(struct format *p, struct pnode *pn)
   
         switch (level) {          switch (level) {
         case 1:          case 1:
                   macro_close(p);
                 macro_open(p, "Sh");                  macro_open(p, "Sh");
                 break;                  break;
         case 2:          case 2:
                   macro_close(p);
                 macro_open(p, "Ss");                  macro_open(p, "Ss");
                 break;                  break;
         default:          default:
Line 187  pnode_printrefmeta(struct format *p, struct pnode *pn)
Line 256  pnode_printrefmeta(struct format *p, struct pnode *pn)
                 else if (pp->node == NODE_REFENTRYTITLE)                  else if (pp->node == NODE_REFENTRYTITLE)
                         title = pp;                          title = pp;
         }          }
           macro_close(p);
         macro_open(p, "Dt");          macro_open(p, "Dt");
         if (title == NULL)          if (title == NULL)
                 macro_addarg(p, "UNKNOWN", ARG_SPACE);                  macro_addarg(p, "UNKNOWN", ARG_SPACE);
Line 451  pnode_printauthor(struct format *f, struct pnode *n)
Line 521  pnode_printauthor(struct format *f, struct pnode *n)
 }  }
   
 static void  static void
   pnode_printlink(struct format *f, struct pnode *n)
   {
           const char      *uri, *text;
   
           uri = pnode_getattr_raw(n, ATTRKEY_LINKEND, NULL);
           if (uri != NULL) {
                   if (TAILQ_FIRST(&n->childq) != NULL) {
                           print_textnode(f, n);
                           text = "";
                   } else {
                           text = pnode_getattr_raw(n, ATTRKEY_ENDTERM, NULL);
                           if (text != NULL)
                                   print_text(f, text, ARG_SPACE);
                   }
                   if (text != NULL)
                           macro_open(f, "Pq");
                   macro_open(f, "Sx");
                   macro_addarg(f, uri, ARG_SPACE);
                   pnode_unlinksub(n);
                   return;
           }
           uri = pnode_getattr_raw(n, ATTRKEY_XLINK_HREF, NULL);
           if (uri == NULL)
                   uri = pnode_getattr_raw(n, ATTRKEY_URL, NULL);
           if (uri != NULL) {
                   macro_open(f, "Lk");
                   macro_addarg(f, uri, ARG_SPACE | ARG_SINGLE);
                   if (TAILQ_FIRST(&n->childq) != NULL)
                           macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);
                   pnode_unlinksub(n);
                   return;
           }
   }
   
   static void
 pnode_printprologue(struct format *p, struct ptree *tree)  pnode_printprologue(struct format *p, struct ptree *tree)
 {  {
         struct pnode    *refmeta;          struct pnode    *refmeta;
Line 487  pnode_printvarlistentry(struct format *p, struct pnode
Line 592  pnode_printvarlistentry(struct format *p, struct pnode
         struct pnode    *pp;          struct pnode    *pp;
         int              first = 1;          int              first = 1;
   
           macro_close(p);
         macro_open(p, "It");          macro_open(p, "It");
         TAILQ_FOREACH(pp, &pn->childq, child) {          TAILQ_FOREACH(pp, &pn->childq, child) {
                 if (pp->node != NODE_TERM)                  if (pp->node != NODE_TERM)
Line 555  pnode_printtgroup2(struct format *f, struct pnode *n)
Line 661  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");
                 pnode_print(f, ne);                  pnode_print(f, ne);
                 macro_close(f);                  macro_close(f);
Line 634  static void
Line 741  static void
 pnode_print(struct format *p, struct pnode *pn)  pnode_print(struct format *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
         const char      *ccp;  
         char            *cp;  
         int              last;  
         enum linestate   sv;          enum linestate   sv;
   
         if (pn == NULL)          if (pn == NULL)
                 return;                  return;
   
           p->spc = pn->spc;
         sv = p->linestate;          sv = p->linestate;
   
         switch (pn->node) {          switch (pn->node) {
Line 666  pnode_print(struct format *p, struct pnode *pn)
Line 771  pnode_print(struct format *p, struct pnode *pn)
         case NODE_CITETITLE:          case NODE_CITETITLE:
                 macro_open(p, "%T");                  macro_open(p, "%T");
                 break;                  break;
         case NODE_CODE:  
                 macro_open(p, "Li");  
                 break;  
         case NODE_COMMAND:          case NODE_COMMAND:
                 macro_open(p, "Nm");                  macro_open(p, "Nm");
                 break;                  break;
Line 677  pnode_print(struct format *p, struct pnode *pn)
Line 779  pnode_print(struct format *p, struct pnode *pn)
                 break;                  break;
         case NODE_EDITOR:          case NODE_EDITOR:
                 print_text(p, "editor:", ARG_SPACE);                  print_text(p, "editor:", ARG_SPACE);
                   sv = LINE_TEXT;
                 macro_open(p, "An");                  macro_open(p, "An");
                 break;                  break;
         case NODE_EMAIL:          case NODE_EMAIL:
Line 689  pnode_print(struct format *p, struct pnode *pn)
Line 792  pnode_print(struct format *p, struct pnode *pn)
         case NODE_ENVAR:          case NODE_ENVAR:
                 macro_open(p, "Ev");                  macro_open(p, "Ev");
                 break;                  break;
         case NODE_ESCAPE:          case NODE_ERRORNAME:
                 if (p->linestate == LINE_NEW)                  macro_open(p, "Er");
                         p->linestate = LINE_TEXT;  
                 else  
                         putchar(' ');  
                 fputs(pn->b, stdout);  
                 break;                  break;
         case NODE_FILENAME:          case NODE_FILENAME:
                 macro_open(p, "Pa");                  macro_open(p, "Pa");
Line 729  pnode_print(struct format *p, struct pnode *pn)
Line 828  pnode_print(struct format *p, struct pnode *pn)
                 macro_line(p, "Sh LEGAL NOTICE");                  macro_line(p, "Sh LEGAL NOTICE");
                 break;                  break;
         case NODE_LINK:          case NODE_LINK:
                 ccp = pnode_getattr_raw(pn, ATTRKEY_LINKEND, NULL);                  pnode_printlink(p, pn);
                 if (ccp == NULL)                  break;
                         break;  
                 macro_argline(p, "Sx", ccp);  
                 return;  
         case NODE_LITERAL:          case NODE_LITERAL:
                 macro_open(p, "Li");                  macro_open(p, "Ql");
                 break;                  break;
         case NODE_LITERALLAYOUT:          case NODE_LITERALLAYOUT:
                   macro_close(p);
                 macro_argline(p, "Bd", pnode_getattr(pn, ATTRKEY_CLASS) ==                  macro_argline(p, "Bd", pnode_getattr(pn, ATTRKEY_CLASS) ==
                     ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");                      ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");
                 break;                  break;
Line 813  pnode_print(struct format *p, struct pnode *pn)
Line 910  pnode_print(struct format *p, struct pnode *pn)
                 macro_line(p, "br");                  macro_line(p, "br");
                 break;                  break;
         case NODE_SGMLTAG:          case NODE_SGMLTAG:
                 macro_open(p, "Li");                  macro_open(p, "Ic");
                 break;                  break;
         case NODE_STRUCTNAME:  
                 macro_open(p, "Vt");  
                 break;  
         case NODE_TEXT:          case NODE_TEXT:
                 if (pn->bsz == 0) {          case NODE_ESCAPE:
                         assert(pn->real != pn->b);                  pnode_printtext(p, pn);
                         break;  
                 }  
                 if (p->linestate == LINE_NEW)  
                         p->linestate = LINE_TEXT;  
                 else  
                         putchar(' ');  
   
                 /*  
                  * Output all characters, squeezing out whitespace  
                  * between newlines.  
                  * XXX: all whitespace, including tabs (?).  
                  * Remember to escape control characters and escapes.  
                  */  
                 cp = pn->b;  
   
                 /*  
                  * There's often a superfluous "-" in its <option> tags  
                  * before the actual flags themselves.  
                  * "Fl" does this for us, so remove it.  
                  */  
                 if (pn->parent != NULL &&  
                     pn->parent->node == NODE_OPTION &&  
                     *cp == '-')  
                         cp++;  
                 for (last = '\n'; *cp != '\0'; ) {  
                         if (last == '\n') {  
                                 /* Consume all whitespace. */  
                                 if (isspace((unsigned char)*cp)) {  
                                         while (isspace((unsigned char)*cp))  
                                                 cp++;  
                                         continue;  
                                 } else if (*cp == '\'' || *cp == '.')  
                                         fputs("\\&", stdout);  
                         }  
                         putchar(last = *cp++);  
                         /* If we're a character escape, escape us. */  
                         if (last == '\\')  
                                 putchar('e');  
                 }  
                 break;                  break;
         case NODE_TGROUP:          case NODE_TGROUP:
                 pnode_printtgroup(p, pn);                  pnode_printtgroup(p, pn);
Line 876  pnode_print(struct format *p, struct pnode *pn)
Line 931  pnode_print(struct format *p, struct pnode *pn)
         case NODE_TYPE:          case NODE_TYPE:
                 macro_open(p, "Vt");                  macro_open(p, "Vt");
                 break;                  break;
         case NODE_USERINPUT:  
                 macro_open(p, "Li");  
                 break;  
         case NODE_VARIABLELIST:          case NODE_VARIABLELIST:
                 pnode_printvariablelist(p, pn);                  pnode_printvariablelist(p, pn);
                 break;                  break;
Line 900  pnode_print(struct format *p, struct pnode *pn)
Line 952  pnode_print(struct format *p, struct pnode *pn)
                 fputs("$ ", stdout);                  fputs("$ ", stdout);
                 p->linestate = sv;                  p->linestate = sv;
                 break;                  break;
           case NODE_MEMBER:
                   if ((pp = TAILQ_NEXT(pn, child)) != NULL &&
                       pp->node != NODE_MEMBER)
                           pp = NULL;
                   switch (p->linestate) {
                   case LINE_TEXT:
                           if (pp != NULL)
                                   print_text(p, ",", 0);
                           break;
                   case LINE_MACRO:
                           if (pp != NULL)
                                   macro_addarg(p, ",", ARG_SPACE);
                           macro_close(p);
                           break;
                   case LINE_NEW:
                           break;
                   }
                   break;
         case NODE_MML_MROW:          case NODE_MML_MROW:
         case NODE_MML_MI:          case NODE_MML_MI:
         case NODE_MML_MN:          case NODE_MML_MN:
Line 913  pnode_print(struct format *p, struct pnode *pn)
Line 983  pnode_print(struct format *p, struct pnode *pn)
         case NODE_AUTHOR:          case NODE_AUTHOR:
         case NODE_CITEREFENTRY:          case NODE_CITEREFENTRY:
         case NODE_CITETITLE:          case NODE_CITETITLE:
         case NODE_CODE:  
         case NODE_COMMAND:          case NODE_COMMAND:
         case NODE_CONSTANT:          case NODE_CONSTANT:
         case NODE_EDITOR:          case NODE_EDITOR:
         case NODE_EMAIL:          case NODE_EMAIL:
         case NODE_EMPHASIS:          case NODE_EMPHASIS:
         case NODE_ENVAR:          case NODE_ENVAR:
           case NODE_ERRORNAME:
         case NODE_FILENAME:          case NODE_FILENAME:
         case NODE_FIRSTTERM:          case NODE_FIRSTTERM:
         case NODE_FUNCTION:          case NODE_FUNCTION:
         case NODE_FUNCSYNOPSISINFO:          case NODE_FUNCSYNOPSISINFO:
         case NODE_KEYSYM:          case NODE_KEYSYM:
           case NODE_LINK:
         case NODE_LITERAL:          case NODE_LITERAL:
         case NODE_OPTION:          case NODE_OPTION:
         case NODE_PARAMETER:          case NODE_PARAMETER:
         case NODE_REPLACEABLE:          case NODE_REPLACEABLE:
         case NODE_REFPURPOSE:          case NODE_REFPURPOSE:
         case NODE_SGMLTAG:          case NODE_SGMLTAG:
         case NODE_STRUCTNAME:  
         case NODE_TYPE:          case NODE_TYPE:
         case NODE_USERINPUT:  
         case NODE_VARNAME:          case NODE_VARNAME:
                 if (sv != LINE_MACRO && p->linestate == LINE_MACRO)                  if (sv != LINE_MACRO && p->linestate == LINE_MACRO &&
                       (pn->parent == NULL || pn->parent->node != NODE_MEMBER))
                         macro_closepunct(p, pn);                          macro_closepunct(p, pn);
                 break;                  break;
         case NODE_QUOTE:          case NODE_QUOTE:
Legend:
Removed from v.1.89  
changed lines
  Added in v.1.96
CVSweb