ref: 17b3ae4f1a1ce71b26bd2d383c9be513af29bb66
dir: /libxml/xmlparse.c/
#include <u.h>
#include <libc.h>
#include <ctype.h>
#include <bio.h>
#include "xml.h"
#include "state-machine.h"
int xmldebug = 0;
enum {
Grain = 16
};
#define isname1(c) (isalpha((c)) || c == '_') /* FIXME: not enforced yet */
#define isnameN(r) (isalpharune((r)) || isdigitrune((r)) || r == L'_' || r == L'-' || r == L'.' || r == L':')
#define Roundup(x, g) (((x) + (unsigned)(g-1)) & ~((unsigned)(g-1)))
enum {
Ntext = 1024, /* longest name or atribute value possible */
Nref = 32 /* longest entity reference name */
};
typedef struct {
int line; /* Line number (for errors) */
Biobuf *bp; /* input stream */
int flags; /* misc flags, see xml.h */
Xml *xml;
int failed;
} State;
typedef struct {
char *buf;
int sz;
} Lexbuf;
static int
trimwhite(char *s)
{
char *p;
for(p = s; *p; p++)
if(! isspace(*p))
return 0;
/* trim any whitespace into a single space */
s[0] = ' ';
s[1] = 0;
return 1;
}
static void
growstr(State *st, Lexbuf *lb, char *str)
{
int b, s, sz;
if(str == nil || *str == 0)
return;
if((st->flags & Fcrushwhite) && trimwhite(str) &&
(lb->buf == nil || lb->buf[0] == 0))
return;
b = 0;
if(lb->buf)
b = strlen(lb->buf);
s = strlen(str);
sz = Roundup(b+s+1, Grain);
if(sz >= lb->sz){
lb->buf = realloc(lb->buf, sz);
if(lb->buf == nil)
sysfatal("No memory, wanted %d bytes\n", sz);
lb->sz = sz;
}
strcpy(lb->buf+b, str);
}
static void
growrune(State *st, Lexbuf *lb, Rune r)
{
int n;
char str[UTFmax+1];
n = runetochar(str, &r);
str[n] = 0;
growstr(st, lb, str);
}
static void
stripns(char *str)
{
char *p;
if((p = strrchr(str, ':')) == nil)
return;
strcpy(str, p+1);
}
static void
failed(State *st, char *fmt, ...)
{
int n;
va_list arg;
char err[ERRMAX];
st->failed = 1;
va_start(arg, fmt);
n = snprint(err, sizeof(err), "%d ", st->line);
vsnprint(err+n, sizeof(err)-n, fmt, arg);
va_end(arg);
werrstr("%s", err);
}
static void
unget(State *st, int c)
{
if(c == '\n')
st->line--;
Bungetrune(st->bp);
}
static long
get(State *st)
{
long r;
r = Bgetrune(st->bp);
if(r == Runeerror){
failed(st, "bad UTF-8 sequence");
r = L' ';
}
if(r == L'\n')
st->line++;
if(xmldebug){
if(xmldebug == 3)
fprint(2, "%C", (Rune)r);
if(xmldebug == 1 && r == -1)
fprint(2, "EOF\n");
}
return r;
}
static struct {
char *name;
Rune rune;
} Entities[] = {
{ "amp", L'&' },
{ "lt", L'<' },
{ "gt", L'>' },
{ "apos", L'\'' },
{ "quot", L'"' },
{ "nbsp", 0xa0 }, /* no-break space */
};
static long
entityref(State *st)
{
int n, i, l;
long r;
Rune x;
char *p, buf[Nref];
l = 0;
p = buf;
while((r = get(st)) != -1 && r != L';' && ! isspacerune(r))
if(l < (sizeof(buf) - UTFmax)){
x = r;
n = runetochar(p, &x);
p += n;
l += n;
}
*p = 0;
if(r == -1)
return -1;
/* false positive */
if(r != L';'){
fprint(2, "%d: unquoted '&' - ignored\n", st->line);
for(i = --l; i >= 0; i--)
unget(st, buf[i]);
return L'&';
}
if(buf[0] == '#'){
if(buf[1] == 'x' || buf[1] == 'X')
return strtol(buf+2, 0, 16);
return strtol(buf+1, 0, 10);
}
for(i = 0; i < nelem(Entities); i++)
if(memcmp(Entities[i].name, buf, l) == 0)
return Entities[i].rune;
fprint(2, "%d: '&%s;' unknown/unsupported entity reference\n", st->line, buf);
return L'?';
}
static int
match(State *st, Rune *s)
{
long r;
Rune *p;
r = -1;
for(p = s; *p; p++)
if((r = get(st)) != *p)
break;
if(r == -1)
return -1; /* EOF */
if(*p == 0)
return 0; /* match */
unget(st, r);
for(p--; p >= s; p--)
unget(st, *p);
return 1; /* no match */
}
static int
comment(State *st)
{
long r;
int startline;
startline = st->line;
do{
if(get(st) == -1)
break;
}while(match(st, L"--") == 1);
r = get(st);
if(r == -1){
failed(st, "EOF in comment (re: line %d)", startline);
return -1;
}
if(r != L'>'){
failed(st, "'--' illegal in a comment (re: line %d)", startline);
return Twhite;
}
return Twhite;
}
static int
doctype(State *st, Lexbuf *lb)
{
long r;
char *p;
int startline;
startline = st->line;
/* trim leading whitespace */
while((r = get(st)) != -1 && isspacerune(r))
continue;
unget(st, r);
if(lb->buf)
lb->buf[0] = 0;
while((r = get(st)) != -1 && r != L'>')
growrune(st, lb, r);
if(r == -1){
failed(st, "EOF in DOCTYPE (re: line %d)", startline);
return -1;
}
/* trim trailing whitespace */
p = strrchr(lb->buf, 0);
for(p--; p >= lb->buf && isspace(*p); p--)
*p = 0;
st->xml->doctype = xmlstrdup(st->xml, lb->buf, 0);
return Twhite;
}
static int
cdata(State *st, Lexbuf *lb)
{
long r;
int startline;
startline = st->line;
do{
if((r = get(st)) == -1)
break;
if(r == L'&')
if((r = entityref(st)) == -1)
break;
growrune(st, lb, r);
}while(match(st, L"]]>") == 1);
if(r == -1){
failed(st, "EOF in CDATA (re: line %d)", startline);
return -1;
}
return Tname;
}
/*
* byte order mark.
* This is pointless for utf8 which has defined byte order,
* and we don't support utf16 or utf32 but some xml seems to
* prepend them to utf8 so we need to find them and skip them
*/
static int
bom(State *st)
{
long r;
if((r = get(st)) == -1)
return -1;
if(r != 0xbb){
unget(st, 0xef);
unget(st, r);
return -1;
}
if((r = get(st)) == -1){
unget(st, 0xef);
unget(st, 0xbb);
return -1;
}
if(r != 0xbf){
unget(st, 0xef);
unget(st, 0xbb);
unget(st, r);
}
return 0;
}
static int
xlex(State *st, Lexbuf *lb, int s)
{
long r;
Rune q;
while((r = get(st)) != -1){
if(r == 0xef)
if(bom(st) == 0)
continue;
if(r == L'<'){
r = get(st);
switch(r){
case L'?':
while((r = get(st)) != -1 && r != L'>')
continue;
if(r == -1)
return -1;
return Twhite;
case L'!':
if(match(st, L"--") == 0)
return comment(st);
if(match(st, L"DOCTYPE ") == 0)
return doctype(st, lb);
if(match(st, L"[CDATA[") == 0)
return cdata(st, lb);
failed(st, "<!name not known");
case L'/':
return Tendblk;
case L' ':
case L'\t':
case L'\f':
case L'\n':
case L'\r':
failed(st, "whitespace following '<'");
break;
default:
unget(st, r);
return Topen;
}
continue;
}
if(s != Slost){
switch(r){
case '=':
return Tequal;
case '>':
return Tclose;
case '/':
r = get(st);
if(r == '>')
return Tnulblk;
unget(st, r);
continue;
case '\'':
case '"': /* attribute value */
q = r;
while((r = get(st)) != -1 && r != q){
if(r == L'&')
if((r = entityref(st)) == -1)
break;
growrune(st, lb, r);
}
if(r == -1)
return -1;
return Tname;
case '\n':
case '\r':
case ' ':
case '\v':
case '\f':
case '\t':
do
growrune(st, lb, r);
while((r = get(st)) != -1 && isspacerune(r));
if(r == -1)
return -1;
unget(st, r);
return Twhite;
default: /* attribute name */
do
growrune(st, lb, r);
while((r = get(st)) != -1 && isnameN(r));
if(r == -1)
return -1;
unget(st, r);
return Tname;
}
}
do{
if(r == L'&')
if((r = entityref(st)) == -1)
break;
growrune(st, lb, r);
}while((r = get(st)) != -1 && r != '<');
if(r == -1)
return -1;
unget(st, r);
return Tname;
}
return -1;
}
static Elem *
_xmlparse(State *st, Elem *parent, int depth)
{
Attr *ap;
Lexbuf lexbuf, *lb;
Lexbuf pcdata, *pc;
Elem *root, *ep;
int os, s, t, a;
ap = nil;
ep = nil;
s = Slost;
root = nil;
lb = &lexbuf;
memset(lb, 0, sizeof(Lexbuf));
pc = &pcdata;
memset(pc, 0, sizeof(Lexbuf));
while((t = xlex(st, lb, s)) != -1){
os = s;
s = statab[os][t];
a = acttab[os][t];
if(xmldebug == 2)
fprint(2, "depth=%d token=%s action=%s state=%s->%s str='%s'\n",
depth, tokstr[t], actstr[a], stastr[os], stastr[s], lb->buf);
switch(a){
case Aelem:
if(xmldebug == 1)
fprint(2, "%-3d %*.selem name='%s'\n", st->line, depth, "", lb->buf);
if(!isname1(lb->buf[0]))
failed(st, "'%s' is an illegal element name", lb->buf);
if(st->flags & Fstripnamespace)
stripns(lb->buf);
assert((ep = xmlelem(st->xml, &root, parent, lb->buf)) != nil);
ep->line = st->line;
break;
case Apcdata:
if(parent)
growstr(st, pc, lb->buf);
break;
case Aattr:
assert(ep != nil);
if(xmldebug == 1)
fprint(2, "%-3d %*.sattr name='%s'\n", st->line, depth, "", lb->buf);
if(!isname1(lb->buf[0]))
failed(st, "'%s' is an illegal attribute name", lb->buf);
if(st->flags & Fstripnamespace)
stripns(lb->buf);
assert((ap = xmlattr(st->xml, &(ep->attrs), ep, lb->buf, nil)) != nil);
break;
case Avalue:
assert(ep != nil);
assert(ap != nil);
ap->value = xmlstrdup(st->xml, lb->buf, 0);
ap = nil;
if(xmldebug == 1)
fprint(2, "%*.sattr value=%s\n", depth, "", lb->buf);
break;
case Adown:
assert(ep != nil);
if(xmldebug == 1)
fprint(2, "%*.sdown name=%s\n", depth, "", ep->name);
ep->child = _xmlparse(st, ep, depth+1);
if(xmldebug == 1 && ep->pcdata)
fprint(2, "%*.s name=%s pcdata len=%ld\n",
depth, "",
ep->name,
(ep->pcdata)? strlen(ep->pcdata): 0L);
break;
case Aup:
if(pc->buf){
parent->pcdata = xmlstrdup(st->xml, pc->buf, 0);
free(pc->buf);
}
free(lb->buf);
return root;
/* NOTREACHED */
break;
case Acheck:
assert(ep != nil);
if(st->flags & Fstripnamespace)
stripns(lb->buf);
if(ep->name && strcmp(lb->buf, ep->name) != 0)
failed(st, "</%s> found, expecting match for <%s> (re: line %d) - nesting error",
lb->buf, ep->name, ep->line);
break;
case Anop:
break;
case Aerr:
failed(st, "%s syntax error", lb->buf);
break;
default:
sysfatal("xmlparse: %d - internal error, unknown action\n", a);
break;
}
if(lb->buf)
lb->buf[0] = 0;
}
if(t == -1 && depth != 0)
failed(st, "unexpected EOF (depth=%d)", depth);
if(pc->buf){
parent->pcdata = xmlstrdup(st->xml, pc->buf, 0);
free(pc->buf);
}
free(lb->buf);
return root;
}
Xml *
xmlparse(int fd, int blksize, int flags)
{
State s;
Biobuf bio;
Xml *x;
memset(&s, 0, sizeof(s));
s.line = 1;
Binit(&bio, fd, OREAD);
s.bp = &bio;
s.flags = flags;
x = xmlnew(blksize);
s.xml = x;
x->root = _xmlparse(&s, nil, 0);
if(s.failed){
if(x)
xmlfree(x);
x = nil;
}
Bterm(&bio);
return x;
}