XmlShallowValidator::XmlShallowValidator (
std::map<wxString, std::set<wxString> > &elementMap,
std::map<wxString, std::map<wxString, std::set<wxString> > >
&attributeMap,
std::map<wxString, std::set<wxString> > &requiredAttributeMap,
std::set<wxString> &entitySet,
int maxLine,
bool segmentOnly ) : vd ( new XmlShallowValidatorData() )
{
vd->elementMap = elementMap;
vd->attributeMap = attributeMap;
vd->requiredAttributeMap = requiredAttributeMap;
vd->entitySet = entitySet;
vd->isValid = true;
vd->p = p;
vd->depth = 0;
vd->maxLine = maxLine;
vd->segmentOnly = segmentOnly;
vd->overrideFailure = false;
XML_SetUserData ( p, vd.get() );
XML_SetElementHandler ( p, start, end );
XML_SetSkippedEntityHandler ( p, skippedentity );
//XML_SetExternalEntityRefHandler ( p, externalentity );
}
void ParserEngine::init()
{
if (_parser)
XML_ParserFree(_parser);
if (!_pBuffer)
_pBuffer = new char[PARSE_BUFFER_SIZE];
if (dynamic_cast<NoNamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else if (dynamic_cast<NamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetReturnNSTriplet(_parser, 1);
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else
{
_parser = XML_ParserCreate(_encodingSpecified ? _encoding.c_str() : 0);
}
if (!_parser) throw XMLException("Cannot create Expat parser");
XML_SetUserData(_parser, this);
XML_SetElementHandler(_parser, handleStartElement, handleEndElement);
XML_SetCharacterDataHandler(_parser, handleCharacterData);
XML_SetProcessingInstructionHandler(_parser, handleProcessingInstruction);
if (_expandInternalEntities)
XML_SetDefaultHandlerExpand(_parser, handleDefault);
else
XML_SetDefaultHandler(_parser, handleDefault);
XML_SetUnparsedEntityDeclHandler(_parser, handleUnparsedEntityDecl);
XML_SetNotationDeclHandler(_parser, handleNotationDecl);
XML_SetExternalEntityRefHandler(_parser, handleExternalEntityRef);
XML_SetCommentHandler(_parser, handleComment);
XML_SetCdataSectionHandler(_parser, handleStartCdataSection, handleEndCdataSection);
XML_SetDoctypeDeclHandler(_parser, handleStartDoctypeDecl, handleEndDoctypeDecl);
XML_SetEntityDeclHandler(_parser, handleEntityDecl);
XML_SetSkippedEntityHandler(_parser, handleSkippedEntity);
XML_SetParamEntityParsing(_parser, _externalParameterEntities ? XML_PARAM_ENTITY_PARSING_ALWAYS : XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetUnknownEncodingHandler(_parser, handleUnknownEncoding, this);
}
bool_t reset_handlers_parser(parser_t *parser) {
if( parser ) {
XML_SetStartElementHandler(parser->p, parser->callbacks.start_tag ?
xml_startelementhandler : NULL);
XML_SetEndElementHandler(parser->p, parser->callbacks.end_tag ?
xml_endelementhandler : NULL);
XML_SetCommentHandler(parser->p, parser->callbacks.comment ?
xml_commenthandler : NULL);
XML_SetCharacterDataHandler(parser->p, parser->callbacks.chardata ?
xml_characterdatahandler : NULL);
XML_SetProcessingInstructionHandler(parser->p, parser->callbacks.pidata ?
xml_processinginstructionhandler : NULL);
XML_SetStartCdataSectionHandler(parser->p, parser->callbacks.start_cdata ?
xml_startcdatahandler : NULL);
/* if start_cdata, always set endcdatahandler */
XML_SetEndCdataSectionHandler(parser->p, parser->callbacks.start_cdata ?
xml_endcdatahandler : NULL);
XML_SetDefaultHandler(parser->p, parser->callbacks.dfault ?
xml_defaulthandler : NULL);
XML_SetStartDoctypeDeclHandler(parser->p, parser->callbacks.start_doctypedecl ?
xml_startdoctypedeclhandler : NULL);
/* if start_doctypedecl, always set enddoctypedeclhandler */
XML_SetEndDoctypeDeclHandler(parser->p, parser->callbacks.start_doctypedecl ?
xml_enddoctypedeclhandler : NULL);
XML_SetEntityDeclHandler(parser->p, parser->callbacks.entitydecl ?
xml_entitydeclhandler : NULL);
/* what to do about entities: there can be internal and external
* entities, which expat treats differently. We want all our
* entities to stay unprocessed, otherwise we'll get well formedness
* errors. When a handler is called, the raw string is passed to
* the default handler (provided it exists). */
XML_UseForeignDTD(parser->p, XML_TRUE);
XML_SetParamEntityParsing(parser->p, XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetExternalEntityRefHandler(parser->p,
xml_externalentityrefhandler);
XML_SetExternalEntityRefHandlerArg(parser->p, parser);
XML_SetSkippedEntityHandler(parser->p, xml_skippedentityhandler);
return TRUE;
}
return FALSE;
}
void _Expat_XML_SetSkippedEntityHandler(struct ExpatIFace * Self, XML_Parser parser, XML_SkippedEntityHandler handler)
{
XML_SetSkippedEntityHandler(parser, handler);
}
void xs_infoset_scan(xsMachine* the)
{
int c = xsToInteger(xsArgc);
Scanner scanner;
Scanner* self;
xsVars(COUNT);
xsTry {
self = &scanner;
c_memset(self, 0, sizeof(Scanner));
if (c < 1)
xsSyntaxError("no buffer");
self->expat = XML_ParserCreate(NULL);
xsThrowIfNULL(self->expat);
XML_SetUserData(self->expat, self);
XML_SetElementHandler(self->expat, scanStartTag, scanStopTag);
XML_SetCdataSectionHandler(self->expat, scanStartCdata, scanStopCdata);
XML_SetCharacterDataHandler(self->expat, scanCharacter);
XML_SetCommentHandler(self->expat, scanComment);
XML_SetProcessingInstructionHandler(self->expat, scanProcessingInstruction);
XML_SetUnknownEncodingHandler(self->expat, scanUnknownEncoding, NULL);
XML_SetSkippedEntityHandler(self->expat, scanEntity);
self->result = 1;
self->textBuffer = c_malloc(8192);
xsThrowIfNULL(self->textBuffer);
self->textSize = 8192;
self->the = the;
xsVar(ATTRIBUTE_PROTOTYPE) = xsGet(xsThis, xsID_attribute);
xsVar(CDATA_PROTOTYPE) = xsGet(xsThis, xsID_cdata);
xsVar(COMMENT_PROTOTYPE) = xsGet(xsThis, xsID_comment);
xsVar(DOCUMENT_PROTOTYPE) = xsGet(xsThis, xsID_document);
xsVar(ELEMENT_PROTOTYPE) = xsGet(xsThis, xsID_element);
xsVar(NO_NAMESPACE) = xsString("");
xsVar(NO_PREFIX) = xsString("");
xsVar(PATH) = (c > 1) ? xsArg(1) : xsUndefined;
xsVar(PI_PROTOTYPE) = xsGet(xsThis, xsID_pi);
xsVar(XML_NAMESPACE) = xsGet(xsThis, xsID_xmlnsNamespace);
xsVar(XML_PREFIX) = xsGet(xsThis, xsID_xmlnsPrefix);
xsResult = xsNewInstanceOf(xsVar(DOCUMENT_PROTOTYPE));
xsSet(xsResult, xsID_encoding, xsString("UTF-8"));
xsSet(xsResult, xsID_version, xsString("1.0"));
xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
xsArrayCacheBegin(xsVar(CHILDREN));
xsSet(xsResult, xsID_children, xsVar(CHILDREN));
xsSet(xsResult, xsID_parent, xsNull);
xsSet(xsResult, xsID_xmlnsAttributes, xsNull);
if (xsIsInstanceOf(xsArg(0), xsChunkPrototype)) {
xsStringValue buffer = xsGetHostData(xsArg(0));
xsIntegerValue size = xsToInteger(xsGet(xsArg(0), xsID_length));
self->result = XML_Parse(self->expat, (const char *)buffer, size, 1);
}
else if (xsTypeOf(xsArg(0)) == xsStringType) {
xsStringValue string = xsToString(xsArg(0));
xsIntegerValue stringOffset = 0;
xsIntegerValue stringSize = c_strlen(string);
while (self->result && (stringOffset < stringSize)) {
xsIntegerValue size = stringSize - stringOffset;
xsStringValue buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
if (size > 1024)
size = 1024;
c_memcpy(buffer, string + stringOffset, size);
self->result = XML_ParseBuffer(self->expat, size, (size < 1024) ? 1 : 0);
stringOffset += size;
string = xsToString(xsArg(0)); // @@ gc
}
}
else {
xsStreamGetter* streamGetter = xsGetHostData(xsArg(0));
while (self->result) {
xsIntegerValue i;
xsStringValue p, buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
for (i = 0, p = buffer; i < 1024; i++, p++) {
int c = (*(streamGetter->getter))(streamGetter->stream);
if (c == C_EOF)
break;
*p = (char)c;
}
self->result = XML_ParseBuffer(self->expat, i, (i < 1024) ? 1 : 0);
if (i < 1024)
break;
}
}
xsDelete(xsResult, xsID_xmlnsAttributes);
xsDelete(xsResult, xsID_parent);
xsArrayCacheEnd(xsVar(CHILDREN));
if (!self->result) {
xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat));
xsVar(VALUE) = xsString((char*)XML_ErrorString(XML_GetErrorCode(self->expat)));
if (xsHas(xsThis, xsID_reportError))
xsCall3_noResult(xsThis, xsID_reportError, xsVar(PATH), xsVar(LINE), xsVar(VALUE));
xsThrow(xsNewInstanceOf(xsSyntaxErrorPrototype));
}
c_free(self->textBuffer);
self->textBuffer = NULL;
XML_ParserFree(self->expat);
self->expat = NULL;
}
xsCatch {
if (self->textBuffer)
c_free(self->textBuffer);
if (self->expat)
XML_ParserFree(self->expat);
}
}
void bmx_expat_XML_SetSkippedEntityHandler(XML_Parser parser) {
XML_SetSkippedEntityHandler(parser, bmx_expat_SkippedEntityHandler);
}
