// Parse an xml document
// -- Creates and sets up an xml parser context
// -- Parses xml doc body into a DOM tree
// -- Destroys the xml parser context when done
// doc should be a char* to the xml document
// length should be the length of th xml document
// whole doc should be set to true if the entire xml doc is contained in the string pointed to by doc
TreeNode TreeNode_ParseXML(uint8_t* doc, uint32_t length, bool wholeDoc)
{
TreeNode root = NULL;
if (doc)
{
if (length)
{
XMLParser_Context bodyParser = XMLParser_Create();
XMLParser_SetStartHandler(bodyParser, HTTP_xmlDOMBuilder_StartElementHandler);
XMLParser_SetCharDataHandler(bodyParser, HTTP_xmlDOMBuilder_CharDataHandler);
XMLParser_SetEndHandler(bodyParser, HTTP_xmlDOMBuilder_EndElementHandler);
XMLParser_SetUserData(bodyParser, &root);
if (XMLParser_Parse(bodyParser, (const char*) doc, length, wholeDoc))
{
// Parsed ok
}
else
{
// Parsing failed
// Clean up tree
Tree_Delete(root);
root = NULL;
}
XMLParser_Destroy (bodyParser);
currentTreeNode = NULL;
}
}
return root;
}
struct XMLReader_t *XMLReader_Create(struct XMLReader_t *r, int validating)
{
int i;
if (!r) {
r=malloc(sizeof(*r));
ASSERT_MEM_SETERR(r);
r->dynamicalloc = 1;
}
memset(r, 0, sizeof *r);
ASSERT_MEM_SETERR(XMLParser_Create(&r->parser));
XMLVector_Create(&r->atts, 0, sizeof(struct XMLReaderAttribute_t));
ASSERT_MEM_SETERR(r->atts);
XMLVector_Create(&r->eventbuffer, 0, sizeof(union XMLReaderNode_t));
ASSERT_MEM_SETERR(r->eventbuffer);
for (i=0; i<sizeof(r->buf)/sizeof(r->buf[0]); i++) {
ASSERT_MEM_SETERR(XMLStringbuf_Init(&r->buf[i], 256, 256));
}
_XMLParser_SetFlag(r->parser, XMLFLAG_USE_SIMPLEPULL, 1);
if (validating) {
ASSERT_MEM_SETERR(r->dtdv = XMLParser_CreateDTDValidator());
r->dtdv->UserData = r;
r->parser->errorHandler = ErrorHandlerV;
r->parser->startElementHandler = StartElementV;
r->parser->endElementHandler = EndElementV;
r->parser->charactersHandler = CharsV;
r->parser->commentHandler = CommentV;
r->parser->processingInstructionHandler = PiV;
r->parser->endDocumentHandler = EndDocumentV;
}
else {
r->parser->UserData = r;
r->parser->errorHandler = ErrorHandlerN;
r->parser->startElementHandler = StartElementN;
r->parser->endElementHandler = EndElementN;
r->parser->charactersHandler = CharsN;
r->parser->commentHandler = CommentN;
r->parser->processingInstructionHandler = PiN;
}
return r;
}
int main(int argc, char* argv[])
{
LPXMLPARSER parser;
int depth = 0;
if (!XMLParser_Create(&parser)) {
printf("Error creating parser!\n");
return 1;
}
parser->errorHandler = ErrorHandler;
parser->startElementHandler = StartElement;
parser->endElementHandler = EndElement;
parser->UserData = &depth;
if (!XMLParser_Parse(parser, cstream, stdin, 0))
printf("Error: %s\nLine: %d Col: %d\n",
parser->ErrorString, parser->ErrorLine, parser->ErrorColumn);
XMLParser_Free(parser);
return 0;
}
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;
}
int Catalogs_Init(void)
{
LPXMLDTDVALIDATOR dtd;
FILE *f;
int ret=1, i=0;
char t[FILENAME_MAX];
char *env = getenv("XML_CATALOG_FILES");
if (!env) doc = "/etc/xml/catalog";
if (!XMLParser_Create(&parser)) {
fputs("Out of memory\n", stderr);
return 0;
}
if (!(dtd = XMLParser_CreateDTDValidator())) {
XMLParser_Free(parser);
fputs("Out of memory\n", stderr);
return 0;
}
XMLParser_SetExternalSubset(parser, NULL, "catalog_flat.dtd");
parser->startElementHandler = StartElement;
parser->errorHandler = ErrorHandler;
parser->resolveEntityHandler = ResolveEntity;
parser->externalEntityParsedHandler = FreeInputData;
while (ret) {
if (env) doc = mstrtok(&env, t, sizeof(t)/sizeof(t[0]), ';');
if (!doc) {
if (env && *env) {
ret = 0;
fprintf(stderr, "Erroneous token in XML_CATALOG FILES: %s\n", env);
}
break;
}
while (doc) {
if (!(f = mfopen(doc, "rb"))) {
fprintf(stderr, "Error opening file %s\n", doc);
ret = 0;
break;
}
ret = XMLParser_ParseValidateDTD(dtd, parser, filestream, f, 0);
fclose(f);
if (!ret || !nextCatalog || i == nextCatalog->length)
doc = NULL;
else {
char **uri = XMLVector_Get(nextCatalog, i++);
doc = *uri;
}
}
}
if (ret) {
if (publicIDS && publicIDS->length > 1)
qsort(publicIDS->array, publicIDS->length, sizeof(struct IDs),
(int(*)(const void*, const void*))idsort);
if (systemIDS && systemIDS->length > 1)
qsort(systemIDS->array, publicIDS->length, sizeof(struct IDs),
(int(*)(const void*, const void*))idsort);
}
XMLParser_FreeDTDValidator(dtd);
XMLParser_Free(parser);
return ret;
}
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;
}
