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

Diff for /docbook2mdoc/docbook2mdoc.c between version 1.63 and 1.64

version 1.63, 2019/03/22 18:02:07 version 1.64, 2019/03/22 19:07:07
Line 245  xml_char(void *arg, const XML_Char *p, int sz)
Line 245  xml_char(void *arg, const XML_Char *p, int sz)
         int              i;          int              i;
   
         /* Stopped or no tree yet. */          /* Stopped or no tree yet. */
         if (ps->stop || NODE_ROOT == ps->node)          if (ps->stop || ps->node == NODE_ROOT)
                 return;                  return;
   
         assert(NULL != ps->cur);          assert(ps->cur != NULL);
   
         /*          /*
          * Are we in the midst of processing text?           * Are we in the midst of processing text?
Line 257  xml_char(void *arg, const XML_Char *p, int sz)
Line 257  xml_char(void *arg, const XML_Char *p, int sz)
          * However, don't do so unless we have some non-whitespace to           * However, don't do so unless we have some non-whitespace to
          * process: strip out all leading whitespace to be sure.           * process: strip out all leading whitespace to be sure.
          */           */
         if (NODE_TEXT != ps->node) {          if (ps->node != NODE_TEXT) {
                 for (i = 0; i < sz; i++)                  for (i = 0; i < sz; i++)
                         if ( ! isspace((unsigned char)p[i]))                          if ( ! isspace((unsigned char)p[i]))
                                 break;                                  break;
Line 266  xml_char(void *arg, const XML_Char *p, int sz)
Line 266  xml_char(void *arg, const XML_Char *p, int sz)
                 p += i;                  p += i;
                 sz -= i;                  sz -= i;
                 dat = calloc(1, sizeof(struct pnode));                  dat = calloc(1, sizeof(struct pnode));
                 if (NULL == dat) {                  if (dat == NULL) {
                         perror(NULL);                          perror(NULL);
                         exit(1);                          exit(1);
                 }                  }
Line 277  xml_char(void *arg, const XML_Char *p, int sz)
Line 277  xml_char(void *arg, const XML_Char *p, int sz)
                 TAILQ_INIT(&dat->attrq);                  TAILQ_INIT(&dat->attrq);
                 TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);                  TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);
                 ps->cur = dat;                  ps->cur = dat;
                 assert(NULL != ps->root);                  assert(ps->root != NULL);
         }          }
   
         /* Append to current buffer. */          /* Append to current buffer. */
         assert(sz >= 0);          assert(sz >= 0);
         ps->cur->b = realloc(ps->cur->b,          ps->cur->b = realloc(ps->cur->b,
                 ps->cur->bsz + (size_t)sz);                  ps->cur->bsz + (size_t)sz);
         if (NULL == ps->cur->b) {          if (ps->cur->b == NULL) {
                 perror(NULL);                  perror(NULL);
                 exit(1);                  exit(1);
         }          }
