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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.120 and 1.130

version 1.120, 2019/04/14 14:00:16 version 1.130, 2019/04/16 14:26:27
Line 126  pnode_printtext(struct format *f, struct pnode *n)
Line 126  pnode_printtext(struct format *f, struct pnode *n)
 }  }
   
 static void  static void
 pnode_printpara(struct format *f, struct pnode *n)  pnode_printimagedata(struct format *f, struct pnode *n)
 {  {
         struct pnode    *np;          const char      *cp;
   
         if (n->parent == NULL)          if ((cp = pnode_getattr_raw(n, ATTRKEY_FILEREF, NULL)) == NULL)
                 return;                  cp = pnode_getattr_raw(n, ATTRKEY_ENTITYREF, NULL);
           if (cp != NULL) {
         if ((np = TAILQ_PREV(n, pnodeq, child)) == NULL)                  print_text(f, "[image:", ARG_SPACE);
             np = n->parent;                  print_text(f, cp, ARG_SPACE);
                   print_text(f, "]", 0);
         f->flags = 0;          } else
                   print_text(f, "[image]", ARG_SPACE);
         switch (np->node) {  
         case NODE_ENTRY:  
         case NODE_GLOSSTERM:  
         case NODE_LISTITEM:  
         case NODE_TERM:  
                 return;  
         case NODE_APPENDIX:  
         case NODE_LEGALNOTICE:  
         case NODE_PREFACE:  
         case NODE_SECTION:  
                 if (f->level < 3)  
                         return;  
                 break;  
         default:  
                 break;  
         }  
         macro_line(f, "Pp");  
 }  }
   
 static void  static void
