int StartElement(struct XMLReader_t *r, const XMLCH *uri, const XMLCH *localName, const XMLCH *qName, LPXMLVECTOR atts)
{
union XMLReaderNode_t *rn = XMLVector_Append(r->eventbuffer, NULL);
ASSERT_MEM_ABORT(rn);
rn->type = XMLREADERTYPE_STARTELEMENT;
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[1], (XMLCH*)uri, rn->startelement.ibuf[0]));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[1], (XMLCH*)localName, rn->startelement.ibuf[1]));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[1], (XMLCH*)qName, rn->startelement.ibuf[2]));
if (r->atts->length) ASSERT_MEM_ABORT(_XMLVector_RemoveAll(r->atts));
if (atts->length) {
struct XMLReaderAttribute_t *a;
int i;
for (i=0; i<atts->length; i++) {
LPXMLRUNTIMEATT aa = XMLVector_Get(atts, i);
ASSERT_MEM_ABORT(a = XMLVector_Append(r->atts, NULL));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[2], aa->uri, a->ibuf[0]));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[2], aa->localName, a->ibuf[1]));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[2], aa->qname, a->ibuf[2]));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[2], aa->value, a->ibuf[3]));
}
}
return XML_OK;
}
int StartElement(void *UserData, const XMLCH *uri, const XMLCH *localName, const XMLCH *qName, LPXMLVECTOR atts)
{
LPXMLDTDVALIDATOR v = (LPXMLDTDVALIDATOR)UserData;
if (!strcmp(uri, NSVALIDP->wantedUri)) {
LPXMLVECTOR attsF;
if (v->UserFlag) v->UserFlag = 0;
NSVALIDP->elemCount++;
if (!atts->length)
attsF = atts;
else {
int i;
LPXMLRUNTIMEATT a;
if (NSVALIDP->filteredAtts->length)
_XMLVector_RemoveAll(NSVALIDP->filteredAtts);
for (i=0; i<atts->length; i++) {
a = XMLVector_Get(atts, i);
if (!*a->uri || !strcmp(a->uri, NSVALIDP->wantedUri))
a = XMLVector_Append(NSVALIDP->filteredAtts, a);
ASSERT_MEM_ABORT(a);
}
attsF = NSVALIDP->filteredAtts;
}
return DTDValidate_StartElement(v, uri, localName, localName, attsF);
}
v->UserFlag++;
return XML_OK;
}
int StartElement(void *UserData, const XMLCH *uri, const XMLCH *localName, const XMLCH *qName, LPXMLVECTOR atts)
{
LPXMLDTDVALIDATOR v = (LPXMLDTDVALIDATOR)UserData;
if (!strcmp(qName, "book")) {
int ret;
LPXMLRUNTIMEATT a;
/* append and initialize new book: */
BOOKP->curBook = XMLVector_Append(BOOKP->books, NULL);
ASSERT_MEM_ABORT(BOOKP->curBook);
memset(BOOKP->curBook, 0, sizeof(struct tagBOOK));
BOOKP->fld = -1;
/* get book id: */
a = XMLParser_GetNamedItem(v->parser, "id");
/* a == NULL doesn't happen 'cos id is #REQUIRED */
ret = sscanf(a->value, "bk%d", &BOOKP->curBook->id);
ASSERT_SCANF_ABORT(ret, 1, a->qname);
}
else if (!strcmp(qName, "author")) BOOKP->fld = offsetof(BOOK, author);
else if (!strcmp(qName, "title")) BOOKP->fld = offsetof(BOOK, title);
else if (!strcmp(qName, "genre")) BOOKP->fld = offsetof(BOOK, genre);
else if (!strcmp(qName, "price")) BOOKP->fld = offsetof(BOOK, price);
else if (!strcmp(qName, "publish_date")) BOOKP->fld = offsetof(BOOK, publish_date);
else if (!strcmp(qName, "description")) BOOKP->fld = offsetof(BOOK, description);
return XML_OK;
}
static int CommonChars(struct XMLReader_t *r, int type, const XMLCH *chars, int cbSize)
{
if (!r->buf[0].len) {
union XMLReaderNode_t *rn = XMLVector_Append(r->eventbuffer, NULL);
ASSERT_MEM_ABORT(rn);
rn->type = type;
}
ASSERT_MEM_ABORT(XMLStringbuf_Append(&r->buf[0], (XMLCH*)chars, cbSize));
return XML_OK;
}
int EndElement(struct XMLReader_t *r, const XMLCH *uri, const XMLCH *localName, const XMLCH *qName)
{
union XMLReaderNode_t *rn = XMLVector_Append(r->eventbuffer, NULL);
ASSERT_MEM_ABORT(rn);
rn->type = XMLREADERTYPE_ENDELEMENT;
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[1], (XMLCH*)uri, rn->endelement.ibuf[0]));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[1], (XMLCH*)localName, rn->endelement.ibuf[1]));
ASSERT_MEM_ABORT(IBUF_PUT(&r->buf[1], (XMLCH*)qName, rn->endelement.ibuf[2]));
return XML_OK;
}
static struct FSAState *AddState(LPXMLDTDVALIDATOR p)
{
struct FSAState **s2, *s = XMLPool_Alloc(p->StatePool);
CHKMEM(s);
s->mark = 0;
s->trans = NULL;
s2 = XMLVector_Append(p->fsa, NULL);
CHKMEM(s2);
*s2 = s;
return s;
}
static int AddNextCatalog(LPXMLRUNTIMEATT cat)
{
XMLCH **uri;
ASSERT_MEM_ABORT(cat); /* shouldn't happen */
if (!nextCatalog) {
XMLVector_Create(&nextCatalog, 0, sizeof(char*));
ASSERT_MEM_ABORT(nextCatalog);
}
uri = XMLVector_Append(nextCatalog, NULL);
ASSERT_MEM_ABORT(uri);
return GetUriAndBase(cat, uri);
}
static int Pi(struct XMLReader_t *r, const XMLCH *target, const XMLCH *data)
{
union XMLReaderNode_t *rn = XMLVector_Append(r->eventbuffer, NULL);
int idata;
ASSERT_MEM_ABORT(rn);
rn->type = XMLREADERTYPE_PI;
ASSERT_MEM_ABORT(XMLStringbuf_Append(&r->buf[0], (XMLCH*)target, strlen((const char*)target)+1));
idata = r->buf[0].len;
rn->pi.target = XMLStringbuf_Append(&r->buf[0], (XMLCH*)data, strlen((const char*)data)+1);
ASSERT_MEM_ABORT(rn->pi.target);
rn->pi.data = r->buf[0].str+idata;
return XML_OK;
}
static struct FSATran *AddTran(struct FSAState *src, struct FSAState *dst, void *label)
{
struct FSATran *t;
if (!src->trans) {
XMLVector_Create(&src->trans, 4, sizeof(struct FSATran));
CHKMEM(src->trans);
}
t = XMLVector_Append(src->trans, NULL);
CHKMEM(t);
t->label = label;
t->src = src;
t->dst = dst;
return t;
}
static int AddElementDecl(LPXMLDTDVALIDATOR vp, XMLCH *name, XMLCP *cm)
{
struct ElementDecl *e;
e = XMLVector_Append(vp->ElementDecls, NULL);
if (!e) {
Er_(vp, NULL, ERR_XMLDTDV_MEMORY_ALLOC);
return 0;
}
/* We set the initial startState value to SimpleState and not to NULL;
this is good for types ANY, EMPTY or simple (#PCDATA) */
e->startState = (struct FSAState*)SimpleState;
e->fsa = e->declAtts = NULL;
e->name = name;
e->type = cm->type;
e->cp = cm;
return 1;
}
static int AddUri(LPXMLVECTOR *v, LPXMLRUNTIMEATT idAtt)
{
struct IDs *id;
LPXMLRUNTIMEATT a;
ASSERT_MEM_ABORT(idAtt); /* shouldn't happen */
if (!*v) {
XMLVector_Create(v, 0, sizeof(struct IDs));
ASSERT_MEM_ABORT(*v);
}
id = XMLVector_Append(*v, NULL);
ASSERT_MEM_ABORT(id);
id->uri = NULL;
id->id = strdup(idAtt->value);
ASSERT_MEM_ABORT(id->id);
a = XMLParser_GetNamedItem(parser, "uri");
ASSERT_MEM_ABORT(a);
return GetUriAndBase(a, &id->uri);
}
static int NFAtoDFA(LPXMLDTDVALIDATOR vp, struct ElementDecl *e)
{
struct FSAState **sw, **s, **se;
struct FSATran *t, *te;
LPXMLVECTOR o;
int i;
XMLVector_Create(&o, 0, sizeof(struct FSAState*));
if (!o) return 0;
SET_SMARK(e->startState, SMARK_USEFUL, 1);
se = (struct FSAState **)_XMLVector_GetIterP(e->fsa, s);
for (;s!=se;s++) {
if ((*s)->trans) {
te = (struct FSATran *)_XMLVector_GetIterP((*s)->trans, t);
for (; t!=te; t++) {
if (t->label != epsilon) {
SET_SMARK(t->dst, SMARK_USEFUL, 1);
}
}
}
}
se = (struct FSAState **)_XMLVector_GetIterP(e->fsa, s);
for (;s!=se;s++) {
if ((*s)->mark & SMARK_USEFUL) {
SET_SMARK((*s), SMARK_INUSE, 1);
if ((*s)->trans) {
for (i=0; i<(*s)->trans->length; i++) {
t = XMLVector_Get((*s)->trans, i);
if (t->label == epsilon) {
if (!AddEpsilonClosure(*s, t->dst)) return 0;
}
}
}
UnMarkFSA(e->fsa, SMARK_INUSE);
}
}
se = (struct FSAState **)_XMLVector_GetIterP(e->fsa, s);
for (;s!=se;s++) {
if ((*s)->mark & SMARK_USEFUL) {
if ((*s)->trans) {
for (i=0; i<(*s)->trans->length; i++) {
t = XMLVector_Get((*s)->trans, i);
if (t->label == epsilon) {
if (!XMLVector_Remove((*s)->trans, i)) return 0;
i--;
}
}
}
sw = XMLVector_Append(o, NULL);
if (!sw) return 0;
*sw = *s;
}
else if ((*s)->trans) {
XMLVector_Free((*s)->trans);
}
}
XMLVector_Free(e->fsa);
e->fsa = o;
return 1;
}