Line 296  xml_char(void *arg, const XML_Char *p, int sz)
Line 296  xml_char(void *arg, const XML_Char *p, int sz)
 static void  static void
 pnode_trim(struct pnode *pn)  pnode_trim(struct pnode *pn)
 {  {
           assert(pn->node == NODE_TEXT);
         assert(NODE_TEXT == pn->node);  
         for ( ; pn->bsz > 0; pn->bsz--)          for ( ; pn->bsz > 0; pn->bsz--)
                 if ( ! isspace((unsigned char)pn->b[pn->bsz - 1]))                  if ( ! isspace((unsigned char)pn->b[pn->bsz - 1]))
                         break;                          break;
Line 329  xml_elem_start(void *arg, const XML_Char *name, const 
Line 328  xml_elem_start(void *arg, const XML_Char *name, const 
         const XML_Char  **att;          const XML_Char  **att;
   
         /* FIXME: find a better way to ditch other namespaces. */          /* FIXME: find a better way to ditch other namespaces. */
         if (ps->stop || 0 == strcmp(name, "xi:include"))          if (ps->stop || strcmp(name, "xi:include") == 0)
                 return;                  return;
   
         /* Close out text node, if applicable... */          /* Close out text node, if applicable... */
         if (NODE_TEXT == ps->node) {          if (ps->node == NODE_TEXT) {
                 assert(NULL != ps->cur);  
                 pnode_trim(ps->cur);                  pnode_trim(ps->cur);
                 ps->cur = ps->cur->parent;                  ps->cur = ps->cur->parent;
                 assert(NULL != ps->cur);  
                 ps->node = ps->cur->node;                  ps->node = ps->cur->node;
         }          }
   
         for (node = nodes; NULL != node->name; node++)          for (node = nodes; node->name != NULL; node++)
                 if (0 == strcmp(node->name, name))                  if (strcmp(node->name, name) == 0)
                         break;                          break;
   
         if (NULL == node->name) {          if (node->name == NULL) {
                 if (NODE_ROOT == ps->node)                  if (ps->node == NODE_ROOT)
                         return;                          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);
                 ps->stop = 1;                  ps->stop = 1;
                 return;                  return;
         } else if (NODE_ROOT == ps->node && NULL != ps->root) {          } else if (ps->node == NODE_ROOT && ps->root != NULL) {
                 fprintf(stderr, "%s:%zu:%zu: multiple refentries\n",                  fprintf(stderr, "%s:%zu:%zu: multiple refentries\n",
                         ps->fname, XML_GetCurrentLineNumber(ps->xml),                          ps->fname, XML_GetCurrentLineNumber(ps->xml),
                         XML_GetCurrentColumnNumber(ps->xml));                          XML_GetCurrentColumnNumber(ps->xml));
Line 361  xml_elem_start(void *arg, const XML_Char *name, const 
Line 358  xml_elem_start(void *arg, const XML_Char *name, const 
                 return;                  return;
         }          }
   
         if (NODE_INLINEEQUATION == node->node)          if (node->node == NODE_INLINEEQUATION)
                 ps->flags |= PARSE_EQN;                  ps->flags |= PARSE_EQN;
   
         if (NULL == (dat = calloc(1, sizeof(struct pnode)))) {          if ((dat = calloc(1, sizeof(struct pnode))) == NULL) {
                 perror(NULL);                  perror(NULL);
                 exit(1);                  exit(1);
         }          }
Line 374  xml_elem_start(void *arg, const XML_Char *name, const 
Line 371  xml_elem_start(void *arg, const XML_Char *name, const 
         TAILQ_INIT(&dat->childq);          TAILQ_INIT(&dat->childq);
         TAILQ_INIT(&dat->attrq);          TAILQ_INIT(&dat->attrq);
   
         if (NULL != ps->cur)          if (ps->cur != NULL)
                 TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);                  TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);
   
         ps->cur = dat;          ps->cur = dat;
         if (NULL == ps->root)          if (ps->root == NULL)
                 ps->root = dat;                  ps->root = dat;
   
         /*          /*
          * Process attributes.           * Process attributes.
          */           */
         for (att = atts; NULL != *att; att += 2) {          for (att = atts; *att != NULL; att += 2) {
                 for (key = 0; key < ATTRKEY__MAX; key++)                  for (key = 0; key < ATTRKEY__MAX; key++)
                         if (0 == strcmp(*att, attrkeys[key]))                          if (strcmp(*att, attrkeys[key]) == 0)
                                 break;                                  break;
                 if (ATTRKEY__MAX == key) {                  if (key == ATTRKEY__MAX) {
                         if (warn)                          if (warn)
                                 fprintf(stderr, "%s:%zu:%zu: warning: "                                  fprintf(stderr, "%s:%zu:%zu: warning: "
                                         "unknown attribute \"%s\"\n",                                          "unknown attribute \"%s\"\n",
Line 399  xml_elem_start(void *arg, const XML_Char *name, const 
Line 396  xml_elem_start(void *arg, const XML_Char *name, const 
                         continue;                          continue;
                 }                  }
                 for (val = 0; val < ATTRVAL__MAX; val++)                  for (val = 0; val < ATTRVAL__MAX; val++)
                         if (0 == strcmp(*(att + 1), attrvals[val]))                          if (strcmp(att[1], attrvals[val]) == 0)
                                 break;                                  break;
                 pattr = calloc(1, sizeof(struct pattr));                  pattr = calloc(1, sizeof(struct pattr));
                 pattr->key = key;                  pattr->key = key;
                 pattr->val = val;                  pattr->val = val;
                 if (ATTRVAL__MAX == val)                  if (val == ATTRVAL__MAX)
                         pattr->rawval = strdup(*(att + 1));                          pattr->rawval = strdup(att[1]);
                 TAILQ_INSERT_TAIL(&dat->attrq, pattr, child);                  TAILQ_INSERT_TAIL(&dat->attrq, pattr, child);
         }          }
   
Line 422  xml_elem_end(void *arg, const XML_Char *name)
Line 419  xml_elem_end(void *arg, const XML_Char *name)
         struct parse    *ps = arg;          struct parse    *ps = arg;
   
         /* FIXME: find a better way to ditch other namespaces. */          /* FIXME: find a better way to ditch other namespaces. */
         if (ps->stop || NODE_ROOT == ps->node)          if (ps->stop || ps->node == NODE_ROOT)
                 return;                  return;
         else if (0 == strcmp(name, "xi:include"))          else if (strcmp(name, "xi:include") == 0)
                 return;                  return;
   
         /* Close out text node, if applicable... */          /* Close out text node, if applicable... */
         if (NODE_TEXT == ps->node) {          if (ps->node == NODE_TEXT) {
                 assert(NULL != ps->cur);  
                 pnode_trim(ps->cur);                  pnode_trim(ps->cur);
                 ps->cur = ps->cur->parent;                  ps->cur = ps->cur->parent;
                 assert(NULL != ps->cur);  
                 ps->node = ps->cur->node;                  ps->node = ps->cur->node;
         }          }
   
         if (NULL == (ps->cur = ps->cur->parent))          if ((ps->cur = ps->cur->parent) == NULL)
                 ps->node = NODE_ROOT;                  ps->node = NODE_ROOT;
         else          else
                 ps->node = ps->cur->node;                  ps->node = ps->cur->node;
Line 451  pnode_free(struct pnode *pn)
Line 446  pnode_free(struct pnode *pn)
         struct pnode    *pp;          struct pnode    *pp;
         struct pattr    *ap;          struct pattr    *ap;
   
         if (NULL == pn)          if (pn == NULL)
                 return;                  return;
   
         while (NULL != (pp = TAILQ_FIRST(&pn->childq))) {          while ((pp = TAILQ_FIRST(&pn->childq)) != NULL) {
                 TAILQ_REMOVE(&pn->childq, pp, child);                  TAILQ_REMOVE(&pn->childq, pp, child);
                 pnode_free(pp);                  pnode_free(pp);
         }          }
   
         while (NULL != (ap = TAILQ_FIRST(&pn->attrq))) {          while ((ap = TAILQ_FIRST(&pn->attrq)) != NULL) {
                 TAILQ_REMOVE(&pn->attrq, ap, child);                  TAILQ_REMOVE(&pn->attrq, ap, child);
                 free(ap->rawval);                  free(ap->rawval);
                 free(ap);                  free(ap);
Line 475  pnode_free(struct pnode *pn)
Line 470  pnode_free(struct pnode *pn)
 static void  static void
 pnode_unlink(struct pnode *pn)  pnode_unlink(struct pnode *pn)
 {  {
           if (pn->parent != NULL)
         if (NULL != pn->parent)  
                 TAILQ_REMOVE(&pn->parent->childq, pn, child);                  TAILQ_REMOVE(&pn->parent->childq, pn, child);
         pnode_free(pn);          pnode_free(pn);
 }  }
Line 518  pnode_getattr_raw(struct pnode *pn, enum attrkey key, 
Line 512  pnode_getattr_raw(struct pnode *pn, enum attrkey key, 
   
         TAILQ_FOREACH(ap, &pn->attrq, child)          TAILQ_FOREACH(ap, &pn->attrq, child)
                 if (ap->key == key)                  if (ap->key == key)
                         return ATTRVAL__MAX == ap->val ? ap->rawval :                          return ap->val == ATTRVAL__MAX ? ap->rawval :
                             attrvals[ap->val];                              attrvals[ap->val];
         return defval;          return defval;
 }  }
Line 542  static void
Line 536  static void
 bufappend(struct parse *p, struct pnode *pn)  bufappend(struct parse *p, struct pnode *pn)
 {  {
   
         assert(NODE_TEXT == pn->node);          assert(pn->node == NODE_TEXT);
         if (p->bsz + pn->bsz + 1 > p->mbsz) {          if (p->bsz + pn->bsz + 1 > p->mbsz) {
                 p->mbsz = p->bsz + pn->bsz + 1;                  p->mbsz = p->bsz + pn->bsz + 1;
                 if (NULL == (p->b = realloc(p->b, p->mbsz))) {                  if ((p->b = realloc(p->b, p->mbsz)) == NULL) {
                         perror(NULL);                          perror(NULL);
                         exit(1);                          exit(1);
                 }                  }
Line 566  bufappend_r(struct parse *p, struct pnode *pn)
Line 560  bufappend_r(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
   
         if (NODE_TEXT == pn->node)          if (pn->node == NODE_TEXT)
                 bufappend(p, pn);                  bufappend(p, pn);
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 bufappend_r(p, pp);                  bufappend_r(p, pp);
Line 584  pnode_findfirst(struct pnode *pn, enum nodeid node)
Line 578  pnode_findfirst(struct pnode *pn, enum nodeid node)
         TAILQ_FOREACH(pp, &pn->childq, child) {          TAILQ_FOREACH(pp, &pn->childq, child) {
                 res = pp->node == node ? pp :                  res = pp->node == node ? pp :
                         pnode_findfirst(pp, node);                          pnode_findfirst(pp, node);
                 if (NULL != res)                  if (res != NULL)
                         break;                          break;
         }          }
   
Line 603  pnode_printmacrolinetext(struct parse *p, struct pnode
Line 597  pnode_printmacrolinetext(struct parse *p, struct pnode
 {  {
         char            *cp;          char            *cp;
   
         if (0 == p->newln && ! (MACROLINE_NOWS & fl))          if (p->newln == 0 && (fl & MACROLINE_NOWS) == 0)
                 putchar(' ');                  putchar(' ');
   
         bufclear(p);          bufclear(p);
         bufappend_r(p, pn);          bufappend_r(p, pn);
   
         /* Convert all space to spaces. */          /* Convert all space to spaces. */
         for (cp = p->b; '\0' != *cp; cp++)          for (cp = p->b; *cp != '\0'; cp++)
                 if (isspace((unsigned char)*cp))                  if (isspace((unsigned char)*cp))
                         *cp = ' ';                          *cp = ' ';
   
         for (cp = p->b; isspace((unsigned char)*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 ( ; *cp != '\0'; 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((unsigned char)*cp) &&                      isupper((unsigned char)cp[0]) &&
                         '\0' != *(cp + 1) &&                      islower((unsigned char)cp[1]) &&
                         islower((unsigned char)*(cp + 1)) &&                      (cp[2] == '\0' || cp[2] == ' ' ||
                         ('\0' == *(cp + 2) ||                       (islower((unsigned char)cp[2]) &&
                          ' ' == *(cp + 2) ||                        (cp[3] == '\0' || cp[3] == ' '))))
                          (islower((unsigned char)*(cp + 2)) &&  
                           ('\0' == *(cp + 3) ||  
                            ' ' == *(cp + 3)))))  
                         fputs("\\&", stdout);                          fputs("\\&", stdout);
                 if (MACROLINE_UPPER & fl)                  if (fl & MACROLINE_UPPER)
                         putchar(toupper((unsigned char)*cp));                          putchar(toupper((unsigned char)*cp));
                 else                  else
                         putchar(*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 652  pnode_printmacrolinepart(struct parse *p, struct pnode
Line 643  pnode_printmacrolinepart(struct parse *p, struct pnode
 static void  static void
 pnode_printmacroline(struct parse *p, struct pnode *pn)  pnode_printmacroline(struct parse *p, struct pnode *pn)
 {  {
           assert(p->newln == 0);
         assert(0 == p->newln);  
         pnode_printmacrolinetext(p, pn, 0);          pnode_printmacrolinetext(p, pn, 0);
         putchar('\n');          putchar('\n');
         p->newln = 1;          p->newln = 1;
Line 692  pnode_printmclosepunct(struct parse *p, struct pnode *
Line 682  pnode_printmclosepunct(struct parse *p, struct pnode *
                 return;                  return;
   
         /* No next node or it's not text. */          /* No next node or it's not text. */
         if (NULL == (pn = TAILQ_NEXT(pn, child))) {          if ((pn = TAILQ_NEXT(pn, child)) == NULL) {
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
                 return;                  return;
         } else if (NODE_TEXT != pn->node) {          } else if (pn->node != NODE_TEXT) {
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
                 return;                  return;
         }          }
   
         /* 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((unsigned char)pn->b[1]))) {              (pn->bsz == 1 || isspace((unsigned char)pn->b[1]))) {
                 putchar(' ');                  putchar(' ');
                 putchar(pn->b[0]);                  putchar(pn->b[0]);
                 pn->b++;                  pn->b++;
Line 748  pnode_printrefsynopsisdiv(struct parse *p, struct pnod
Line 738  pnode_printrefsynopsisdiv(struct parse *p, struct pnod
         struct pnode    *pp;          struct pnode    *pp;
   
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TITLE == pp->node) {                  if (pp->node == NODE_TITLE) {
                         pnode_unlink(pp);                          pnode_unlink(pp);
                         return;                          return;
                 }                  }
Line 764  pnode_printrefsect(struct parse *p, struct pnode *pn)
Line 754  pnode_printrefsect(struct parse *p, struct pnode *pn)
         const char      *title;          const char      *title;
         int              flags, level;          int              flags, level;
   
         if (NULL == pn->parent)          if (pn->parent == NULL)
                 return;                  return;
   
         level = ++p->level;          level = ++p->level;
         flags = 1 == level ? MACROLINE_UPPER : 0;          flags = level == 1 ? MACROLINE_UPPER : 0;
         if (3 > level) {          if (level < 3) {
                 switch (pn->node) {                  switch (pn->node) {
                 case NODE_CAUTION:                  case NODE_CAUTION:
                 case NODE_NOTE:                  case NODE_NOTE:
Line 783  pnode_printrefsect(struct parse *p, struct pnode *pn)
Line 773  pnode_printrefsect(struct parse *p, struct pnode *pn)
         }          }
   
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TITLE == pp->node)                  if (pp->node == NODE_TITLE)
                         break;                          break;
   
         if (NULL == pp) {          if (pp == NULL) {
                 switch (pn->node) {                  switch (pn->node) {
                 case NODE_PREFACE:                  case NODE_PREFACE:
                         title = "Preface";                          title = "Preface";
Line 822  pnode_printrefsect(struct parse *p, struct pnode *pn)
Line 812  pnode_printrefsect(struct parse *p, struct pnode *pn)
                 break;                  break;
         }          }
   
         if (NULL != pp) {          if (pp != NULL) {
                 p->newln = 0;                  p->newln = 0;
                 pnode_printmacrolinetext(p, pp, flags);                  pnode_printmacrolinetext(p, pp, flags);
                 pnode_printmclose(p, 1);                  pnode_printmclose(p, 1);
Line 841  pnode_printciterefentry(struct parse *p, struct pnode 
Line 831  pnode_printciterefentry(struct parse *p, struct pnode 
   
         title = manvol = NULL;          title = manvol = NULL;
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_MANVOLNUM == pp->node)                  if (pp->node == NODE_MANVOLNUM)
                         manvol = pp;                          manvol = pp;
                 else if (NODE_REFENTRYTITLE == pp->node)                  else if (pp->node == NODE_REFENTRYTITLE)
                         title = pp;                          title = pp;
   
         if (NULL != title) {          if (title != NULL)
                 pnode_printmacrolinepart(p, title);                  pnode_printmacrolinepart(p, title);
         } else          else
                 fputs(" unknown ", stdout);                  fputs(" unknown ", stdout);
   
         if (NULL == manvol) {          if (manvol == NULL) {
                 puts(" 1");                  puts(" 1");
                 p->newln = 1;                  p->newln = 1;
         } else          } else
Line 866  pnode_printrefmeta(struct parse *p, struct pnode *pn)
Line 856  pnode_printrefmeta(struct parse *p, struct pnode *pn)
         title = manvol = NULL;          title = manvol = NULL;
         assert(p->newln);          assert(p->newln);
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_MANVOLNUM == pp->node)                  if (pp->node == NODE_MANVOLNUM)
                         manvol = pp;                          manvol = pp;
                 else if (NODE_REFENTRYTITLE == pp->node)                  else if (pp->node == NODE_REFENTRYTITLE)
                         title = pp;                          title = pp;
   
         fputs(".Dt", stdout);          fputs(".Dt", stdout);
         p->newln = 0;          p->newln = 0;
   
         if (NULL != title)          if (title != NULL)
                 pnode_printmacrolinetext(p, title, MACROLINE_UPPER);                  pnode_printmacrolinetext(p, title, MACROLINE_UPPER);
         else          else
                 fputs(" UNKNOWN ", stdout);                  fputs(" UNKNOWN ", stdout);
   
         if (NULL == manvol) {          if (manvol == NULL) {
                 puts(" 1");                  puts(" 1");
                 p->newln = 1;                  p->newln = 1;
         } else          } else
Line 894  pnode_printfuncdef(struct parse *p, struct pnode *pn)
Line 884  pnode_printfuncdef(struct parse *p, struct pnode *pn)
         assert(p->newln);          assert(p->newln);
         ftype = func = NULL;          ftype = func = NULL;
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TEXT == pp->node)                  if (pp->node == NODE_TEXT)
                         ftype = pp;                          ftype = pp;
                 else if (NODE_FUNCTION == pp->node)                  else if (pp->node == NODE_FUNCTION)
                         func = pp;                          func = pp;
   
         if (NULL != ftype) {          if (ftype != NULL) {
                 fputs(".Ft", stdout);                  fputs(".Ft", stdout);
                 p->newln = 0;                  p->newln = 0;
                 pnode_printmacroline(p, ftype);                  pnode_printmacroline(p, ftype);
         }          }
   
         if (NULL != func) {          if (func != NULL) {
                 fputs(".Fo", stdout);                  fputs(".Fo", stdout);
                 p->newln = 0;                  p->newln = 0;
                 pnode_printmacroline(p, func);                  pnode_printmacroline(p, func);
Line 923  pnode_printparamdef(struct parse *p, struct pnode *pn)
Line 913  pnode_printparamdef(struct parse *p, struct pnode *pn)
         assert(p->newln);          assert(p->newln);
         ptype = param = NULL;          ptype = param = NULL;
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TEXT == pp->node)                  if (pp->node == NODE_TEXT)
                         ptype = pp;                          ptype = pp;
                 else if (NODE_PARAMETER == pp->node)                  else if (pp->node == NODE_PARAMETER)
                         param = pp;                          param = pp;
   
         fputs(".Fa \"", stdout);          fputs(".Fa \"", stdout);
         p->newln = 0;          p->newln = 0;
         if (NULL != ptype) {          if (ptype != NULL) {
                 pnode_printmacrolinetext(p, ptype, MACROLINE_NOWS);                  pnode_printmacrolinetext(p, ptype, MACROLINE_NOWS);
                 putchar(' ');                  putchar(' ');
         }          }
   
         if (NULL != param)          if (param != NULL)
                 pnode_printmacrolinepart(p, param);                  pnode_printmacrolinepart(p, param);
   
         puts("\"");          puts("\"");
Line 958  pnode_printmathfenced(struct parse *p, struct pnode *p
Line 948  pnode_printmathfenced(struct parse *p, struct pnode *p
         pp = TAILQ_FIRST(&pn->childq);          pp = TAILQ_FIRST(&pn->childq);
         pnode_print(p, pp);          pnode_print(p, pp);
   
         while (NULL != (pp = TAILQ_NEXT(pp, child))) {          while ((pp = TAILQ_NEXT(pp, child)) != NULL) {
                 putchar(',');                  putchar(',');
                 pnode_print(p, pp);                  pnode_print(p, pp);
         }          }
Line 1005  pnode_printfuncprototype(struct parse *p, struct pnode
Line 995  pnode_printfuncprototype(struct parse *p, struct pnode
   
         assert(p->newln);          assert(p->newln);
         TAILQ_FOREACH(fdef, &pn->childq, child)          TAILQ_FOREACH(fdef, &pn->childq, child)
                 if (NODE_FUNCDEF == fdef->node)                  if (fdef->node == NODE_FUNCDEF)
                         break;                          break;
   
         if (NULL != fdef)          if (fdef != NULL)
                 pnode_printfuncdef(p, fdef);                  pnode_printfuncdef(p, fdef);
         else          else
                 puts(".Fo UNKNOWN");                  puts(".Fo UNKNOWN");
   
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_PARAMDEF == pp->node)                  if (pp->node == NODE_PARAMDEF)
                         pnode_printparamdef(p, pp);                          pnode_printparamdef(p, pp);
   
         puts(".Fc");          puts(".Fc");
Line 1038  pnode_printarg(struct parse *p, struct pnode *pn)
Line 1028  pnode_printarg(struct parse *p, struct pnode *pn)
         isop = 1;          isop = 1;
         isrep = 0;          isrep = 0;
         TAILQ_FOREACH(ap, &pn->attrq, child)          TAILQ_FOREACH(ap, &pn->attrq, child)
                 if (ATTRKEY_CHOICE == ap->key &&                  if (ap->key == ATTRKEY_CHOICE &&
                         (ATTRVAL_PLAIN == ap->val ||                      (ap->val == ATTRVAL_PLAIN || ap->val == ATTRVAL_REQ))
                          ATTRVAL_REQ == ap->val))  
                         isop = 0;                          isop = 0;
                 else if (ATTRKEY_REP == ap->key &&                  else if (ap->key == ATTRKEY_REP && ap->val == ATTRVAL_REPEAT)
                         (ATTRVAL_REPEAT == ap->val))  
                         isrep = 1;                          isrep = 1;
   
         if (isop) {          if (isop) {
Line 1052  pnode_printarg(struct parse *p, struct pnode *pn)
Line 1040  pnode_printarg(struct parse *p, struct pnode *pn)
         }          }
   
         TAILQ_FOREACH(pp, &pn->childq, child) {          TAILQ_FOREACH(pp, &pn->childq, child) {
                 if (NODE_TEXT == pp->node) {                  if (pp->node == NODE_TEXT) {
                         pnode_printmopen(p);                          pnode_printmopen(p);
                         fputs("Ar", stdout);                          fputs("Ar", stdout);
                 }                  }
                 pnode_print(p, pp);                  pnode_print(p, pp);
                 if (NODE_TEXT == pp->node && isrep)                  if (isrep && pp->node == NODE_TEXT)
                         fputs("...", stdout);                          fputs("...", stdout);
         }          }
 }  }
Line 1071  pnode_printgroup(struct parse *p, struct pnode *pn)
Line 1059  pnode_printgroup(struct parse *p, struct pnode *pn)
   
         isop = 1;          isop = 1;
         TAILQ_FOREACH(ap, &pn->attrq, child)          TAILQ_FOREACH(ap, &pn->attrq, child)
                 if (ATTRKEY_CHOICE == ap->key &&                  if (ap->key == ATTRKEY_CHOICE &&
                         (ATTRVAL_PLAIN == ap->val ||                      (ap->val == ATTRVAL_PLAIN || ap->val == ATTRVAL_REQ)) {
                          ATTRVAL_REQ == ap->val)) {  
                         isop = 0;                          isop = 0;
                         break;                          break;
                 }                  }
Line 1101  pnode_printgroup(struct parse *p, struct pnode *pn)
Line 1088  pnode_printgroup(struct parse *p, struct pnode *pn)
         TAILQ_FOREACH(pp, &pn->childq, child) {          TAILQ_FOREACH(pp, &pn->childq, child) {
                 pnode_print(p, pp);                  pnode_print(p, pp);
                 np = TAILQ_NEXT(pp, child);                  np = TAILQ_NEXT(pp, child);
                 while (NULL != np) {                  while (np != NULL) {
                         if (pp->node != np->node)                          if (pp->node != np->node)
                                 break;                                  break;
                         fputs(" |", stdout);                          fputs(" |", stdout);
Line 1119  pnode_printprologue(struct parse *p, struct pnode *pn)
Line 1106  pnode_printprologue(struct parse *p, struct pnode *pn)
 {  {
         struct pnode    *pp;          struct pnode    *pp;
   
         pp = NULL == p->root ? NULL :          pp = p->root == NULL ? NULL :
                 pnode_findfirst(p->root, NODE_REFMETA);                  pnode_findfirst(p->root, NODE_REFMETA);
   
         puts(".Dd $Mdocdate" "$");          puts(".Dd $Mdocdate" "$");
         if (NULL != pp) {          if (pp != NULL) {
                 pnode_printrefmeta(p, pp);                  pnode_printrefmeta(p, pp);
                 pnode_unlink(pp);                  pnode_unlink(pp);
         } else          } else
Line 1131  pnode_printprologue(struct parse *p, struct pnode *pn)
Line 1118  pnode_printprologue(struct parse *p, struct pnode *pn)
                     pnode_getattr_raw(p->root, ATTRKEY_ID, "UNKNOWN"));                      pnode_getattr_raw(p->root, ATTRKEY_ID, "UNKNOWN"));
         puts(".Os");          puts(".Os");
   
         if (PARSE_EQN & p->flags) {          if (p->flags & PARSE_EQN) {
                 puts(".EQ");                  puts(".EQ");
                 puts("delim $$");                  puts("delim $$");
                 puts(".EN");                  puts(".EN");
Line 1153  pnode_printvarlistentry(struct parse *p, struct pnode 
Line 1140  pnode_printvarlistentry(struct parse *p, struct pnode 
         p->newln = 0;          p->newln = 0;
   
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_TERM == pp->node) {                  if (pp->node == NODE_TERM) {
                         if ( ! first)                          if ( ! first)
                                 putchar(',');                                  putchar(',');
                         pnode_print(p, pp);                          pnode_print(p, pp);
Line 1190  pnode_printtable(struct parse *p, struct pnode *pn)
Line 1177  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 (pp->node == NODE_TITLE) {
                         pnode_printpara(p, pp);                          pnode_printpara(p, pp);
                         pnode_print(p, pp);                          pnode_print(p, pp);
                         pnode_unlink(pp);                          pnode_unlink(pp);
                 }                  }
         assert(p->newln);          assert(p->newln);
         puts(".Bl -ohang");          puts(".Bl -ohang");
         while (NULL != (pp = pnode_findfirst(pn, NODE_ROW))) {          while ((pp = pnode_findfirst(pn, NODE_ROW)) != NULL) {
                 puts(".It Table Row");                  puts(".It Table Row");
                 pnode_printrow(p, pp);                  pnode_printrow(p, pp);
                 pnode_printmclose(p, 1);                  pnode_printmclose(p, 1);
Line 1214  pnode_printlist(struct parse *p, struct pnode *pn)
Line 1201  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 (pp->node == NODE_TITLE) {
                         pnode_printpara(p, pp);                          pnode_printpara(p, pp);
                         pnode_print(p, pp);                          pnode_print(p, pp);
                         pnode_unlink(pp);                          pnode_unlink(pp);
                 }                  }
         assert(p->newln);          assert(p->newln);
   
         if (NODE_ORDEREDLIST == pn->node)          if (pn->node == NODE_ORDEREDLIST)
                 puts(".Bl -enum");                  puts(".Bl -enum");
         else          else
                 puts(".Bl -bullet");                  puts(".Bl -bullet");
Line 1243  pnode_printvariablelist(struct parse *p, struct pnode 
Line 1230  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 (pp->node == NODE_TITLE) {
                         pnode_printpara(p, pp);                          pnode_printpara(p, pp);
                         pnode_print(p, pp);                          pnode_print(p, pp);
                         pnode_unlink(pp);                          pnode_unlink(pp);
Line 1252  pnode_printvariablelist(struct parse *p, struct pnode 
Line 1239  pnode_printvariablelist(struct parse *p, struct pnode 
         assert(p->newln);          assert(p->newln);
         puts(".Bl -tag -width Ds");          puts(".Bl -tag -width Ds");
         TAILQ_FOREACH(pp, &pn->childq, child)          TAILQ_FOREACH(pp, &pn->childq, child)
                 if (NODE_VARLISTENTRY != pp->node) {                  if (pp->node != NODE_VARLISTENTRY) {
                         assert(p->newln);                          assert(p->newln);
                         fputs(".It", stdout);                          fputs(".It", stdout);
                         pnode_printmacroline(p, pp);                          pnode_printmacroline(p, pp);
Line 1278  pnode_print(struct parse *p, struct pnode *pn)
Line 1265  pnode_print(struct parse *p, struct pnode *pn)
         char            *cp;          char            *cp;
         int              last, sv;          int              last, sv;
   
         if (NULL == pn)          if (pn == NULL)
                 return;                  return;
   
         sv = p->newln;          sv = p->newln;
Line 1383  pnode_print(struct parse *p, struct pnode *pn)
Line 1370  pnode_print(struct parse *p, struct pnode *pn)
                 break;                  break;
         case NODE_LINK:          case NODE_LINK:
                 ccp = pnode_getattr_raw(pn, ATTRKEY_LINKEND, NULL);                  ccp = pnode_getattr_raw(pn, ATTRKEY_LINKEND, NULL);
                 if (NULL == ccp)                  if (ccp == NULL)
                         break;                          break;
                 pnode_printmopen(p);                  pnode_printmopen(p);
                 printf("Sx %s\n", ccp);                  printf("Sx %s\n", ccp);
Line 1442  pnode_print(struct parse *p, struct pnode *pn)
Line 1429  pnode_print(struct parse *p, struct pnode *pn)
         case NODE_PROGRAMLISTING:          case NODE_PROGRAMLISTING:
         case NODE_SCREEN:          case NODE_SCREEN:
                 assert(p->newln);                  assert(p->newln);
                 printf(".Bd %s\n", ATTRVAL_MONOSPACED ==                  printf(".Bd %s\n", pnode_getattr(pn, ATTRKEY_CLASS) ==
                     pnode_getattr(pn, ATTRKEY_CLASS) ?                      ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");
                     "-literal" : "-unfilled");  
                 break;                  break;
         case NODE_REFENTRYINFO:          case NODE_REFENTRYINFO:
                 /* Suppress. */                  /* Suppress. */
Line 1507  pnode_print(struct parse *p, struct pnode *pn)
Line 1493  pnode_print(struct parse *p, struct pnode *pn)
                 pnode_unlinksub(pn);                  pnode_unlinksub(pn);
                 break;                  break;
         case NODE_TEXT:          case NODE_TEXT:
                 if (0 == p->newln)                  if (p->newln == 0)
                         putchar(' ');                          putchar(' ');
   
                 bufclear(p);                  bufclear(p);
                 bufappend(p, pn);                  bufappend(p, pn);
   
                 if (0 == p->bsz) {                  if (p->bsz == 0) {
                         assert(pn->real != pn->b);                          assert(pn->real != pn->b);
                         break;                          break;
                 }                  }
Line 1532  pnode_print(struct parse *p, struct pnode *pn)
Line 1518  pnode_print(struct parse *p, struct pnode *pn)
                  * before the actual flags themselves.                   * before the actual flags themselves.
                  * "Fl" does this for us, so remove it.                   * "Fl" does this for us, so remove it.
                  */                   */
                 if (NULL != pn->parent &&                  if (pn->parent != NULL &&
                         NODE_OPTION == pn->parent->node &&                      pn->parent->node == NODE_OPTION &&
                         '-' == *cp)                      *cp == '-')
                         cp++;                          cp++;
                 for (last = '\n'; '\0' != *cp; ) {                  for (last = '\n'; *cp != '\0'; ) {
                         if ('\n' == last) {                          if (last == '\n') {
                                 /* Consume all whitespace. */                                  /* Consume all whitespace. */
                                 if (isspace((unsigned char)*cp)) {                                  if (isspace((unsigned char)*cp)) {
                                         while (isspace((unsigned char)*cp))                                          while (isspace((unsigned char)*cp))
                                                 cp++;                                                  cp++;
                                         continue;                                          continue;
                                 } else if ('\'' == *cp || '.' == *cp)                                  } else if (*cp == '\'' || *cp == '.')
                                         fputs("\\&", stdout);                                          fputs("\\&", stdout);
                         }                          }
                         putchar(last = *cp++);                          putchar(last = *cp++);
                         /* If we're a character escape, escape us. */                          /* If we're a character escape, escape us. */
                         if ('\\' == last)                          if (last == '\\')
                                 putchar('e');                                  putchar('e');
                 }                  }
                 p->newln = 0;                  p->newln = 0;
Line 1646  pnode_print(struct parse *p, struct pnode *pn)
Line 1632  pnode_print(struct parse *p, struct pnode *pn)
                  * <refname> macros in sequence, then print out a                   * <refname> macros in sequence, then print out a
                  * trailing comma before the newline.                   * trailing comma before the newline.
                  */                   */
                 if (NULL != pn->parent &&                  if (pn->parent != NULL &&
                         NODE_REFNAMEDIV == pn->parent->node &&                      pn->parent->node == NODE_REFNAMEDIV &&
                         NULL != TAILQ_NEXT(pn, child) &&                      TAILQ_NEXT(pn, child) != NULL &&
                         NODE_REFNAME == TAILQ_NEXT(pn, child)->node)                      TAILQ_NEXT(pn, child)->node == NODE_REFNAME)
                         fputs(" ,", stdout);                          fputs(" ,", stdout);
                 pnode_printmclose(p, sv);                  pnode_printmclose(p, sv);
                 break;                  break;
Line 1702  readfile(XML_Parser xp, int fd,
Line 1688  readfile(XML_Parser xp, int fd,
         XML_SetUserData(xp, &p);          XML_SetUserData(xp, &p);
   
         while ((ssz = read(fd, b, bsz)) >= 0) {          while ((ssz = read(fd, b, bsz)) >= 0) {
                 if (0 == (rc = XML_Parse(xp, b, ssz, 0 == ssz)))                  if ((rc = XML_Parse(xp, b, ssz, 0 == ssz)) == 0)
                         fprintf(stderr, "%s:%zu:%zu: %s\n", fn,                          fprintf(stderr, "%s:%zu:%zu: %s\n", fn,
                                 XML_GetCurrentLineNumber(xp),                                  XML_GetCurrentLineNumber(xp),
                                 XML_GetCurrentColumnNumber(xp),                                  XML_GetCurrentColumnNumber(xp),
Line 1749  main(int argc, char *argv[])
Line 1735  main(int argc, char *argv[])
         buf = NULL;          buf = NULL;
         rc = 1;          rc = 1;
   
         while (-1 != (ch = getopt(argc, argv, "W")))          while ((ch = getopt(argc, argv, "W")) != -1)
                 switch (ch) {                  switch (ch) {
                 case 'W':                  case 'W':
                         warn = 1;                          warn = 1;
Line 1768  main(int argc, char *argv[])
Line 1754  main(int argc, char *argv[])
                 fname = argv[0];                  fname = argv[0];
   
         /* Read from stdin or a file. */          /* Read from stdin or a file. */
         fd = 0 == strcmp(fname, "-") ?          fd = strcmp(fname, "-") == 0 ?
                 STDIN_FILENO : open(fname, O_RDONLY, 0);                  STDIN_FILENO : open(fname, O_RDONLY, 0);
   
         /*          /*
Line 1777  main(int argc, char *argv[])
Line 1763  main(int argc, char *argv[])
          * Create the parser context.           * Create the parser context.
          * Dive directly into the parse.           * Dive directly into the parse.
          */           */
         if (-1 == fd)          if (fd == -1)
                 perror(fname);                  perror(fname);
         else if (NULL == (buf = malloc(4096)))          else if ((buf = malloc(4096)) == NULL)
                 perror(NULL);                  perror(NULL);
         else if (NULL == (xp = XML_ParserCreate(NULL)))          else if ((xp = XML_ParserCreate(NULL)) == NULL)
                 perror(NULL);                  perror(NULL);
         else if (readfile(xp, fd, buf, 4096, fname))          else if (readfile(xp, fd, buf, 4096, fname))
                 rc = 0;                  rc = 0;
   
         XML_ParserFree(xp);          XML_ParserFree(xp);
         free(buf);          free(buf);
         if (STDIN_FILENO != fd)          if (fd != STDIN_FILENO)
                 close(fd);                  close(fd);
         return rc;          return rc;
   
Legend:
Removed from v.1.63  
changed lines
  Added in v.1.64
CVSweb