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

Diff for /docbook2mdoc/parse.c between version 1.10 and 1.55

version 1.10, 2019/04/03 11:23:48 version 1.55, 2019/04/29 02:00:50
Line 15 
Line 15 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
   #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
   #include <errno.h>
   #include <fcntl.h>
   #include <libgen.h>
 #include <stdarg.h>  #include <stdarg.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
   #include "xmalloc.h"
 #include "node.h"  #include "node.h"
 #include "parse.h"  #include "parse.h"
   
Line 30 
Line 36 
  * The implementation of the DocBook parser.   * The implementation of the DocBook parser.
  */   */
   
   enum    pstate {
           PARSE_ELEM,
           PARSE_TAG,
           PARSE_ARG,
           PARSE_SQ,
           PARSE_DQ
   };
   
 /*  /*
  * Global parse state.   * Global parse state.
  * Keep this as simple and small as possible.   * Keep this as simple and small as possible.
Line 37 
Line 51 
 struct  parse {  struct  parse {
         const char      *fname;  /* Name of the input file. */          const char      *fname;  /* Name of the input file. */
         struct ptree    *tree;   /* Complete parse result. */          struct ptree    *tree;   /* Complete parse result. */
           struct pnode    *doctype;
         struct pnode    *cur;    /* Current node in the tree. */          struct pnode    *cur;    /* Current node in the tree. */
         enum nodeid      ncur;   /* Type of the current node. */          enum nodeid      ncur;   /* Type of the current node. */
         int              line;   /* Line number in the input file. */          int              line;   /* Line number in the input file. */
