result_t XmlParser::parse(XmlDocument* doc, exlib::string source) { XmlParser parser(doc, true); parser.m_now = doc; parser.m_list.push_back(doc); XML_Parser xml_parser = XML_ParserCreate(NULL); XML_SetParamEntityParsing(xml_parser, XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE); XML_SetUserData(xml_parser, &parser); XML_SetXmlDeclHandler(xml_parser, XmlDeclHandler); XML_SetElementHandler(xml_parser, StartElementHandler, EndElementHandler); XML_SetCharacterDataHandler(xml_parser, CharacterDataHandler); XML_SetProcessingInstructionHandler(xml_parser, ProcessingInstructionHandler); XML_SetCommentHandler(xml_parser, CommentHandler); XML_SetCdataSectionHandler(xml_parser, StartCdataSectionHandler, EndCdataSectionHandler); XML_SetStartDoctypeDeclHandler(xml_parser, StartDoctypeDeclHandler); if (XML_Parse(xml_parser, source.c_str(), (int32_t)source.length(), true) != XML_STATUS_OK) { char msg[128]; sprintf(msg, "XmlParser: error on line %lu at column %lu: %s", XML_GetCurrentLineNumber(xml_parser), XML_GetCurrentColumnNumber(xml_parser) + 1, XML_ErrorString(XML_GetErrorCode(xml_parser))); XML_ParserFree(xml_parser); return CHECK_ERROR(Runtime::setError(msg)); } XML_ParserFree(xml_parser); return 0; }
void xmlg_parser_error_abort( xmlGParser *xml_parser, HqBool fire_error_handler, uint8 *detail, int32 detail_len) { xmlGParserCommon *c ; xmlGFilterChain *filter_chain ; uint32 line, column ; XMLGASSERT(xml_parser != NULL, "xml_parser is NULL") ; c = xmlg_get_parser_common(xml_parser); XMLGASSERT(c != NULL, "common is NULL"); filter_chain = c->filter_chain ; /* setting the callback functions to NULL ensures we stop */ XML_SetElementHandler(xml_parser->ctxt, NULL, NULL) ; XML_SetStartNamespaceDeclHandler(xml_parser->ctxt, NULL) ; XML_SetCharacterDataHandler(xml_parser->ctxt, NULL) ; XML_SetXmlDeclHandler(xml_parser->ctxt, NULL) ; XML_SetStartDoctypeDeclHandler(xml_parser->ctxt, NULL) ; if (fire_error_handler) { xmlg_parser_line_and_column(xml_parser, &line, &column) ; /* only ever invoke the error handler once */ if (c->parse_error_cb != NULL && fire_error_handler && ! c->success_abort) c->parse_error_cb(xml_parser, xmlg_fc_get_uri(filter_chain), line, column, detail, detail_len) ; } if (! c->success_abort) c->error_abort = TRUE ; }
XmlEncodingSpy::XmlEncodingSpy ( const char *encoding ) : WrapExpat ( encoding ) , d ( new EncodingData() ) { XML_SetUserData ( p, d.get() ); XML_SetXmlDeclHandler ( p, xmldeclhandler ); XML_SetStartElementHandler ( p, start ); d->p = p; }
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; }
/* ============================================================================ * Abort and information functions. */ void xmlg_p_abort_parse( xmlGParser *xml_parser) { xmlGParserCommon *c; XMLGASSERT(xml_parser != NULL, "xml_parser is NULL"); c = xmlg_get_parser_common(xml_parser); XMLGASSERT(c != NULL, "common is NULL"); c->success_abort = TRUE; /* setting the callback functions to NULL ensures we stop */ XML_SetElementHandler(xml_parser->ctxt, NULL, NULL); XML_SetStartNamespaceDeclHandler(xml_parser->ctxt, NULL); XML_SetCharacterDataHandler(xml_parser->ctxt, NULL); XML_SetXmlDeclHandler(xml_parser->ctxt, NULL) ; XML_SetStartDoctypeDeclHandler(xml_parser->ctxt, NULL) ; }
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; }
int Encode (CFileReader &p_coFileReader) { int iRetVal = 0; XML_Parser psoParser; psoParser = XML_ParserCreate ("UTF-8"); if (NULL == psoParser) { iRetVal = ENOMEM; return iRetVal; } SDoc soDoc; /* регистрация обработчика данных */ XML_SetElementHandler (psoParser, StartElementHandler, EndElementHandler); XML_SetXmlDeclHandler (psoParser, XmlDeclHandler); XML_SetDoctypeDeclHandler (psoParser, StartDoctypeDeclHandler, EndDoctypeDeclHandler); XML_SetUserData (psoParser, &soDoc); /* парсинг данных */ char mcBuf[256]; int iDataLen; int iIsFinal = 0; do { iDataLen = sizeof (mcBuf); if (p_coFileReader.ReadData ((unsigned char*)mcBuf, iDataLen)) iIsFinal = 1; XML_Parse (psoParser, mcBuf, iDataLen, iIsFinal); if (iIsFinal) break; } while (1); Tokenize (soDoc); if (psoParser) { XML_ParserFree (psoParser); psoParser = NULL; } return iRetVal; }
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; }
WBXML_DECLARE(WBXMLError) wbxml_tree_from_xml(WB_UTINY *xml, WB_ULONG xml_len, WBXMLTree **tree) { #if defined( HAVE_EXPAT ) const XML_Feature *feature_list = NULL; XML_Parser xml_parser = NULL; WBXMLError ret = WBXML_OK; WB_BOOL expat_utf16 = FALSE; WBXMLTreeClbCtx wbxml_tree_clb_ctx; /* First Check if Expat is outputing UTF-16 strings */ feature_list = (const XML_Feature *)XML_GetFeatureList(); if ((feature_list != NULL) && (feature_list[0].value != sizeof(WB_TINY))) { #if !defined( HAVE_ICONV ) /* Ouch, can't convert from UTF-16 to UTF-8 */ return WBXML_ERROR_XMLPARSER_OUTPUT_UTF16; #else /* Expat returns UTF-16 encoded strings in its callbacks */ expat_utf16 = TRUE; #endif /* !HAVE_ICONV */ } if (tree != NULL) *tree = NULL; /* Create Expat XML Parser */ if ((xml_parser = XML_ParserCreateNS(NULL, WBXML_NAMESPACE_SEPARATOR)) == NULL) return WBXML_ERROR_NOT_ENOUGH_MEMORY; /* Init context */ wbxml_tree_clb_ctx.current = NULL; wbxml_tree_clb_ctx.error = WBXML_OK; wbxml_tree_clb_ctx.skip_lvl = 0; wbxml_tree_clb_ctx.skip_start = 0; wbxml_tree_clb_ctx.xml_parser = xml_parser; wbxml_tree_clb_ctx.input_buff = xml; wbxml_tree_clb_ctx.expat_utf16 = expat_utf16; /* Create WBXML Tree */ if ((wbxml_tree_clb_ctx.tree = wbxml_tree_create(WBXML_LANG_UNKNOWN, WBXML_CHARSET_UNKNOWN)) == NULL) { XML_ParserFree(xml_parser); WBXML_ERROR((WBXML_PARSER, "Can't create WBXML Tree")); return WBXML_ERROR_NOT_ENOUGH_MEMORY; } /* Set Handlers Callbacks */ XML_SetXmlDeclHandler(xml_parser, wbxml_tree_clb_xml_decl); XML_SetStartDoctypeDeclHandler(xml_parser, wbxml_tree_clb_xml_doctype_decl); XML_SetElementHandler(xml_parser, wbxml_tree_clb_xml_start_element, wbxml_tree_clb_xml_end_element); XML_SetCdataSectionHandler(xml_parser, wbxml_tree_clb_xml_start_cdata, wbxml_tree_clb_xml_end_cdata); XML_SetProcessingInstructionHandler(xml_parser , wbxml_tree_clb_xml_pi); XML_SetCharacterDataHandler(xml_parser, wbxml_tree_clb_xml_characters); XML_SetUserData(xml_parser, (void*)&wbxml_tree_clb_ctx); /* Parse the XML Document to WBXML Tree */ if (XML_Parse(xml_parser, (WB_TINY*) xml, xml_len, TRUE) == 0) { WBXML_ERROR((WBXML_CONV, "xml2wbxml conversion failed - expat error %i\n" "\tdescription: %s\n" "\tline: %i\n" "\tcolumn: %i\n" "\tbyte index: %i\n" "\ttotal bytes: %i\n%s", XML_GetErrorCode(xml_parser), XML_ErrorString(XML_GetErrorCode(xml_parser)), XML_GetCurrentLineNumber(xml_parser), XML_GetCurrentColumnNumber(xml_parser), XML_GetCurrentByteIndex(xml_parser), XML_GetCurrentByteCount(xml_parser), xml)); wbxml_tree_destroy(wbxml_tree_clb_ctx.tree); ret = WBXML_ERROR_XML_PARSING_FAILED; } else { if ((ret = wbxml_tree_clb_ctx.error) != WBXML_OK) { WBXML_ERROR((WBXML_CONV, "xml2wbxml conversion failed - context error %i", ret)); wbxml_tree_destroy(wbxml_tree_clb_ctx.tree); } else *tree = wbxml_tree_clb_ctx.tree; } /* Clean-up */ XML_ParserFree(xml_parser); return ret; #else /* HAVE_EXPAT */ #if defined( HAVE_LIBXML ) /** @todo Use LibXML2 SAX interface ! */ return WBXML_ERROR_NO_XMLPARSER; #else /* HAVE_LIBXML */ /** @note You can add here another XML Parser support */ return WBXML_ERROR_NO_XMLPARSER; #endif /* HAVE_LIBXML */ #endif /* HAVE_EXPAT */ }
/* ============================================================================ * Create/Destroy XML parse handler. */ HqBool xmlg_p_new( xmlGContext *xml_ctxt, xmlGParser **xml_parser, xmlGMemoryHandler *memory_handler, xmlGFilterChain *filter_chain) { xmlGParser *new_xml_parser; XMLGASSERT(xml_ctxt != NULL, "xml_ctxt is NULL"); XMLGASSERT(xml_parser != NULL, "xml_parser is NULL"); XMLGASSERT(filter_chain != NULL, "filter_chain is NULL"); *xml_parser = NULL; /* Although this code is going to be common to all back end XML parsers, we need to do it here because only this file knows about the size of xmlGParser - which is back end specific. */ if (memory_handler != NULL) { if (memory_handler->f_malloc == NULL || memory_handler->f_realloc == NULL || memory_handler->f_free == NULL) { XMLGASSERT(FALSE, "incomplete memory handler") ; return FALSE ; } /* Use the pluged memory handler to allocate this structure */ if ((new_xml_parser = memory_handler->f_malloc(sizeof(xmlGParser))) == NULL) return FALSE; } else { /* use the XML sub-system memory management */ if ((new_xml_parser = xmlg_subsystem_malloc(xml_ctxt, sizeof(xmlGParser))) == NULL) return FALSE; } if (! xmlg_parser_common_init(new_xml_parser, xml_ctxt, memory_handler, filter_chain)) { /* We need to do this as we don't know if the memory handlers have been plugged successfuly. Better safe than sorry. */ if (memory_handler != NULL) { memory_handler->f_free(new_xml_parser); } else { xmlg_subsystem_free(xml_ctxt, new_xml_parser); } return FALSE; } /* xmlg_parser_malloc and friends are now available for this handler. */ /* Do backend XML parser specific stuff. */ /* setup expat memory handler structure */ if (memory_handler != NULL) { new_xml_parser->expat_mem.malloc_fcn = memory_handler->f_malloc ; new_xml_parser->expat_mem.realloc_fcn = memory_handler->f_realloc ; new_xml_parser->expat_mem.free_fcn = memory_handler->f_free ; } else { new_xml_parser->expat_mem.malloc_fcn = xml_ctxt->memory_handler.f_malloc ; new_xml_parser->expat_mem.realloc_fcn = xml_ctxt->memory_handler.f_realloc ; new_xml_parser->expat_mem.free_fcn = xml_ctxt->memory_handler.f_free ; } new_xml_parser->ctxt = XML_ParserCreate_MM(NULL, &new_xml_parser->expat_mem, &sep); if (new_xml_parser->ctxt == NULL) { xmlg_parser_free(new_xml_parser, new_xml_parser); return FALSE; } /* Turn prefix mapping on. */ XML_SetReturnNSTriplet(new_xml_parser->ctxt, 1); XML_SetUserData(new_xml_parser->ctxt, (void *)(new_xml_parser)) ; XML_SetElementHandler(new_xml_parser->ctxt, expat_start_element_ns_cb, expat_end_element_ns_cb) ; XML_SetStartNamespaceDeclHandler(new_xml_parser->ctxt, expat_start_namespace_cb) ; XML_SetCharacterDataHandler(new_xml_parser->ctxt, expat_characters_data_cb) ; XML_SetXmlDeclHandler(new_xml_parser->ctxt, expat_xml_decl_cb) ; XML_SetStartDoctypeDeclHandler(new_xml_parser->ctxt, expat_xml_dtd_cb) ; if (filter_chain != NULL) { xmlg_p_set_parse_error_cb(new_xml_parser, filter_chain->parse_error_cb) ; } *xml_parser = new_xml_parser; return TRUE; }
void _Expat_XML_SetXmlDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_XmlDeclHandler handler) { XML_SetXmlDeclHandler(parser, handler); }
void XMLParser::EnableXmlDeclHandler(bool enable) { assert(m_parser != NULL); XML_SetXmlDeclHandler(m_parser, enable ? XmlDeclHandler : NULL); }
/* * Initialize an IterParser object * * The Python arguments are: * * *fd*: A Python file object or a callable object * *buffersize*: The size of the read buffer */ static int IterParser_init(IterParser *self, PyObject *args, PyObject *kwds) { PyObject* fd = NULL; PyObject* read = NULL; ssize_t buffersize = 1 << 14; static char *kwlist[] = {"fd", "buffersize", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|n:IterParser.__init__", kwlist, &fd, &buffersize)) { return -1; } /* Keep the buffersize within a reasonable range */ self->buffersize = CLAMP(buffersize, (ssize_t)(1 << 10), (ssize_t)(1 << 24)); #ifdef __clang__ /* Clang can't handle the file descriptors Python gives us, so in that case, we just call the object's read method. */ read = PyObject_GetAttrString(fd, "read"); if (read != NULL) { fd = read; } #else self->file = PyObject_AsFileDescriptor(fd); if (self->file != -1) { /* This is a real C file handle or descriptor. We therefore need to allocate our own read buffer, and get the real C object. */ self->buffer = malloc((size_t)self->buffersize); if (self->buffer == NULL) { PyErr_SetString(PyExc_MemoryError, "Out of memory"); goto fail; } self->fd = fd; Py_INCREF(self->fd); lseek(self->file, 0, SEEK_SET); } else #endif if (PyCallable_Check(fd)) { /* fd is a Python callable */ self->fd = fd; Py_INCREF(self->fd); self->read = fd; Py_INCREF(self->read); } else { PyErr_SetString( PyExc_TypeError, "Arg 1 to iterparser must be a file object or callable object"); goto fail; } PyErr_Clear(); self->queue_read_idx = 0; self->queue_write_idx = 0; self->done = 0; self->text = malloc((size_t)buffersize * sizeof(XML_Char)); self->text_alloc = buffersize; if (self->text == NULL) { PyErr_SetString(PyExc_MemoryError, "Out of memory"); goto fail; } text_clear(self); self->read_args = Py_BuildValue("(n)", buffersize); if (self->read_args == NULL) { goto fail; } self->dict_singleton = PyDict_New(); if (self->dict_singleton == NULL) { goto fail; } self->td_singleton = PyUnicode_FromString("TD"); if (self->td_singleton == NULL) { goto fail; } if (queue_realloc(self, buffersize)) { goto fail; } /* Set up an expat parser with our callbacks */ self->parser = XML_ParserCreate(NULL); if (self->parser == NULL) { PyErr_SetString(PyExc_MemoryError, "Out of memory"); goto fail; } XML_SetUserData(self->parser, self); XML_SetElementHandler( self->parser, (XML_StartElementHandler)startElement, (XML_EndElementHandler)endElement); XML_SetCharacterDataHandler( self->parser, (XML_CharacterDataHandler)characterData); XML_SetXmlDeclHandler( self->parser, (XML_XmlDeclHandler)xmlDecl); Py_XDECREF(read); return 0; fail: Py_XDECREF(read); Py_XDECREF(self->fd); Py_XDECREF(self->read); free(self->text); Py_XDECREF(self->dict_singleton); Py_XDECREF(self->td_singleton); Py_XDECREF(self->read_args); free(self->queue); return -1; }
void bmx_expat_XML_SetXmlDeclHandler(XML_Parser parser) { XML_SetXmlDeclHandler(parser, bmx_expat_XmlDeclHandler); }