// 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;
}
int XMLReader_Parse(struct XMLReader_t *r, LPFNINPUTSRC inputSrc, void *inputData,
const XMLCH *encoding)
{
if (r->errorcode) r->errorcode=0;
if (r->eventbuffer->length) /* clean up in the next _Read is necessary */
r->eventbufferpos = r->eventbuffer->length;
return (r->dtdv) ?
XMLParser_ParseValidateDTD(r->dtdv, r->parser, inputSrc, inputData, encoding) :
XMLParser_Parse(r->parser, inputSrc, inputData, encoding);
}
void XMLReader_AbortParse(struct XMLReader_t *r)
{
/* supress error reporting by removing errorHandler
before calling parse(NULL) so we don't get
ERR_XMLP_UNCLOSED_TAG etc. errors. parser->ErrorCode
will be set though */
XML_ERROR_HANDLER h = r->parser->errorHandler;
r->parser->errorHandler = NULL;
XMLParser_Parse(r->parser, NULL, NULL, NULL);
r->parser->errorHandler = h;
}
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 RunTest(XMLCONFPARSER *xcp, char *uri)
{
LPXMLRUNTIMEATT att, tatt;
XMLCH testuri[MAX_PATH];
XMLCH xmlbase[MAX_PATH];
XMLCH id[256];
XMLCH *s;
FILE *f;
RUNPARSERDATA rdata;
int result, expect;
LPXMLPARSER parser = xcp->runParser;
int type;
if ((s = XMLParser_GetPrefixMapping(xcp->parser, "xml:base")))
strcpy(xmlbase, s); /* we save current xmlbase
(although it shouldn't get modified 'cos
main parser isn't running during RunTest()) */
else {
/* rmt-e2e-18:
External entity containing start of entity declaration is
base URI for system identifier, so: */
XMLCH *sysID = XMLParser_GetSystemID(xcp->parser);
if (!sysID) xmlbase[0] = '\0';
else GetBaseDir(sysID, xmlbase);
}
strcpy(testuri, xmlbase);
strcat(testuri, uri);
puts(testuri);
/* resolve basedir for external entities, DTD and for canonxml */
GetBaseDir(testuri, rdata.testbasedir);
tatt = XMLParser_GetNamedItem(xcp->parser, "TYPE");
if (tatt) {
/* "Nonvalidating parsers must also accept "invalid" testcases,
but validating ones must reject them." */
if (!strcmp(tatt->value, "valid")) type = TYPE_VALID;
else if (!strcmp(tatt->value, "invalid")) type = TYPE_INVALID;
else type = TYPE_OTHER; /* error, not-wf */
}
if ((f = fopen(testuri, "rb"))) {
#ifdef TEST_VALIDATING
xcp->v->UserData = &rdata;
xcp->v->UserFlag = type;
xcp->v->startElementHandlerFilter = StartElementDetermineValidation;
result = XMLParser_ParseValidateDTD(xcp->v, parser, cstream, f, 0);
#else
parser->UserData = &rdata;
result = XMLParser_Parse(parser, cstream, f, 0);
#endif
fclose(f);
}
else {
fprintf(PFERR, "Error opening file %s\n", testuri);
return 0;
}
xcp->testCount++;
/* 1 row columns: ID, TYPE, PASS/FAIL, ERRORSTRING
2 row columns: ENTITIES + OUTPUT in one col, 3 empty cols
3 row: test description, 3 empty cols
*/
att = XMLParser_GetNamedItem(xcp->parser, "ID");
strcpy(id, (att) ? att->value : "unknown");
fputs((xcp->testCount % 2) ? "<tr bgcolor='#EEEEEE'>" : "<tr>", xcp->pfout);
fprintf(xcp->pfout, "<td><a href='%s'>%s</a></td>", testuri, id);
if (tatt) {
if (type == TYPE_VALID) expect = 1;
else if (type == TYPE_INVALID)
#ifdef TEST_VALIDATING
expect = 0;
#else
expect = 1;
#endif
else expect = 0;
fprintf(xcp->pfout, "<td>%s</td>", tatt->value);
if (result == expect) xcp->testSuccess++;
}
int XMLAPI XMLParser_ParseValidateDTD(LPXMLDTDVALIDATOR dtd, LPXMLPARSER parser,
LPFNINPUTSRC inputSrc, void *inputData, const XMLCH *encoding)
{
int ret;
if (!dtd || !parser) return 0;
if (!inputSrc)
ret = (parser->ErrorCode==0);
else {
dtd->parser = parser;
dtd->ErrorCode = dtd->ErrorColumn = dtd->ErrorLine = 0; /* must be
set before FreeDTDValidator */
if (*dtd->ErrorString) dtd->ErrorString[0] = '\0';
if (dtd->ContextStack->length)
_XMLVector_RemoveAll(dtd->ContextStack);
if (dtd->cpNodesPool) {
FreeDTDValidator(dtd, 1);
if (dtd->ErrorCode) return 0;
}
dtd->ElementTable = NULL;
dtd->cpNodesPool = NULL;
dtd->idTable = NULL;
/* save handlers: */
dtd->startElementHandler = parser->startElementHandler;
dtd->endElementHandler = parser->endElementHandler;
dtd->charactersHandler = parser->charactersHandler;
dtd->ignorableWhitespaceHandler = parser->ignorableWhitespaceHandler;
dtd->elementDeclHandler = parser->elementDeclHandler;
dtd->endDTDHandler = parser->endDTDHandler;
/* set the validating ones: */
parser->startElementHandler = dtd->startElementHandlerFilter;
parser->endElementHandler = dtd->endElementHandlerFilter;
parser->charactersHandler = dtd->charactersHandlerFilter;
parser->ignorableWhitespaceHandler = dtd->ignorableWhitespaceHandlerFilter;
parser->elementDeclHandler = DTDValidate_ElementDecl;
parser->endDTDHandler = DTDValidate_EndDTD;
_XMLParser_SetFlag(parser, XMLFLAG_REPORT_DTD_EXT, 1);
parser->UserData = dtd;
ret = XMLParser_Parse(parser, inputSrc, inputData, encoding);
if (ret && _XMLParser_GetFlag(parser, XMLFLAG_USE_SIMPLEPULL)) return 1;
}
if (!ret) {
/* Assign ElementTable and content particle pool 'cos validator
will be responsible for freeing them and endDTD might not be called */
if (dtd->ElementTable!=parser->prt->cpNames)
dtd->ElementTable = parser->prt->cpNames;
if (dtd->cpNodesPool!=parser->prt->cpNodesPool)
dtd->cpNodesPool = parser->prt->cpNodesPool;
}
else if (dtd->idTable) {
dtd->idTable->userdata = dtd;
XMLHTable_Destroy(dtd->idTable, CheckIDREFS, 0);
dtd->idTable = NULL;
ret = (parser->ErrorCode==0);
}
if (parser->prt->doctypeStr) {
free(parser->prt->doctypeStr);
parser->prt->doctypeStr = NULL;
}
_XMLParser_SetFlag(parser, XMLFLAG_REPORT_DTD_EXT, 0);
/* restore handlers: */
parser->startElementHandler = dtd->startElementHandler;
parser->endElementHandler = dtd->endElementHandler;
parser->charactersHandler = dtd->charactersHandler;
parser->ignorableWhitespaceHandler = dtd->ignorableWhitespaceHandler;
parser->elementDeclHandler = dtd->elementDeclHandler;
parser->endDTDHandler = dtd->endDTDHandler;
return ret;
}
