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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.128 and 1.138

version 1.128, 2019/04/15 00:34:15 version 1.138, 2019/04/24 18:38:02
Line 42  pnode_printtext(struct format *f, struct pnode *n)
Line 42  pnode_printtext(struct format *f, struct pnode *n)
   
         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 && !accept_arg) {          if (f->linestate == LINE_MACRO && !accept_arg &&
               (n->flags & NFLAG_SPC) == 0) {
                 for (;;) {                  for (;;) {
                         if (*cp == '\0')                          if (*cp == '\0')
                                 return;                                  return;
Line 71  pnode_printtext(struct format *f, struct pnode *n)
Line 72  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->flags & NFLAG_SPC) == 0) {
                 switch (pnode_class(nn->node)) {                  switch (pnode_class(nn->node)) {
                 case CLASS_LINE:                  case CLASS_LINE:
                 case CLASS_ENCL:                  case CLASS_ENCL:
                         macro_open(f, "Pf");                          macro_open(f, "Pf");
                         accept_arg = 1;                          accept_arg = 1;
                         f->flags |= FMT_CHILD;                          f->flags |= FMT_CHILD;
                         nn->spc = 1;                          nn->flags |= NFLAG_SPC;
                         break;                          break;
                 default:                  default:
                         break;                          break;
Line 89  pnode_printtext(struct format *f, struct pnode *n)
Line 91  pnode_printtext(struct format *f, struct pnode *n)
         case LINE_NEW:          case LINE_NEW:
                 break;                  break;
         case LINE_TEXT:          case LINE_TEXT:
                 if (n->spc) {                  if (n->flags & NFLAG_SPC) {
                         if (n->node == NODE_TEXT)                          if (n->flags & NFLAG_LINE &&
                               pnode_class(n->node) == CLASS_TEXT)
                                 macro_close(f);                                  macro_close(f);
                         else                          else
                                 putchar(' ');                                  putchar(' ');
                 }                  }
                 break;                  break;
         case LINE_MACRO:          case LINE_MACRO:
                 if (accept_arg)                  if (accept_arg == 0)
                         putchar(' ');  
                 else  
                         macro_close(f);                          macro_close(f);
                   else if (n->flags & NFLAG_SPC ||
                       (f->flags & FMT_ARG) == 0 ||
                       (nn = TAILQ_PREV(n, pnodeq, child)) == NULL ||
                       pnode_class(nn->node) != CLASS_TEXT)
                           putchar(' ');
                 break;                  break;
         }          }
   
Line 141  pnode_printimagedata(struct format *f, struct pnode *n
Line 147  pnode_printimagedata(struct format *f, struct pnode *n
 }  }
   
 static void  static void
 pnode_printpara(struct format *f, struct pnode *n)  
 {  
         struct pnode    *np;  
   
         if (n->parent == NULL)  
                 return;  
   
         if ((np = TAILQ_PREV(n, pnodeq, child)) == NULL)  
             np = n->parent;  
   
         f->flags = 0;  
   
         switch (np->node) {  
         case NODE_ENTRY:  
         case NODE_FOOTNOTE:  
         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  
 pnode_printrefnamediv(struct format *f, struct pnode *n)  pnode_printrefnamediv(struct format *f, struct pnode *n)
 {  {
         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 206  pnode_printrefsynopsisdiv(struct format *f, struct pno
Line 181  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 280  pnode_printsection(struct format *f, struct pnode *n)
Line 257  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 304  pnode_printsection(struct format *f, struct pnode *n)
Line 284  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 339  pnode_printciterefentry(struct format *f, struct pnode
Line 321  pnode_printciterefentry(struct format *f, struct pnode
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
 static void  
 pnode_printfuncdef(struct format *f, struct pnode *n)  
 {  
         struct pnode    *nc;  
   
         nc = TAILQ_FIRST(&n->childq);  
         if (nc != NULL && nc->node == NODE_TEXT) {  
                 macro_argline(f, "Ft", nc->b);  
                 pnode_unlink(nc);  
         }  
         macro_nodeline(f, "Fo", n, ARG_SINGLE);  
         pnode_unlinksub(n);  
 }  
   
 /*  /*
  * The <mml:mfenced> node is a little peculiar.   * The <mml:mfenced> node is a little peculiar.
  * First, it can have arbitrary open and closing tokens, which default   * First, it can have arbitrary open and closing tokens, which default
Line 413  pnode_printmath(struct format *f, struct pnode *n)
Line 381  pnode_printmath(struct format *f, struct pnode *n)
 static void  static void
 pnode_printfuncprototype(struct format *f, struct pnode *n)  pnode_printfuncprototype(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc, *fdef;          struct pnode    *fdef, *ftype, *nc, *nn;
   
         TAILQ_FOREACH(fdef, &n->childq, child)          /*
                 if (fdef->node == NODE_FUNCDEF)           * Extract <funcdef> child and ignore <void> child.
            * Leave other children in place, to be treated as parameters.
            */
   
           fdef = NULL;
           TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
                   switch (nc->node) {
                   case NODE_FUNCDEF:
                           if (fdef == NULL) {
                                   fdef = nc;
                                   TAILQ_REMOVE(&n->childq, nc, child);
                                   nc->parent = NULL;
                           }
                         break;                          break;
                   case NODE_VOID:
                           pnode_unlink(nc);
                           break;
                   default:
                           break;
                   }
           }
   
           /*
            * If no children are left, the function is void; use .Fn.
            * Otherwise, use .Fo.
            */
   
           nc = TAILQ_FIRST(&n->childq);
         if (fdef != NULL) {          if (fdef != NULL) {
                 pnode_printfuncdef(f, fdef);                  ftype = TAILQ_FIRST(&fdef->childq);
                   if (ftype != NULL && ftype->node == NODE_TEXT) {
                           macro_argline(f, "Ft", ftype->b);
                           pnode_unlink(ftype);
                   }
                   if (nc == NULL) {
                           macro_open(f, "Fn");
                           macro_addnode(f, fdef, ARG_SPACE | ARG_SINGLE);
                           macro_addarg(f, "void", ARG_SPACE);
                           macro_close(f);
                   } else
                           macro_nodeline(f, "Fo", fdef, ARG_SINGLE);
                 pnode_unlink(fdef);                  pnode_unlink(fdef);
         } else          } else if (nc == NULL)
                   macro_line(f, "Fn UNKNOWN void");
           else
                 macro_line(f, "Fo UNKNOWN");                  macro_line(f, "Fo UNKNOWN");
   
         TAILQ_FOREACH(nc, &n->childq, child)          if (nc == NULL)
                 macro_nodeline(f, "Fa", nc, ARG_SINGLE);                  return;
   
           while (nc != NULL) {
                   macro_nodeline(f, "Fa", nc, ARG_SINGLE);
                   pnode_unlink(nc);
                   nc = TAILQ_FIRST(&n->childq);
           }
         macro_line(f, "Fc");          macro_line(f, "Fc");
         pnode_unlinksub(n);  
 }  }
   
 /*  /*
Line 625  pnode_printauthor(struct format *f, struct pnode *n)
Line 635  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 773  pnode_printprologue(struct format *f, struct pnode *ro
Line 795  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 795  pnode_printrefentry(struct format *f, struct pnode *n)
Line 818  pnode_printrefentry(struct format *f, struct pnode *n)
                         pnode_unlink(info);                          pnode_unlink(info);
                         info = NULL;                          info = NULL;
                 }                  }
                   if (info == NULL)
                           info = pnode_takefirst(n, NODE_INFO);
                 meta = pnode_takefirst(n, NODE_REFMETA);                  meta = pnode_takefirst(n, NODE_REFMETA);
                 if (meta != NULL && TAILQ_FIRST(&meta->childq) == NULL) {                  if (meta != NULL && TAILQ_FIRST(&meta->childq) == NULL) {
                         pnode_unlink(meta);                          pnode_unlink(meta);
Line 868  pnode_printrefentry(struct format *f, struct pnode *n)
Line 893  pnode_printrefentry(struct format *f, struct pnode *n)
                         exit(1);                          exit(1);
                 }                  }
                 match->node = NODE_SECTION;                  match->node = NODE_SECTION;
                 match->spc = 1;                  match->flags |= NFLAG_SPC;
                 match->parent = n;                  match->parent = n;
                 TAILQ_INIT(&match->childq);                  TAILQ_INIT(&match->childq);
                 TAILQ_INIT(&match->attrq);                  TAILQ_INIT(&match->attrq);
Line 877  pnode_printrefentry(struct format *f, struct pnode *n)
Line 902  pnode_printrefentry(struct format *f, struct pnode *n)
                         exit(1);                          exit(1);
                 }                  }
                 nc->node = NODE_TITLE;                  nc->node = NODE_TITLE;
                 nc->spc = 1;                  nc->flags |= NFLAG_SPC;
                 if ((nc = pnode_alloc(nc)) == NULL) {                  if ((nc = pnode_alloc(nc)) == NULL) {
                         perror(NULL);                          perror(NULL);
                         exit(1);                          exit(1);
Line 887  pnode_printrefentry(struct format *f, struct pnode *n)
Line 912  pnode_printrefentry(struct format *f, struct pnode *n)
                         perror(NULL);                          perror(NULL);
                         exit(1);                          exit(1);
                 }                  }
                 nc->spc = 1;                  nc->flags |= NFLAG_SPC;
                 if (later == NULL)                  if (later == NULL)
                         TAILQ_INSERT_TAIL(&n->childq, match, child);                          TAILQ_INSERT_TAIL(&n->childq, match, child);
                 else                  else
Line 912  pnode_printrefentry(struct format *f, struct pnode *n)
Line 937  pnode_printrefentry(struct format *f, struct pnode *n)
 static void  static void
 pnode_printvarlistentry(struct format *f, struct pnode *n)  pnode_printvarlistentry(struct format *f, struct pnode *n)
 {  {
         struct pnode    *nc, *nn;          struct pnode    *nc, *nn, *ncc;
         int              first = 1;          int              comma;
   
         macro_open(f, "It");          macro_open(f, "It");
           f->parastate = PARA_HAVE;
         f->flags |= FMT_IMPL;          f->flags |= FMT_IMPL;
           comma = -1;
         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)
                         continue;                          continue;
                 if (first == 0) {                  if (comma != -1) {
                         switch (f->linestate) {                          switch (f->linestate) {
                         case LINE_NEW:                          case LINE_NEW:
                                 break;                                  break;
Line 928  pnode_printvarlistentry(struct format *f, struct pnode
Line 955  pnode_printvarlistentry(struct format *f, struct pnode
                                 print_text(f, ",", 0);                                  print_text(f, ",", 0);
                                 break;                                  break;
                         case LINE_MACRO:                          case LINE_MACRO:
                                 macro_addarg(f, ",", 0);                                  macro_addarg(f, ",", comma);
                                 break;                                  break;
                         }                          }
                 }                  }
                   f->parastate = PARA_HAVE;
                   comma = (ncc = TAILQ_FIRST(&nc->childq)) == NULL ||
                       pnode_class(ncc->node) == CLASS_TEXT ? 0 : ARG_SPACE;
                 pnode_print(f, nc);                  pnode_print(f, nc);
                 pnode_unlink(nc);                  pnode_unlink(nc);
                 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 951  pnode_printtitle(struct format *f, struct pnode *n)
Line 982  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 980  pnode_printtgroup1(struct format *f, struct pnode *n)
Line 1012  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 992  pnode_printtgroup2(struct format *f, struct pnode *n)
Line 1026  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");
           f->parastate = PARA_WANT;
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
Line 1024  pnode_printtgroup(struct format *f, struct pnode *n)
Line 1063  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");
                 pnode_printrow(f, nc);                  pnode_printrow(f, nc);
         }          }
         macro_line(f, "El");          macro_line(f, "El");
           f->parastate = PARA_WANT;
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
Line 1039  pnode_printlist(struct format *f, struct pnode *n)
Line 1080  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");
           f->parastate = PARA_WANT;
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
Line 1055  pnode_printvariablelist(struct format *f, struct pnode
Line 1100  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 1063  pnode_printvariablelist(struct format *f, struct pnode
Line 1109  pnode_printvariablelist(struct format *f, struct pnode
                         macro_nodeline(f, "It", nc, 0);                          macro_nodeline(f, "It", nc, 0);
         }          }
         macro_line(f, "El");          macro_line(f, "El");
           f->parastate = PARA_WANT;
         pnode_unlinksub(n);          pnode_unlinksub(n);
 }  }
   
Line 1082  pnode_print(struct format *f, struct pnode *n)
Line 1129  pnode_print(struct format *f, struct pnode *n)
                 return;                  return;
   
         was_impl = f->flags & FMT_IMPL;          was_impl = f->flags & FMT_IMPL;
         if (n->spc)          if (n->flags & NFLAG_SPC)
                 f->flags &= ~FMT_NOSPC;                  f->flags &= ~FMT_NOSPC;
         else          else
                 f->flags |= FMT_NOSPC;                  f->flags |= FMT_NOSPC;
Line 1098  pnode_print(struct format *f, struct pnode *n)
Line 1145  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 1134  pnode_print(struct format *f, struct pnode *n)
Line 1183  pnode_print(struct format *f, struct pnode *n)
                 if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                     pnode_class(nc->node) < CLASS_LINE)                      pnode_class(nc->node) < CLASS_LINE)
                         macro_open(f, "Em");                          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 1146  pnode_print(struct format *f, struct pnode *n)
Line 1197  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_FOOTNOTE:          case NODE_FOOTNOTE:
                 macro_line(f, "Bo");                  macro_line(f, "Bo");
                   f->parastate = PARA_HAVE;
                 break;                  break;
         case NODE_FUNCTION:          case NODE_FUNCTION:
                 macro_open(f, "Fn");                  macro_open(f, "Fn");
Line 1160  pnode_print(struct format *f, struct pnode *n)
Line 1212  pnode_print(struct format *f, struct pnode *n)
                 pnode_printimagedata(f, n);                  pnode_printimagedata(f, n);
                 break;                  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 1172  pnode_print(struct format *f, struct pnode *n)
Line 1226  pnode_print(struct format *f, struct pnode *n)
                 pnode_printgroup(f, n);                  pnode_printgroup(f, n);
                 break;                  break;
         case NODE_KEYSYM:          case NODE_KEYSYM:
           case NODE_PRODUCTNAME:
                 macro_open(f, "Sy");                  macro_open(f, "Sy");
                 break;                  break;
         case NODE_LINK:          case NODE_LINK:
Line 1189  pnode_print(struct format *f, struct pnode *n)
Line 1244  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 1223  pnode_print(struct format *f, struct pnode *n)
Line 1280  pnode_print(struct format *f, struct pnode *n)
                 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 1236  pnode_print(struct format *f, struct pnode *n)
Line 1294  pnode_print(struct format *f, struct pnode *n)
                 if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                     nc->node == NODE_FILENAME &&                      nc->node == NODE_FILENAME &&
                     TAILQ_NEXT(nc, child) == NULL) {                      TAILQ_NEXT(nc, child) == NULL) {
                         if (n->spc)                          if (n->flags & NFLAG_SPC)
                                 nc->spc = 1;                                  nc->flags |= NFLAG_SPC;
                 } else if (was_impl)                  } else if (was_impl)
                         macro_open(f, "Do");                          macro_open(f, "Do");
                 else {                  else {
Line 1248  pnode_print(struct format *f, struct pnode *n)
Line 1306  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 1284  pnode_print(struct format *f, struct pnode *n)
Line 1344  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:          case NODE_SUBSCRIPT:
                 if (f->linestate == LINE_MACRO)                  if (f->linestate == LINE_MACRO)
Line 1292  pnode_print(struct format *f, struct pnode *n)
Line 1353  pnode_print(struct format *f, struct pnode *n)
                 else                  else
                         print_text(f, "_", 0);                          print_text(f, "_", 0);
                 if ((nc = TAILQ_FIRST(&n->childq)) != NULL)                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL)
                         nc->spc = 0;                          nc->flags &= ~(NFLAG_LINE | NFLAG_SPC);
                 break;                  break;
         case NODE_SUPERSCRIPT:          case NODE_SUPERSCRIPT:
                 fputs("\\(ha", stdout);                  fputs("\\(ha", stdout);
                 if ((nc = TAILQ_FIRST(&n->childq)) != NULL)                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL)
                         nc->spc = 0;                          nc->flags &= ~(NFLAG_LINE | NFLAG_SPC);
                 break;                  break;
         case NODE_TEXT:          case NODE_TEXT:
         case NODE_ESCAPE:          case NODE_ESCAPE:
Line 1308  pnode_print(struct format *f, struct pnode *n)
Line 1369  pnode_print(struct format *f, struct pnode *n)
                 break;                  break;
         case NODE_TITLE:          case NODE_TITLE:
         case NODE_SUBTITLE:          case NODE_SUBTITLE:
                 pnode_printpara(f, n);                  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 1321  pnode_print(struct format *f, struct pnode *n)
Line 1383  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_VOID:
                   print_text(f, "void", ARG_SPACE);
                   break;
           case NODE_XREF:
                   pnode_printxref(f, n);
                   break;
         default:          default:
                 break;                  break;
         }          }
Line 1342  pnode_print(struct format *f, struct pnode *n)
Line 1410  pnode_print(struct format *f, struct pnode *n)
                 /* Accept more arguments to the previous macro. */                  /* Accept more arguments to the previous macro. */
                 return;                  return;
         case NODE_FOOTNOTE:          case NODE_FOOTNOTE:
                   f->parastate = PARA_HAVE;
                 macro_line(f, "Bc");                  macro_line(f, "Bc");
                 break;                  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 1386  pnode_print(struct format *f, struct pnode *n)
Line 1458  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 ((nc = TAILQ_FIRST(&n->childq)) != NULL &&                  if ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
                     nc->node == NODE_FILENAME &&                      nc->node == NODE_FILENAME &&
Line 1412  pnode_print(struct format *f, struct pnode *n)
Line 1488  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");
                   f->parastate = PARA_WANT;
                 break;                  break;
           case NODE_TITLE:
           case NODE_SUBTITLE:
                   f->parastate = PARA_WANT;
                   break;
         default:          default:
                 break;                  break;
         }          }
Line 1427  ptree_print_mdoc(struct ptree *tree)
Line 1509  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.128  
changed lines
  Added in v.1.138
CVSweb