void XMLReader_Free(struct XMLReader_t *r)
{
int i;
if (!r) return;
if (r->parser) XMLParser_Free(r->parser);
if (r->atts) XMLVector_Free(r->atts);
if (r->eventbuffer) XMLVector_Free(r->eventbuffer);
for (i=0; i<sizeof(r->buf)/sizeof(r->buf[0]); i++) {
XMLStringbuf_Free(&r->buf[i]);
}
if (r->dtdv) XMLParser_FreeDTDValidator(r->dtdv);
if (r->dynamicalloc) free(r);
}
void vfilter_Cleanup(LPXMLDTDVALIDATOR dtd)
{
if (dtd && filteredAtts) {
XMLVector_Free(filteredAtts);
filteredAtts = NULL;
}
}
static void FreeDTDValidator(LPXMLDTDVALIDATOR p, int ForReuse)
{
if (p->ElementDecls) {
struct ElementDecl *pEl, *pEnd;
struct FSAState **pS, **pSEnd;
pEnd = (struct ElementDecl *)_XMLVector_GetIterP(p->ElementDecls, pEl);
for (; pEl!=pEnd; pEl++) {
if (pEl->fsa) {
pSEnd = (struct FSAState **)_XMLVector_GetIterP(pEl->fsa, pS);
for (; pS!=pSEnd; pS++) {
if ((*pS)->trans) XMLVector_Free((*pS)->trans);
}
XMLVector_Free(pEl->fsa);
}
}
if (ForReuse) _XMLVector_RemoveAll(p->ElementDecls);
else XMLVector_Free(p->ElementDecls);
}
/* these are allocated by the parser when XMLFLAG_REPORT_DTD_EXT
is set, we're responsible for freeing them: */
if (p->cpNodesPool)
XMLPool_FreePool(p->cpNodesPool);
if (p->ElementTable)
XMLHTable_Destroy(p->ElementTable, NULL, 0);
if (p->idTable)
XMLHTable_Destroy(p->idTable, NULL, 0);
if (ForReuse) {
if (p->StatePool && p->StatePool->blocksAllocated) {
XMLPool_FreePool(p->StatePool);
p->StatePool = XMLPool_Create(sizeof(struct FSAState), 16);
if (!p->StatePool) Er_(p, NULL, ERR_XMLDTDV_MEMORY_ALLOC);
}
return;
}
if (p->StatePool)
XMLPool_FreePool(p->StatePool);
if (p->ContextStack)
XMLVector_Free(p->ContextStack);
free(p);
}
static void CleanupIds(LPXMLVECTOR v)
{
int i;
for (i=0; i<v->length; i++) {
struct IDs *id = XMLVector_Get(v, i);
if (id->id) free(id->id);
if (id->uri) free(id->uri);
}
XMLVector_Free(v);
}
void Catalogs_Cleanup(void)
{
if (publicIDS) CleanupIds(publicIDS);
if (systemIDS) CleanupIds(systemIDS);
if (nextCatalog) {
int i;
char **uri;
for (i=0; i<nextCatalog->length; i++) {
uri = XMLVector_Get(nextCatalog, i);
if (*uri) free(*uri);
}
XMLVector_Free(nextCatalog);
}
}
LPXMLDTDVALIDATOR XMLAPI XMLParser_CreateDTDValidator(void)
{
LPXMLDTDVALIDATOR v = malloc(sizeof(XMLDTDVALIDATOR));
if (!v) return NULL;
memset(v, 0, sizeof(XMLDTDVALIDATOR));
XMLVector_Create(&v->ElementDecls, 16, sizeof(struct ElementDecl));
if (!v->ElementDecls) goto ExitErr;
XMLVector_Create(&v->ContextStack, 0, sizeof(struct vContext));
if (!v->ContextStack) goto ExitErr;
v->StatePool = XMLPool_Create(sizeof(struct FSAState), 16);
if (!v->StatePool) goto ExitErr;
v->startElementHandlerFilter = DTDValidate_StartElement;
v->endElementHandlerFilter = DTDValidate_EndElement;
v->charactersHandlerFilter = DTDValidate_Characters;
v->ignorableWhitespaceHandlerFilter = DTDValidate_IgnorableWhitespace;
return v;
ExitErr:
if (v->ElementDecls) XMLVector_Free(v->ElementDecls);
if (v->ContextStack) XMLVector_Free(v->ContextStack);
if (v->StatePool) XMLPool_FreePool(v->StatePool);
free(v);
return NULL;
}
int main(int argc, char* argv[])
{
NSVALIDPARSER nsparser;
LPXMLPARSER parser;
LPXMLDTDVALIDATOR vp;
FILE *f;
int i;
XMLCH *filename = NULL;
if (argc < 2 || argc > 4) goto USAGE;
nsparser.elemCount = 0;
nsparser.wantedUri = "";
*nsparser.userDTD = '\0';
*nsparser.base = '\0';
for (i=1; i<argc; i++) {
if (!strncmp(argv[i], "/DTD:", 5))
strcpy(nsparser.userDTD, argv[i]+5);
else if (!strncmp(argv[i], "/URI:", 5))
nsparser.wantedUri = argv[i]+5;
else {
if (filename) goto USAGE;
filename = argv[i];
}
}
if (!filename) goto USAGE;
if (!XMLParser_Create(&parser)) {
puts("Out of memory!");
return 1;
}
vp = XMLParser_CreateDTDValidator();
if (!vp) {
puts("Out of memory!");
return 1;
}
if (!XMLVector_Create(&nsparser.filteredAtts, 0, sizeof(XMLRUNTIMEATT))) {
puts("Out of memory!");
return 1;
}
vp->UserData = &nsparser;
parser->errorHandler = ErrorHandler;
parser->resolveEntityHandler = ResolveEntity;
parser->externalEntityParsedHandler = FreeInputData;
if (*nsparser.userDTD) {
int filepos = GetBaseDir(nsparser.base, nsparser.userDTD);
if (filepos) strcpy(nsparser.userDTD, nsparser.userDTD+filepos);
XMLParser_SetExternalSubset(parser, NULL, nsparser.userDTD);
}
if (!*nsparser.base)
GetBaseDir(nsparser.base, filename);
if (*nsparser.wantedUri) {
vp->startElementHandlerFilter = StartElement;
vp->endElementHandlerFilter = EndElement;
vp->charactersHandlerFilter = Characters;
vp->ignorableWhitespaceHandlerFilter = IgnorableWS;
}
else /* simple validator w/o namespace filter: */
parser->startElementHandler = StartElementSimple;
if (!(f = fopen(filename, "rb"))) {
printf("Error opening file %s\n", filename);
return 1;
}
if (XMLParser_ParseValidateDTD(vp, parser, cstream, f, 0)) {
printf("Elements (total: %d) in namespace \"%s\" were valid\nin the"
" document %s\n", nsparser.elemCount,
((*nsparser.wantedUri) ? nsparser.wantedUri : "not specified"),
filename);
}
fclose(f);
XMLVector_Free(nsparser.filteredAtts);
XMLParser_FreeDTDValidator(vp);
XMLParser_Free(parser);
return 0;
USAGE:
puts("Usage: nsvalid document.xml /DTD:<optional> /URI:<optional>\n"
"Example: nsvalid my.xml /DTD:/home/my.dtd /URI:http://my.org");
return 1;
}
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;
}
int main(int argc, char* argv[])
{
BOOKPARSER bparser;
BOOK *b;
LPXMLPARSER parser;
LPXMLDTDVALIDATOR vp;
int i, success;
if (!XMLParser_Create(&parser)) {
puts("Error creating parser!");
return 1;
}
vp = XMLParser_CreateDTDValidator();
if (!vp) {
puts("Error creating DTDValidator in main()");
return 1;
}
if (!XMLVector_Create(&bparser.books, 6, sizeof(BOOK))) {
puts("Error creating books vector in main()");
return 1;
}
/* init Stringbuf: blockSize 256, no pre-allocation: */
XMLStringbuf_Init(&bparser.textBuf, 256, 0);
vp->UserData = &bparser;
parser->errorHandler = ErrorHandler;
parser->startElementHandler = StartElement;
parser->endElementHandler = EndElement;
parser->charactersHandler = Characters;
success = XMLParser_ParseValidateDTD(vp, parser, cstream, stdin, 0);
for (i=0; i<bparser.books->length; i++) {
b = XMLVector_Get(bparser.books, i);
if (success)
printf("id: %d\n"
"author: %s\n"
"title: %s\n"
"genre: %s\n"
"price: %f\n"
"publish_date: %s\n"
"description: %s\n\n",
b->id, b->author, b->title, b->genre,
b->price, b->publish_date, b->description
);
SAFE_FREE(b->author);
SAFE_FREE(b->title);
SAFE_FREE(b->genre);
SAFE_FREE(b->publish_date);
SAFE_FREE(b->description);
}
XMLParser_FreeDTDValidator(vp);
XMLParser_Free(parser);
XMLStringbuf_Free(&bparser.textBuf);
XMLVector_Free(bparser.books);
return 0;
}
