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

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

version 1.52, 2019/03/22 16:21:23 version 1.62, 2019/03/22 17:42:53
Line 51  struct parse {
Line 51  struct parse {
   
 struct  node {  struct  node {
         const char      *name; /* docbook element name */          const char      *name; /* docbook element name */
         unsigned int     flags;          enum nodeid      node; /* docbook element to generate */
 #define NODE_IGNTEXT     1 /* ignore all contained text */  
 };  };
   
 TAILQ_HEAD(pnodeq, pnode);  TAILQ_HEAD(pnodeq, pnode);
Line 78  struct pnode {
Line 77  struct pnode {
   
 static  const char *attrkeys[ATTRKEY__MAX] = {  static  const char *attrkeys[ATTRKEY__MAX] = {
         "choice",          "choice",
           "class",
         "close",          "close",
         "id",          "id",
           "linkend",
         "open",          "open",
         "rep"          "rep"
 };  };
   
 static  const char *attrvals[ATTRVAL__MAX] = {  static  const char *attrvals[ATTRVAL__MAX] = {
           "monospaced",
         "norepeat",          "norepeat",
         "opt",          "opt",
         "plain",          "plain",
Line 92  static const char *attrvals[ATTRVAL__MAX] = {
Line 94  static const char *attrvals[ATTRVAL__MAX] = {
         "req"          "req"
 };  };
   
 static  const struct node nodes[NODE__MAX] = {  static  const struct node nodes[] = {
         { NULL, 0 },          { "acronym",            NODE_ACRONYM },
         { "acronym", 0 },          { "affiliation",        NODE_AFFILIATION },
         { "affiliation", NODE_IGNTEXT },          { "anchor",             NODE_ANCHOR },
         { "anchor", NODE_IGNTEXT },          { "application",        NODE_APPLICATION },
         { "application", 0 },          { "arg",                NODE_ARG },
         { "arg", 0 },          { "author",             NODE_AUTHOR },
         { "author", NODE_IGNTEXT },          { "authorgroup",        NODE_AUTHORGROUP },
         { "authorgroup", NODE_IGNTEXT },          { "blockquote",         NODE_BLOCKQUOTE },
         { "blockquote", NODE_IGNTEXT },          { "book",               NODE_BOOK },
         { "book", NODE_IGNTEXT },          { "bookinfo",           NODE_BOOKINFO },
         { "bookinfo", NODE_IGNTEXT },          { "caution",            NODE_CAUTION },
         { "caution", NODE_IGNTEXT },          { "chapter",            NODE_SECTION },
         { "chapter", NODE_IGNTEXT },          { "citerefentry",       NODE_CITEREFENTRY },
         { "citerefentry", NODE_IGNTEXT },          { "citetitle",          NODE_CITETITLE },
         { "citetitle", 0 },          { "cmdsynopsis",        NODE_CMDSYNOPSIS },
         { "cmdsynopsis", NODE_IGNTEXT },          { "code",               NODE_CODE },
         { "code", 0 },          { "colspec",            NODE_COLSPEC },
         { "colspec", NODE_IGNTEXT },          { "command",            NODE_COMMAND },
         { "command", 0 },          { "constant",           NODE_CONSTANT },
         { "constant", 0 },          { "copyright",          NODE_COPYRIGHT },
         { "copyright", NODE_IGNTEXT },          { "date",               NODE_DATE },
         { "date", 0 },          { "editor",             NODE_EDITOR },
         { "editor", NODE_IGNTEXT },          { "emphasis",           NODE_EMPHASIS },
         { "emphasis", 0 },          { "entry",              NODE_ENTRY },
         { "entry", 0 },          { "envar",              NODE_ENVAR },
         { "envar", 0 },          { "fieldsynopsis",      NODE_FIELDSYNOPSIS },
         { "fieldsynopsis", NODE_IGNTEXT },          { "filename",           NODE_FILENAME },
         { "filename", 0 },          { "firstname",          NODE_FIRSTNAME },
         { "firstname", 0 },          { "firstterm",          NODE_FIRSTTERM },
         { "firstterm", 0 },          { "footnote",           NODE_FOOTNOTE },
         { "footnote", 0 },          { "funcdef",            NODE_FUNCDEF },
         { "funcdef", 0 },          { "funcprototype",      NODE_FUNCPROTOTYPE },
         { "funcprototype", NODE_IGNTEXT },          { "funcsynopsis",       NODE_FUNCSYNOPSIS },
         { "funcsynopsis", NODE_IGNTEXT },          { "funcsynopsisinfo",   NODE_FUNCSYNOPSISINFO },
         { "funcsynopsisinfo", 0 },          { "function",           NODE_FUNCTION },
         { "function", 0 },          { "glossterm",          NODE_GLOSSTERM },
         { "glossterm", 0 },          { "group",              NODE_GROUP },
         { "group", NODE_IGNTEXT },          { "holder",             NODE_HOLDER },
         { "holder", NODE_IGNTEXT },          { "index",              NODE_INDEX },
         { "index", NODE_IGNTEXT },          { "indexterm",          NODE_INDEXTERM },
         { "indexterm", NODE_IGNTEXT },          { "info",               NODE_INFO },
         { "info", NODE_IGNTEXT },          { "informalequation",   NODE_INFORMALEQUATION },
         { "informalequation", NODE_IGNTEXT },          { "informaltable",      NODE_INFORMALTABLE },
         { "informaltable", NODE_IGNTEXT },          { "inlineequation",     NODE_INLINEEQUATION },
         { "inlineequation", NODE_IGNTEXT },          { "itemizedlist",       NODE_ITEMIZEDLIST },
         { "itemizedlist", NODE_IGNTEXT },          { "keysym",             NODE_KEYSYM },
         { "keysym", 0 },          { "legalnotice",        NODE_LEGALNOTICE },
         { "legalnotice", NODE_IGNTEXT },          { "link",               NODE_LINK },
         { "link", 0 },          { "listitem",           NODE_LISTITEM },
         { "listitem", NODE_IGNTEXT },          { "literal",            NODE_LITERAL },
         { "literal", 0 },          { "literallayout",      NODE_LITERALLAYOUT },
         { "literallayout", 0 },          { "manvolnum",          NODE_MANVOLNUM },
         { "manvolnum", 0 },          { "member",             NODE_MEMBER },
         { "member", 0 },          { "mml:math",           NODE_MML_MATH },
         { "mml:math", NODE_IGNTEXT },          { "mml:mfenced",        NODE_MML_MFENCED },
         { "mml:mfenced", 0 },          { "mml:mfrac",          NODE_MML_MFRAC },
         { "mml:mfrac", 0 },          { "mml:mi",             NODE_MML_MI },
         { "mml:mi", 0 },          { "mml:mn",             NODE_MML_MN },
         { "mml:mn", 0 },          { "mml:mo",             NODE_MML_MO },
         { "mml:mo", 0 },          { "mml:mrow",           NODE_MML_MROW },
         { "mml:mrow", 0 },          { "mml:msub",           NODE_MML_MSUB },
         { "mml:msub", 0 },          { "mml:msup",           NODE_MML_MSUP },
         { "mml:msup", 0 },          { "modifier",           NODE_MODIFIER },
         { "modifier", 0 },          { "note",               NODE_NOTE },
         { "note", NODE_IGNTEXT },          { "option",             NODE_OPTION },
         { "option", 0 },          { "orderedlist",        NODE_ORDEREDLIST },
         { "orderedlist", NODE_IGNTEXT },          { "orgname",            NODE_ORGNAME },
         { "orgname", 0 },          { "othername",          NODE_OTHERNAME },
         { "othername", 0 },          { "para",               NODE_PARA },
         { "para", 0 },          { "paramdef",           NODE_PARAMDEF },
         { "paramdef", 0 },          { "parameter",          NODE_PARAMETER },
         { "parameter", 0 },          { "part",               NODE_SECTION },
         { "part", NODE_IGNTEXT },          { "phrase",             NODE_PHRASE },
         { "phrase", 0 },          { "preface",            NODE_PREFACE },
         { "preface", NODE_IGNTEXT },          { "primary",            NODE_PRIMARY },
         { "primary", 0 },          { "programlisting",     NODE_PROGRAMLISTING },
         { "programlisting", 0 },          { "prompt",             NODE_PROMPT },
         { "prompt", 0 },          { "quote",              NODE_QUOTE },
         { "quote", 0 },          { "refclass",           NODE_REFCLASS },
         { "refclass", NODE_IGNTEXT },          { "refdescriptor",      NODE_REFDESCRIPTOR },
         { "refdescriptor", NODE_IGNTEXT },          { "refentry",           NODE_REFENTRY },
         { "refentry", NODE_IGNTEXT },          { "refentryinfo",       NODE_REFENTRYINFO },
         { "refentryinfo", NODE_IGNTEXT },          { "refentrytitle",      NODE_REFENTRYTITLE },
         { "refentrytitle", 0 },          { "refmeta",            NODE_REFMETA },
         { "refmeta", NODE_IGNTEXT },          { "refmetainfo",        NODE_REFMETAINFO },
         { "refmetainfo", NODE_IGNTEXT },          { "refmiscinfo",        NODE_REFMISCINFO },
         { "refmiscinfo", NODE_IGNTEXT },          { "refname",            NODE_REFNAME },
         { "refname", 0 },          { "refnamediv",         NODE_REFNAMEDIV },
         { "refnamediv", NODE_IGNTEXT },          { "refpurpose",         NODE_REFPURPOSE },
         { "refpurpose", 0 },          { "refsect1",           NODE_SECTION },
         { "refsect1", NODE_IGNTEXT },          { "refsect2",           NODE_SECTION },
         { "refsect2", NODE_IGNTEXT },          { "refsect3",           NODE_SECTION },
         { "refsect3", NODE_IGNTEXT },          { "refsection",         NODE_SECTION },
         { "refsection", NODE_IGNTEXT },          { "refsynopsisdiv",     NODE_REFSYNOPSISDIV },
         { "refsynopsisdiv", NODE_IGNTEXT },          { "releaseinfo",        NODE_RELEASEINFO },
         { "releaseinfo", 0 },          { "replaceable",        NODE_REPLACEABLE },
         { "replaceable", 0 },          { "row",                NODE_ROW },
         { "row", NODE_IGNTEXT },          { "sbr",                NODE_SBR },
         { "sbr", NODE_IGNTEXT },          { "screen",             NODE_SCREEN },
         { "screen", NODE_IGNTEXT },          { "secondary",          NODE_SECONDARY },
         { "secondary", 0 },          { "sect1",              NODE_SECTION },
         { "sect1", NODE_IGNTEXT },          { "sect2",              NODE_SECTION },
         { "sect2", NODE_IGNTEXT },          { "section",            NODE_SECTION },
         { "section", NODE_IGNTEXT },          { "sgmltag",            NODE_SGMLTAG },
         { "sgmltag", 0 },          { "simplelist",         NODE_SIMPLELIST },
         { "simplelist", NODE_IGNTEXT },          { "spanspec",           NODE_SPANSPEC },
         { "spanspec", NODE_IGNTEXT },          { "structname",         NODE_STRUCTNAME },
         { "structname", 0 },          { "subtitle",           NODE_SUBTITLE },
         { "subtitle", 0 },          { "surname",            NODE_SURNAME },
         { "surname", 0 },          { "synopsis",           NODE_SYNOPSIS },
         { "synopsis", 0 },          { "table",              NODE_TABLE },
         { "table", NODE_IGNTEXT },          { "tbody",              NODE_TBODY },
         { "tbody", NODE_IGNTEXT },          { "term",               NODE_TERM },
         { "term", 0 },          { "tfoot",              NODE_TFOOT },
         { NULL, 0 },          { "tgroup",             NODE_TGROUP },
         { "tfoot", NODE_IGNTEXT },          { "thead",              NODE_THEAD },
         { "tgroup", NODE_IGNTEXT },          { "tip",                NODE_TIP },
         { "thead", NODE_IGNTEXT },          { "title",              NODE_TITLE },
         { "tip", NODE_IGNTEXT },          { "trademark",          NODE_TRADEMARK },
         { "title", 0 },          { "type",               NODE_TYPE },
         { "trademark", 0 },          { "ulink",              NODE_ULINK },
         { "type", 0 },          { "userinput",          NODE_USERINPUT },
         { "ulink", 0 },          { "variablelist",       NODE_VARIABLELIST },
         { "userinput", 0 },          { "varlistentry",       NODE_VARLISTENTRY },
         { "variablelist", NODE_IGNTEXT },          { "varname",            NODE_VARNAME },
         { "varlistentry", NODE_IGNTEXT },          { "warning",            NODE_WARNING },
         { "varname", 0 },          { "wordasword",         NODE_WORDASWORD },
         { "warning", NODE_IGNTEXT },          { "year",               NODE_YEAR },
         { "wordasword", 0 },          { NULL,                 NODE__MAX }
         { "year", NODE_IGNTEXT },  
 };  };
   
 static  int warn = 0;  static  int warn = 0;
Line 247  xml_char(void *arg, const XML_Char *p, int sz)
Line 248  xml_char(void *arg, const XML_Char *p, int sz)
         if (ps->stop || NODE_ROOT == ps->node)          if (ps->stop || NODE_ROOT == ps->node)
                 return;                  return;
   
         /* Not supposed to be collecting text. */  
         assert(NULL != ps->cur);          assert(NULL != ps->cur);
         if (NODE_IGNTEXT & nodes[ps->node].flags)  
                 return;  
   
         /*          /*
          * Are we in the midst of processing text?           * Are we in the midst of processing text?
Line 323  static void
Line 321  static void
 xml_elem_start(void *arg, const XML_Char *name, const XML_Char **atts)  xml_elem_start(void *arg, const XML_Char *name, const XML_Char **atts)
 {  {
         struct parse     *ps = arg;          struct parse     *ps = arg;
         enum nodeid       node;          const struct node *node;
         enum attrkey      key;          enum attrkey      key;
         enum attrval      val;          enum attrval      val;
         struct pnode     *dat;          struct pnode     *dat;
Line 343  xml_elem_start(void *arg, const XML_Char *name, const 
Line 341  xml_elem_start(void *arg, const XML_Char *name, const 
                 ps->node = ps->cur->node;                  ps->node = ps->cur->node;
         }          }
   
         for (node = 0; node < NODE__MAX; node++)          for (node = nodes; NULL != node->name; node++)
                 if (NULL == nodes[node].name)                  if (0 == strcmp(node->name, name))
                         continue;  
                 else if (0 == strcmp(nodes[node].name, name))  
                         break;                          break;
   
         if (NODE__MAX == node && NODE_ROOT == ps->node) {          if (NULL == node->name) {
                 return;                  if (NODE_ROOT == ps->node)
         } else if (NODE__MAX == node) {                          return;
                 fprintf(stderr, "%s:%zu:%zu: unknown node \"%s\"\n",                  fprintf(stderr, "%s:%zu:%zu: unknown node \"%s\"\n",
                         ps->fname, XML_GetCurrentLineNumber(ps->xml),                          ps->fname, XML_GetCurrentLineNumber(ps->xml),
                         XML_GetCurrentColumnNumber(ps->xml), name);                          XML_GetCurrentColumnNumber(ps->xml), name);
Line 363  xml_elem_start(void *arg, const XML_Char *name, const 
Line 359  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 &&  
             NODE_PART != node && NODE_BOOK != node) {  
                 return;  
         }          }
   
         if (NODE_INLINEEQUATION == node)          if (NODE_INLINEEQUATION == node->node)
                 ps->flags |= PARSE_EQN;                  ps->flags |= PARSE_EQN;
   
         if (NULL == (dat = calloc(1, sizeof(struct pnode)))) {          if (NULL == (dat = calloc(1, sizeof(struct pnode)))) {
Line 376  xml_elem_start(void *arg, const XML_Char *name, const 
Line 369  xml_elem_start(void *arg, const XML_Char *name, const 
                 exit(EXIT_FAILURE);                  exit(EXIT_FAILURE);
         }          }
   
         dat->node = ps->node = node;          dat->node = ps->node = node->node;
         dat->parent = ps->cur;          dat->parent = ps->cur;
         TAILQ_INIT(&dat->childq);          TAILQ_INIT(&dat->childq);
         TAILQ_INIT(&dat->attrq);          TAILQ_INIT(&dat->attrq);
Line 500  pnode_unlinksub(struct pnode *pn)
Line 493  pnode_unlinksub(struct pnode *pn)
 }  }
   
 /*  /*
    * Retrieve an enumeration attribute from a node.
    * Return ATTRVAL__MAX if the node has no such attribute.
    */
   enum attrval
   pnode_getattr(struct pnode *pn, enum attrkey key)
   {
           struct pattr    *ap;
   
           TAILQ_FOREACH(ap, &pn->attrq, child)
                   if (ap->key == key)
                           return ap->val;
           return(ATTRVAL__MAX);
   }
   
   /*
    * Retrieve an attribute string from a node.
    * Return defval if the node has no such attribute.
    */
   const char *
   pnode_getattr_raw(struct pnode *pn, enum attrkey key, const char *defval)
   {
           struct pattr    *ap;
   
           TAILQ_FOREACH(ap, &pn->attrq, child)
                   if (ap->key == key)
                           return ATTRVAL__MAX == ap->val ? ap->rawval :
                               attrvals[ap->val];
           return(defval);
   }
   
   /*
  * Reset the lookaside buffer.   * Reset the lookaside buffer.
  */   */
 static void  static void
Line 690  pnode_printmclosepunct(struct parse *p, struct pnode *
Line 714  pnode_printmclosepunct(struct parse *p, struct pnode *
         p->newln = 1;          p->newln = 1;
 }  }
   
   static void
   pnode_printpara(struct parse *p, struct pnode *pn)
   {
           struct pnode    *pp;
   
           assert(p->newln);
           if ((pp = TAILQ_PREV(pn, pnodeq, child)) == NULL &&
               (pp = pn->parent) == NULL)
                   return;
   
           switch (pp->node) {
           case NODE_ENTRY:
           case NODE_LISTITEM:
                   return;
           case NODE_PREFACE:
           case NODE_SECTION:
                   if (p->level < 3)
                           return;
                   break;
           default:
                   break;
           }
           puts(".Pp");
   }
   
 /*  /*
  * If the SYNOPSIS macro has a superfluous title, kill it.   * If the SYNOPSIS macro has a superfluous title, kill it.
  */   */
Line 715  pnode_printrefsect(struct parse *p, struct pnode *pn)
Line 764  pnode_printrefsect(struct parse *p, struct pnode *pn)
         const char      *title;          const char      *title;
         int              flags, level;          int              flags, level;
   
           if (NULL == pn->parent)
                   return;
   
         level = ++p->level;          level = ++p->level;
         flags = 1 == level ? MACROLINE_UPPER : 0;          flags = 1 == level ? MACROLINE_UPPER : 0;
         if (3 > level) {          if (3 > level) {
                 switch (pn->node) {                  switch (pn->node) {
                 case (NODE_CAUTION):                  case NODE_CAUTION:
                 case (NODE_NOTE):                  case NODE_NOTE:
                 case (NODE_TIP):                  case NODE_TIP:
                 case (NODE_WARNING):                  case NODE_WARNING:
                         level = 3;                          level = 3;
                         break;                          break;
                 default:                  default:
Line 736  pnode_printrefsect(struct parse *p, struct pnode *pn)
Line 788  pnode_printrefsect(struct parse *p, struct pnode *pn)
   
         if (NULL == pp) {          if (NULL == pp) {
                 switch (pn->node) {                  switch (pn->node) {
                 case (NODE_PREFACE):                  case NODE_PREFACE:
                         title = "Preface";                          title = "Preface";
                         break;                          break;
                 case (NODE_CAUTION):                  case NODE_CAUTION:
                         title = "Caution";                          title = "Caution";
                         break;                          break;
                 case (NODE_NOTE):                  case NODE_NOTE:
                         title = "Note";                          title = "Note";
                         break;                          break;
                 case (NODE_TIP):                  case NODE_TIP:
                         title = "Tip";                          title = "Tip";
                         break;                          break;
                 case (NODE_WARNING):                  case NODE_WARNING:
                         title = "Warning";                          title = "Warning";
                         break;                          break;
                 default:                  default:
Line 758  pnode_printrefsect(struct parse *p, struct pnode *pn)
Line 810  pnode_printrefsect(struct parse *p, struct pnode *pn)
         }          }
   
         switch (level) {          switch (level) {
         case (1):          case 1:
                 fputs(".Sh", stdout);                  fputs(".Sh", stdout);
                 break;                  break;
         case (2):          case 2:
                 fputs(".Ss", stdout);                  fputs(".Ss", stdout);
                 break;                  break;
         default:          default:
                 puts(".Pp");                  pnode_printpara(p, pn);
                 fputs(".Sy", stdout);                  fputs(".Sy", stdout);
                 break;                  break;
         }          }
Line 900  static void
Line 952  static void
 pnode_printmathfenced(struct parse *p, struct pnode *pn)  pnode_printmathfenced(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
         struct pattr    *ap;  
   
         TAILQ_FOREACH(ap, &pn->attrq, child)          printf("left %s ", pnode_getattr_raw(pn, ATTRKEY_OPEN, "("));
                 if (ATTRKEY_OPEN == ap->key) {  
                         printf("left %s ", ap->rawval);  
                         break;  
                 }  
         if (NULL == ap)  
                 printf("left ( ");  
   
         pp = TAILQ_FIRST(&pn->childq);          pp = TAILQ_FIRST(&pn->childq);
         pnode_print(p, pp);          pnode_print(p, pp);
Line 918  pnode_printmathfenced(struct parse *p, struct pnode *p
Line 963  pnode_printmathfenced(struct parse *p, struct pnode *p
                 pnode_print(p, pp);                  pnode_print(p, pp);
         }          }
   
         TAILQ_FOREACH(ap, &pn->attrq, child)          printf("right %s ", pnode_getattr_raw(pn, ATTRKEY_CLOSE, ")"));
                 if (ATTRKEY_CLOSE == ap->key) {  
                         printf("right %s ", ap->rawval);  
                         break;  
                 }  
         if (NULL == ap)  
                 printf("right ) ");  
 }  }
   
 /*  /*
Line 942  pnode_printmath(struct parse *p, struct pnode *pn)
Line 981  pnode_printmath(struct parse *p, struct pnode *pn)
         pnode_print(p, pp);          pnode_print(p, pp);
   
         switch (pn->node) {          switch (pn->node) {
         case (NODE_MML_MSUP):          case NODE_MML_MSUP:
                 fputs(" sup ", stdout);                  fputs(" sup ", stdout);
                 break;                  break;
         case (NODE_MML_MFRAC):          case NODE_MML_MFRAC:
                 fputs(" over ", stdout);                  fputs(" over ", stdout);
                 break;                  break;
         case (NODE_MML_MSUB):          case NODE_MML_MSUB:
                 fputs(" sub ", stdout);                  fputs(" sub ", stdout);
                 break;                  break;
         default:          default:
Line 1079  static void
Line 1118  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);
Line 1089  pnode_printprologue(struct parse *p, struct pnode *pn)
Line 1126  pnode_printprologue(struct parse *p, struct pnode *pn)
         if (NULL != pp) {          if (NULL != pp) {
                 pnode_printrefmeta(p, pp);                  pnode_printrefmeta(p, pp);
                 pnode_unlink(pp);                  pnode_unlink(pp);
         } else {          } else
                 name = "UNKNOWN";                  printf(".Dt %s 1\n",
                 TAILQ_FOREACH(ap, &p->root->attrq, child) {                      pnode_getattr_raw(p->root, ATTRKEY_ID, "UNKNOWN"));
                         if (ATTRKEY_ID == ap->key) {  
                                 name = ap->rawval;  
                                 break;  
                         }  
                 }  
                 printf(".Dt %s 1\n", name);  
         }  
         puts(".Os");          puts(".Os");
   
         if (PARSE_EQN & p->flags) {          if (PARSE_EQN & p->flags) {
Line 1161  pnode_printtable(struct parse *p, struct pnode *pn)
Line 1191  pnode_printtable(struct parse *p, struct pnode *pn)
         assert(p->newln);          assert(p->newln);
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TITLE == pp->node) {                  if (NODE_TITLE == pp->node) {
                         puts(".Pp");                          pnode_printpara(p, pp);
                         pnode_print(p, pp);                          pnode_print(p, pp);
                         pnode_unlink(pp);                          pnode_unlink(pp);
                 }                  }
Line 1185  pnode_printlist(struct parse *p, struct pnode *pn)
Line 1215  pnode_printlist(struct parse *p, struct pnode *pn)
         assert(p->newln);          assert(p->newln);
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TITLE == pp->node) {                  if (NODE_TITLE == pp->node) {
                         puts(".Pp");                          pnode_printpara(p, pp);
                         pnode_print(p, pp);                          pnode_print(p, pp);
                         pnode_unlink(pp);                          pnode_unlink(pp);
                 }                  }
Line 1194  pnode_printlist(struct parse *p, struct pnode *pn)
Line 1224  pnode_printlist(struct parse *p, struct pnode *pn)
         if (NODE_ORDEREDLIST == pn->node)          if (NODE_ORDEREDLIST == pn->node)
                 puts(".Bl -enum");                  puts(".Bl -enum");
         else          else
                 puts(".Bl -item");                  puts(".Bl -bullet");
   
         TAILQ_FOREACH(pp, &pn->childq, child) {          TAILQ_FOREACH(pp, &pn->childq, child) {
                 assert(p->newln);                  assert(p->newln);
Line 1214  pnode_printvariablelist(struct parse *p, struct pnode 
Line 1244  pnode_printvariablelist(struct parse *p, struct pnode 
         assert(p->newln);          assert(p->newln);
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TITLE == pp->node) {                  if (NODE_TITLE == pp->node) {
                         puts(".Pp");                          pnode_printpara(p, pp);
                         pnode_print(p, pp);                          pnode_print(p, pp);
                         pnode_unlink(pp);                          pnode_unlink(pp);
                 }                  }
Line 1244  static void
Line 1274  static void
 pnode_print(struct parse *p, struct pnode *pn)  pnode_print(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
           const char      *ccp;
         char            *cp;          char            *cp;
         int              last, sv;          int              last, sv;
   
Line 1252  pnode_print(struct parse *p, struct pnode *pn)
Line 1283  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);
                 fputs("Nm", stdout);                  fputs("Nm", stdout);
                 break;                  break;
         case (NODE_ANCHOR):          case NODE_ANCHOR:
                 /* Don't print anything! */                  /* Don't print anything! */
                 return;                  return;
         case (NODE_ARG):          case NODE_ARG:
                 pnode_printarg(p, pn);                  pnode_printarg(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_AUTHOR):          case NODE_AUTHOR:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("An", stdout);                  fputs("An", stdout);
                 break;                  break;
         case (NODE_AUTHORGROUP):          case NODE_AUTHORGROUP:
                 assert(p->newln);                  assert(p->newln);
                 puts(".An -split");                  puts(".An -split");
                 break;                  break;
         case (NODE_BOOKINFO):          case NODE_BOOKINFO:
                 assert(p->newln);                  assert(p->newln);
                 puts(".Sh NAME");                  puts(".Sh NAME");
                 break;                  break;
         case (NODE_CITEREFENTRY):          case NODE_CITEREFENTRY:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Xr", stdout);                  fputs("Xr", stdout);
                 pnode_printciterefentry(p, pn);                  pnode_printciterefentry(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_CODE):          case NODE_CODE:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Li", stdout);                  fputs("Li", stdout);
                 break;                  break;
         case (NODE_COMMAND):          case NODE_COMMAND:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Nm", stdout);                  fputs("Nm", stdout);
                 break;                  break;
         case (NODE_CONSTANT):          case NODE_CONSTANT:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Dv", stdout);                  fputs("Dv", stdout);
                 break;                  break;
         case (NODE_EDITOR):          case NODE_EDITOR:
                 puts("editor: ");                  puts("editor: ");
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("An", stdout);                  fputs("An", stdout);
                 break;                  break;
         case (NODE_EMPHASIS):          case NODE_EMPHASIS:
           case NODE_FIRSTTERM:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Em", stdout);                  fputs("Em", stdout);
                 break;                  break;
         case (NODE_ENVAR):          case NODE_ENVAR:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Ev", stdout);                  fputs("Ev", stdout);
                 break;                  break;
         case (NODE_FILENAME):          case NODE_FILENAME:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Pa", stdout);                  fputs("Pa", stdout);
                 break;                  break;
         case (NODE_FUNCTION):          case NODE_FUNCTION:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Fn", stdout);                  fputs("Fn", stdout);
                 break;                  break;
         case (NODE_FUNCPROTOTYPE):          case NODE_FUNCPROTOTYPE:
                 assert(p->newln);                  assert(p->newln);
                 pnode_printfuncprototype(p, pn);                  pnode_printfuncprototype(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_FUNCSYNOPSISINFO):          case NODE_FUNCSYNOPSISINFO:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Fd", stdout);                  fputs("Fd", stdout);
                 break;                  break;
         case (NODE_INFORMALEQUATION):          case NODE_INDEXTERM:
                   return;
           case NODE_INFORMALEQUATION:
                 if ( ! p->newln)                  if ( ! p->newln)
                         putchar('\n');                          putchar('\n');
                 puts(".EQ");                  puts(".EQ");
                 p->newln = 0;                  p->newln = 0;
                 break;                  break;
         case (NODE_INLINEEQUATION):          case NODE_INLINEEQUATION:
                 fputc('$', stdout);                  fputc('$', stdout);
                 p->newln = 0;                  p->newln = 0;
                 break;                  break;
         case (NODE_ITEMIZEDLIST):          case NODE_ITEMIZEDLIST:
                 assert(p->newln);                  assert(p->newln);
                 pnode_printlist(p, pn);                  pnode_printlist(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_GROUP):          case NODE_GROUP:
                 pnode_printgroup(p, pn);                  pnode_printgroup(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_LEGALNOTICE):          case NODE_LEGALNOTICE:
                 assert(p->newln);                  assert(p->newln);
                 puts(".Sh LEGAL NOTICE");                  puts(".Sh LEGAL NOTICE");
                 break;                  break;
         case (NODE_LITERAL):          case NODE_LINK:
                   ccp = pnode_getattr_raw(pn, ATTRKEY_LINKEND, NULL);
                   if (NULL == ccp)
                           break;
                 pnode_printmopen(p);                  pnode_printmopen(p);
                   printf("Sx %s\n", ccp);
                   p->newln = 1;
                   return;
           case NODE_LITERAL:
                   pnode_printmopen(p);
                 fputs("Li", stdout);                  fputs("Li", stdout);
                 break;                  break;
         case (NODE_MML_MFENCED):          case NODE_LITERALLAYOUT:
                   assert(p->newln);
                   puts(".Bd -literal");
                   break;
           case NODE_MML_MFENCED:
                 pnode_printmathfenced(p, pn);                  pnode_printmathfenced(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_MML_MROW):          case NODE_MML_MROW:
         case (NODE_MML_MI):          case NODE_MML_MI:
         case (NODE_MML_MN):          case NODE_MML_MN:
         case (NODE_MML_MO):          case NODE_MML_MO:
                 if (TAILQ_EMPTY(&pn->childq))                  if (TAILQ_EMPTY(&pn->childq))
                         break;                          break;
                 fputs(" { ", stdout);                  fputs(" { ", stdout);
                 break;                  break;
         case (NODE_MML_MFRAC):          case NODE_MML_MFRAC:
         case (NODE_MML_MSUB):          case NODE_MML_MSUB:
         case (NODE_MML_MSUP):          case NODE_MML_MSUP:
                 pnode_printmath(p, pn);                  pnode_printmath(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_OPTION):          case NODE_OPTION:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Fl", stdout);                  fputs("Fl", stdout);
                 break;                  break;
         case (NODE_ORDEREDLIST):          case NODE_ORDEREDLIST:
                 assert(p->newln);                  assert(p->newln);
                 pnode_printlist(p, pn);                  pnode_printlist(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_PARA):          case NODE_PARA:
                 assert(p->newln);                  pnode_printpara(p, pn);
                 if (NULL != pn->parent &&  
                         NODE_LISTITEM == pn->parent->node)  
                         break;  
                 puts(".Pp");  
                 break;                  break;
         case (NODE_PARAMETER):          case NODE_PARAMETER:
                 /* Suppress non-text children... */                  /* Suppress non-text children... */
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Fa \"", stdout);                  fputs("Fa \"", stdout);
Line 1394  pnode_print(struct parse *p, struct pnode *pn)
Line 1435  pnode_print(struct parse *p, struct pnode *pn)
                 fputs("\"", stdout);                  fputs("\"", stdout);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_QUOTE):          case NODE_QUOTE:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Qo", stdout);                  fputs("Qo", stdout);
                 break;                  break;
         case (NODE_LITERALLAYOUT):          case NODE_PROGRAMLISTING:
                 /* FALLTHROUGH */          case NODE_SCREEN:
         case (NODE_PROGRAMLISTING):  
                 /* FALLTHROUGH */  
         case (NODE_SCREEN):  
                 assert(p->newln);                  assert(p->newln);
                 puts(".Bd -literal");                  printf(".Bd %s\n", ATTRVAL_MONOSPACED ==
                       pnode_getattr(pn, ATTRKEY_CLASS) ?
                       "-literal" : "-unfilled");
                 break;                  break;
         case (NODE_REFENTRYINFO):          case NODE_REFENTRYINFO:
                 /* Suppress. */                  /* Suppress. */
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_REFMETA):          case NODE_REFMETA:
                 abort();                  abort();
                 break;                  break;
         case (NODE_REFNAME):          case NODE_REFNAME:
                 /* Suppress non-text children... */                  /* Suppress non-text children... */
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Nm", stdout);                  fputs("Nm", stdout);
Line 1421  pnode_print(struct parse *p, struct pnode *pn)
Line 1461  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_printmacrolinepart(p, pn);                  pnode_printmacrolinepart(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_REFNAMEDIV):          case NODE_REFNAMEDIV:
                 assert(p->newln);                  assert(p->newln);
                 puts(".Sh NAME");                  puts(".Sh NAME");
                 break;                  break;
         case (NODE_REFPURPOSE):          case NODE_REFPURPOSE:
                 assert(p->newln);                  assert(p->newln);
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Nd", stdout);                  fputs("Nd", stdout);
                 break;                  break;
         case (NODE_REFSYNOPSISDIV):          case NODE_REFSYNOPSISDIV:
                 assert(p->newln);                  assert(p->newln);
                 pnode_printrefsynopsisdiv(p, pn);                  pnode_printrefsynopsisdiv(p, pn);
                 puts(".Sh SYNOPSIS");                  puts(".Sh SYNOPSIS");
                 break;                  break;
         case (NODE_PREFACE):          case NODE_PREFACE:
         case (NODE_REFSECT1):          case NODE_SECTION:
         case (NODE_REFSECT2):          case NODE_NOTE:
         case (NODE_REFSECT3):          case NODE_TIP:
         case (NODE_REFSECTION):          case NODE_CAUTION:
         case (NODE_CHAPTER):          case NODE_WARNING:
         case (NODE_SECT1):  
         case (NODE_SECT2):  
         case (NODE_SECTION):  
         case (NODE_NOTE):  
         case (NODE_TIP):  
         case (NODE_CAUTION):  
         case (NODE_WARNING):  
                 assert(p->newln);                  assert(p->newln);
                 pnode_printrefsect(p, pn);                  pnode_printrefsect(p, pn);
                 break;                  break;
         case (NODE_REPLACEABLE):          case NODE_REPLACEABLE:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Ar", stdout);                  fputs("Ar", stdout);
                 break;                  break;
         case (NODE_SBR):          case NODE_SBR:
                 assert(p->newln);                  assert(p->newln);
                 puts(".br");                  puts(".br");
                 break;                  break;
         case (NODE_SGMLTAG):          case NODE_SGMLTAG:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Li", stdout);                  fputs("Li", stdout);
                 break;                  break;
         case (NODE_STRUCTNAME):          case NODE_STRUCTNAME:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Vt", stdout);                  fputs("Vt", stdout);
                 break;                  break;
         case (NODE_TABLE):          case NODE_TABLE:
                 /* FALLTHROUGH */          case NODE_INFORMALTABLE:
         case (NODE_INFORMALTABLE):  
                 assert(p->newln);                  assert(p->newln);
                 pnode_printtable(p, pn);                  pnode_printtable(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_TEXT):          case NODE_TEXT:
                 if (0 == p->newln)                  if (0 == p->newln)
                         putchar(' ');                          putchar(' ');
   
Line 1521  pnode_print(struct parse *p, struct pnode *pn)
Line 1553  pnode_print(struct parse *p, struct pnode *pn)
                 }                  }
                 p->newln = 0;                  p->newln = 0;
                 break;                  break;
         case (NODE_TITLE):          case NODE_TITLE:
                 if (pn->parent->node == NODE_BOOKINFO) {                  if (pn->parent->node == NODE_BOOKINFO) {
                         pnode_printmopen(p);                          pnode_printmopen(p);
                         fputs("Nd", stdout);                          fputs("Nd", stdout);
                 }                  }
                 break;                  break;
         case (NODE_TYPE):          case NODE_TYPE:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Vt", stdout);                  fputs("Vt", stdout);
                 break;                  break;
         case (NODE_USERINPUT):          case NODE_USERINPUT:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Li", stdout);                  fputs("Li", stdout);
                 break;                  break;
         case (NODE_VARIABLELIST):          case NODE_VARIABLELIST:
                 assert(p->newln);                  assert(p->newln);
                 pnode_printvariablelist(p, pn);                  pnode_printvariablelist(p, pn);
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case (NODE_VARLISTENTRY):          case NODE_VARLISTENTRY:
                 assert(p->newln);                  assert(p->newln);
                 pnode_printvarlistentry(p, pn);                  pnode_printvarlistentry(p, pn);
                 break;                  break;
         case (NODE_VARNAME):          case NODE_VARNAME:
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Va", stdout);                  fputs("Va", stdout);
                 break;                  break;
Line 1556  pnode_print(struct parse *p, struct pnode *pn)
Line 1588  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_print(p, pp);                  pnode_print(p, pp);
   
         switch (pn->node) {          switch (pn->node) {
         case (NODE_INFORMALEQUATION):          case NODE_INFORMALEQUATION:
                 if ( ! p->newln)                  if ( ! p->newln)
                         putchar('\n');                          putchar('\n');
                 puts(".EN");                  puts(".EN");
                 p->newln = 1;                  p->newln = 1;
                 break;                  break;
         case (NODE_INLINEEQUATION):          case NODE_INLINEEQUATION:
                 fputs("$ ", stdout);                  fputs("$ ", stdout);
                 p->newln = sv;                  p->newln = sv;
                 break;                  break;
         case (NODE_MML_MROW):          case NODE_MML_MROW:
         case (NODE_MML_MI):          case NODE_MML_MI:
         case (NODE_MML_MN):          case NODE_MML_MN:
         case (NODE_MML_MO):          case NODE_MML_MO:
                 if (TAILQ_EMPTY(&pn->childq))                  if (TAILQ_EMPTY(&pn->childq))
                         break;                          break;
                 fputs(" } ", stdout);                  fputs(" } ", stdout);
                 break;                  break;
         case (NODE_APPLICATION):          case NODE_APPLICATION:
         case (NODE_ARG):          case NODE_ARG:
         case (NODE_AUTHOR):          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_EDITOR:
         case (NODE_EMPHASIS):          case NODE_EMPHASIS:
         case (NODE_ENVAR):          case NODE_ENVAR:
         case (NODE_FILENAME):          case NODE_FILENAME:
         case (NODE_FUNCTION):          case NODE_FIRSTTERM:
         case (NODE_FUNCSYNOPSISINFO):          case NODE_FUNCTION:
         case (NODE_LITERAL):          case NODE_FUNCSYNOPSISINFO:
         case (NODE_OPTION):          case NODE_LITERAL:
         case (NODE_PARAMETER):          case NODE_OPTION:
         case (NODE_REPLACEABLE):          case NODE_PARAMETER:
         case (NODE_REFPURPOSE):          case NODE_REPLACEABLE:
         case (NODE_SGMLTAG):          case NODE_REFPURPOSE:
         case (NODE_STRUCTNAME):          case NODE_SGMLTAG:
         case (NODE_TEXT):          case NODE_STRUCTNAME:
         case (NODE_TYPE):          case NODE_TEXT:
         case (NODE_USERINPUT):          case NODE_TYPE:
         case (NODE_VARNAME):          case NODE_USERINPUT:
           case NODE_VARNAME:
                 pnode_printmclosepunct(p, pn, sv);                  pnode_printmclosepunct(p, pn, sv);
                 break;                  break;
         case (NODE_QUOTE):          case NODE_QUOTE:
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
                 sv = p->newln;                  sv = p->newln;
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 fputs("Qc", stdout);                  fputs("Qc", stdout);
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
                 break;                  break;
         case (NODE_REFNAME):          case NODE_REFNAME:
                 /*                  /*
                  * If we're in the NAME macro and we have multiple                   * If we're in the NAME macro and we have multiple
                  * <refname> macros in sequence, then print out a                   * <refname> macros in sequence, then print out a
Line 1620  pnode_print(struct parse *p, struct pnode *pn)
Line 1653  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_PREFACE:
         case (NODE_REFSECT1):          case NODE_SECTION:
         case (NODE_REFSECT2):          case NODE_NOTE:
         case (NODE_REFSECT3):          case NODE_TIP:
         case (NODE_REFSECTION):          case NODE_CAUTION:
         case (NODE_CHAPTER):          case NODE_WARNING:
         case (NODE_SECT1):  
         case (NODE_SECT2):  
         case (NODE_SECTION):  
         case (NODE_NOTE):  
         case (NODE_TIP):  
         case (NODE_CAUTION):  
         case (NODE_WARNING):  
                 p->level--;                  p->level--;
                 break;                  break;
         case (NODE_LITERALLAYOUT):          case NODE_LITERALLAYOUT:
                 /* FALLTHROUGH */          case NODE_PROGRAMLISTING:
         case (NODE_PROGRAMLISTING):          case NODE_SCREEN:
                 /* FALLTHROUGH */  
         case (NODE_SCREEN):  
                 assert(p->newln);                  assert(p->newln);
                 puts(".Ed");                  puts(".Ed");
                 p->newln = 1;                  p->newln = 1;
                 break;                  break;
         case (NODE_TITLE):          case NODE_TITLE:
                 if (pn->parent->node == NODE_BOOKINFO) {                  if (pn->parent->node == NODE_BOOKINFO) {
                         pnode_printmclose(p, 1);                          pnode_printmclose(p, 1);
                         puts(".Sh AUTHORS");                          puts(".Sh AUTHORS");
Line 1727  main(int argc, char *argv[])
Line 1751  main(int argc, char *argv[])
   
         while (-1 != (ch = getopt(argc, argv, "W")))          while (-1 != (ch = getopt(argc, argv, "W")))
                 switch (ch) {                  switch (ch) {
                 case ('W'):                  case 'W':
                         warn = 1;                          warn = 1;
                         break;                          break;
                 default:                  default:
Legend:
Removed from v.1.52  
changed lines
  Added in v.1.62
CVSweb