=================================================================== RCS file: /cvs/docbook2mdoc/parse.c,v retrieving revision 1.8 retrieving revision 1.25 diff -u -p -r1.8 -r1.25 --- docbook2mdoc/parse.c 2019/04/02 13:11:09 1.8 +++ docbook2mdoc/parse.c 2019/04/08 23:40:17 1.25 @@ -1,4 +1,4 @@ -/* $Id: parse.c,v 1.8 2019/04/02 13:11:09 schwarze Exp $ */ +/* $Id: parse.c,v 1.25 2019/04/08 23:40:17 schwarze Exp $ */ /* * Copyright (c) 2014 Kristaps Dzonsons * Copyright (c) 2019 Ingo Schwarze @@ -17,6 +17,9 @@ */ #include #include +#include +#include +#include #include #include #include @@ -30,6 +33,14 @@ * The implementation of the DocBook parser. */ +enum pstate { + PARSE_ELEM, + PARSE_TAG, + PARSE_ARG, + PARSE_SQ, + PARSE_DQ +}; + /* * Global parse state. * Keep this as simple and small as possible. @@ -37,6 +48,7 @@ struct parse { const char *fname; /* Name of the input file. */ struct ptree *tree; /* Complete parse result. */ + struct pnode *doctype; struct pnode *cur; /* Current node in the tree. */ enum nodeid ncur; /* Type of the current node. */ int line; /* Line number in the input file. */ @@ -44,8 +56,11 @@ struct parse { int nline; /* Line number of next token. */ int ncol; /* Column number of next token. */ int del; /* Levels of nested nodes being deleted. */ - int attr; /* The most recent attribute is valid. */ - int warn; + int flags; +#define PFLAG_WARN (1 << 0) /* Print warning messages. */ +#define PFLAG_SPC (1 << 1) /* Whitespace before the next element. */ +#define PFLAG_ATTR (1 << 2) /* The most recent attribute is valid. */ +#define PFLAG_EEND (1 << 3) /* This element is self-closing. */ }; struct element { @@ -57,30 +72,36 @@ static const struct element elements[] = { { "acronym", NODE_IGNORE }, { "affiliation", NODE_AFFILIATION }, { "anchor", NODE_DELETE }, + { "appendix", NODE_APPENDIX }, { "application", NODE_APPLICATION }, { "arg", NODE_ARG }, + { "article", NODE_SECTION }, { "author", NODE_AUTHOR }, { "authorgroup", NODE_AUTHORGROUP }, { "blockquote", NODE_BLOCKQUOTE }, - { "book", NODE_BOOK }, + { "book", NODE_SECTION }, { "bookinfo", NODE_BOOKINFO }, { "caution", NODE_CAUTION }, { "chapter", NODE_SECTION }, { "citerefentry", NODE_CITEREFENTRY }, { "citetitle", NODE_CITETITLE }, { "cmdsynopsis", NODE_CMDSYNOPSIS }, - { "code", NODE_CODE }, + { "code", NODE_LITERAL }, { "colspec", NODE_COLSPEC }, { "command", NODE_COMMAND }, { "constant", NODE_CONSTANT }, { "contrib", NODE_CONTRIB }, { "copyright", NODE_COPYRIGHT }, { "date", NODE_DATE }, + { "!doctype", NODE_DOCTYPE }, + { "!DOCTYPE", NODE_DOCTYPE }, { "editor", NODE_EDITOR }, { "email", NODE_EMAIL }, { "emphasis", NODE_EMPHASIS }, + { "!ENTITY", NODE_ENTITY }, { "entry", NODE_ENTRY }, { "envar", NODE_ENVAR }, + { "errorname", NODE_ERRORNAME }, { "fieldsynopsis", NODE_FIELDSYNOPSIS }, { "filename", NODE_FILENAME }, { "firstname", NODE_PERSONNAME }, @@ -91,6 +112,11 @@ static const struct element elements[] = { { "funcsynopsis", NODE_FUNCSYNOPSIS }, { "funcsynopsisinfo", NODE_FUNCSYNOPSISINFO }, { "function", NODE_FUNCTION }, + { "glossary", NODE_VARIABLELIST }, + { "glossdef", NODE_IGNORE }, + { "glossdiv", NODE_IGNORE }, + { "glossentry", NODE_VARLISTENTRY }, + { "glosslist", NODE_VARIABLELIST }, { "glossterm", NODE_GLOSSTERM }, { "group", NODE_GROUP }, { "holder", NODE_HOLDER }, @@ -98,7 +124,7 @@ static const struct element elements[] = { { "indexterm", NODE_DELETE }, { "info", NODE_INFO }, { "informalequation", NODE_INFORMALEQUATION }, - { "informaltable", NODE_INFORMALTABLE }, + { "informaltable", NODE_TABLE }, { "inlineequation", NODE_INLINEEQUATION }, { "itemizedlist", NODE_ITEMIZEDLIST }, { "keysym", NODE_KEYSYM }, @@ -161,11 +187,14 @@ static const struct element elements[] = { { "sect2", NODE_SECTION }, { "section", NODE_SECTION }, { "sgmltag", NODE_SGMLTAG }, + { "simpara", NODE_PARA }, { "simplelist", NODE_SIMPLELIST }, { "spanspec", NODE_SPANSPEC }, - { "structname", NODE_STRUCTNAME }, + { "structfield", NODE_PARAMETER }, + { "structname", NODE_TYPE }, { "subtitle", NODE_SUBTITLE }, { "surname", NODE_PERSONNAME }, + { "symbol", NODE_CONSTANT }, { "synopsis", NODE_SYNOPSIS }, { "table", NODE_TABLE }, { "tbody", NODE_TBODY }, @@ -177,8 +206,8 @@ static const struct element elements[] = { { "title", NODE_TITLE }, { "trademark", NODE_IGNORE }, { "type", NODE_TYPE }, - { "ulink", NODE_ULINK }, - { "userinput", NODE_USERINPUT }, + { "ulink", NODE_LINK }, + { "userinput", NODE_LITERAL }, { "variablelist", NODE_VARIABLELIST }, { "varlistentry", NODE_VARLISTENTRY }, { "varname", NODE_VARNAME }, @@ -189,6 +218,67 @@ static const struct element elements[] = { { NULL, NODE_IGNORE } }; +struct entity { + const char *name; + const char *roff; +}; + +/* + * XML character entity references found in the wild. + * Those that don't have an exact mandoc_char(7) representation + * are approximated, and the desired codepoint is given as a comment. + * Encoding them as \\[u...] would leave -Tascii out in the cold. + */ +static const struct entity entities[] = { + { "alpha", "\\(*a" }, + { "amp", "&" }, + { "apos", "'" }, + { "auml", "\\(:a" }, + { "beta", "\\(*b" }, + { "circ", "^" }, /* U+02C6 */ + { "copy", "\\(co" }, + { "dagger", "\\(dg" }, + { "Delta", "\\(*D" }, + { "eacute", "\\('e" }, + { "emsp", "\\ " }, /* U+2003 */ + { "gt", ">" }, + { "hairsp", "\\^" }, + { "kappa", "\\(*k" }, + { "larr", "\\(<-" }, + { "ldquo", "\\(lq" }, + { "le", "\\(<=" }, + { "lowbar", "_" }, + { "lsqb", "[" }, + { "lt", "<" }, + { "mdash", "\\(em" }, + { "minus", "\\-" }, + { "ndash", "\\(en" }, + { "nbsp", "\\ " }, + { "num", "#" }, + { "oslash", "\\(/o" }, + { "ouml", "\\(:o" }, + { "percnt", "%" }, + { "quot", "\\(dq" }, + { "rarr", "\\(->" }, + { "rArr", "\\(rA" }, + { "rdquo", "\\(rq" }, + { "reg", "\\(rg" }, + { "rho", "\\(*r" }, + { "rsqb", "]" }, + { "sigma", "\\(*s" }, + { "shy", "\\&" }, /* U+00AD */ + { "tau", "\\(*t" }, + { "tilde", "\\[u02DC]" }, + { "times", "\\[tmu]" }, + { "uuml", "\\(:u" }, + { NULL, NULL } +}; + +static size_t parse_string(struct parse *, char *, size_t, + enum pstate *, int); +static void parse_fd(struct parse *, int); + + static void error_msg(struct parse *p, const char *fmt, ...) { @@ -207,7 +297,7 @@ warn_msg(struct parse *p, const char *fmt, ...) { va_list ap; - if (p->warn == 0) + if ((p->flags & PFLAG_WARN) == 0) return; fprintf(stderr, "%s:%d:%d: warning: ", p->fname, p->line, p->col); @@ -226,6 +316,7 @@ static void xml_char(struct parse *ps, const char *p, int sz) { struct pnode *dat; + size_t newsz; if (ps->del > 0) return; @@ -241,6 +332,7 @@ xml_char(struct parse *ps, const char *p, int sz) exit(1); } dat->node = NODE_TEXT; + dat->spc = (ps->flags & PFLAG_SPC) != 0; dat->parent = ps->cur; TAILQ_INIT(&dat->childq); TAILQ_INIT(&dat->attrq); @@ -255,24 +347,108 @@ xml_char(struct parse *ps, const char *p, int sz) /* Append to the current text node. */ assert(sz >= 0); - ps->cur->b = realloc(ps->cur->b, ps->cur->bsz + sz + 1); + newsz = ps->cur->bsz + (ps->cur->bsz && (ps->flags & PFLAG_SPC)) + sz; + ps->cur->b = realloc(ps->cur->b, newsz + 1); if (ps->cur->b == NULL) { perror(NULL); exit(1); } + if (ps->cur->bsz && (ps->flags & PFLAG_SPC)) + ps->cur->b[ps->cur->bsz++] = ' '; memcpy(ps->cur->b + ps->cur->bsz, p, sz); - ps->cur->bsz += sz; - ps->cur->b[ps->cur->bsz] = '\0'; + ps->cur->b[ps->cur->bsz = newsz] = '\0'; ps->cur->real = ps->cur->b; + ps->flags &= ~PFLAG_SPC; } +/* + * Close out the text node and strip trailing whitespace, if one is open. + */ static void -pnode_trim(struct pnode *pn) +pnode_closetext(struct parse *p) { - assert(pn->node == NODE_TEXT); - for (; pn->bsz > 0; pn->b[--pn->bsz] = '\0') - if (isspace((unsigned char)pn->b[pn->bsz - 1]) == 0) + struct pnode *n; + + if ((n = p->cur) == NULL || n->node != NODE_TEXT) + return; + p->cur = n->parent; + while (n->bsz > 0 && isspace((unsigned char)n->b[n->bsz - 1])) { + n->b[--n->bsz] = '\0'; + p->flags |= PFLAG_SPC; + } +} + +static void +xml_entity(struct parse *p, const char *name) +{ + const struct entity *entity; + struct pnode *dat; + const char *ccp; + char *cp; + enum pstate pstate; + + if (p->del > 0) + return; + + if (p->cur == NULL) { + error_msg(p, "discarding entity before document: &%s;", name); + return; + } + + pnode_closetext(p); + + if (p->tree->flags & TREE_CLOSED && p->cur == p->tree->root) + warn_msg(p, "entity after end of document: &%s;", name); + + for (entity = entities; entity->name != NULL; entity++) + if (strcmp(name, entity->name) == 0) break; + + if (entity->roff == NULL) { + if (p->doctype != NULL) { + TAILQ_FOREACH(dat, &p->doctype->childq, child) { + if ((ccp = pnode_getattr_raw(dat, + ATTRKEY_NAME, NULL)) == NULL || + strcmp(ccp, name) != 0) + continue; + if ((ccp = pnode_getattr_raw(dat, + ATTRKEY_SYSTEM, NULL)) != NULL) { + parse_file(p, -1, ccp); + p->flags &= ~PFLAG_SPC; + return; + } + if ((ccp = pnode_getattr_raw(dat, + ATTRKEY_DEFINITION, NULL)) == NULL) + continue; + if ((cp = strdup(ccp)) == NULL) { + perror(NULL); + exit(1); + } + pstate = PARSE_ELEM; + parse_string(p, cp, strlen(cp), &pstate, 0); + p->flags &= ~PFLAG_SPC; + free(cp); + return; + } + } + error_msg(p, "unknown entity &%s;", name); + return; + } + + /* Create, append, and close out an entity node. */ + if ((dat = calloc(1, sizeof(*dat))) == NULL || + (dat->b = dat->real = strdup(entity->roff)) == NULL) { + perror(NULL); + exit(1); + } + dat->node = NODE_ESCAPE; + dat->bsz = strlen(dat->b); + dat->spc = (p->flags & PFLAG_SPC) != 0; + dat->parent = p->cur; + TAILQ_INIT(&dat->childq); + TAILQ_INIT(&dat->attrq); + TAILQ_INSERT_TAIL(&p->cur->childq, dat, child); + p->flags &= ~PFLAG_SPC; } /* @@ -284,30 +460,27 @@ xml_elem_start(struct parse *ps, const char *name) const struct element *elem; struct pnode *dat; - if (*name == '!' || *name == '?') - return; - /* * An ancestor is excluded from the tree; * keep track of the number of levels excluded. */ if (ps->del > 0) { - ps->del++; + if (*name != '!' && *name != '?') + ps->del++; return; } - /* Close out the text node, if there is one. */ - if (ps->cur != NULL && ps->cur->node == NODE_TEXT) { - pnode_trim(ps->cur); - ps->cur = ps->cur->parent; - } + pnode_closetext(ps); for (elem = elements; elem->name != NULL; elem++) if (strcmp(elem->name, name) == 0) break; - if (elem->name == NULL) + if (elem->name == NULL) { + if (*name == '!' || *name == '?') + return; error_msg(ps, "unknown element <%s>", name); + } ps->ncur = elem->node; @@ -334,7 +507,56 @@ xml_elem_start(struct parse *ps, const char *name) perror(NULL); exit(1); } - dat->node = elem->node; + + /* + * Nodes that begin a new macro or request line or start by + * printing text always want whitespace before themselves. + */ + + switch (dat->node = elem->node) { + case NODE_DOCTYPE: + case NODE_ENTITY: + case NODE_SBR: + ps->flags |= PFLAG_EEND; + /* FALLTHROUGH */ + case NODE_APPENDIX: + case NODE_AUTHORGROUP: + case NODE_BLOCKQUOTE: + case NODE_BOOKINFO: + case NODE_CAUTION: + case NODE_EDITOR: + case NODE_ENTRY: + case NODE_FUNCDEF: + case NODE_FUNCPROTOTYPE: + case NODE_INFORMALEQUATION: + case NODE_INLINEEQUATION: + case NODE_ITEMIZEDLIST: + case NODE_LEGALNOTICE: + case NODE_LITERALLAYOUT: + case NODE_NOTE: + case NODE_ORDEREDLIST: + case NODE_PARA: + case NODE_PREFACE: + case NODE_PROGRAMLISTING: + case NODE_REFMETA: + case NODE_REFNAMEDIV: + case NODE_REFSYNOPSISDIV: + case NODE_ROW: + case NODE_SCREEN: + case NODE_SECTION: + case NODE_SYNOPSIS: + case NODE_TGROUP: + case NODE_TIP: + case NODE_TITLE: + case NODE_VARIABLELIST: + case NODE_VARLISTENTRY: + case NODE_WARNING: + dat->spc = 1; + break; + default: + dat->spc = (ps->flags & PFLAG_SPC) != 0; + break; + } dat->parent = ps->cur; TAILQ_INIT(&dat->childq); TAILQ_INIT(&dat->attrq); @@ -343,7 +565,12 @@ xml_elem_start(struct parse *ps, const char *name) TAILQ_INSERT_TAIL(&ps->cur->childq, dat, child); ps->cur = dat; - if (ps->tree->root == NULL) + if (dat->node == NODE_DOCTYPE) { + if (ps->doctype == NULL) + ps->doctype = dat; + else + error_msg(ps, "duplicate doctype"); + } else if (dat->parent == NULL && ps->tree->root == NULL) ps->tree->root = dat; } @@ -351,12 +578,21 @@ static void xml_attrkey(struct parse *ps, const char *name) { struct pattr *attr; + const char *value; enum attrkey key; - if (ps->del > 0 || *name == '\0') + if (ps->del > 0 || ps->ncur == NODE_IGNORE || *name == '\0') return; + + if ((ps->ncur == NODE_DOCTYPE || ps->ncur == NODE_ENTITY) && + TAILQ_FIRST(&ps->cur->attrq) == NULL) { + value = name; + name = "NAME"; + } else + value = NULL; + if ((key = attrkey_parse(name)) == ATTRKEY__MAX) { - ps->attr = 0; + ps->flags &= ~PFLAG_ATTR; return; } if ((attr = calloc(1, sizeof(*attr))) == NULL) { @@ -365,9 +601,19 @@ xml_attrkey(struct parse *ps, const char *name) } attr->key = key; attr->val = ATTRVAL__MAX; - attr->rawval = NULL; + if (value == NULL) { + attr->rawval = NULL; + ps->flags |= PFLAG_ATTR; + } else { + if ((attr->rawval = strdup(value)) == NULL) { + perror(NULL); + exit(1); + } + ps->flags &= ~PFLAG_ATTR; + } TAILQ_INSERT_TAIL(&ps->cur->attrq, attr, child); - ps->attr = 1; + if (ps->ncur == NODE_ENTITY && key == ATTRKEY_NAME) + xml_attrkey(ps, "DEFINITION"); } static void @@ -375,7 +621,8 @@ xml_attrval(struct parse *ps, const char *name) { struct pattr *attr; - if (ps->del > 0 || ps->attr == 0) + if (ps->del > 0 || ps->ncur == NODE_IGNORE || + (ps->flags & PFLAG_ATTR) == 0) return; if ((attr = TAILQ_LAST(&ps->cur->attrq, pattrq)) == NULL) return; @@ -405,11 +652,8 @@ xml_elem_end(struct parse *ps, const char *name) return; } - /* Close out the text node, if there is one. */ - if (ps->del == 0 && ps->cur != NULL && ps->cur->node == NODE_TEXT) { - pnode_trim(ps->cur); - ps->cur = ps->cur->parent; - } + if (ps->del == 0) + pnode_closetext(ps); if (name != NULL) { for (elem = elements; elem->name != NULL; elem++) @@ -427,6 +671,9 @@ xml_elem_end(struct parse *ps, const char *name) break; case NODE_IGNORE: break; + case NODE_DOCTYPE: + ps->flags &= ~PFLAG_EEND; + /* FALLTHROUGH */ default: if (ps->cur == NULL || node != ps->cur->node) { warn_msg(ps, "element not open: ", name); @@ -440,10 +687,13 @@ xml_elem_end(struct parse *ps, const char *name) * obviously better than discarding it or crashing. */ - if (ps->cur->parent == NULL) - ps->tree->flags |= TREE_CLOSED; - else + if (ps->cur->parent != NULL || node == NODE_DOCTYPE) { ps->cur = ps->cur->parent; + if (ps->cur != NULL) + ps->ncur = ps->cur->node; + } else + ps->tree->flags |= TREE_CLOSED; + ps->flags &= ~PFLAG_SPC; break; } assert(ps->del == 0); @@ -461,7 +711,10 @@ parse_alloc(int warn) free(p); return NULL; } - p->warn = warn; + if (warn) + p->flags |= PFLAG_WARN; + else + p->flags &= ~PFLAG_WARN; return p; } @@ -477,6 +730,19 @@ parse_free(struct parse *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. * If the charset starts with a space, it stands for any whitespace. @@ -487,7 +753,7 @@ parse_free(struct parse *p) */ static int advance(struct parse *p, char *b, size_t rlen, size_t *pend, - const char *charset) + const char *charset, int refill) { int space; @@ -497,222 +763,304 @@ advance(struct parse *p, char *b, size_t rlen, size_t } else space = 0; - p->nline = p->line; - p->ncol = p->col; + if (refill) { + p->nline = p->line; + p->ncol = p->col; + } while (*pend < rlen) { - if (b[*pend] == '\n') { - p->nline++; - p->ncol = 1; - } else - p->ncol++; if (space && isspace((unsigned char)b[*pend])) break; if (strchr(charset, b[*pend]) != NULL) break; - ++*pend; + increment(p, b, pend, refill); } if (*pend == rlen) { b[rlen] = '\0'; - return 1; + return refill; } else return 0; } -struct ptree * -parse_file(struct parse *p, int fd, const char *fname) +size_t +parse_string(struct parse *p, char *b, size_t rlen, + enum pstate *pstate, int refill) { - char b[4096]; char *cp; - ssize_t rsz; /* Return value from read(2). */ - size_t rlen; /* Number of bytes in b[]. */ size_t poff; /* Parse offset in b[]. */ 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; - p->nline = 1; - p->ncol = 1; - rlen = 0; - in_tag = in_arg = in_quotes = 0; + pend = 0; + for (;;) { - /* - * 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. - */ + /* Proceed to the next token, skipping whitespace. */ - while ((rsz = read(fd, b + rlen, sizeof(b) - rlen - 1)) >= 0) { - if ((rlen += rsz) == 0) + if (refill) { + p->line = p->nline; + p->col = p->ncol; + } + if ((poff = pend) == rlen) break; + if (isspace((unsigned char)b[pend])) { + p->flags |= PFLAG_SPC; + 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; - for (;;) { + /* Parse an attribute value. */ - /* Proceed to the next token, skipping whitespace. */ - - p->line = p->nline; - p->col = p->ncol; - if ((poff = pend) == rlen) - break; - if (isspace((unsigned char)b[pend])) { - if (b[pend++] == '\n') { - p->nline++; - p->ncol = 1; - } else - p->ncol++; + if (*pstate >= PARSE_ARG) { + if (*pstate == PARSE_ARG && + (b[pend] == '\'' || b[pend] == '"')) { + *pstate = b[pend] == '"' ? + PARSE_DQ : PARSE_SQ; + increment(p, b, &pend, refill); 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); - /* - * The following three cases (in_arg, in_tag, - * and starting 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, they all 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. - */ + /* Look for an attribute name. */ - /* Parse an attribute value. */ - - if (in_arg) { - if (in_quotes == 0 && b[pend] == '"') { - in_quotes = 1; - p->ncol++; - pend++; + } else if (*pstate == PARSE_TAG) { + switch (p->ncur) { + case NODE_DOCTYPE: + if (b[pend] == '[') { + *pstate = PARSE_ELEM; + increment(p, b, &pend, refill); continue; } - if (advance(p, b, rlen, &pend, - in_quotes ? "\"" : " >") && rsz > 0) - break; - 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, ""); - 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++; - } + /* FALLTHROUGH */ + case NODE_ENTITY: + if (b[pend] == '"' || b[pend] == '\'') { + *pstate = PARSE_ARG; continue; } - elem_end = 0; - if (b[pend] != '>') - in_tag = 1; - else if (pend > 0 && b[pend - 1] == '/') { + break; + default: + break; + } + 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'; elem_end = 1; } - b[pend] = '\0'; - if (pend < rlen) - pend++; - if (b[++poff] == '/') { + if (p->flags & PFLAG_EEND) elem_end = 1; - poff++; - } else - xml_elem_start(p, b + poff); - if (elem_end) - xml_elem_end(p, b + poff); + break; + case '=': + *pstate = PARSE_ARG; + break; + 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 text up to the next tag. */ + /* Begin an opening or closing tag. */ + } else if (b[poff] == '<') { + if (advance(p, b, rlen, &pend, " >", refill)) + break; + if (pend > poff + 3 && + strncmp(b + poff, ""); + 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 { - if (advance(p, b, rlen, &pend, "<") == 0) - p->ncol--; - xml_char(p, b + poff, pend - poff); + xml_elem_start(p, b + poff); + if (*pstate == PARSE_ELEM && + 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, "<&", refill); + xml_char(p, b + poff, pend - poff); } + } + 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); - memmove(b, b + poff, rlen - poff); rlen -= poff; + memmove(b, b + poff, rlen); } - if (rsz < 0) { - perror(fname); - p->tree->flags |= TREE_FAIL; + if (rsz < 0) + error_msg(p, "read: %s", strerror(errno)); +} + +/* + * 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); + 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; }