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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.45 and 1.52

version 1.45, 2019/03/08 10:04:01 version 1.52, 2019/03/22 16:21:23
Line 1 
Line 1 
 /*      $Id$ */  /* $Id$ */
 /*  /*
  * Copyright (c) 2014 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2014 Kristaps Dzonsons <kristaps@bsd.lv>
    * Copyright (c) 2019 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 41  struct parse {
Line 42  struct parse {
         unsigned int     flags; /* document-wide flags */          unsigned int     flags; /* document-wide flags */
         struct pnode    *root; /* root of parse tree */          struct pnode    *root; /* root of parse tree */
         struct pnode    *cur; /* current node in tree */          struct pnode    *cur; /* current node in tree */
         char            *b; /* nil-terminated buffer for pre-print */          char            *b; /* NUL-terminated buffer for pre-print */
         size_t           bsz; /* current length of b */          size_t           bsz; /* current length of b */
         size_t           mbsz; /* max bsz allocation */          size_t           mbsz; /* max bsz allocation */
           int              level; /* header level, starting at 1 */
         int              newln; /* output: are we on a fresh line */          int              newln; /* output: are we on a fresh line */
 };  };
   
Line 93  static const char *attrvals[ATTRVAL__MAX] = {
Line 95  static const char *attrvals[ATTRVAL__MAX] = {
 static  const struct node nodes[NODE__MAX] = {  static  const struct node nodes[NODE__MAX] = {
         { NULL, 0 },          { NULL, 0 },
         { "acronym", 0 },          { "acronym", 0 },
           { "affiliation", NODE_IGNTEXT },
         { "anchor", NODE_IGNTEXT },          { "anchor", NODE_IGNTEXT },
         { "application", 0 },          { "application", 0 },
         { "arg", 0 },          { "arg", 0 },
           { "author", NODE_IGNTEXT },
           { "authorgroup", NODE_IGNTEXT },
           { "blockquote", NODE_IGNTEXT },
           { "book", NODE_IGNTEXT },
           { "bookinfo", NODE_IGNTEXT },
         { "caution", NODE_IGNTEXT },          { "caution", NODE_IGNTEXT },
           { "chapter", NODE_IGNTEXT },
         { "citerefentry", NODE_IGNTEXT },          { "citerefentry", NODE_IGNTEXT },
           { "citetitle", 0 },
         { "cmdsynopsis", NODE_IGNTEXT },          { "cmdsynopsis", NODE_IGNTEXT },
         { "code", 0 },          { "code", 0 },
         { "colspec", NODE_IGNTEXT },          { "colspec", NODE_IGNTEXT },
Line 105  static const struct node nodes[NODE__MAX] = {
Line 115  static const struct node nodes[NODE__MAX] = {
         { "constant", 0 },          { "constant", 0 },
         { "copyright", NODE_IGNTEXT },          { "copyright", NODE_IGNTEXT },
         { "date", 0 },          { "date", 0 },
           { "editor", NODE_IGNTEXT },
         { "emphasis", 0 },          { "emphasis", 0 },
         { "entry", 0 },          { "entry", 0 },
         { "envar", 0 },          { "envar", 0 },
         { "fieldsynopsis", NODE_IGNTEXT },          { "fieldsynopsis", NODE_IGNTEXT },
         { "filename", 0 },          { "filename", 0 },
           { "firstname", 0 },
           { "firstterm", 0 },
           { "footnote", 0 },
         { "funcdef", 0 },          { "funcdef", 0 },
         { "funcprototype", NODE_IGNTEXT },          { "funcprototype", NODE_IGNTEXT },
         { "funcsynopsis", NODE_IGNTEXT },          { "funcsynopsis", NODE_IGNTEXT },
         { "funcsynopsisinfo", 0 },          { "funcsynopsisinfo", 0 },
         { "function", 0 },          { "function", 0 },
           { "glossterm", 0 },
         { "group", NODE_IGNTEXT },          { "group", NODE_IGNTEXT },
         { "holder", NODE_IGNTEXT },          { "holder", NODE_IGNTEXT },
           { "index", NODE_IGNTEXT },
           { "indexterm", NODE_IGNTEXT },
         { "info", NODE_IGNTEXT },          { "info", NODE_IGNTEXT },
         { "informalequation", NODE_IGNTEXT },          { "informalequation", NODE_IGNTEXT },
         { "informaltable", NODE_IGNTEXT },          { "informaltable", NODE_IGNTEXT },
         { "inlineequation", NODE_IGNTEXT },          { "inlineequation", NODE_IGNTEXT },
         { "itemizedlist", NODE_IGNTEXT },          { "itemizedlist", NODE_IGNTEXT },
           { "keysym", 0 },
           { "legalnotice", NODE_IGNTEXT },
         { "link", 0 },          { "link", 0 },
         { "listitem", NODE_IGNTEXT },          { "listitem", NODE_IGNTEXT },
         { "literal", 0 },          { "literal", 0 },
           { "literallayout", 0 },
         { "manvolnum", 0 },          { "manvolnum", 0 },
           { "member", 0 },
         { "mml:math", NODE_IGNTEXT },          { "mml:math", NODE_IGNTEXT },
         { "mml:mfenced", 0 },          { "mml:mfenced", 0 },
         { "mml:mfrac", 0 },          { "mml:mfrac", 0 },
Line 139  static const struct node nodes[NODE__MAX] = {
Line 160  static const struct node nodes[NODE__MAX] = {
         { "note", NODE_IGNTEXT },          { "note", NODE_IGNTEXT },
         { "option", 0 },          { "option", 0 },
         { "orderedlist", NODE_IGNTEXT },          { "orderedlist", NODE_IGNTEXT },
           { "orgname", 0 },
           { "othername", 0 },
         { "para", 0 },          { "para", 0 },
         { "paramdef", 0 },          { "paramdef", 0 },
         { "parameter", 0 },          { "parameter", 0 },
           { "part", NODE_IGNTEXT },
           { "phrase", 0 },
           { "preface", NODE_IGNTEXT },
           { "primary", 0 },
         { "programlisting", 0 },          { "programlisting", 0 },
         { "prompt", 0 },          { "prompt", 0 },
         { "quote", 0 },          { "quote", 0 },
Line 161  static const struct node nodes[NODE__MAX] = {
Line 188  static const struct node nodes[NODE__MAX] = {
         { "refsect3", NODE_IGNTEXT },          { "refsect3", NODE_IGNTEXT },
         { "refsection", NODE_IGNTEXT },          { "refsection", NODE_IGNTEXT },
         { "refsynopsisdiv", NODE_IGNTEXT },          { "refsynopsisdiv", NODE_IGNTEXT },
           { "releaseinfo", 0 },
         { "replaceable", 0 },          { "replaceable", 0 },
         { "row", NODE_IGNTEXT },          { "row", NODE_IGNTEXT },
         { "sbr", NODE_IGNTEXT },          { "sbr", NODE_IGNTEXT },
         { "screen", NODE_IGNTEXT },          { "screen", NODE_IGNTEXT },
           { "secondary", 0 },
           { "sect1", NODE_IGNTEXT },
           { "sect2", NODE_IGNTEXT },
           { "section", NODE_IGNTEXT },
         { "sgmltag", 0 },          { "sgmltag", 0 },
           { "simplelist", NODE_IGNTEXT },
           { "spanspec", NODE_IGNTEXT },
         { "structname", 0 },          { "structname", 0 },
           { "subtitle", 0 },
           { "surname", 0 },
         { "synopsis", 0 },          { "synopsis", 0 },
         { "table", NODE_IGNTEXT },          { "table", NODE_IGNTEXT },
         { "tbody", NODE_IGNTEXT },          { "tbody", NODE_IGNTEXT },
Line 225  xml_char(void *arg, const XML_Char *p, int sz)
Line 261  xml_char(void *arg, const XML_Char *p, int sz)
          */           */
         if (NODE_TEXT != ps->node) {          if (NODE_TEXT != ps->node) {
                 for (i = 0; i < sz; i++)                  for (i = 0; i < sz; i++)
                         if ( ! isspace((int)p[i]))                          if ( ! isspace((unsigned char)p[i]))
                                 break;                                  break;
                 if (i == sz)                  if (i == sz)
                         return;                          return;
Line 265  pnode_trim(struct pnode *pn)
Line 301  pnode_trim(struct pnode *pn)
   
         assert(NODE_TEXT == pn->node);          assert(NODE_TEXT == pn->node);
         for ( ; pn->bsz > 0; pn->bsz--)          for ( ; pn->bsz > 0; pn->bsz--)
                 if ( ! isspace((int)pn->b[pn->bsz - 1]))                  if ( ! isspace((unsigned char)pn->b[pn->bsz - 1]))
                         break;                          break;
 }  }
   
Line 327  xml_elem_start(void *arg, const XML_Char *name, const 
Line 363  xml_elem_start(void *arg, const XML_Char *name, const 
                         XML_GetCurrentColumnNumber(ps->xml));                          XML_GetCurrentColumnNumber(ps->xml));
                 ps->stop = 1;                  ps->stop = 1;
                 return;                  return;
         } else if (NODE_ROOT == ps->node && NODE_REFENTRY != node) {          } else if (NODE_ROOT == ps->node && NODE_REFENTRY != node &&
               NODE_PART != node && NODE_BOOK != node) {
                 return;                  return;
         } else if ( ! isparent(node, ps->node)) {  
                 fprintf(stderr, "%s:%zu:%zu: bad parent \"%s\" "  
                         "of node \"%s\"\n",  
                         ps->fname, XML_GetCurrentLineNumber(ps->xml),  
                         XML_GetCurrentColumnNumber(ps->xml),  
                         NULL == nodes[ps->node].name ?  
                         "(none)" : nodes[ps->node].name,  
                         NULL == nodes[node].name ?  
                         "(none)" : nodes[node].name);  
                 ps->stop = 1;  
                 return;  
         }          }
   
         if (NODE_INLINEEQUATION == node)          if (NODE_INLINEEQUATION == node)
Line 378  xml_elem_start(void *arg, const XML_Char *name, const 
Line 404  xml_elem_start(void *arg, const XML_Char *name, const 
                                         XML_GetCurrentColumnNumber(ps->xml),                                          XML_GetCurrentColumnNumber(ps->xml),
                                         *att);                                          *att);
                         continue;                          continue;
                 } else if ( ! isattrkey(node, key)) {  
                         if (warn)  
                                 fprintf(stderr, "%s:%zu:%zu: warning: "  
                                         "bad attribute \"%s\"\n",  
                                         ps->fname,  
                                         XML_GetCurrentLineNumber(ps->xml),  
                                         XML_GetCurrentColumnNumber(ps->xml),  
                                         *att);  
                         continue;  
                 }                  }
                 for (val = 0; val < ATTRVAL__MAX; val++)                  for (val = 0; val < ATTRVAL__MAX; val++)
                         if (0 == strcmp(*(att + 1), attrvals[val]))                          if (0 == strcmp(*(att + 1), attrvals[val]))
                                 break;                                  break;
                 if (ATTRVAL__MAX != val && ! isattrval(key, val)) {  
                         if (warn)  
                                 fprintf(stderr, "%s:%zu:%zu: warning: "  
                                         "bad attribute value \"%s\"\n",  
                                         ps->fname,  
                                         XML_GetCurrentLineNumber(ps->xml),  
                                         XML_GetCurrentColumnNumber(ps->xml),  
                                         *(att + 1));  
                         continue;  
                 }  
                 pattr = calloc(1, sizeof(struct pattr));                  pattr = calloc(1, sizeof(struct pattr));
                 pattr->key = key;                  pattr->key = key;
                 pattr->val = val;                  pattr->val = val;
Line 505  bufclear(struct parse *p)
Line 512  bufclear(struct parse *p)
 /*  /*
  * Append NODE_TEXT contents to the current buffer, reallocating its   * Append NODE_TEXT contents to the current buffer, reallocating its
  * size if necessary.   * size if necessary.
  * The buffer is ALWAYS nil-terminated.   * The buffer is ALWAYS NUL-terminated.
  */   */
 static void  static void
 bufappend(struct parse *p, struct pnode *pn)  bufappend(struct parse *p, struct pnode *pn)
Line 580  pnode_printmacrolinetext(struct parse *p, struct pnode
Line 587  pnode_printmacrolinetext(struct parse *p, struct pnode
   
         /* Convert all space to spaces. */          /* Convert all space to spaces. */
         for (cp = p->b; '\0' != *cp; cp++)          for (cp = p->b; '\0' != *cp; cp++)
                 if (isspace((int)*cp))                  if (isspace((unsigned char)*cp))
                         *cp = ' ';                          *cp = ' ';
   
         for (cp = p->b; isspace((int)*cp); cp++)          for (cp = p->b; isspace((unsigned char)*cp); cp++)
                 /* Spin past whitespace (XXX: necessary?) */ ;                  /* Spin past whitespace (XXX: necessary?) */ ;
         for ( ; '\0' != *cp; cp++) {          for ( ; '\0' != *cp; cp++) {
                 /* Escape us if we look like a macro. */                  /* Escape us if we look like a macro. */
                 if ((cp == p->b || ' ' == *(cp - 1)) &&                  if ((cp == p->b || ' ' == *(cp - 1)) &&
                         isupper((int)*cp) &&                          isupper((unsigned char)*cp) &&
                         '\0' != *(cp + 1) &&                          '\0' != *(cp + 1) &&
                         islower((int)*(cp + 1)) &&                          islower((unsigned char)*(cp + 1)) &&
                         ('\0' == *(cp + 2) ||                          ('\0' == *(cp + 2) ||
                          ' ' == *(cp + 2) ||                           ' ' == *(cp + 2) ||
                          (islower((int)*(cp + 2)) &&                           (islower((unsigned char)*(cp + 2)) &&
                           ('\0' == *(cp + 3) ||                            ('\0' == *(cp + 3) ||
                            ' ' == *(cp + 3)))))                             ' ' == *(cp + 3)))))
                         fputs("\\&", stdout);                          fputs("\\&", stdout);
                 if (MACROLINE_UPPER & fl)                  if (MACROLINE_UPPER & fl)
                         putchar(toupper((int)*cp));                          putchar(toupper((unsigned char)*cp));
                 else                  else
                         putchar((int)*cp);                          putchar(*cp);
                 /* If we're a character escape, escape us. */                  /* If we're a character escape, escape us. */
                 if ('\\' == *cp)                  if ('\\' == *cp)
                         putchar('e');                          putchar('e');
Line 672  pnode_printmclosepunct(struct parse *p, struct pnode *
Line 679  pnode_printmclosepunct(struct parse *p, struct pnode *
         /* Only do this for the comma/period. */          /* Only do this for the comma/period. */
         if (pn->bsz > 0 &&          if (pn->bsz > 0 &&
                 (',' == pn->b[0] || '.' == pn->b[0]) &&                  (',' == pn->b[0] || '.' == pn->b[0]) &&
                 (1 == pn->bsz || isspace((int)pn->b[1]))) {                  (1 == pn->bsz || isspace((unsigned char)pn->b[1]))) {
                 putchar(' ');                  putchar(' ');
                 putchar(pn->b[0]);                  putchar(pn->b[0]);
                 pn->b++;                  pn->b++;
Line 705  static void
Line 712  static void
 pnode_printrefsect(struct parse *p, struct pnode *pn)  pnode_printrefsect(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
           const char      *title;
           int              flags, level;
   
           level = ++p->level;
           flags = 1 == level ? MACROLINE_UPPER : 0;
           if (3 > level) {
                   switch (pn->node) {
                   case (NODE_CAUTION):
                   case (NODE_NOTE):
                   case (NODE_TIP):
                   case (NODE_WARNING):
                           level = 3;
                           break;
                   default:
                           break;
                   }
           }
   
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TITLE == pp->node)                  if (NODE_TITLE == pp->node)
                         break;                          break;
   
         switch (pn->node) {          if (NULL == pp) {
         case (NODE_REFSECT1):                  switch (pn->node) {
                   case (NODE_PREFACE):
                           title = "Preface";
                           break;
                   case (NODE_CAUTION):
                           title = "Caution";
                           break;
                   case (NODE_NOTE):
                           title = "Note";
                           break;
                   case (NODE_TIP):
                           title = "Tip";
                           break;
                   case (NODE_WARNING):
                           title = "Warning";
                           break;
                   default:
                           title = "Unknown";
                           break;
                   }
           }
   
           switch (level) {
           case (1):
                 fputs(".Sh", stdout);                  fputs(".Sh", stdout);
                 break;                  break;
         case (NODE_REFSECT2):          case (2):
                 fputs(".Ss", stdout);                  fputs(".Ss", stdout);
                 break;                  break;
         case (NODE_REFSECT3):          default:
                 puts(".Pp");                  puts(".Pp");
                 fputs(".Sy", stdout);                  fputs(".Sy", stdout);
                 break;                  break;
         case (NODE_NOTE):  
                 /* FALLTHROUGH */  
         case (NODE_REFSECTION):  
                 /* FALLTHROUGH */  
         case (NODE_TIP):  
                 /* FALLTHROUGH */  
         case (NODE_CAUTION):  
                 /* FALLTHROUGH */  
         case (NODE_WARNING):  
                 puts(".Pp");  
                 if (NULL == pp)  
                         return;  
                 fputs(".Em", stdout);  
                 break;  
         default:  
                 break;  
         }          }
   
         p->newln = 0;  
   
         if (NULL != pp) {          if (NULL != pp) {
                 pnode_printmacrolinetext(p, pp,                  p->newln = 0;
                         NODE_REFSECT1 == pn->node ?                  pnode_printmacrolinetext(p, pp, flags);
                         MACROLINE_UPPER : 0);  
                 pnode_printmclose(p, 1);                  pnode_printmclose(p, 1);
                 pnode_unlink(pp);                  pnode_unlink(pp);
         } else {          } else
                 puts(NODE_REFSECT1 == pn->node ?                  printf(" %s\n", title);
                         "UNKNOWN" : "unknown");  
                 p->newln = 1;  
         }  
 }  }
   
 /*  /*
Line 794  pnode_printrefmeta(struct parse *p, struct pnode *pn)
Line 819  pnode_printrefmeta(struct parse *p, struct pnode *pn)
                 else if (NODE_REFENTRYTITLE == pp->node)                  else if (NODE_REFENTRYTITLE == pp->node)
                         title = pp;                          title = pp;
   
         puts(".Dd $Mdocdate" "$");  
         fputs(".Dt", stdout);          fputs(".Dt", stdout);
         p->newln = 0;          p->newln = 0;
   
Line 808  pnode_printrefmeta(struct parse *p, struct pnode *pn)
Line 832  pnode_printrefmeta(struct parse *p, struct pnode *pn)
                 p->newln = 1;                  p->newln = 1;
         } else          } else
                 pnode_printmacroline(p, manvol);                  pnode_printmacroline(p, manvol);
   
         puts(".Os");  
 }  }
   
 static void  static void
Line 1057  static void
Line 1079  static void
 pnode_printprologue(struct parse *p, struct pnode *pn)  pnode_printprologue(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
           struct pattr    *ap;
           const char      *name;
   
         pp = NULL == p->root ? NULL :          pp = NULL == p->root ? NULL :
                 pnode_findfirst(p->root, NODE_REFMETA);                  pnode_findfirst(p->root, NODE_REFMETA);
   
           puts(".Dd $Mdocdate" "$");
         if (NULL != pp) {          if (NULL != pp) {
                 pnode_printrefmeta(p, pp);                  pnode_printrefmeta(p, pp);
                 pnode_unlink(pp);                  pnode_unlink(pp);
         } else {          } else {
                 puts(".\\\" Supplying bogus prologue...");                  name = "UNKNOWN";
                 puts(".Dd $Mdocdate" "$");                  TAILQ_FOREACH(ap, &p->root->attrq, child) {
                 puts(".Dt UNKNOWN 1");                          if (ATTRKEY_ID == ap->key) {
                 puts(".Os");                                  name = ap->rawval;
                                   break;
                           }
                   }
                   printf(".Dt %s 1\n", name);
         }          }
           puts(".Os");
   
         if (PARSE_EQN & p->flags) {          if (PARSE_EQN & p->flags) {
                 puts(".EQ");                  puts(".EQ");
Line 1222  pnode_print(struct parse *p, struct pnode *pn)
Line 1252  pnode_print(struct parse *p, struct pnode *pn)
   
         sv = p->newln;          sv = p->newln;
   
           /* XXX fprintf(stderr, "NODE %s\n", nodes[pn->node].name); */
         switch (pn->node) {          switch (pn->node) {
         case (NODE_APPLICATION):          case (NODE_APPLICATION):
                 pnode_printmopen(p);                  pnode_printmopen(p);
Line 1234  pnode_print(struct parse *p, struct pnode *pn)
Line 1265  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_printarg(p, pn);                  pnode_printarg(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
           case (NODE_AUTHOR):
                   pnode_printmopen(p);
                   fputs("An", stdout);
                   break;
           case (NODE_AUTHORGROUP):
                   assert(p->newln);
                   puts(".An -split");
                   break;
           case (NODE_BOOKINFO):
                   assert(p->newln);
                   puts(".Sh NAME");
                   break;
         case (NODE_CITEREFENTRY):          case (NODE_CITEREFENTRY):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Xr", stdout);                  fputs("Xr", stdout);
Line 1252  pnode_print(struct parse *p, struct pnode *pn)
Line 1295  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Dv", stdout);                  fputs("Dv", stdout);
                 break;                  break;
           case (NODE_EDITOR):
                   puts("editor: ");
                   pnode_printmopen(p);
                   fputs("An", stdout);
                   break;
         case (NODE_EMPHASIS):          case (NODE_EMPHASIS):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Em", stdout);                  fputs("Em", stdout);
Line 1296  pnode_print(struct parse *p, struct pnode *pn)
Line 1344  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_printgroup(p, pn);                  pnode_printgroup(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
           case (NODE_LEGALNOTICE):
                   assert(p->newln);
                   puts(".Sh LEGAL NOTICE");
                   break;
         case (NODE_LITERAL):          case (NODE_LITERAL):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Li", stdout);                  fputs("Li", stdout);
Line 1346  pnode_print(struct parse *p, struct pnode *pn)
Line 1398  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Qo", stdout);                  fputs("Qo", stdout);
                 break;                  break;
           case (NODE_LITERALLAYOUT):
                   /* FALLTHROUGH */
         case (NODE_PROGRAMLISTING):          case (NODE_PROGRAMLISTING):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (NODE_SCREEN):          case (NODE_SCREEN):
Line 1381  pnode_print(struct parse *p, struct pnode *pn)
Line 1435  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_printrefsynopsisdiv(p, pn);                  pnode_printrefsynopsisdiv(p, pn);
                 puts(".Sh SYNOPSIS");                  puts(".Sh SYNOPSIS");
                 break;                  break;
           case (NODE_PREFACE):
         case (NODE_REFSECT1):          case (NODE_REFSECT1):
                 /* FALLTHROUGH */  
         case (NODE_REFSECT2):          case (NODE_REFSECT2):
                 /* FALLTHROUGH */  
         case (NODE_REFSECT3):          case (NODE_REFSECT3):
                 /* FALLTHROUGH */  
         case (NODE_REFSECTION):          case (NODE_REFSECTION):
                 /* FALLTHROUGH */          case (NODE_CHAPTER):
           case (NODE_SECT1):
           case (NODE_SECT2):
           case (NODE_SECTION):
         case (NODE_NOTE):          case (NODE_NOTE):
                 /* FALLTHROUGH */  
         case (NODE_TIP):          case (NODE_TIP):
                 /* FALLTHROUGH */  
         case (NODE_CAUTION):          case (NODE_CAUTION):
                 /* FALLTHROUGH */  
         case (NODE_WARNING):          case (NODE_WARNING):
                 assert(p->newln);                  assert(p->newln);
                 pnode_printrefsect(p, pn);                  pnode_printrefsect(p, pn);
Line 1455  pnode_print(struct parse *p, struct pnode *pn)
Line 1507  pnode_print(struct parse *p, struct pnode *pn)
                 for (last = '\n'; '\0' != *cp; ) {                  for (last = '\n'; '\0' != *cp; ) {
                         if ('\n' == last) {                          if ('\n' == last) {
                                 /* Consume all whitespace. */                                  /* Consume all whitespace. */
                                 if (isspace((int)*cp)) {                                  if (isspace((unsigned char)*cp)) {
                                         while (isspace((int)*cp))                                          while (isspace((unsigned char)*cp))
                                                 cp++;                                                  cp++;
                                         continue;                                          continue;
                                 } else if ('\'' == *cp || '.' == *cp)                                  } else if ('\'' == *cp || '.' == *cp)
Line 1469  pnode_print(struct parse *p, struct pnode *pn)
Line 1521  pnode_print(struct parse *p, struct pnode *pn)
                 }                  }
                 p->newln = 0;                  p->newln = 0;
                 break;                  break;
           case (NODE_TITLE):
                   if (pn->parent->node == NODE_BOOKINFO) {
                           pnode_printmopen(p);
                           fputs("Nd", stdout);
                   }
                   break;
         case (NODE_TYPE):          case (NODE_TYPE):
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Vt", stdout);                  fputs("Vt", stdout);
Line 1518  pnode_print(struct parse *p, struct pnode *pn)
Line 1576  pnode_print(struct parse *p, struct pnode *pn)
                 break;                  break;
         case (NODE_APPLICATION):          case (NODE_APPLICATION):
         case (NODE_ARG):          case (NODE_ARG):
           case (NODE_AUTHOR):
         case (NODE_CITEREFENTRY):          case (NODE_CITEREFENTRY):
         case (NODE_CODE):          case (NODE_CODE):
         case (NODE_COMMAND):          case (NODE_COMMAND):
         case (NODE_CONSTANT):          case (NODE_CONSTANT):
           case (NODE_EDITOR):
         case (NODE_EMPHASIS):          case (NODE_EMPHASIS):
         case (NODE_ENVAR):          case (NODE_ENVAR):
         case (NODE_FILENAME):          case (NODE_FILENAME):
Line 1560  pnode_print(struct parse *p, struct pnode *pn)
Line 1620  pnode_print(struct parse *p, struct pnode *pn)
                         fputs(" ,", stdout);                          fputs(" ,", stdout);
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
                 break;                  break;
           case (NODE_PREFACE):
           case (NODE_REFSECT1):
           case (NODE_REFSECT2):
           case (NODE_REFSECT3):
           case (NODE_REFSECTION):
           case (NODE_CHAPTER):
           case (NODE_SECT1):
           case (NODE_SECT2):
           case (NODE_SECTION):
           case (NODE_NOTE):
           case (NODE_TIP):
           case (NODE_CAUTION):
           case (NODE_WARNING):
                   p->level--;
                   break;
           case (NODE_LITERALLAYOUT):
                   /* FALLTHROUGH */
         case (NODE_PROGRAMLISTING):          case (NODE_PROGRAMLISTING):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (NODE_SCREEN):          case (NODE_SCREEN):
                 assert(p->newln);                  assert(p->newln);
                 puts(".Ed");                  puts(".Ed");
                 p->newln = 1;                  p->newln = 1;
                   break;
           case (NODE_TITLE):
                   if (pn->parent->node == NODE_BOOKINFO) {
                           pnode_printmclose(p, 1);
                           puts(".Sh AUTHORS");
                   }
                 break;                  break;
         default:          default:
                 break;                  break;
Legend:
Removed from v.1.45  
changed lines
  Added in v.1.52
CVSweb