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

Diff for /docbook2mdoc/parse.c between version 1.24 and 1.33

version 1.24, 2019/04/08 22:47:34 version 1.33, 2019/04/12 04:17:11
Line 213  static const struct element elements[] = {
Line 213  static const struct element elements[] = {
         { "varname",            NODE_VARNAME },          { "varname",            NODE_VARNAME },
         { "warning",            NODE_WARNING },          { "warning",            NODE_WARNING },
         { "wordasword",         NODE_WORDASWORD },          { "wordasword",         NODE_WORDASWORD },
         { "xi:include",         NODE_DELETE_WARN },          { "xi:include",         NODE_INCLUDE },
         { "year",               NODE_YEAR },          { "year",               NODE_YEAR },
         { NULL,                 NODE_IGNORE }          { NULL,                 NODE_IGNORE }
 };  };
Line 280  static void  parse_fd(struct parse *, int);
Line 280  static void  parse_fd(struct parse *, int);
   
   
 static void  static void
   fatal(struct parse *p)
   {
           fprintf(stderr, "%s:%d:%d: FATAL: ", p->fname, p->line, p->col);
           perror(NULL);
           exit(6);
   }
   
   static void
 error_msg(struct parse *p, const char *fmt, ...)  error_msg(struct parse *p, const char *fmt, ...)
 {  {
         va_list          ap;          va_list          ap;
   
         fprintf(stderr, "%s:%d:%d: ", p->fname, p->line, p->col);          fprintf(stderr, "%s:%d:%d: ERROR: ", p->fname, p->line, p->col);
         va_start(ap, fmt);          va_start(ap, fmt);
         vfprintf(stderr, fmt, ap);          vfprintf(stderr, fmt, ap);
         va_end(ap);          va_end(ap);
         fputc('\n', stderr);          fputc('\n', stderr);
         p->tree->flags |= TREE_FAIL;          p->tree->flags |= TREE_ERROR;
 }  }
   
 static void  static void