Line 163  pnode_printrefnamediv(struct format *f, struct pnode *
Line 146  pnode_printrefnamediv(struct format *f, struct pnode *
         struct pnode    *nc, *nn;          struct pnode    *nc, *nn;
         int              comma;          int              comma;
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Sh NAME");          macro_line(f, "Sh NAME");
           f->parastate = PARA_HAVE;
         comma = 0;          comma = 0;
         TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {          TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                 if (nc->node != NODE_REFNAME)                  if (nc->node != NODE_REFNAME)
Line 190  pnode_printrefsynopsisdiv(struct format *f, struct pno
Line 175  pnode_printrefsynopsisdiv(struct format *f, struct pno
                 if (nc->node == NODE_TITLE)                  if (nc->node == NODE_TITLE)
                         pnode_unlink(nc);                          pnode_unlink(nc);
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Sh SYNOPSIS");          macro_line(f, "Sh SYNOPSIS");
           f->parastate = PARA_HAVE;
 }  }
   
 /*  /*
Line 210  pnode_printsection(struct format *f, struct pnode *n)
Line 197  pnode_printsection(struct format *f, struct pnode *n)
   
         level = ++f->level;          level = ++f->level;
         flags = ARG_SPACE;          flags = ARG_SPACE;
         if (level == 1)          switch (n->node) {
                 flags |= ARG_UPPER;          case NODE_PREFACE:
         if (level < 3) {          case NODE_SECTION:
                 switch (n->node) {          case NODE_APPENDIX:
                 case NODE_CAUTION:                  if (level == 1)
                 case NODE_NOTE:                          flags |= ARG_UPPER;
                 case NODE_TIP:                  break;
                 case NODE_WARNING:          case NODE_SIMPLESECT:
           case NODE_LEGALNOTICE:
                   if (level < 2)
                           level = 2;
                   break;
           default:
                   if (level < 3)
                         level = 3;                          level = 3;
                         break;                  break;
                 default:  
                         break;  
                 }  
         }          }
   
         TAILQ_FOREACH(nc, &n->childq, child)          TAILQ_FOREACH(nc, &n->childq, child)
Line 261  pnode_printsection(struct format *f, struct pnode *n)
Line 251  pnode_printsection(struct format *f, struct pnode *n)
         switch (level) {          switch (level) {
         case 1:          case 1:
                 macro_close(f);                  macro_close(f);
                   f->parastate = PARA_HAVE;
                 macro_open(f, "Sh");                  macro_open(f, "Sh");
                 break;                  break;
         case 2:          case 2:
                 macro_close(f);                  macro_close(f);
                   f->parastate = PARA_HAVE;
                 macro_open(f, "Ss");                  macro_open(f, "Ss");
                 break;                  break;
         default:          default:
                 pnode_printpara(f, n);                  if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                 macro_open(f, "Sy");                  macro_open(f, "Sy");
                 break;                  break;
         }          }
Line 285  pnode_printsection(struct format *f, struct pnode *n)
Line 278  pnode_printsection(struct format *f, struct pnode *n)
          */           */
   
         if (nc != NULL) {          if (nc != NULL) {
                 ncc = TAILQ_FIRST(&nc->childq);                  if (level == 1 &&
                 if (ncc != NULL && ncc->node == NODE_TEXT &&                      (ncc = TAILQ_FIRST(&nc->childq)) != NULL &&
                       ncc->node == NODE_TEXT &&
                     strcasecmp(ncc->b, "AUTHORS") == 0)                      strcasecmp(ncc->b, "AUTHORS") == 0)
                         macro_line(f, "An -nosplit");                          macro_line(f, "An -nosplit");
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
           f->parastate = level > 2 ? PARA_WANT : PARA_HAVE;
 }  }
   
 /*  /*
Line 606  pnode_printauthor(struct format *f, struct pnode *n)
Line 601  pnode_printauthor(struct format *f, struct pnode *n)
 }  }
   
 static void  static void
   pnode_printxref(struct format *f, struct pnode *n)
   {
           const char      *linkend;
   
           linkend = pnode_getattr_raw(n, ATTRKEY_LINKEND, NULL);
           if (linkend != NULL) {
                   macro_open(f, "Sx");
                   macro_addarg(f, linkend, ARG_SPACE);
           }
   }
   
   static void
 pnode_printlink(struct format *f, struct pnode *n)  pnode_printlink(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc;          struct pnode    *nc;
Line 648  pnode_printlink(struct format *f, struct pnode *n)
Line 655  pnode_printlink(struct format *f, struct pnode *n)
                 if (TAILQ_FIRST(&n->childq) != NULL)                  if (TAILQ_FIRST(&n->childq) != NULL)
                         macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);                          macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
           }
   }
   
   static void
   pnode_printolink(struct format *f, struct pnode *n)
   {
           const char      *uri, *ptr, *local;
   
           uri = pnode_getattr_raw(n, ATTRKEY_TARGETDOC, NULL);
           ptr = pnode_getattr_raw(n, ATTRKEY_TARGETPTR, NULL);
           local = pnode_getattr_raw(n, ATTRKEY_LOCALINFO, NULL);
           if (uri == NULL) {
                   uri = ptr;
                   ptr = NULL;
           }
           if (uri == NULL) {
                   uri = local;
                   local = NULL;
           }
           if (uri == NULL)
                 return;                  return;
   
           macro_open(f, "Lk");
           macro_addarg(f, uri, ARG_SPACE | ARG_SINGLE);
           macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);
           if (ptr != NULL || local != NULL) {
                   macro_close(f);
                   macro_open(f, "Pq");
                   if (ptr != NULL)
                           macro_addarg(f, ptr, ARG_SPACE);
                   if (local != NULL)
                           macro_addarg(f, local, ARG_SPACE);
         }          }
           pnode_unlinksub(n);
 }  }
   
 static void  static void
Line 722  pnode_printprologue(struct format *f, struct pnode *ro
Line 761  pnode_printprologue(struct format *f, struct pnode *ro
         pnode_unlink(name);          pnode_unlink(name);
         pnode_unlink(vol);          pnode_unlink(vol);
         pnode_unlink(descr);          pnode_unlink(descr);
           f->parastate = PARA_HAVE;
 }  }
   
 static void  static void
Line 865  pnode_printvarlistentry(struct format *f, struct pnode
Line 905  pnode_printvarlistentry(struct format *f, struct pnode
         int              first = 1;          int              first = 1;
   
         macro_open(f, "It");          macro_open(f, "It");
           f->parastate = PARA_HAVE;
         f->flags |= FMT_IMPL;          f->flags |= FMT_IMPL;
         TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {          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)
Line 881  pnode_printvarlistentry(struct format *f, struct pnode
Line 922  pnode_printvarlistentry(struct format *f, struct pnode
                                 break;                                  break;
                         }                          }
                 }                  }
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                 pnode_unlink(nc);                  pnode_unlink(nc);
                 first = 0;                  first = 0;
         }          }
         macro_close(f);          macro_close(f);
           f->parastate = PARA_HAVE;
         while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {          while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {
                 pnode_print(f, nc);                  pnode_print(f, nc);
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
         macro_close(f);          macro_close(f);
           f->parastate = PARA_HAVE;
 }  }
   
 static void  static void
Line 900  pnode_printtitle(struct format *f, struct pnode *n)
Line 944  pnode_printtitle(struct format *f, struct pnode *n)
   
         TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {          TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                 if (nc->node == NODE_TITLE) {                  if (nc->node == NODE_TITLE) {
                         pnode_printpara(f, nc);                          if (f->parastate == PARA_MID)
                         pnode_print(f, nc);                                  f->parastate = PARA_WANT;
                           macro_nodeline(f, "Sy", nc, 0);
                         pnode_unlink(nc);                          pnode_unlink(nc);
                 }                  }
         }          }
Line 929  pnode_printtgroup1(struct format *f, struct pnode *n)
Line 974  pnode_printtgroup1(struct format *f, struct pnode *n)
         macro_line(f, "Bl -bullet -compact");          macro_line(f, "Bl -bullet -compact");
         while ((nc = pnode_findfirst(n, NODE_ENTRY)) != NULL) {          while ((nc = pnode_findfirst(n, NODE_ENTRY)) != NULL) {
                 macro_line(f, "It");                  macro_line(f, "It");
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                   f->parastate = PARA_HAVE;
                 pnode_unlink(nc);                  pnode_unlink(nc);
         }          }
         macro_line(f, "El");          macro_line(f, "El");
Line 941  pnode_printtgroup2(struct format *f, struct pnode *n)
Line 988  pnode_printtgroup2(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nr, *ne;          struct pnode    *nr, *ne;
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Bl -tag -width Ds");          macro_line(f, "Bl -tag -width Ds");
         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_open(f, "It");                  macro_open(f, "It");
                 f->flags |= FMT_IMPL;                  f->flags |= FMT_IMPL;
                   f->parastate = PARA_HAVE;
                 pnode_print(f, ne);                  pnode_print(f, ne);
                 macro_close(f);                  macro_close(f);
                 pnode_unlink(ne);                  pnode_unlink(ne);
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nr);                  pnode_print(f, nr);
                   f->parastate = PARA_HAVE;
                 pnode_unlink(nr);                  pnode_unlink(nr);
         }          }
         macro_line(f, "El");          macro_line(f, "El");
Line 973  pnode_printtgroup(struct format *f, struct pnode *n)
Line 1024  pnode_printtgroup(struct format *f, struct pnode *n)
                 break;                  break;
         }          }
   
           f->parastate = PARA_HAVE;
         macro_line(f, "Bl -ohang");          macro_line(f, "Bl -ohang");
         while ((nc = pnode_findfirst(n, NODE_ROW)) != NULL) {          while ((nc = pnode_findfirst(n, NODE_ROW)) != NULL) {
                 macro_line(f, "It Table Row");                  macro_line(f, "It Table Row");
Line 988  pnode_printlist(struct format *f, struct pnode *n)
Line 1040  pnode_printlist(struct format *f, struct pnode *n)
         struct pnode    *nc;          struct pnode    *nc;
   
         pnode_printtitle(f, n);          pnode_printtitle(f, n);
           f->parastate = PARA_HAVE;
         macro_argline(f, "Bl",          macro_argline(f, "Bl",
             n->node == NODE_ORDEREDLIST ? "-enum" : "-bullet");              n->node == NODE_ORDEREDLIST ? "-enum" : "-bullet");
         TAILQ_FOREACH(nc, &n->childq, child) {          TAILQ_FOREACH(nc, &n->childq, child) {
                 macro_line(f, "It");                  macro_line(f, "It");
                   f->parastate = PARA_HAVE;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                   f->parastate = PARA_HAVE;
         }          }
         macro_line(f, "El");          macro_line(f, "El");
         pnode_unlinksub(n);          pnode_unlinksub(n);
Line 1004  pnode_printvariablelist(struct format *f, struct pnode
Line 1059  pnode_printvariablelist(struct format *f, struct pnode
         struct pnode    *nc;          struct pnode    *nc;
   
         pnode_printtitle(f, n);          pnode_printtitle(f, n);
           f->parastate = PARA_HAVE;
         macro_line(f, "Bl -tag -width Ds");          macro_line(f, "Bl -tag -width Ds");
         TAILQ_FOREACH(nc, &n->childq, child) {          TAILQ_FOREACH(nc, &n->childq, child) {
                 if (nc->node == NODE_VARLISTENTRY)                  if (nc->node == NODE_VARLISTENTRY)
Line 1047  pnode_print(struct format *f, struct pnode *n)
Line 1103  pnode_print(struct format *f, struct pnode *n)
                 macro_line(f, "An -split");                  macro_line(f, "An -split");
                 break;                  break;
         case NODE_BLOCKQUOTE:          case NODE_BLOCKQUOTE:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bd -ragged -offset indent");                  macro_line(f, "Bd -ragged -offset indent");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_CITEREFENTRY:          case NODE_CITEREFENTRY:
                 pnode_printciterefentry(f, n);                  pnode_printciterefentry(f, n);
Line 1061  pnode_print(struct format *f, struct pnode *n)
Line 1119  pnode_print(struct format *f, struct pnode *n)
         case NODE_CONSTANT:          case NODE_CONSTANT:
                 macro_open(f, "Dv");                  macro_open(f, "Dv");
                 break;                  break;
           case NODE_COPYRIGHT:
                   print_text(f, "Copyright", ARG_SPACE);
                   fputs(" \\(co", stdout);
                   break;
         case NODE_EDITOR:          case NODE_EDITOR:
                 print_text(f, "editor:", ARG_SPACE);                  print_text(f, "editor:", ARG_SPACE);
                 macro_open(f, "An");                  pnode_printauthor(f, n);
                 break;                  break;
         case NODE_EMAIL:          case NODE_EMAIL:
                 if (was_impl)                  if (was_impl)
Line 1076  pnode_print(struct format *f, struct pnode *n)
Line 1138  pnode_print(struct format *f, struct pnode *n)
         case NODE_EMPHASIS:          case NODE_EMPHASIS:
         case NODE_FIRSTTERM:          case NODE_FIRSTTERM:
         case NODE_GLOSSTERM:          case NODE_GLOSSTERM:
                 macro_open(f, "Em");                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                       pnode_class(nc->node) < CLASS_LINE)
                           macro_open(f, "Em");
                   if (n->node == NODE_GLOSSTERM)
                           f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_ENVAR:          case NODE_ENVAR:
                 macro_open(f, "Ev");                  macro_open(f, "Ev");
Line 1087  pnode_print(struct format *f, struct pnode *n)
Line 1153  pnode_print(struct format *f, struct pnode *n)
         case NODE_FILENAME:          case NODE_FILENAME:
                 macro_open(f, "Pa");                  macro_open(f, "Pa");
                 break;                  break;
           case NODE_FOOTNOTE:
                   macro_line(f, "Bo");
                   f->parastate = PARA_HAVE;
                   break;
         case NODE_FUNCTION:          case NODE_FUNCTION:
                 macro_open(f, "Fn");                  macro_open(f, "Fn");
                 break;                  break;
Line 1096  pnode_print(struct format *f, struct pnode *n)
Line 1166  pnode_print(struct format *f, struct pnode *n)
         case NODE_FUNCSYNOPSISINFO:          case NODE_FUNCSYNOPSISINFO:
                 macro_open(f, "Fd");                  macro_open(f, "Fd");
                 break;                  break;
           case NODE_IMAGEDATA:
                   pnode_printimagedata(f, n);
                   break;
         case NODE_INFORMALEQUATION:          case NODE_INFORMALEQUATION:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bd -ragged -offset indent");                  macro_line(f, "Bd -ragged -offset indent");
                   f->parastate = PARA_HAVE;
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case NODE_INLINEEQUATION:          case NODE_INLINEEQUATION:
                 macro_line(f, "EQ");                  macro_line(f, "EQ");
Line 1115  pnode_print(struct format *f, struct pnode *n)
Line 1190  pnode_print(struct format *f, struct pnode *n)
                 pnode_printlink(f, n);                  pnode_printlink(f, n);
                 break;                  break;
         case NODE_LITERAL:          case NODE_LITERAL:
                 if (was_impl)                  if (n->parent != NULL && n->parent->node == NODE_QUOTE)
                         macro_open(f, "So");                          macro_open(f, "Li");
                   else if (was_impl)
                           macro_open(f, "So Li");
                 else {                  else {
                         macro_open(f, "Ql");                          macro_open(f, "Ql");
                         f->flags |= FMT_IMPL;                          f->flags |= FMT_IMPL;
Line 1124  pnode_print(struct format *f, struct pnode *n)
Line 1201  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_LITERALLAYOUT:          case NODE_LITERALLAYOUT:
                 macro_close(f);                  macro_close(f);
                   f->parastate = PARA_HAVE;
                 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");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_MARKUP:          case NODE_MARKUP:
                 macro_open(f, "Ic");                  macro_open(f, "Ic");
Line 1146  pnode_print(struct format *f, struct pnode *n)
Line 1225  pnode_print(struct format *f, struct pnode *n)
         case NODE_MML_MSUP:          case NODE_MML_MSUP:
                 pnode_printmath(f, n);                  pnode_printmath(f, n);
                 break;                  break;
           case NODE_OLINK:
                   pnode_printolink(f, n);
                   break;
         case NODE_OPTION:          case NODE_OPTION:
                 macro_open(f, "Fl");                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                       pnode_class(nc->node) < CLASS_LINE)
                           macro_open(f, "Fl");
                 break;                  break;
         case NODE_ORDEREDLIST:          case NODE_ORDEREDLIST:
                 pnode_printlist(f, n);                  pnode_printlist(f, n);
                 break;                  break;
         case NODE_PARA:          case NODE_PARA:
                 pnode_printpara(f, n);                  if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                 break;                  break;
         case NODE_PARAMDEF:          case NODE_PARAMDEF:
         case NODE_PARAMETER:          case NODE_PARAMETER:
Line 1163  pnode_print(struct format *f, struct pnode *n)
Line 1248  pnode_print(struct format *f, struct pnode *n)
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
                 break;                  break;
         case NODE_QUOTE:          case NODE_QUOTE:
                 if (was_impl)                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                       nc->node == NODE_FILENAME &&
                       TAILQ_NEXT(nc, child) == NULL) {
                           if (n->spc)
                                   nc->spc = 1;
                   } else if (was_impl)
                         macro_open(f, "Do");                          macro_open(f, "Do");
                 else {                  else {
                         macro_open(f, "Dq");                          macro_open(f, "Dq");
Line 1173  pnode_print(struct format *f, struct pnode *n)
Line 1263  pnode_print(struct format *f, struct pnode *n)
         case NODE_PROGRAMLISTING:          case NODE_PROGRAMLISTING:
         case NODE_SCREEN:          case NODE_SCREEN:
         case NODE_SYNOPSIS:          case NODE_SYNOPSIS:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bd -literal");                  macro_line(f, "Bd -literal");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_SYSTEMITEM:          case NODE_SYSTEMITEM:
                 pnode_printsystemitem(f, n);                  pnode_printsystemitem(f, n);
Line 1196  pnode_print(struct format *f, struct pnode *n)
Line 1288  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_PREFACE:          case NODE_PREFACE:
         case NODE_SECTION:          case NODE_SECTION:
           case NODE_SIMPLESECT:
         case NODE_APPENDIX:          case NODE_APPENDIX:
         case NODE_LEGALNOTICE:          case NODE_LEGALNOTICE:
         case NODE_NOTE:          case NODE_NOTE:
Line 1208  pnode_print(struct format *f, struct pnode *n)
Line 1301  pnode_print(struct format *f, struct pnode *n)
                 macro_open(f, "Ar");                  macro_open(f, "Ar");
                 break;                  break;
         case NODE_SBR:          case NODE_SBR:
                 macro_line(f, "br");                  if (f->parastate == PARA_MID)
                           macro_line(f, "br");
                 break;                  break;
           case NODE_SUBSCRIPT:
                   if (f->linestate == LINE_MACRO)
                           macro_addarg(f, "_", 0);
                   else
                           print_text(f, "_", 0);
                   if ((nc = TAILQ_FIRST(&n->childq)) != NULL)
                           nc->spc = 0;
                   break;
           case NODE_SUPERSCRIPT:
                   fputs("\\(ha", stdout);
                   if ((nc = TAILQ_FIRST(&n->childq)) != NULL)
                           nc->spc = 0;
                   break;
         case NODE_TEXT:          case NODE_TEXT:
         case NODE_ESCAPE:          case NODE_ESCAPE:
                 pnode_printtext(f, n);                  pnode_printtext(f, n);
Line 1218  pnode_print(struct format *f, struct pnode *n)
Line 1325  pnode_print(struct format *f, struct pnode *n)
                 pnode_printtgroup(f, n);                  pnode_printtgroup(f, n);
                 break;                  break;
         case NODE_TITLE:          case NODE_TITLE:
                 pnode_printpara(f, n);          case NODE_SUBTITLE:
                   if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                 macro_nodeline(f, "Sy", n, 0);                  macro_nodeline(f, "Sy", n, 0);
                 pnode_unlinksub(n);                  pnode_unlinksub(n);
                 break;                  break;
Line 1231  pnode_print(struct format *f, struct pnode *n)
Line 1340  pnode_print(struct format *f, struct pnode *n)
         case NODE_VARNAME:          case NODE_VARNAME:
                 macro_open(f, "Va");                  macro_open(f, "Va");
                 break;                  break;
           case NODE_XREF:
                   pnode_printxref(f, n);
                   break;
         default:          default:
                 break;                  break;
         }          }
Line 1251  pnode_print(struct format *f, struct pnode *n)
Line 1363  pnode_print(struct format *f, struct pnode *n)
         case NODE_TEXT:          case NODE_TEXT:
                 /* Accept more arguments to the previous macro. */                  /* Accept more arguments to the previous macro. */
                 return;                  return;
           case NODE_FOOTNOTE:
                   f->parastate = PARA_HAVE;
                   macro_line(f, "Bc");
                   break;
           case NODE_GLOSSTERM:
                   f->parastate = PARA_HAVE;
                   break;
         case NODE_INFORMALEQUATION:          case NODE_INFORMALEQUATION:
                 macro_line(f, "EN");                  macro_line(f, "EN");
                 macro_line(f, "Ed");                  macro_line(f, "Ed");
Line 1259  pnode_print(struct format *f, struct pnode *n)
Line 1378  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 (n->parent != NULL && n->parent->node == NODE_QUOTE)
                           /* nothing */;
                   else if (was_impl) {
                         f->flags &= ~FMT_NOSPC;                          f->flags &= ~FMT_NOSPC;
                         macro_open(f, "Sc");                          macro_open(f, "Sc");
                 } else                  } else
Line 1291  pnode_print(struct format *f, struct pnode *n)
Line 1412  pnode_print(struct format *f, struct pnode *n)
                         break;                          break;
                 fputs(" } ", stdout);                  fputs(" } ", stdout);
                 break;                  break;
           case NODE_PARA:
                   if (f->parastate == PARA_MID)
                           f->parastate = PARA_WANT;
                   break;
         case NODE_QUOTE:          case NODE_QUOTE:
                 if (was_impl) {                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                       nc->node == NODE_FILENAME &&
                       TAILQ_NEXT(nc, child) == NULL)
                           /* nothing */;
                   else if (was_impl) {
                         f->flags &= ~FMT_NOSPC;                          f->flags &= ~FMT_NOSPC;
                         macro_open(f, "Dc");                          macro_open(f, "Dc");
                 } else                  } else
Line 1313  pnode_print(struct format *f, struct pnode *n)
Line 1442  pnode_print(struct format *f, struct pnode *n)
         case NODE_PROGRAMLISTING:          case NODE_PROGRAMLISTING:
         case NODE_SCREEN:          case NODE_SCREEN:
         case NODE_SYNOPSIS:          case NODE_SYNOPSIS:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Ed");                  macro_line(f, "Ed");
                 break;                  break;
           case NODE_TITLE:
           case NODE_SUBTITLE:
                   f->parastate = PARA_WANT;
                   break;
         default:          default:
                 break;                  break;
         }          }
Line 1328  ptree_print_mdoc(struct ptree *tree)
Line 1462  ptree_print_mdoc(struct ptree *tree)
   
         formatter.level = 0;          formatter.level = 0;
         formatter.linestate = LINE_NEW;          formatter.linestate = LINE_NEW;
           formatter.parastate = PARA_HAVE;
         pnode_printprologue(&formatter, tree->root);          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)
Legend:
Removed from v.1.120  
changed lines
  Added in v.1.130
CVSweb