Line 44  struct parse {
Line 59  struct parse {
         int              nline;  /* Line number of next token. */          int              nline;  /* Line number of next token. */
         int              ncol;   /* Column number of next token. */          int              ncol;   /* Column number of next token. */
         int              del;    /* Levels of nested nodes being deleted. */          int              del;    /* Levels of nested nodes being deleted. */
         int              attr;   /* The most recent attribute is valid. */          int              nofill; /* Levels of open no-fill displays. */
         int              warn;          int              flags;
   #define PFLAG_WARN       (1 << 0)  /* Print warning messages. */
   #define PFLAG_LINE       (1 << 1)  /* New line before the next element. */
   #define PFLAG_SPC        (1 << 2)  /* Whitespace before the next element. */
   #define PFLAG_ATTR       (1 << 3)  /* The most recent attribute is valid. */
   #define PFLAG_EEND       (1 << 4)  /* This element is self-closing. */
 };  };
   
 struct  element {  struct  alias {
         const char      *name;   /* DocBook element name. */          const char      *name;   /* DocBook element name. */
         enum nodeid      node;   /* Node type to generate. */          enum nodeid      node;   /* Node type to generate. */
 };  };
   
 static  const struct element elements[] = {  static  const struct alias aliases[] = {
         { "acronym",            NODE_IGNORE },          { "acronym",            NODE_IGNORE },
         { "affiliation",        NODE_AFFILIATION },          { "affiliation",        NODE_IGNORE },
         { "anchor",             NODE_DELETE },          { "anchor",             NODE_DELETE },
         { "application",        NODE_APPLICATION },          { "application",        NODE_COMMAND },
         { "arg",                NODE_ARG },          { "article",            NODE_SECTION },
         { "author",             NODE_AUTHOR },          { "articleinfo",        NODE_BOOKINFO },
         { "authorgroup",        NODE_AUTHORGROUP },          { "book",               NODE_SECTION },
         { "blockquote",         NODE_BLOCKQUOTE },  
         { "book",               NODE_BOOK },  
         { "bookinfo",           NODE_BOOKINFO },  
         { "caution",            NODE_CAUTION },  
         { "chapter",            NODE_SECTION },          { "chapter",            NODE_SECTION },
         { "citerefentry",       NODE_CITEREFENTRY },          { "caption",            NODE_IGNORE },
         { "citetitle",          NODE_CITETITLE },          { "code",               NODE_LITERAL },
         { "cmdsynopsis",        NODE_CMDSYNOPSIS },          { "computeroutput",     NODE_LITERAL },
         { "code",               NODE_CODE },          { "!doctype",           NODE_DOCTYPE },
         { "colspec",            NODE_COLSPEC },          { "figure",             NODE_IGNORE },
         { "command",            NODE_COMMAND },  
         { "constant",           NODE_CONSTANT },  
         { "contrib",            NODE_CONTRIB },  
         { "copyright",          NODE_COPYRIGHT },  
         { "date",               NODE_DATE },  
         { "editor",             NODE_EDITOR },  
         { "email",              NODE_EMAIL },  
         { "emphasis",           NODE_EMPHASIS },  
         { "entry",              NODE_ENTRY },  
         { "envar",              NODE_ENVAR },  
         { "fieldsynopsis",      NODE_FIELDSYNOPSIS },  
         { "filename",           NODE_FILENAME },  
         { "firstname",          NODE_PERSONNAME },          { "firstname",          NODE_PERSONNAME },
         { "firstterm",          NODE_FIRSTTERM },          { "glossary",           NODE_VARIABLELIST },
         { "footnote",           NODE_FOOTNOTE },          { "glossdef",           NODE_IGNORE },
         { "funcdef",            NODE_FUNCDEF },          { "glossdiv",           NODE_IGNORE },
         { "funcprototype",      NODE_FUNCPROTOTYPE },          { "glossentry",         NODE_VARLISTENTRY },
         { "funcsynopsis",       NODE_FUNCSYNOPSIS },          { "glosslist",          NODE_VARIABLELIST },
         { "funcsynopsisinfo",   NODE_FUNCSYNOPSISINFO },          { "holder",             NODE_IGNORE },
         { "function",           NODE_FUNCTION },          { "imageobject",        NODE_IGNORE },
         { "glossterm",          NODE_GLOSSTERM },  
         { "group",              NODE_GROUP },  
         { "holder",             NODE_HOLDER },  
         { "index",              NODE_INDEX },  
         { "indexterm",          NODE_DELETE },          { "indexterm",          NODE_DELETE },
         { "info",               NODE_INFO },          { "informaltable",      NODE_TABLE },
         { "informalequation",   NODE_INFORMALEQUATION },          { "keycap",             NODE_KEYSYM },
         { "informaltable",      NODE_INFORMALTABLE },          { "keycode",            NODE_IGNORE },
         { "inlineequation",     NODE_INLINEEQUATION },          { "keycombo",           NODE_IGNORE },
         { "itemizedlist",       NODE_ITEMIZEDLIST },          { "mediaobject",        NODE_BLOCKQUOTE },
         { "keysym",             NODE_KEYSYM },          { "orgname",            NODE_IGNORE },
         { "legalnotice",        NODE_LEGALNOTICE },          { "othercredit",        NODE_AUTHOR },
         { "link",               NODE_LINK },  
         { "listitem",           NODE_LISTITEM },  
         { "literal",            NODE_LITERAL },  
         { "literallayout",      NODE_LITERALLAYOUT },  
         { "manvolnum",          NODE_MANVOLNUM },  
         { "member",             NODE_MEMBER },  
         { "mml:math",           NODE_MML_MATH },  
         { "mml:mfenced",        NODE_MML_MFENCED },  
         { "mml:mfrac",          NODE_MML_MFRAC },  
         { "mml:mi",             NODE_MML_MI },  
         { "mml:mn",             NODE_MML_MN },  
         { "mml:mo",             NODE_MML_MO },  
         { "mml:mrow",           NODE_MML_MROW },  
         { "mml:msub",           NODE_MML_MSUB },  
         { "mml:msup",           NODE_MML_MSUP },  
         { "modifier",           NODE_MODIFIER },  
         { "note",               NODE_NOTE },  
         { "option",             NODE_OPTION },  
         { "orderedlist",        NODE_ORDEREDLIST },  
         { "orgname",            NODE_ORGNAME },  
         { "othername",          NODE_PERSONNAME },          { "othername",          NODE_PERSONNAME },
         { "para",               NODE_PARA },  
         { "paramdef",           NODE_PARAMDEF },  
         { "parameter",          NODE_PARAMETER },  
         { "part",               NODE_SECTION },          { "part",               NODE_SECTION },
         { "personname",         NODE_PERSONNAME },  
         { "phrase",             NODE_IGNORE },          { "phrase",             NODE_IGNORE },
         { "preface",            NODE_PREFACE },  
         { "primary",            NODE_DELETE },          { "primary",            NODE_DELETE },
         { "programlisting",     NODE_PROGRAMLISTING },          { "property",           NODE_PARAMETER },
         { "prompt",             NODE_PROMPT },          { "reference",          NODE_SECTION },
         { "quote",              NODE_QUOTE },  
         { "refclass",           NODE_REFCLASS },  
         { "refdescriptor",      NODE_REFDESCRIPTOR },  
         { "refentry",           NODE_REFENTRY },  
         { "refentryinfo",       NODE_REFENTRYINFO },  
         { "refentrytitle",      NODE_REFENTRYTITLE },  
         { "refmeta",            NODE_REFMETA },  
         { "refmetainfo",        NODE_REFMETAINFO },  
         { "refmiscinfo",        NODE_REFMISCINFO },  
         { "refname",            NODE_REFNAME },  
         { "refnamediv",         NODE_REFNAMEDIV },  
         { "refpurpose",         NODE_REFPURPOSE },  
         { "refsect1",           NODE_SECTION },          { "refsect1",           NODE_SECTION },
         { "refsect2",           NODE_SECTION },          { "refsect2",           NODE_SECTION },
         { "refsect3",           NODE_SECTION },          { "refsect3",           NODE_SECTION },
         { "refsection",         NODE_SECTION },          { "refsection",         NODE_SECTION },
         { "refsynopsisdiv",     NODE_REFSYNOPSISDIV },          { "releaseinfo",        NODE_IGNORE },
         { "releaseinfo",        NODE_RELEASEINFO },          { "returnvalue",        NODE_IGNORE },
         { "replaceable",        NODE_REPLACEABLE },  
         { "row",                NODE_ROW },  
         { "sbr",                NODE_SBR },  
         { "screen",             NODE_SCREEN },  
         { "secondary",          NODE_DELETE },          { "secondary",          NODE_DELETE },
         { "sect1",              NODE_SECTION },          { "sect1",              NODE_SECTION },
         { "sect2",              NODE_SECTION },          { "sect2",              NODE_SECTION },
         { "section",            NODE_SECTION },          { "sect3",              NODE_SECTION },
         { "sgmltag",            NODE_SGMLTAG },          { "sect4",              NODE_SECTION },
         { "simplelist",         NODE_SIMPLELIST },          { "sgmltag",            NODE_MARKUP },
         { "spanspec",           NODE_SPANSPEC },          { "simpara",            NODE_PARA },
         { "structname",         NODE_STRUCTNAME },          { "structfield",        NODE_PARAMETER },
         { "subtitle",           NODE_SUBTITLE },          { "structname",         NODE_TYPE },
         { "surname",            NODE_PERSONNAME },          { "surname",            NODE_PERSONNAME },
         { "synopsis",           NODE_SYNOPSIS },          { "symbol",             NODE_CONSTANT },
         { "table",              NODE_TABLE },          { "tag",                NODE_MARKUP },
         { "tbody",              NODE_TBODY },  
         { "term",               NODE_TERM },  
         { "tfoot",              NODE_TFOOT },  
         { "tgroup",             NODE_TGROUP },  
         { "thead",              NODE_THEAD },  
         { "tip",                NODE_TIP },  
         { "title",              NODE_TITLE },  
         { "trademark",          NODE_IGNORE },          { "trademark",          NODE_IGNORE },
         { "type",               NODE_TYPE },          { "ulink",              NODE_LINK },
         { "ulink",              NODE_ULINK },          { "userinput",          NODE_LITERAL },
         { "userinput",          NODE_USERINPUT },          { "year",               NODE_IGNORE },
         { "variablelist",       NODE_VARIABLELIST },  
         { "varlistentry",       NODE_VARLISTENTRY },  
         { "varname",            NODE_VARNAME },  
         { "warning",            NODE_WARNING },  
         { "wordasword",         NODE_WORDASWORD },  
         { "xi:include",         NODE_DELETE_WARN },  
         { "year",               NODE_YEAR },  
         { NULL,                 NODE_IGNORE }          { NULL,                 NODE_IGNORE }
 };  };
   