Line 300  warn_msg(struct parse *p, const char *fmt, ...)
Line 308  warn_msg(struct parse *p, const char *fmt, ...)
         if ((p->flags & PFLAG_WARN) == 0)          if ((p->flags & PFLAG_WARN) == 0)
                 return;                  return;
   
         fprintf(stderr, "%s:%d:%d: warning: ", p->fname, p->line, p->col);          fprintf(stderr, "%s:%d:%d: WARNING: ", p->fname, p->line, p->col);
         va_start(ap, fmt);          va_start(ap, fmt);
         vfprintf(stderr, fmt, ap);          vfprintf(stderr, fmt, ap);
         va_end(ap);          va_end(ap);
         fputc('\n', stderr);          fputc('\n', stderr);
           p->tree->flags |= TREE_WARN;
 }  }
   
 /*  /*
Line 313  warn_msg(struct parse *p, const char *fmt, ...)
Line 322  warn_msg(struct parse *p, const char *fmt, ...)
  * Otherwise, create a new one as a child of the current node.   * Otherwise, create a new one as a child of the current node.
  */   */
 static void  static void
 xml_char(struct parse *ps, const char *p, int sz)  xml_char(struct parse *p, const char *word, int sz)
 {  {
         struct pnode    *dat;          struct pnode    *n;
         size_t           newsz;          size_t           oldsz, newsz;
   
         if (ps->del > 0)          assert(sz > 0);
           if (p->del > 0)
                 return;                  return;
   
         if (ps->cur == NULL) {          if ((n = p->cur) == NULL) {
                 error_msg(ps, "discarding text before document: %.*s", sz, p);                  error_msg(p, "discarding text before document: %.*s", sz, word);
                 return;                  return;
         }          }
   
         if (ps->cur->node != NODE_TEXT) {          if (n->node != NODE_TEXT) {
                 if ((dat = calloc(1, sizeof(*dat))) == NULL) {                  if ((n = calloc(1, sizeof(*n))) == NULL)
                         perror(NULL);                          fatal(p);
                         exit(1);                  n->node = NODE_TEXT;
                 }                  n->spc = (p->flags & PFLAG_SPC) != 0;
                 dat->node = NODE_TEXT;                  n->parent = p->cur;
                 dat->spc = (ps->flags & PFLAG_SPC) != 0;                  TAILQ_INIT(&n->childq);
                 dat->parent = ps->cur;                  TAILQ_INIT(&n->attrq);
                 TAILQ_INIT(&dat->childq);                  TAILQ_INSERT_TAIL(&p->cur->childq, n, child);
                 TAILQ_INIT(&dat->attrq);                  p->cur = n;
                 TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);  
                 ps->cur = dat;  
         }          }
   
         if (ps->tree->flags & TREE_CLOSED &&          if (p->tree->flags & TREE_CLOSED && n->parent == p->tree->root)
             ps->cur->parent == ps->tree->root)                  warn_msg(p, "text after end of document: %.*s", sz, word);
                 warn_msg(ps, "text after end of document: %.*s", sz, p);  
   
         /* Append to the current text node. */          /* Append to the current text node. */
   
         assert(sz >= 0);          oldsz = n->b == NULL ? 0 : strlen(n->b);
         newsz = ps->cur->bsz + (ps->cur->bsz && (ps->flags & PFLAG_SPC)) + sz;          newsz = oldsz + sz;
         ps->cur->b = realloc(ps->cur->b, newsz + 1);          if (oldsz && (p->flags & PFLAG_SPC))
         if (ps->cur->b == NULL) {                  newsz++;
                 perror(NULL);          if ((n->b = realloc(n->b, newsz + 1)) == NULL)
                 exit(1);                  fatal(p);
         }          if (oldsz && (p->flags & PFLAG_SPC))
         if (ps->cur->bsz && (ps->flags & PFLAG_SPC))                  n->b[oldsz++] = ' ';
                 ps->cur->b[ps->cur->bsz++] = ' ';          memcpy(n->b + oldsz, word, sz);
         memcpy(ps->cur->b + ps->cur->bsz, p, sz);          n->b[newsz] = '\0';
         ps->cur->b[ps->cur->bsz = newsz] = '\0';          p->flags &= ~PFLAG_SPC;
         ps->cur->real = ps->cur->b;  
         ps->flags &= ~PFLAG_SPC;  
 }  }
   
 /*  /*
Line 368  static void
Line 373  static void
 pnode_closetext(struct parse *p)  pnode_closetext(struct parse *p)
 {  {
         struct pnode    *n;          struct pnode    *n;
           char            *cp;
   
         if ((n = p->cur) == NULL || n->node != NODE_TEXT)          if ((n = p->cur) == NULL || n->node != NODE_TEXT)
                 return;                  return;
         p->cur = n->parent;          p->cur = n->parent;
         while (n->bsz > 0 && isspace((unsigned char)n->b[n->bsz - 1])) {          for (cp = strchr(n->b, '\0');
                 n->b[--n->bsz] = '\0';              cp > n->b && isspace((unsigned char)cp[-1]);
               *--cp = '\0')
                 p->flags |= PFLAG_SPC;                  p->flags |= PFLAG_SPC;
         }  
 }  }
   
 static void  static void
 xml_entity(struct parse *p, const char *name)  xml_entity(struct parse *p, const char *name)
 {  {
         const struct entity     *entity;          const struct entity     *entity;
         struct pnode            *dat;          struct pnode            *n;
         const char              *ccp;          const char              *ccp;
         char                    *cp;          char                    *cp;
         enum pstate              pstate;          enum pstate              pstate;
Line 406  xml_entity(struct parse *p, const char *name)
Line 412  xml_entity(struct parse *p, const char *name)
   
         if (entity->roff == NULL) {          if (entity->roff == NULL) {
                 if (p->doctype != NULL) {                  if (p->doctype != NULL) {
                         TAILQ_FOREACH(dat, &p->doctype->childq, child) {                          TAILQ_FOREACH(n, &p->doctype->childq, child) {
                                 if ((ccp = pnode_getattr_raw(dat,                                  if ((ccp = pnode_getattr_raw(n,
                                      ATTRKEY_NAME, NULL)) == NULL ||                                       ATTRKEY_NAME, NULL)) == NULL ||
                                     strcmp(ccp, name) != 0 ||                                      strcmp(ccp, name) != 0)
                                     (ccp = pnode_getattr_raw(dat,  
                                      ATTRKEY_DEFINITION, NULL)) == NULL)  
                                         continue;                                          continue;
                                 if ((cp = strdup(ccp)) == NULL) {                                  if ((ccp = pnode_getattr_raw(n,
                                         perror(NULL);                                      ATTRKEY_SYSTEM, NULL)) != NULL) {
                                         exit(1);                                          parse_file(p, -1, ccp);
                                           p->flags &= ~PFLAG_SPC;
                                           return;
                                 }                                  }
                                   if ((ccp = pnode_getattr_raw(n,
                                        ATTRKEY_DEFINITION, NULL)) == NULL)
                                           continue;
                                   if ((cp = strdup(ccp)) == NULL)
                                           fatal(p);
                                 pstate = PARSE_ELEM;                                  pstate = PARSE_ELEM;
                                 parse_string(p, cp, strlen(cp), &pstate, 0);                                  parse_string(p, cp, strlen(cp), &pstate, 0);
                                 p->flags &= ~PFLAG_SPC;                                  p->flags &= ~PFLAG_SPC;
Line 429  xml_entity(struct parse *p, const char *name)
Line 440  xml_entity(struct parse *p, const char *name)
         }          }
   
         /* Create, append, and close out an entity node. */          /* Create, append, and close out an entity node. */
         if ((dat = calloc(1, sizeof(*dat))) == NULL ||          if ((n = calloc(1, sizeof(*n))) == NULL ||
             (dat->b = dat->real = strdup(entity->roff)) == NULL) {              (n->b = strdup(entity->roff)) == NULL)
                 perror(NULL);                  fatal(p);
                 exit(1);          n->node = NODE_ESCAPE;
         }          n->spc = (p->flags & PFLAG_SPC) != 0;
         dat->node = NODE_ESCAPE;          n->parent = p->cur;
         dat->bsz = strlen(dat->b);          TAILQ_INIT(&n->childq);
         dat->spc = (p->flags & PFLAG_SPC) != 0;          TAILQ_INIT(&n->attrq);
         dat->parent = p->cur;          TAILQ_INSERT_TAIL(&p->cur->childq, n, child);
         TAILQ_INIT(&dat->childq);  
         TAILQ_INIT(&dat->attrq);  
         TAILQ_INSERT_TAIL(&p->cur->childq, dat, child);  
         p->flags &= ~PFLAG_SPC;          p->flags &= ~PFLAG_SPC;
 }  }
   
