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); }