Line 245  static const struct entity entities[] = {
Line 190  static const struct entity entities[] = {
         { NULL,         NULL }          { NULL,         NULL }
 };  };
   
   static size_t    parse_string(struct parse *, char *, size_t,
                            enum pstate *, int);
   static void      parse_fd(struct parse *, int);
   
   
 static void  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 263  warn_msg(struct parse *p, const char *fmt, ...)
Line 213  warn_msg(struct parse *p, const char *fmt, ...)
 {  {
         va_list          ap;          va_list          ap;
   
         if (p->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 279  warn_msg(struct parse *p, const char *fmt, ...)
Line 230  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_text(struct parse *p, const char *word, int sz)
 {  {
         struct pnode    *dat;          struct pnode    *n, *np;
           size_t           oldsz, newsz;
           int              i;
   
         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) {          /* Append to the current text node, if one is open. */
                 if ((dat = calloc(1, sizeof(*dat))) == NULL) {  
                         perror(NULL);          if (n->node == NODE_TEXT) {
                         exit(1);                  oldsz = strlen(n->b);
                 }                  newsz = oldsz + sz;
                 dat->node = NODE_TEXT;                  if (oldsz && (p->flags & PFLAG_SPC))
                 dat->parent = ps->cur;                          newsz++;
                 TAILQ_INIT(&dat->childq);                  n->b = xrealloc(n->b, newsz + 1);
                 TAILQ_INIT(&dat->attrq);                  if (oldsz && (p->flags & PFLAG_SPC))
                 TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);                          n->b[oldsz++] = ' ';
                 ps->cur = dat;                  memcpy(n->b + oldsz, word, sz);
                   n->b[newsz] = '\0';
                   p->flags &= ~(PFLAG_LINE | PFLAG_SPC);
                   return;
         }          }
   
         if (ps->tree->flags & TREE_CLOSED &&          if (p->tree->flags & TREE_CLOSED && n == 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. */          /* Create a new text node. */
   
         assert(sz >= 0);          n = pnode_alloc(p->cur);
         ps->cur->b = realloc(ps->cur->b, ps->cur->bsz + sz + 1);          n->node = NODE_TEXT;
         if (ps->cur->b == NULL) {          n->flags = ((p->flags & PFLAG_LINE) ? NFLAG_LINE : 0) |
                 perror(NULL);              ((p->flags & PFLAG_SPC) ? NFLAG_SPC : 0);
                 exit(1);          p->flags &= ~(PFLAG_LINE | PFLAG_SPC);
   
           /*
            * If this node follows an in-line macro without intervening
            * whitespace, keep the text in it as short as possible,
            * and do not keep it open.
            */
   
           np = n->flags & NFLAG_SPC ? NULL : TAILQ_PREV(n, pnodeq, child);
           while (np != NULL) {
                   switch (pnode_class(np->node)) {
                   case CLASS_VOID:
                   case CLASS_TEXT:
                   case CLASS_BLOCK:
                   case CLASS_NOFILL:
                           np = NULL;
                           break;
                   case CLASS_TRANS:
                           np = TAILQ_LAST(&np->childq, pnodeq);
                           continue;
                   case CLASS_LINE:
                   case CLASS_ENCL:
                           break;
                   }
                   break;
         }          }
         memcpy(ps->cur->b + ps->cur->bsz, p, sz);          if (np != NULL) {
         ps->cur->bsz += sz;                  i = 0;
         ps->cur->b[ps->cur->bsz] = '\0';                  while (i < sz && !isspace((unsigned char)word[i]))
         ps->cur->real = ps->cur->b;                          i++;
                   n->b = xstrndup(word, i);
                   if (i == sz)
                           return;
                   while (i < sz && isspace((unsigned char)word[i]))
                           i++;
                   if (i == sz) {
                           p->flags |= PFLAG_SPC;
                           return;
                   }
   
                   /* Put any remaining text into a second node. */
   
                   n = pnode_alloc(p->cur);
                   n->node = NODE_TEXT;
                   n->flags |= NFLAG_SPC;
                   word += i;
                   sz -= i;
           }
           n->b = xstrndup(word, sz);
   
           /* The new node remains open for later pnode_closetext(). */
   
           p->cur = n;
 }  }
   
   /*
    * Close out the text node and strip trailing whitespace, if one is open.
    */
 static void  static void
 pnode_trim(struct pnode *pn)  pnode_closetext(struct parse *p, int check_last_word)
 {  {
         assert(pn->node == NODE_TEXT);          struct pnode    *n;
         for (; pn->bsz > 0; pn->b[--pn->bsz] = '\0')          char            *cp, *last_word;
                 if (isspace((unsigned char)pn->b[pn->bsz - 1]) == 0)  
                         break;          if ((n = p->cur) == NULL || n->node != NODE_TEXT)
                   return;
           p->cur = n->parent;
           for (cp = strchr(n->b, '\0');
               cp > n->b && isspace((unsigned char)cp[-1]);
               *--cp = '\0')
                   p->flags |= PFLAG_SPC;
   
           if (p->flags & PFLAG_SPC || !check_last_word)
                   return;
   
           /*
            * Find the beginning of the last word
            * and delete whitespace before it.
            */
   
           while (cp > n->b && !isspace((unsigned char)cp[-1]))
                   cp--;
           if (cp == n->b)
                   return;
   
           last_word = cp;
           while (cp > n->b && isspace((unsigned char)cp[-1]))
               *--cp = '\0';
   
           /* Move the last word into its own node, for use with .Pf. */
   
           n = pnode_alloc_text(p->cur, last_word);
           n->flags |= NFLAG_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;
           char                    *cp;
           unsigned int             codepoint;
           enum pstate              pstate;
   
         if (p->del > 0)          if (p->del > 0)
                 return;                  return;
Line 345  xml_entity(struct parse *p, const char *name)
Line 384  xml_entity(struct parse *p, const char *name)
                 return;                  return;
         }          }
   
         /* Close out the text node, if there is one. */          pnode_closetext(p, 0);
         if (p->cur->node == NODE_TEXT) {  
                 pnode_trim(p->cur);  
                 p->cur = p->cur->parent;  
         }  
   
         if (p->tree->flags & TREE_CLOSED && p->cur == p->tree->root)          if (p->tree->flags & TREE_CLOSED && p->cur == p->tree->root)
                 warn_msg(p, "entity after end of document: &%s;", name);                  warn_msg(p, "entity after end of document: &%s;", name);
Line 359  xml_entity(struct parse *p, const char *name)
Line 394  xml_entity(struct parse *p, const char *name)
                         break;                          break;
   
         if (entity->roff == NULL) {          if (entity->roff == NULL) {
                   if (p->doctype != NULL) {
                           TAILQ_FOREACH(n, &p->doctype->childq, child) {
                                   if ((ccp = pnode_getattr_raw(n,
                                        ATTRKEY_NAME, NULL)) == NULL ||
                                       strcmp(ccp, name) != 0)
                                           continue;
                                   if ((ccp = pnode_getattr_raw(n,
                                       ATTRKEY_SYSTEM, NULL)) != NULL) {
                                           parse_file(p, -1, ccp);
                                           p->flags &= ~(PFLAG_LINE | PFLAG_SPC);
                                           return;
                                   }
                                   if ((ccp = pnode_getattr_raw(n,
                                        ATTRKEY_DEFINITION, NULL)) == NULL)
                                           continue;
                                   cp = xstrdup(ccp);
                                   pstate = PARSE_ELEM;
                                   parse_string(p, cp, strlen(cp), &pstate, 0);
                                   p->flags &= ~(PFLAG_LINE | PFLAG_SPC);
                                   free(cp);
                                   return;
                           }
                   }
                   if (*name == '#') {
                           codepoint = strtonum(name + 1, 0, 0x10ffff, &ccp);
                           if (ccp == NULL) {
                                   n = pnode_alloc(p->cur);
                                   xasprintf(&n->b, "\\[u%4.4X]", codepoint);
                                   goto done;
                           }
                   }
                 error_msg(p, "unknown entity &%s;", name);                  error_msg(p, "unknown entity &%s;", name);
                 return;                  return;
         }          }
   
         /* Create, append, and close out an entity node. */          /* Create, append, and close out an entity node. */
         if ((dat = calloc(1, sizeof(*dat))) == NULL ||          n = pnode_alloc(p->cur);
             (dat->b = dat->real = strdup(entity->roff)) == NULL) {          n->b = xstrdup(entity->roff);
                 perror(NULL);  done:
                 exit(1);          n->node = NODE_ESCAPE;
         }          n->flags = ((p->flags & PFLAG_LINE) ? NFLAG_LINE : 0) |
         dat->node = NODE_ESCAPE;              ((p->flags & PFLAG_SPC) ? NFLAG_SPC : 0);
         dat->bsz = strlen(dat->b);          p->flags &= ~(PFLAG_LINE | PFLAG_SPC);
         dat->parent = p->cur;  
         TAILQ_INIT(&dat->childq);  
         TAILQ_INIT(&dat->attrq);  
         TAILQ_INSERT_TAIL(&p->cur->childq, dat, child);  
 }  }
   
 /*  /*
    * Parse an element name.
    */
   static enum nodeid
   xml_name2node(struct parse *p, const char *name)
   {
           const struct alias      *alias;
           enum nodeid              node;
   
           if ((node = pnode_parse(name)) < NODE_UNKNOWN)
                   return node;
   
           for (alias = aliases; alias->name != NULL; alias++)
                   if (strcmp(alias->name, name) == 0)
                           return alias->node;
   
           return NODE_UNKNOWN;
   }
   
   /*
  * 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;          struct pnode            *n;
         struct pnode            *dat;  
   
         if (*name == '!' || *name == '?')  
                 return;  
   
         /*          /*
          * 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) {
                 ps->del++;                  if (*name != '!' && *name != '?')
                           p->del++;
                 return;                  return;
         }          }
   
         /* Close out the text node, if there is one. */          switch (p->ncur = xml_name2node(p, name)) {
         if (ps->cur != NULL && ps->cur->node == NODE_TEXT) {  
                 pnode_trim(ps->cur);  
                 ps->cur = ps->cur->parent;  
         }  
   
         for (elem = elements; elem->name != NULL; elem++)  
                 if (strcmp(elem->name, name) == 0)  
                         break;  
   
         if (elem->name == NULL)  
                 error_msg(ps, "unknown element <%s>", name);  
   
         ps->ncur = elem->node;  
   
         switch (ps->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_UNKNOWN:
                 ps->tree->flags |= TREE_EQN;                  if (*name != '!' && *name != '?')
                 break;                          error_msg(p, "unknown element <%s>", name);
                   return;
         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) {          switch (pnode_class(p->ncur)) {
                 perror(NULL);          case CLASS_LINE:
                 exit(1);          case CLASS_ENCL:
                   pnode_closetext(p, 1);
                   break;
           default:
                   pnode_closetext(p, 0);
                   break;
         }          }
         dat->node = elem->node;  
         dat->parent = ps->cur;  
         TAILQ_INIT(&dat->childq);  
         TAILQ_INIT(&dat->attrq);  
   
         if (ps->cur != NULL)          n = pnode_alloc(p->cur);
                 TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child);  
   
         ps->cur = dat;          /*
         if (ps->tree->root == NULL)           * Some elements are self-closing.
                 ps->tree->root = dat;           * Nodes that begin a new macro or request line or start by
            * printing text always want whitespace before themselves.
            */
   
           switch (n->node = p->ncur) {
           case NODE_DOCTYPE:
           case NODE_ENTITY:
           case NODE_SBR:
           case NODE_VOID:
                   p->flags |= PFLAG_EEND;
                   break;
           default:
                   break;
           }
           switch (pnode_class(p->ncur)) {
           case CLASS_LINE:
           case CLASS_ENCL:
                   n->flags = ((p->flags & PFLAG_LINE) ? NFLAG_LINE : 0) |
                       ((p->flags & PFLAG_SPC) ? NFLAG_SPC : 0);
                   break;
           case CLASS_NOFILL:
                   p->nofill++;
                   /* FALLTHROUGH */
           default:
                   n->flags |= NFLAG_SPC;
                   break;
           }
           p->cur = n;
           if (n->node == NODE_DOCTYPE) {
                   if (p->doctype == NULL)
                           p->doctype = n;
                   else
                           error_msg(p, "duplicate doctype");
           } else if (n->parent == NULL && p->tree->root == NULL)
                   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;
         enum attrkey     key;          enum attrkey     key;
   
         if (ps->del > 0 || *name == '\0')          if (p->del > 0 || p->ncur >= NODE_UNKNOWN || *name == '\0')
                 return;                  return;
   
           if ((p->ncur == NODE_DOCTYPE || p->ncur == NODE_ENTITY) &&
               TAILQ_FIRST(&p->cur->attrq) == NULL) {
                   value = name;
                   name = "NAME";
           } else
                   value = NULL;
   
         if ((key = attrkey_parse(name)) == ATTRKEY__MAX) {          if ((key = attrkey_parse(name)) == ATTRKEY__MAX) {
                 ps->attr = 0;                  p->flags &= ~PFLAG_ATTR;
                 return;                  return;
         }          }
         if ((attr = calloc(1, sizeof(*attr))) == NULL) {          a = xcalloc(1, sizeof(*a));
                 perror(NULL);          a->key = key;
                 exit(1);          a->val = ATTRVAL__MAX;
           if (value == NULL) {
                   a->rawval = NULL;
                   p->flags |= PFLAG_ATTR;
           } else {
                   a->rawval = xstrdup(value);
                   p->flags &= ~PFLAG_ATTR;
         }          }
         attr->key = key;          TAILQ_INSERT_TAIL(&p->cur->attrq, a, child);
         attr->val = ATTRVAL__MAX;          if (p->ncur == NODE_ENTITY && key == ATTRKEY_NAME)
         attr->rawval = NULL;                  xml_attrkey(p, "DEFINITION");
         TAILQ_INSERT_TAIL(&ps->cur->attrq, attr, child);  
         ps->attr = 1;  
 }  }
   
 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->attr == 0)          if (p->del > 0 || p->ncur >= NODE_UNKNOWN ||
               (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 = xstrdup(name);
                 perror(NULL);          p->flags &= ~PFLAG_ATTR;
                 exit(1);  
         }  
 }  }
   
 /*  /*
Line 493  xml_attrval(struct parse *ps, const char *name)
Line 603  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;          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;
         }          }
   
         /* Close out the text node, if there is one. */          if (p->del == 0)
         if (ps->del == 0 && ps->cur != NULL && ps->cur->node == NODE_TEXT) {                  pnode_closetext(p, 0);
                 pnode_trim(ps->cur);  
                 ps->cur = ps->cur->parent;  
         }  
   
         if (name != NULL) {          n = p->cur;
                 for (elem = elements; elem->name != NULL; elem++)          node = name == NULL ? p->ncur : xml_name2node(p, name);
                         if (strcmp(elem->name, name) == 0)  
                                 break;  
                 node = elem->node;  
         } else  
                 node = ps->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:
           case NODE_UNKNOWN:
                 break;                  break;
           case NODE_INCLUDE:
                   p->cur = n->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_LINE | PFLAG_SPC);
                   break;
           case NODE_DOCTYPE:
           case NODE_SBR:
           case NODE_VOID:
                   p->flags &= ~PFLAG_EEND;
                   /* FALLTHROUGH */
         default:          default:
                 if (ps->cur == NULL || node != ps->cur->node) {                  if (n == NULL || node != n->node) {
                         warn_msg(ps, "element not open: </%s>", name);                          warn_msg(p, "element not open: </%s>", name);
                         break;                          break;
                 }                  }
                   if (pnode_class(node) == CLASS_NOFILL)
                           p->nofill--;
   
                 /*                  /*
                  * Refrain from actually closing the document element.                   * Refrain from actually closing the document element.
Line 542  xml_elem_end(struct parse *ps, const char *name)
Line 664  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)                  if (n->parent != NULL || node == NODE_DOCTYPE) {
                         ps->tree->flags |= TREE_CLOSED;                          p->cur = n->parent;
                 else                          if (p->cur != NULL)
                         ps->cur = ps->cur->parent;                                  p->ncur = p->cur->node;
                   } else
                           p->tree->flags |= TREE_CLOSED;
                   p->flags &= ~(PFLAG_LINE | PFLAG_SPC);
   
                   /* Include a file containing entity declarations. */
   
                   if (node == NODE_ENTITY && strcmp("%",
                       pnode_getattr_raw(n, ATTRKEY_NAME, "")) == 0 &&
                       (cp = pnode_getattr_raw(n, ATTRKEY_SYSTEM, NULL)) != NULL)
                           parse_file(p, -1, cp);
   
                 break;                  break;
         }          }
         assert(ps->del == 0);          assert(p->del == 0);
 }  }
   
 struct parse *  struct parse *