Line 448  xml_entity(struct parse *p, const char *name)
Line 456  xml_entity(struct parse *p, const char *name)
  * Begin an element.   * Begin an element.
  */   */
 static void  static void
 xml_elem_start(struct parse *ps, const char *name)  xml_elem_start(struct parse *p, const char *name)
 {  {
         const struct element    *elem;          const struct element    *elem;
         struct pnode            *dat;          struct pnode            *n;
   
         /*          /*
          * An ancestor is excluded from the tree;           * An ancestor is excluded from the tree;
          * keep track of the number of levels excluded.           * keep track of the number of levels excluded.
          */           */
         if (ps->del > 0) {          if (p->del > 0) {
                 if (*name != '!' && *name != '?')                  if (*name != '!' && *name != '?')
                         ps->del++;                          p->del++;
                 return;                  return;
         }          }
   
         pnode_closetext(ps);          pnode_closetext(p);
   
         for (elem = elements; elem->name != NULL; elem++)          for (elem = elements; elem->name != NULL; elem++)
                 if (strcmp(elem->name, name) == 0)                  if (strcmp(elem->name, name) == 0)
Line 472  xml_elem_start(struct parse *ps, const char *name)
Line 480  xml_elem_start(struct parse *ps, const char *name)
         if (elem->name == NULL) {          if (elem->name == NULL) {
                 if (*name == '!' || *name == '?')                  if (*name == '!' || *name == '?')
                         return;                          return;
                 error_msg(ps, "unknown element <%s>", name);                  error_msg(p, "unknown element <%s>", name);
         }          }
   
         ps->ncur = elem->node;          p->ncur = elem->node;
   
         switch (ps->ncur) {          switch (p->ncur) {
         case NODE_DELETE_WARN:          case NODE_DELETE_WARN:
                 warn_msg(ps, "skipping element <%s>", name);                  warn_msg(p, "skipping element <%s>", name);
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case NODE_DELETE:          case NODE_DELETE:
                 ps->del = 1;                  p->del = 1;
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case NODE_IGNORE:          case NODE_IGNORE:
                 return;                  return;
         case NODE_INLINEEQUATION:          case NODE_INLINEEQUATION:
                 ps->tree->flags |= TREE_EQN;                  p->tree->flags |= TREE_EQN;
                 break;                  break;
         default:          default:
                 break;                  break;
         }          }
   
         if (ps->tree->flags & TREE_CLOSED && ps->cur->parent == NULL)          if (p->tree->flags & TREE_CLOSED && p->cur->parent == NULL)
                 warn_msg(ps, "element after end of document: <%s>", name);                  warn_msg(p, "element after end of document: <%s>", name);
   
         if ((dat = calloc(1, sizeof(*dat))) == NULL) {          if ((n = calloc(1, sizeof(*n))) == NULL)
                 perror(NULL);                  fatal(p);
                 exit(1);  
         }  
   
         /*          /*
          * Nodes that begin a new macro or request line or start by           * Nodes that begin a new macro or request line or start by
          * printing text always want whitespace before themselves.           * printing text always want whitespace before themselves.
          */           */
   
         switch (dat->node = elem->node) {          switch (n->node = elem->node) {
         case NODE_DOCTYPE:          case NODE_DOCTYPE:
         case NODE_ENTITY:          case NODE_ENTITY:
         case NODE_SBR:          case NODE_SBR:
                 ps->flags |= PFLAG_EEND;                  p->flags |= PFLAG_EEND;
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case NODE_APPENDIX:          case NODE_APPENDIX:
         case NODE_AUTHORGROUP:          case NODE_AUTHORGROUP:
Line 544  xml_elem_start(struct parse *ps, const char *name)
Line 550  xml_elem_start(struct parse *ps, const char *name)
         case NODE_VARIABLELIST:          case NODE_VARIABLELIST:
         case NODE_VARLISTENTRY:          case NODE_VARLISTENTRY:
         case NODE_WARNING:          case NODE_WARNING:
                 dat->spc = 1;                  n->spc = 1;
                 break;                  break;
         default:          default:
                 dat->spc = (ps->flags & PFLAG_SPC) != 0;                  n->spc = (p->flags & PFLAG_SPC) != 0;
                 break;                  break;
         }          }
         dat->parent = ps->cur;          n->parent = p->cur;
         TAILQ_INIT(&dat->childq);          TAILQ_INIT(&n->childq);
         TAILQ_INIT(&dat->attrq);          TAILQ_INIT(&n->attrq);
   
         if (ps->cur != NULL)          if (p->cur != NULL)
                 TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);                  TAILQ_INSERT_TAIL(&p->cur->childq, n, child);
   
         ps->cur = dat;          p->cur = n;
         if (dat->node == NODE_DOCTYPE) {          if (n->node == NODE_DOCTYPE) {
                 if (ps->doctype == NULL)                  if (p->doctype == NULL)
                         ps->doctype = dat;                          p->doctype = n;
                 else                  else
                         error_msg(ps, "duplicate doctype");                          error_msg(p, "duplicate doctype");
         } else if (dat->parent == NULL && ps->tree->root == NULL)          } else if (n->parent == NULL && p->tree->root == NULL)
                 ps->tree->root = dat;                  p->tree->root = n;
 }  }
   
 static void  static void
 xml_attrkey(struct parse *ps, const char *name)  xml_attrkey(struct parse *p, const char *name)
 {  {
         struct pattr    *attr;          struct pattr    *a;
         const char      *value;          const char      *value;
         enum attrkey     key;          enum attrkey     key;
   
         if (ps->del > 0 || ps->ncur == NODE_IGNORE || *name == '\0')          if (p->del > 0 || p->ncur == NODE_IGNORE || *name == '\0')
                 return;                  return;
   
         if ((ps->ncur == NODE_DOCTYPE || ps->ncur == NODE_ENTITY) &&          if ((p->ncur == NODE_DOCTYPE || p->ncur == NODE_ENTITY) &&
             TAILQ_FIRST(&ps->cur->attrq) == NULL) {              TAILQ_FIRST(&p->cur->attrq) == NULL) {
                 value = name;                  value = name;
                 name = "NAME";                  name = "NAME";
         } else          } else
                 value = NULL;                  value = NULL;
   
         if ((key = attrkey_parse(name)) == ATTRKEY__MAX) {          if ((key = attrkey_parse(name)) == ATTRKEY__MAX) {
                 ps->flags &= ~PFLAG_ATTR;                  p->flags &= ~PFLAG_ATTR;
                 return;                  return;
         }          }
         if ((attr = calloc(1, sizeof(*attr))) == NULL) {          if ((a = calloc(1, sizeof(*a))) == NULL)
                 perror(NULL);                  fatal(p);
                 exit(1);  
         }          a->key = key;
         attr->key = key;          a->val = ATTRVAL__MAX;
         attr->val = ATTRVAL__MAX;  
         if (value == NULL) {          if (value == NULL) {
                 attr->rawval = NULL;                  a->rawval = NULL;
                 ps->flags |= PFLAG_ATTR;                  p->flags |= PFLAG_ATTR;
         } else {          } else {
                 if ((attr->rawval = strdup(value)) == NULL) {                  if ((a->rawval = strdup(value)) == NULL)
                         perror(NULL);                          fatal(p);
                         exit(1);                  p->flags &= ~PFLAG_ATTR;
                 }  
                 ps->flags &= ~PFLAG_ATTR;  
         }          }
         TAILQ_INSERT_TAIL(&ps->cur->attrq, attr, child);          TAILQ_INSERT_TAIL(&p->cur->attrq, a, child);
         if (ps->ncur == NODE_ENTITY && key == ATTRKEY_NAME)          if (p->ncur == NODE_ENTITY && key == ATTRKEY_NAME)
                 xml_attrkey(ps, "DEFINITION");                  xml_attrkey(p, "DEFINITION");
 }  }
   
 static void  static void
 xml_attrval(struct parse *ps, const char *name)  xml_attrval(struct parse *p, const char *name)
 {  {
         struct pattr    *attr;          struct pattr    *a;
   
         if (ps->del > 0 || ps->ncur == NODE_IGNORE ||          if (p->del > 0 || p->ncur == NODE_IGNORE ||
             (ps->flags & PFLAG_ATTR) == 0)              (p->flags & PFLAG_ATTR) == 0)
                 return;                  return;
         if ((attr = TAILQ_LAST(&ps->cur->attrq, pattrq)) == NULL)          if ((a = TAILQ_LAST(&p->cur->attrq, pattrq)) == NULL)
                 return;                  return;
         if ((attr->val = attrval_parse(name)) == ATTRVAL__MAX &&          if ((a->val = attrval_parse(name)) == ATTRVAL__MAX &&
             (attr->rawval = strdup(name)) == NULL) {              (a->rawval = strdup(name)) == NULL)
                 perror(NULL);                  fatal(p);
                 exit(1);          p->flags &= ~PFLAG_ATTR;
         }  
 }  }
   
 /*  /*
Line 631  xml_attrval(struct parse *ps, const char *name)
Line 633  xml_attrval(struct parse *ps, const char *name)
  * If we're at a text node, roll that one up first.   * If we're at a text node, roll that one up first.
  */   */
 static void  static void
 xml_elem_end(struct parse *ps, const char *name)  xml_elem_end(struct parse *p, const char *name)
 {  {
         const struct element    *elem;          const struct element    *elem;
           struct pnode            *n;
           const char              *cp;
         enum nodeid              node;          enum nodeid              node;
   
         /*          /*
          * An ancestor is excluded from the tree;           * An ancestor is excluded from the tree;
          * keep track of the number of levels excluded.           * keep track of the number of levels excluded.
          */           */
         if (ps->del > 1) {          if (p->del > 1) {
                 ps->del--;                  p->del--;
                 return;                  return;
         }          }
   
         if (ps->del == 0)          if (p->del == 0)
                 pnode_closetext(ps);                  pnode_closetext(p);
   
         if (name != NULL) {          if (name != NULL) {
                 for (elem = elements; elem->name != NULL; elem++)                  for (elem = elements; elem->name != NULL; elem++)
Line 654  xml_elem_end(struct parse *ps, const char *name)
Line 658  xml_elem_end(struct parse *ps, const char *name)
                                 break;                                  break;
                 node = elem->node;                  node = elem->node;
         } else          } else
                 node = ps->ncur;                  node = p->ncur;
   
         switch (node) {          switch (node) {
         case NODE_DELETE_WARN:          case NODE_DELETE_WARN:
         case NODE_DELETE:          case NODE_DELETE:
                 if (ps->del > 0)                  if (p->del > 0)
                         ps->del--;                          p->del--;
                 break;                  break;
         case NODE_IGNORE:          case NODE_IGNORE:
                 break;                  break;
           case NODE_INCLUDE:
                   n = p->cur;
                   p->cur = p->cur->parent;
                   cp = pnode_getattr_raw(n, ATTRKEY_HREF, NULL);
                   if (cp == NULL)
                           error_msg(p, "<xi:include> element "
                               "without href attribute");
                   else
                           parse_file(p, -1, cp);
                   pnode_unlink(n);
                   p->flags &= ~PFLAG_SPC;
                   break;
         case NODE_DOCTYPE:          case NODE_DOCTYPE:
                 ps->flags &= ~PFLAG_EEND;          case NODE_SBR:
                   p->flags &= ~PFLAG_EEND;
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         default:          default:
                 if (ps->cur == NULL || node != ps->cur->node) {                  if (p->cur == NULL || node != p->cur->node) {
                         warn_msg(ps, "element not open: </%s>", name);                          warn_msg(p, "element not open: </%s>", name);
                         break;                          break;
                 }                  }
   
Line 680  xml_elem_end(struct parse *ps, const char *name)
Line 697  xml_elem_end(struct parse *ps, const char *name)
                  * obviously better than discarding it or crashing.                   * obviously better than discarding it or crashing.
                  */                   */
   
                 if (ps->cur->parent != NULL || node == NODE_DOCTYPE) {                  if (p->cur->parent != NULL || node == NODE_DOCTYPE) {
                         ps->cur = ps->cur->parent;                          p->cur = p->cur->parent;
                         if (ps->cur != NULL)                          if (p->cur != NULL)
                                 ps->ncur = ps->cur->node;                                  p->ncur = p->cur->node;
                 } else                  } else
                         ps->tree->flags |= TREE_CLOSED;                          p->tree->flags |= TREE_CLOSED;
                 ps->flags &= ~PFLAG_SPC;                  p->flags &= ~PFLAG_SPC;
                 break;                  break;
         }          }
         assert(ps->del == 0);          assert(p->del == 0);
 }  }
   
 struct parse *  struct parse *
Line 954  parse_string(struct parse *p, char *b, size_t rlen,
Line 971  parse_string(struct parse *p, char *b, size_t rlen,
                 /* Process text up to the next tag, entity, or EOL. */                  /* Process text up to the next tag, entity, or EOL. */
   
                 } else {                  } else {
                         advance(p, b, rlen, &pend, "<&", refill);                          advance(p, b, rlen, &pend,
                               p->ncur == NODE_DOCTYPE ? "<&]\n" : "<&\n",
                               refill);
                         xml_char(p, b + poff, pend - poff);                          xml_char(p, b + poff, pend - poff);
                           if (b[pend] == '\n')
                                   pnode_closetext(p);
                 }                  }
         }          }
         return poff;          return poff;
Legend:
Removed from v.1.24  
changed lines
  Added in v.1.33
CVSweb