CXmlLoader::CXmlLoader(IXmlIOHandler & handler):m_handler(handler){ m_parser = XML_ParserCreate(NULL); m_ctx.root = m_ctx.node = NULL; XML_SetUserData(m_parser, (void*)&m_ctx); XML_SetElementHandler(m_parser, StartElementHnd, EndElementHnd); XML_SetCharacterDataHandler(m_parser, TextHnd); XML_SetCommentHandler(m_parser, CommentHnd); };
TinyDomElement* TinyDom::parse(std::istream& istr) { XML_Parser parser = XML_ParserCreate(0); TinyDomParser tdparser; XML_SetUserData(parser, &tdparser); XML_SetCharacterDataHandler(parser, characterDataHandler); XML_SetElementHandler(parser, startElementHandler, endElementHandler); XML_SetCommentHandler(parser, commentHandler); XML_SetProcessingInstructionHandler(parser, processingInstructionHandler); XML_SetXmlDeclHandler(parser, xmlDeclHandler); XML_SetDefaultHandler(parser, defaultHandler); XML_SetDoctypeDeclHandler(parser, startDoctypeDeclHandler, endDoctypeDeclHandler); try { while (1) { void* buf = XML_GetBuffer(parser, 1024); if (!buf) { throw std::runtime_error("out of memory!"); } istr.read((char*)buf, 1024); std::streamsize len = istr.gcount(); if (istr.fail() && !istr.eof()) { throw std::runtime_error("failed IO"); } bool isFinal = (istr.eof() || len < 1024); if (! XML_ParseBuffer(parser, len, isFinal)) { std::ostringstream ostr; ostr << "parse error at line " << XML_GetErrorLineNumber(parser) << ", column " << XML_GetErrorColumnNumber(parser) << ": " << XML_ErrorString(XML_GetErrorCode(parser)); throw std::runtime_error(ostr.str()); } if (isFinal) { break; } } XML_ParserFree(parser); } catch (...) { //std::cerr << "Got exception: " << e.what() << "\n"; if (parser) { XML_ParserFree(parser); } delete tdparser.rootElement; throw; } return tdparser.rootElement; }
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); }
void RS_XML(initParser)(XML_Parser parser, RS_XMLParserData *parserData) { XML_SetUserData(parser, parserData); XML_SetElementHandler(parser, RS_XML(startElement), RS_XML(endElement)); XML_SetCommentHandler(parser, RS_XML(commentHandler)); XML_SetExternalEntityRefHandler(parser, RS_XML(externalEntityHandler)); XML_SetUnparsedEntityDeclHandler(parser, RS_XML(entityDeclarationHandler)); XML_SetCharacterDataHandler(parser, RS_XML(textHandler)); XML_SetProcessingInstructionHandler(parser, RS_XML(processingInstructionHandler)); XML_SetCdataSectionHandler(parser, RS_XML(startCdataSectionHandler), RS_XML(endCdataSectionHandler)); XML_SetBase(parser, parserData->fileName); XML_SetNotStandaloneHandler(parser, RS_XML(notStandAloneHandler)); }
/** * Creates a new Expat parser. Called from the Java ExpatParser constructor. * * @param object the Java ExpatParser instance * @param javaEncoding the character encoding name * @param processNamespaces true if the parser should handle namespaces * @returns the pointer to the C Expat parser */ static jlong ExpatParser_initialize(JNIEnv* env, jobject object, jstring javaEncoding, jboolean processNamespaces) { // Allocate parsing context. UniquePtr<ParsingContext> context(new ParsingContext(object)); if (context.get() == NULL) { jniThrowOutOfMemoryError(env, NULL); return 0; } context->processNamespaces = processNamespaces; // Create a parser. XML_Parser parser; ScopedUtfChars encoding(env, javaEncoding); if (encoding.c_str() == NULL) { return 0; } if (processNamespaces) { // Use '|' to separate URIs from local names. parser = XML_ParserCreateNS(encoding.c_str(), '|'); } else { parser = XML_ParserCreate(encoding.c_str()); } if (parser != NULL) { if (processNamespaces) { XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace); XML_SetReturnNSTriplet(parser, 1); } XML_SetCdataSectionHandler(parser, startCdata, endCdata); XML_SetCharacterDataHandler(parser, text); XML_SetCommentHandler(parser, comment); XML_SetDoctypeDeclHandler(parser, startDtd, endDtd); XML_SetElementHandler(parser, startElement, endElement); XML_SetExternalEntityRefHandler(parser, handleExternalEntity); XML_SetNotationDeclHandler(parser, notationDecl); XML_SetProcessingInstructionHandler(parser, processingInstruction); XML_SetUnparsedEntityDeclHandler(parser, unparsedEntityDecl); XML_SetUserData(parser, context.release()); } else { jniThrowOutOfMemoryError(env, NULL); return 0; } return fromXMLParser(parser); }
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; }
sp<XMLNode> XMLNode::parse(const sp<AaptFile>& file) { char buf[16384]; int fd = open(file->getSourceFile().string(), O_RDONLY | O_BINARY); if (fd < 0) { SourcePos(file->getSourceFile(), -1).error("Unable to open file for read: %s", strerror(errno)); return NULL; } XML_Parser parser = XML_ParserCreateNS(NULL, 1); ParseState state; state.filename = file->getPrintableSource(); state.parser = parser; XML_SetUserData(parser, &state); XML_SetElementHandler(parser, startElement, endElement); XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace); XML_SetCharacterDataHandler(parser, characterData); XML_SetCommentHandler(parser, commentData); ssize_t len; bool done; do { len = read(fd, buf, sizeof(buf)); done = len < (ssize_t)sizeof(buf); if (len < 0) { SourcePos(file->getSourceFile(), -1).error("Error reading file: %s\n", strerror(errno)); close(fd); return NULL; } if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) { SourcePos(file->getSourceFile(), (int)XML_GetCurrentLineNumber(parser)).error( "Error parsing XML: %s\n", XML_ErrorString(XML_GetErrorCode(parser))); close(fd); return NULL; } } while (!done); XML_ParserFree(parser); if (state.root == NULL) { SourcePos(file->getSourceFile(), -1).error("No XML data generated when parsing"); } close(fd); return state.root; }
static int lxp_make_parser (lua_State *L) { XML_Parser p; int bufferCharData = (lua_type(L, 3) != LUA_TBOOLEAN) || (lua_toboolean(L, 3) != 0); char sep = *luaL_optstring(L, 2, ""); lxp_userdata *xpu = createlxp(L); xpu->bufferCharData = bufferCharData; p = xpu->parser = (sep == '\0') ? XML_ParserCreate(NULL) : XML_ParserCreateNS(NULL, sep); if (!p) luaL_error(L, "XML_ParserCreate failed"); luaL_checktype(L, 1, LUA_TTABLE); checkcallbacks(L); lua_pushvalue(L, 1); xpu->tableref = luaL_ref(L, LUA_REGISTRYINDEX); XML_SetUserData(p, xpu); if (hasfield(L, StartCdataKey) || hasfield(L, EndCdataKey)) XML_SetCdataSectionHandler(p, f_StartCdata, f_EndCdataKey); if (hasfield(L, CharDataKey)) XML_SetCharacterDataHandler(p, f_CharData); if (hasfield(L, CommentKey)) XML_SetCommentHandler(p, f_Comment); if (hasfield(L, DefaultKey)) XML_SetDefaultHandler(p, f_Default); if (hasfield(L, DefaultExpandKey)) XML_SetDefaultHandlerExpand(p, f_DefaultExpand); if (hasfield(L, StartElementKey) || hasfield(L, EndElementKey)) XML_SetElementHandler(p, f_StartElement, f_EndElement); if (hasfield(L, ExternalEntityKey)) XML_SetExternalEntityRefHandler(p, f_ExternaEntity); if (hasfield(L, StartNamespaceDeclKey) || hasfield(L, EndNamespaceDeclKey)) XML_SetNamespaceDeclHandler(p, f_StartNamespaceDecl, f_EndNamespaceDecl); if (hasfield(L, NotationDeclKey)) XML_SetNotationDeclHandler(p, f_NotationDecl); if (hasfield(L, NotStandaloneKey)) XML_SetNotStandaloneHandler(p, f_NotStandalone); if (hasfield(L, ProcessingInstructionKey)) XML_SetProcessingInstructionHandler(p, f_ProcessingInstruction); if (hasfield(L, UnparsedEntityDeclKey)) XML_SetUnparsedEntityDeclHandler(p, f_UnparsedEntityDecl); if (hasfield(L, StartDoctypeDeclKey)) XML_SetStartDoctypeDeclHandler(p, f_StartDoctypeDecl); if (hasfield(L, XmlDeclKey)) XML_SetXmlDeclHandler(p, f_XmlDecl); return 1; }
LLXmlParser::LLXmlParser() : mParser( NULL ), mDepth( 0 ) { mAuxErrorString = "no error"; // Override the document's declared encoding. mParser = XML_ParserCreate(NULL); XML_SetUserData(mParser, this); XML_SetElementHandler( mParser, startElementHandler, endElementHandler); XML_SetCharacterDataHandler( mParser, characterDataHandler); XML_SetProcessingInstructionHandler( mParser, processingInstructionHandler); XML_SetCommentHandler( mParser, commentHandler); XML_SetCdataSectionHandler( mParser, startCdataSectionHandler, endCdataSectionHandler); // This sets the default handler but does not inhibit expansion of internal entities. // The entity reference will not be passed to the default handler. XML_SetDefaultHandlerExpand( mParser, defaultDataHandler); XML_SetUnparsedEntityDeclHandler( mParser, unparsedEntityDeclHandler); }
/** * Parses the given input stream and returns a DOM Document. * A NULL pointer will be returned if errors occurred */ nsresult txXMLParser::parse(istream& aInputStream, const nsAString& aUri, txXPathNode** aResultDoc) { mErrorString.Truncate(); *aResultDoc = nsnull; if (!aInputStream) { mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered."); return NS_ERROR_FAILURE; } static const XML_Memory_Handling_Suite memsuite = { (void *(*)(size_t))PR_Malloc, (void *(*)(void *, size_t))PR_Realloc, PR_Free }; static const PRUnichar expatSeparator = kExpatSeparatorChar; mExpatParser = XML_ParserCreate_MM(nsnull, &memsuite, &expatSeparator); if (!mExpatParser) { return NS_ERROR_OUT_OF_MEMORY; } mDocument = new Document(); if (!mDocument) { XML_ParserFree(mExpatParser); return NS_ERROR_OUT_OF_MEMORY; } mDocument->documentBaseURI = aUri; mCurrentNode = mDocument; XML_SetReturnNSTriplet(mExpatParser, XML_TRUE); XML_SetUserData(mExpatParser, this); XML_SetElementHandler(mExpatParser, startElement, endElement); XML_SetCharacterDataHandler(mExpatParser, charData); XML_SetProcessingInstructionHandler(mExpatParser, piHandler); XML_SetCommentHandler(mExpatParser, commentHandler); #ifdef XML_DTD XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS); #endif XML_SetExternalEntityRefHandler(mExpatParser, externalEntityRefHandler); XML_SetExternalEntityRefHandlerArg(mExpatParser, this); XML_SetBase(mExpatParser, (const XML_Char*)(PromiseFlatString(aUri).get())); const int bufferSize = 1024; char buf[bufferSize]; PRBool done; do { aInputStream.read(buf, bufferSize); done = aInputStream.eof(); if (!XML_Parse(mExpatParser, buf, aInputStream.gcount(), done)) { createErrorString(); done = MB_TRUE; delete mDocument; mDocument = nsnull; } } while (!done); aInputStream.clear(); // clean up XML_ParserFree(mExpatParser); // ownership to the caller *aResultDoc = txXPathNativeNode::createXPathNode(mDocument); mDocument = nsnull; return *aResultDoc ? NS_OK : NS_ERROR_OUT_OF_MEMORY; }
void _Expat_XML_SetCommentHandler(struct ExpatIFace * Self, XML_Parser parser, XML_CommentHandler handler) { XML_SetCommentHandler(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); } }
int DOM_DocumentLS_load(DOM_Document *doc, const DOM_String *uri) { FILE *fd; XML_Parser p; struct stack *stk; size_t n; // was ssize_t (DBL) void *buf; int ret, done; DOM_Exception=DOM_NO_ERR; //line added by DBL if (doc == NULL || uri == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return 0; } fd = fopen(uri, "r"); if (fd == NULL) { DOM_Exception = DOM_SYSTEM_ERR; return 0; } p = XML_ParserCreate(NULL); if (p == NULL) { DOM_Exception = DOM_XML_PARSER_ERR; fclose(fd); return 0; } stk = stack_new(INT_MAX); if (stk == NULL || stack_push(stk, doc) == 0) { DOM_Exception = DOM_SYSTEM_ERR; XML_ParserFree(p); fclose(fd); stack_del(stk, NULL); return 0; } XML_SetElementHandler(p, start_fn, end_fn); XML_SetCharacterDataHandler(p, chardata_fn); XML_SetCommentHandler(p, comment_fn); XML_SetProcessingInstructionHandler(p , processing_fn); XML_SetUserData(p, stk); ret = 1; for ( ;; ) { if ((buf = XML_GetBuffer(p, BUF_SIZ)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; ret = 0; break; } if ((n = fread(buf, 1, BUF_SIZ, fd)) == 0 && ferror(fd)) { DOM_Exception = DOM_SYSTEM_ERR; ret = 0; break; } if (XML_ParseBuffer(p, (int) n, (done = feof(fd))) == 0 || DOM_Exception) { if (DOM_Exception == 0) { DOM_Exception = DOM_XML_PARSER_ERR; } ret = 0; break; } if (done) { break; } } stack_del(stk, NULL); XML_ParserFree(p); fclose(fd); return ret; }
void XMLParser::EnableCommentHandler(bool enable) { assert(m_parser != NULL); XML_SetCommentHandler(m_parser, enable ? CommentHandler : NULL); }
NS_IMETHODIMP nsExpatDriver::WillBuildModel(const CParserContext& aParserContext, nsITokenizer* aTokenizer, nsIContentSink* aSink) { mSink = do_QueryInterface(aSink); if (!mSink) { NS_ERROR("nsExpatDriver didn't get an nsIExpatSink"); // Make sure future calls to us bail out as needed mInternalState = NS_ERROR_UNEXPECTED; return mInternalState; } mOriginalSink = aSink; static const XML_Memory_Handling_Suite memsuite = { (void *(*)(size_t))PR_Malloc, (void *(*)(void *, size_t))PR_Realloc, PR_Free }; static const PRUnichar kExpatSeparator[] = { kExpatSeparatorChar, '\0' }; mExpatParser = XML_ParserCreate_MM(kUTF16, &memsuite, kExpatSeparator); NS_ENSURE_TRUE(mExpatParser, NS_ERROR_FAILURE); XML_SetReturnNSTriplet(mExpatParser, XML_TRUE); #ifdef XML_DTD XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS); #endif mURISpec = aParserContext.mScanner->GetFilename(); XML_SetBase(mExpatParser, mURISpec.get()); nsCOMPtr<nsIDocument> doc = do_QueryInterface(mOriginalSink->GetTarget()); if (doc) { nsCOMPtr<nsPIDOMWindow> win = doc->GetWindow(); if (!win) { PRBool aHasHadScriptHandlingObject; nsIScriptGlobalObject *global = doc->GetScriptHandlingObject(aHasHadScriptHandlingObject); if (global) { win = do_QueryInterface(global); } } if (win && !win->IsInnerWindow()) { win = win->GetCurrentInnerWindow(); } if (win) { mInnerWindowID = win->WindowID(); } } // Set up the callbacks XML_SetXmlDeclHandler(mExpatParser, Driver_HandleXMLDeclaration); XML_SetElementHandler(mExpatParser, Driver_HandleStartElement, Driver_HandleEndElement); XML_SetCharacterDataHandler(mExpatParser, Driver_HandleCharacterData); XML_SetProcessingInstructionHandler(mExpatParser, Driver_HandleProcessingInstruction); XML_SetDefaultHandlerExpand(mExpatParser, Driver_HandleDefault); XML_SetExternalEntityRefHandler(mExpatParser, (XML_ExternalEntityRefHandler) Driver_HandleExternalEntityRef); XML_SetExternalEntityRefHandlerArg(mExpatParser, this); XML_SetCommentHandler(mExpatParser, Driver_HandleComment); XML_SetCdataSectionHandler(mExpatParser, Driver_HandleStartCdataSection, Driver_HandleEndCdataSection); XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE); XML_SetDoctypeDeclHandler(mExpatParser, Driver_HandleStartDoctypeDecl, Driver_HandleEndDoctypeDecl); // If the sink is an nsIExtendedExpatSink, // register some addtional handlers. mExtendedSink = do_QueryInterface(mSink); if (mExtendedSink) { XML_SetNamespaceDeclHandler(mExpatParser, Driver_HandleStartNamespaceDecl, Driver_HandleEndNamespaceDecl); XML_SetUnparsedEntityDeclHandler(mExpatParser, Driver_HandleUnparsedEntityDecl); XML_SetNotationDeclHandler(mExpatParser, Driver_HandleNotationDecl); } // Set up the user data. XML_SetUserData(mExpatParser, this); // XML must detect invalid character convertion aParserContext.mScanner->OverrideReplacementCharacter(0xffff); return mInternalState; }
bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding, int flags) { #if wxUSE_UNICODE (void)encoding; #else m_encoding = encoding; #endif const size_t BUFSIZE = 1024; char buf[BUFSIZE]; wxXmlParsingContext ctx; bool done; XML_Parser parser = XML_ParserCreate(NULL); ctx.root = ctx.node = NULL; ctx.encoding = wxT("UTF-8"); // default in absence of encoding="" ctx.conv = NULL; #if !wxUSE_UNICODE if ( encoding.CmpNoCase(wxT("UTF-8")) != 0 ) ctx.conv = new wxCSConv(encoding); #endif ctx.removeWhiteOnlyNodes = (flags & wxXMLDOC_KEEP_WHITESPACE_NODES) == 0; XML_SetUserData(parser, (void*)&ctx); XML_SetElementHandler(parser, StartElementHnd, EndElementHnd); XML_SetCharacterDataHandler(parser, TextHnd); XML_SetStartCdataSectionHandler(parser, StartCdataHnd); XML_SetCommentHandler(parser, CommentHnd); XML_SetDefaultHandler(parser, DefaultHnd); XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL); bool ok = true; do { size_t len = stream.Read(buf, BUFSIZE).LastRead(); done = (len < BUFSIZE); if (!XML_Parse(parser, buf, len, done)) { wxString error(XML_ErrorString(XML_GetErrorCode(parser)), *wxConvCurrent); wxLogError(_("XML parsing error: '%s' at line %d"), error.c_str(), XML_GetCurrentLineNumber(parser)); ok = false; break; } } while (!done); if (ok) { if (!ctx.version.empty()) SetVersion(ctx.version); if (!ctx.encoding.empty()) SetFileEncoding(ctx.encoding); SetRoot(ctx.root); } else { delete ctx.root; } XML_ParserFree(parser); #if !wxUSE_UNICODE if ( ctx.conv ) delete ctx.conv; #endif return ok; }
/* The handler. Create a new parser and/or filter context where appropriate * and parse the chunks of data received from the brigade */ static int idlChunkHandler( ap_filter_t *f, apr_bucket_brigade *brigade ) { idlChunkContext* ctx = f->ctx; apr_bucket* currentBucket = NULL; apr_pool_t* pool = f->r->pool; const char* data; apr_size_t len; osrfStringArray* params = NULL; mparams = NULL; /* load the per-dir/location config */ idlChunkConfig* config = ap_get_module_config( f->r->per_dir_config, &idlchunk_module ); ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r, "IDLCHUNK Config:\nContent Type = %s, " "Strip PI = %s, Strip Comments = %s, Doctype = %s", config->contentType, (config->stripPI) ? "yes" : "no", (config->stripComments) ? "yes" : "no", config->doctype); /* set the content type based on the config */ ap_set_content_type(f->r, config->contentType); //ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r, "Set content type"); params = apacheParseParms(f->r); /* free me */ mparams = apacheGetParamValues( params, "class" ); /* free me */ all = 1; if (mparams && mparams->size > 0) all = 0; //ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, f->r, "Parsed the params, if any"); /* create the XML parser */ int firstrun = 0; if( parser == NULL ) { firstrun = 1; parser = XML_ParserCreate("UTF-8"); XML_SetUserData(parser, f); XML_SetElementHandler(parser, startElement, endElement); XML_SetCharacterDataHandler(parser, charHandler); if(!config->stripDoctype) XML_SetStartDoctypeDeclHandler( parser, doctypeHandler ); if(!config->stripPI) XML_SetProcessingInstructionHandler(parser, handlePI); if(!config->stripComments) XML_SetCommentHandler(parser, handleComment); } /* create the filter context */ if( ctx == NULL ) { f->ctx = ctx = apr_pcalloc( pool, sizeof(*ctx)); ctx->brigade = apr_brigade_create( pool, f->c->bucket_alloc ); ctx->parser = parser; } if(firstrun) { /* we haven't started writing the data to the stream yet */ /* go ahead and write the doctype out if we have one defined */ if(config->doctype) { ap_log_rerror( APLOG_MARK, APLOG_DEBUG, 0, f->r, "IDLCHUNK DOCTYPE => %s", config->doctype); _fwrite(f, "%s\n", config->doctype); } } /* cycle through the buckets in the brigade */ while (!APR_BRIGADE_EMPTY(brigade)) { /* grab the next bucket */ currentBucket = APR_BRIGADE_FIRST(brigade); /* clean up when we're done */ if (APR_BUCKET_IS_EOS(currentBucket) || APR_BUCKET_IS_FLUSH(currentBucket)) { APR_BUCKET_REMOVE(currentBucket); APR_BRIGADE_INSERT_TAIL(ctx->brigade, currentBucket); ap_pass_brigade(f->next, ctx->brigade); XML_ParserFree(parser); if (params) osrfStringArrayFree(params); if (mparams) osrfStringArrayFree(mparams); parser = NULL; return APR_SUCCESS; } /* read the incoming data */ int s = apr_bucket_read(currentBucket, &data, &len, APR_NONBLOCK_READ); if( s != APR_SUCCESS ) { ap_log_rerror( APLOG_MARK, APLOG_ERR, 0, f->r, "IDLCHUNK error reading data from filter with status %d", s); if (params) osrfStringArrayFree(params); if (mparams) osrfStringArrayFree(mparams); return s; } if (len > 0) { ap_log_rerror( APLOG_MARK, APLOG_DEBUG, 0, f->r, "IDLCHUNK read %d bytes", (int)len); /* push data into the XML push parser */ if ( XML_Parse(ctx->parser, data, len, 0) == XML_STATUS_ERROR ) { char tmp[len+1]; memcpy(tmp, data, len); tmp[len] = '\0'; /* log and die on XML errors */ ap_log_rerror( APLOG_MARK, APLOG_ERR, 0, f->r, "IDLCHUNK XML Parse Error: %s at line %d: parsing %s: data %s", XML_ErrorString(XML_GetErrorCode(ctx->parser)), (int) XML_GetCurrentLineNumber(ctx->parser), f->r->filename, tmp); XML_ParserFree(parser); if (params) osrfStringArrayFree(params); if (mparams) osrfStringArrayFree(mparams); parser = NULL; return HTTP_INTERNAL_SERVER_ERROR; } } /* so a subrequest doesn't re-read this bucket */ apr_bucket_delete(currentBucket); } apr_brigade_destroy(brigade); if (params) osrfStringArrayFree(params); if (mparams) osrfStringArrayFree(mparams); return APR_SUCCESS; }
void bmx_expat_XML_SetCommentHandler(XML_Parser parser) { XML_SetCommentHandler(parser, bmx_expat_CommentHandler); }