Line 556  parse_alloc(int warn)
Line 689  parse_alloc(int warn)
 {  {
         struct parse    *p;          struct parse    *p;
   
         if ((p = calloc(1, sizeof(*p))) == NULL)          p = xcalloc(1, sizeof(*p));
                 return NULL;          p->tree = xcalloc(1, sizeof(*p->tree));
           if (warn)
         if ((p->tree = calloc(1, sizeof(*p->tree))) == NULL) {                  p->flags |= PFLAG_WARN;
                 free(p);          else
                 return NULL;                  p->flags &= ~PFLAG_WARN;
         }  
         p->warn = warn;  
         return p;          return p;
 }  }
   
Line 579  parse_free(struct parse *p)
Line 710  parse_free(struct parse *p)
         free(p);          free(p);
 }  }
   
   static void
   increment(struct parse *p, char *b, size_t *pend, int refill)
   {
           if (refill) {
                   if (b[*pend] == '\n') {
                           p->nline++;
                           p->ncol = 1;
                   } else
                           p->ncol++;
           }
           ++*pend;
   }
   
 /*  /*
  * Advance the pend pointer to the next character in the charset.   * Advance the pend pointer to the next character in the charset.
  * If the charset starts with a space, it stands for any whitespace.   * If the charset starts with a space, it stands for any whitespace.
Line 589  parse_free(struct parse *p)
Line 733  parse_free(struct parse *p)
  */   */
 static int  static int
 advance(struct parse *p, char *b, size_t rlen, size_t *pend,  advance(struct parse *p, char *b, size_t rlen, size_t *pend,
     const char *charset)      const char *charset, int refill)
 {  {
         int              space;          int              space;
   
Line 599  advance(struct parse *p, char *b, size_t rlen, size_t 
Line 743  advance(struct parse *p, char *b, size_t rlen, size_t 
         } else          } else
                 space = 0;                  space = 0;
   
         p->nline = p->line;          if (refill) {
         p->ncol = p->col;                  p->nline = p->line;
                   p->ncol = p->col;
           }
         while (*pend < rlen) {          while (*pend < rlen) {
                 if (b[*pend] == '\n') {  
                         p->nline++;  
                         p->ncol = 1;  
                 } else  
                         p->ncol++;  
                 if (space && isspace((unsigned char)b[*pend]))                  if (space && isspace((unsigned char)b[*pend]))
                         break;                          break;
                 if (strchr(charset, b[*pend]) != NULL)                  if (strchr(charset, b[*pend]) != NULL)
                         break;                          break;
                 ++*pend;                  increment(p, b, pend, refill);
         }          }
         if (*pend == rlen) {          if (*pend == rlen) {
                 b[rlen] = '\0';                  b[rlen] = '\0';
                 return 1;                  return refill;
         } else          } else
                 return 0;                  return 0;
 }  }
   
 struct ptree *  size_t
 parse_file(struct parse *p, int fd, const char *fname)  parse_string(struct parse *p, char *b, size_t rlen,
       enum pstate *pstate, int refill)
 {  {
         char             b[4096];  
         char            *cp;          char            *cp;
         ssize_t          rsz;   /* Return value from read(2). */          size_t           pws;   /* Parse offset including whitespace. */
         size_t           rlen;  /* Number of bytes in b[]. */  
         size_t           poff;  /* Parse offset in b[]. */          size_t           poff;  /* Parse offset in b[]. */
         size_t           pend;  /* Offset of the end of the current word. */          size_t           pend;  /* Offset of the end of the current word. */
         int              in_tag, in_arg, in_quotes, elem_end;          int              elem_end;
   
         p->fname = fname;          pend = pws = 0;
         p->nline = 1;          for (;;) {
         p->ncol = 1;  
         rlen = 0;  
         in_tag = in_arg = in_quotes = 0;  
   
         /*                  /* Proceed to the next token, skipping whitespace. */
          * Read loop.  
          *  
          * We have to enter the read loop once more even on EOF  
          * because the previous token may have been incomplete,  
          * such that it asked for more input.  
          * Once rsz is 0, incomplete tokens will no longer ask  
          * for more input but instead use whatever there is,  
          * and then exit the read loop.  
          * The minus one on the size limit for read(2) is needed  
          * such that advance() can set b[rlen] to NUL when needed.  
          */  
   
         while ((rsz = read(fd, b + rlen, sizeof(b) - rlen - 1)) >= 0) {                  if (refill) {
                 if ((rlen += rsz) == 0)                          p->line = p->nline;
                           p->col = p->ncol;
                   }
                   if ((poff = pend) == rlen)
                         break;                          break;
                   if (isspace((unsigned char)b[pend])) {
                           p->flags |= PFLAG_SPC;
                           if (b[pend] == '\n') {
                                   p->flags |= PFLAG_LINE;
                                   pws = pend + 1;
                           }
                           increment(p, b, &pend, refill);
                           continue;
                   }
   
                 /* Token loop. */                  /*
                    * The following four cases (ARG, TAG, and starting an
                    * entity or a tag) all parse a word or quoted string.
                    * If that extends beyond the read buffer and the last
                    * read(2) still got data, they all break out of the
                    * token loop to request more data from the read loop.
                    *
                    * Also, three of them detect self-closing tags, those
                    * ending with "/>", setting the flag elem_end and
                    * calling xml_elem_end() at the very end, after
                    * handling the attribute value, attribute name, or
                    * tag name, respectively.
                    */
   
                 pend = 0;                  /* Parse an attribute value. */
                 for (;;) {  
   
                         /* Proceed to the next token, skipping whitespace. */                  if (*pstate >= PARSE_ARG) {
                           if (*pstate == PARSE_ARG &&
                         p->line = p->nline;                              (b[pend] == '\'' || b[pend] == '"')) {
                         p->col = p->ncol;                                  *pstate = b[pend] == '"' ?
                         if ((poff = pend) == rlen)                                      PARSE_DQ : PARSE_SQ;
                                 break;                                  increment(p, b, &pend, refill);
                         if (isspace((unsigned char)b[pend])) {  
                                 if (b[pend++] == '\n') {  
                                         p->nline++;  
                                         p->ncol = 1;  
                                 } else  
                                         p->ncol++;  
                                 continue;                                  continue;
                         }                          }
                           if (advance(p, b, rlen, &pend,
                               *pstate == PARSE_DQ ? "\"" :
                               *pstate == PARSE_SQ ? "'" : " >", refill))
                                   break;
                           *pstate = PARSE_TAG;
                           elem_end = 0;
                           if (b[pend] == '>') {
                                   *pstate = PARSE_ELEM;
                                   if (pend > 0 && b[pend - 1] == '/') {
                                           b[pend - 1] = '\0';
                                           elem_end = 1;
                                   }
                                   if (p->flags & PFLAG_EEND)
                                           elem_end = 1;
                           }
                           b[pend] = '\0';
                           if (pend < rlen)
                                   increment(p, b, &pend, refill);
                           xml_attrval(p, b + poff);
                           if (elem_end)
                                   xml_elem_end(p, NULL);
   
                         /*                  /* Look for an attribute name. */
                          * The following four cases (in_arg, in_tag, and  
                          * starting an entity or a tag) all parse a word  
                          * or quoted string.  If that extends beyond the  
                          * read buffer and the last read(2) still got  
                          * data, they all break out of the token loop  
                          * to request more data from the read loop.  
                          *  
                          * Also, three of them detect self-closing tags,  
                          * those ending with "/>", setting the flag  
                          * elem_end and calling xml_elem_end() at the  
                          * very end, after handling the attribute value,  
                          * attribute name, or tag name, respectively.  
                          */  
   
                         /* Parse an attribute value. */                  } else if (*pstate == PARSE_TAG) {
                           switch (p->ncur) {
                         if (in_arg) {                          case NODE_DOCTYPE:
                                 if (in_quotes == 0 &&                                  if (b[pend] == '[') {
                                     (b[pend] == '\'' || b[pend] == '"')) {                                          *pstate = PARSE_ELEM;
                                         in_quotes = b[pend] == '"' ? 2 : 1;                                          increment(p, b, &pend, refill);
                                         p->ncol++;  
                                         pend++;  
                                         continue;                                          continue;
                                 }                                  }
                                 if (advance(p, b, rlen, &pend,                                  /* FALLTHROUGH */
                                     in_quotes == 2 ? "\"" :                          case NODE_ENTITY:
                                     in_quotes == 1 ? "'" : " >") && rsz > 0)                                  if (b[pend] == '"' || b[pend] == '\'') {
                                         break;                                          *pstate = PARSE_ARG;
                                 in_arg = in_quotes = elem_end = 0;  
                                 if (b[pend] == '>') {  
                                         in_tag = 0;  
                                         if (pend > 0 && b[pend - 1] == '/') {  
                                                 b[pend - 1] = '\0';  
                                                 elem_end = 1;  
                                         }  
                                 }  
                                 b[pend] = '\0';  
                                 if (pend < rlen)  
                                         pend++;  
                                 xml_attrval(p, b + poff);  
                                 if (elem_end)  
                                         xml_elem_end(p, NULL);  
   
                         /* Look for an attribute name. */  
   
                         } else if (in_tag) {  
                                 if (advance(p, b, rlen, &pend, " =>") &&  
                                     rsz > 0)  
                                         break;  
                                 elem_end = 0;  
                                 switch (b[pend]) {  
                                 case '>':  
                                         in_tag = 0;  
                                         if (pend > 0 && b[pend - 1] == '/') {  
                                                 b[pend - 1] = '\0';  
                                                 elem_end = 1;  
                                         }  
                                         break;  
                                 case '=':  
                                         in_arg = 1;  
                                         break;  
                                 default:  
                                         break;  
                                 }  
                                 b[pend] = '\0';  
                                 if (pend < rlen)  
                                         pend++;  
                                 xml_attrkey(p, b + poff);  
                                 if (elem_end)  
                                         xml_elem_end(p, NULL);  
   
                         /* Begin an opening or closing tag. */  
   
                         } else if (b[poff] == '<') {  
                                 if (advance(p, b, rlen, &pend, " >") &&  
                                     rsz > 0)  
                                         break;  
                                 if (pend > poff + 3 &&  
                                     strncmp(b + poff, "<!--", 4) == 0) {  
   
                                         /* Skip a comment. */  
   
                                         cp = strstr(b + pend - 2, "-->");  
                                         if (cp == NULL) {  
                                                 if (rsz > 0) {  
                                                         pend = rlen;  
                                                         break;  
                                                 }  
                                                 cp = b + rlen;  
                                         } else  
                                                 cp += 3;  
                                         while (b + pend < cp) {  
                                                 if (b[++pend] == '\n') {  
                                                         p->nline++;  
                                                         p->ncol = 1;  
                                                 } else  
                                                         p->ncol++;  
                                         }  
                                         continue;                                          continue;
                                 }                                  }
                                 elem_end = 0;                                  break;
                                 if (b[pend] != '>')                          default:
                                         in_tag = 1;                                  break;
                                 else if (pend > 0 && b[pend - 1] == '/') {                          }
                           if (advance(p, b, rlen, &pend, " =>", refill))
                                   break;
                           elem_end = 0;
                           switch (b[pend]) {
                           case '>':
                                   *pstate = PARSE_ELEM;
                                   if (pend > 0 && b[pend - 1] == '/') {
                                         b[pend - 1] = '\0';                                          b[pend - 1] = '\0';
                                         elem_end = 1;                                          elem_end = 1;
                                 }                                  }
                                 b[pend] = '\0';                                  if (p->flags & PFLAG_EEND)
                                 if (pend < rlen)  
                                         pend++;  
                                 if (b[++poff] == '/') {  
                                         elem_end = 1;                                          elem_end = 1;
                                         poff++;                                  break;
                                 } else                          case '=':
                                         xml_elem_start(p, b + poff);                                  *pstate = PARSE_ARG;
                                 if (elem_end)                                  break;
                                         xml_elem_end(p, b + poff);                          default:
                                   break;
                           }
                           b[pend] = '\0';
                           if (pend < rlen)
                                   increment(p, b, &pend, refill);
                           xml_attrkey(p, b + poff);
                           if (elem_end)
                                   xml_elem_end(p, NULL);
   
                         /* Process an entity. */                  /* Begin an opening or closing tag. */
   
                         } else if (b[poff] == '&') {                  } else if (b[poff] == '<') {
                                 if (advance(p, b, rlen, &pend, ";") &&                          if (advance(p, b, rlen, &pend, " >", refill))
                                     rsz > 0)                                  break;
                                         break;                          if (pend > poff + 3 &&
                                 b[pend] = '\0';                              strncmp(b + poff, "<!--", 4) == 0) {
                                 if (pend < rlen)  
                                         pend++;  
                                 xml_entity(p, b + poff + 1);  
   
                         /* Process text up to the next tag or entity. */                                  /* Skip a comment. */
   
                                   cp = strstr(b + pend - 2, "-->");
                                   if (cp == NULL) {
                                           if (refill)
                                                   break;
                                           cp = b + rlen;
                                   } else
                                           cp += 3;
                                   while (b + pend < cp)
                                           increment(p, b, &pend, refill);
                                   continue;
                           }
                           elem_end = 0;
                           if (b[pend] != '>')
                                   *pstate = PARSE_TAG;
                           else if (pend > 0 && b[pend - 1] == '/') {
                                   b[pend - 1] = '\0';
                                   elem_end = 1;
                           }
                           b[pend] = '\0';
                           if (pend < rlen)
                                   increment(p, b, &pend, refill);
                           if (b[++poff] == '/') {
                                   elem_end = 1;
                                   poff++;
                         } else {                          } else {
                                 if (advance(p, b, rlen, &pend, "<&") == 0)                                  xml_elem_start(p, b + poff);
                                         p->ncol--;                                  if (*pstate == PARSE_ELEM &&
                                 xml_char(p, b + poff, pend - poff);                                      p->flags & PFLAG_EEND)
                                           elem_end = 1;
                         }                          }
                           if (elem_end)
                                   xml_elem_end(p, b + poff);
   
                   /* Close a doctype. */
   
                   } else if (p->ncur == NODE_DOCTYPE && b[poff] == ']') {
                           *pstate = PARSE_TAG;
                           increment(p, b, &pend, refill);
   
                   /* Process an entity. */
   
                   } else if (b[poff] == '&') {
                           if (advance(p, b, rlen, &pend, ";", refill))
                                   break;
                           b[pend] = '\0';
                           if (pend < rlen)
                                   increment(p, b, &pend, refill);
                           xml_entity(p, b + poff + 1);
   
                   /* Process text up to the next tag, entity, or EOL. */
   
                   } else {
                           advance(p, b, rlen, &pend,
                               p->ncur == NODE_DOCTYPE ? "<&]\n" : "<&\n",
                               refill);
                           if (p->nofill)
                                   poff = pws;
                           xml_text(p, b + poff, pend - poff);
                           if (b[pend] == '\n')
                                   pnode_closetext(p, 0);
                 }                  }
                   pws = pend;
           }
           return poff;
   }
   
                 /* Buffer exhausted; shift left and re-fill. */  
   
   /*
    * The read loop.
    * If the previous token was incomplete and asked for more input,
    * we have to enter the read loop once more even on EOF.
    * Once rsz is 0, incomplete tokens will no longer ask for more input
    * but instead use whatever there is, and then exit the read loop.
    * The minus one on the size limit for read(2) is needed such that
    * advance() can set b[rlen] to NUL when needed.
    */
   static void
   parse_fd(struct parse *p, int fd)
   {
           char             b[4096];
           ssize_t          rsz;   /* Return value from read(2). */
           size_t           rlen;  /* Number of bytes in b[]. */
           size_t           poff;  /* Parse offset in b[]. */
           enum pstate      pstate;
   
           rlen = 0;
           pstate = PARSE_ELEM;
           while ((rsz = read(fd, b + rlen, sizeof(b) - rlen - 1)) >= 0 &&
               (rlen += rsz) > 0) {
                   poff = parse_string(p, b, rlen, &pstate, rsz > 0);
                   /* Buffer exhausted; shift left and re-fill. */
                 assert(poff > 0);                  assert(poff > 0);
                 memmove(b, b + poff, rlen - poff);  
                 rlen -= poff;                  rlen -= poff;
                   memmove(b, b + poff, rlen);
         }          }
         if (rsz < 0) {          if (rsz < 0)
                 perror(fname);                  error_msg(p, "read: %s", strerror(errno));
                 p->tree->flags |= TREE_FAIL;  }
   
   /*
    * Open and parse a file.
    */
   struct ptree *
   parse_file(struct parse *p, int fd, const char *fname)
   {
           const char      *save_fname;
           int              save_line, save_col;
   
           /* Save and initialize reporting data. */
   
           save_fname = p->fname;
           save_line = p->nline;
           save_col = p->ncol;
           p->fname = fname;
           p->line = 0;
           p->col = 0;
   
           /* Open the file, unless it is already open. */
   
           if (fd == -1 && (fd = open(fname, O_RDONLY, 0)) == -1) {
                   error_msg(p, "open: %s", strerror(errno));
                   p->fname = save_fname;
                   return p->tree;
         }          }
         if (p->cur != NULL && p->cur->node == NODE_TEXT) {  
                 pnode_trim(p->cur);          /*
                 p->cur = p->cur->parent;           * After opening the starting file, change to the directory it
            * is located in, in case it wants to include any further files,
            * which are typically given with relative paths in DocBook.
            * Do this on a best-effort basis; don't complain about failure.
            */
   
           if (save_fname == NULL && (fname = dirname(fname)) != NULL &&
               strcmp(fname, ".") != 0)
                   (void)chdir(fname);
   
           /* Run the read loop. */
   
           p->nline = 1;
           p->ncol = 1;
           parse_fd(p, fd);
   
           /* On the top level, finalize the parse tree. */
   
           if (save_fname == NULL) {
                   pnode_closetext(p, 0);
                   if (p->tree->root == NULL)
                           error_msg(p, "empty document");
                   else if ((p->tree->flags & TREE_CLOSED) == 0)
                           warn_msg(p, "document not closed");
                   pnode_unlink(p->doctype);
         }          }
         if ((p->tree->flags & TREE_CLOSED) == 0)  
                 warn_msg(p, "document not closed");          /* Clean up. */
   
           if (fd != STDIN_FILENO)
                   close(fd);
           p->fname = save_fname;
           p->nline = save_line;
           p->ncol = save_col;
         return p->tree;          return p->tree;
 }  }
Legend:
Removed from v.1.10  
changed lines
  Added in v.1.55
CVSweb