static VALUE parse_doc(VALUE ctxt_val) { xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val; xmlParseDocument(ctxt); return Qnil; }
// A modified version of XmlSAXParseFile in gnome-xml. This one lets us set // the user_data that is passed to the various callbacks, to make it possible // to avoid lots of global variables. gboolean oreganoXmlSAXParseFile (xmlSAXHandlerPtr sax, gpointer user_data, const gchar *filename) { g_return_val_if_fail (filename != NULL, FALSE); gboolean parser_failed, ret = TRUE; xmlParserCtxtPtr ctxt; ctxt = xmlCreateFileParserCtxt (filename); if (ctxt == NULL) return FALSE; ctxt->sax = sax; ctxt->userData = user_data; #if defined(LIBXML_VERSION) && LIBXML_VERSION >= 20000 xmlKeepBlanksDefault (0); #endif parser_failed = FALSE; if (xmlParseDocument (ctxt) < 0) { // FIXME post a message to the log buffer with as much details as possible g_message ("Failed to parse \"%s\"", filename); ret = FALSE; parser_failed = TRUE; } else { ret = ctxt->wellFormed ? TRUE : FALSE; if (sax != NULL) ctxt->sax = NULL; } if (!parser_failed) xmlFreeParserCtxt (ctxt); return ret; }
int main(int argc, char **argv) { xmlParserCtxtPtr ctxt; xmlsatParseState state; if (argc<2) { printf("Usage: %s [-fta] filename.xmlsat\n",argv[0]); } else { if (argc==2) { ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[1]); } else if (argc==3) { if (strcmp(argv[1],"-fta")==0) { fta=1; } ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[2]); } if (ctxt == NULL) { fprintf(stderr,"ERROR: can not open file\n"); } ctxt->sax = &xmlsatSAXParser; ctxt->userData = &state; xmlParseDocument(ctxt); ctxt->sax = NULL; xmlFreeParserCtxt(ctxt); } return 0; }
bool XParser::ParseContext(xmlParserCtxtPtr pxParseCtxt) { /** initialize context begin **/ pxParseCtxt->linenumbers = 1; //有效性检查 //pxParseCtxt->validate = (validate_ ? 1 : 0); //初始化error和varning的回调函数 //pxParseCtxt->vctxt.error = &callback_validity_error; //pxParseCtxt->vctxt.warning = &callback_validity_warning; //允许callback_validity_*回调函数回去C++指针 pxParseCtxt->_private = this; //pxParseCtxt->replaceEntities = (substitute_entities_ ? 1 : 0); /** initialize context end **/ xmlParseDocument(pxParseCtxt); if(!pxParseCtxt->wellFormed) { return false; } if(pxParseCtxt->errNo != 0) { return false; } return true; }
gboolean ide_xml_sax_parse (IdeXmlSax *self, const gchar *data, gsize length, const gchar *uri, gpointer user_data) { gboolean wellformed; g_return_val_if_fail (IDE_IS_XML_SAX (self), FALSE); g_return_val_if_fail (data != NULL, FALSE); g_return_val_if_fail (length > 0, FALSE); g_return_val_if_fail (self->initialized == TRUE, FALSE); g_return_val_if_fail (self->context == NULL, FALSE); self->context = xmlCreateMemoryParserCtxt (data, length); self->context->userData = user_data; self->context->sax = &self->handler; self->handler.initialized = XML_SAX2_MAGIC; xmlCtxtUseOptions (self->context, XML_PARSE_RECOVER | XML_PARSE_NOENT); xmlParseDocument (self->context); wellformed = self->context->wellFormed; self->context->sax = NULL; g_clear_pointer (&self->context, xmlFreeParserCtxt); return wellformed; }
/* * call-seq: * parser.parse -> (true|false) * * Parse the input XML, generating callbacks to the object * registered via the +callbacks+ attributesibute. */ static VALUE rxml_sax_parser_parse(VALUE self) { int status; VALUE context = rb_ivar_get(self, CONTEXT_ATTR); xmlParserCtxtPtr ctxt; Data_Get_Struct(context, xmlParserCtxt, ctxt); ctxt->sax2 = 1; ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR); if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) xmlFree(ctxt->sax); ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(rxml_sax_handler)); if (ctxt->sax == NULL) rb_fatal("Not enough memory."); memcpy(ctxt->sax, &rxml_sax_handler, sizeof(rxml_sax_handler)); status = xmlParseDocument(ctxt); /* Now check the parsing result*/ if (status == -1 || !ctxt->wellFormed) { if (ctxt->myDoc) xmlFreeDoc(ctxt->myDoc); rxml_raise(&ctxt->lastError); } return Qtrue; }
/* * call-seq: * parse_with(sax_handler) * * Use +sax_handler+ and parse the current document */ static VALUE parse_with(VALUE self, VALUE sax_handler) { if(!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser)) rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser"); xmlParserCtxtPtr ctxt; Data_Get_Struct(self, xmlParserCtxt, ctxt); xmlSAXHandlerPtr sax; Data_Get_Struct(sax_handler, xmlSAXHandler, sax); // Free the sax handler since we'll assign our own if(ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) xmlFree(ctxt->sax); ctxt->sax = sax; ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler); xmlParseDocument(ctxt); if(NULL != ctxt->myDoc) xmlFreeDoc(ctxt->myDoc); NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData); return Qnil ; }
/* Taken from libxml2, xmlSAXParseMemoryWithData */ xmlDocPtr mxslt_doc_xml_load_entity(mxslt_doc_t * document, char * localfile) { xmlParserCtxtPtr ctx; xmlParserInputPtr input; xmlDocPtr retval; xmlChar * filename; mxslt_doc_debug_print(document, MXSLT_DBG_LIBXML | MXSLT_DBG_DEBUG | MXSLT_DBG_VERBOSE0, "load_entity/xmlCreateMemoryParserCtxt -- replacing entities: %08x\n", xmlSubstituteEntitiesDefaultValue); /* SNIPPET: This is a good mix&shake of * xmlCreateMemoryParserCtxt, xmlCreateFileParserCtxt */ ctx=xmlNewParserCtxt(); if(ctx == NULL) return NULL; #if LIBXML_VERSION >= 20600 xmlCtxtUseOptions(ctx, MXSLT_XSLT_OPTIONS); #endif /* Remember which document we are parsing * in this context */ /* ctx->_private=document; */ filename=xmlCanonicPath((xmlChar *)localfile); if(filename == NULL) { xmlFreeParserCtxt(ctx); return NULL; } input=xmlLoadExternalEntity((char *)filename, NULL, ctx); xmlFree(filename); if(input == NULL) { xmlFreeParserCtxt(ctx); return NULL; } inputPush(ctx, input); if(ctx->directory == NULL) ctx->directory=xmlParserGetDirectory(localfile); /* END SNIPPET */ /* MXSLT_DUMP_CTX(ctx); */ /* Parse document */ xmlParseDocument(ctx); if(ctx->wellFormed) retval=ctx->myDoc; else { retval=NULL; xmlFreeDoc(ctx->myDoc); ctx->myDoc=NULL; } xmlFreeParserCtxt(ctx); return retval; }
static int rxml_sax_parser_parse_io(VALUE self, VALUE input) { VALUE io = rb_ivar_get(input, IO_ATTR); VALUE encoding = rb_ivar_get(input, ENCODING_ATTR); xmlCharEncoding xmlEncoding = NUM2INT(encoding); xmlParserCtxtPtr ctxt = xmlCreateIOParserCtxt((xmlSAXHandlerPtr)&rxml_sax_hander_struct, (void *)self, (xmlInputReadCallback) rxml_read_callback, NULL, (void *)io, xmlEncoding); return xmlParseDocument(ctxt); }
xmlDocPtr soap_xmlParseFile(const char *filename) { xmlParserCtxtPtr ctxt = NULL; xmlDocPtr ret; zend_bool old_allow_url_fopen; /* xmlInitParser(); */ old_allow_url_fopen = PG(allow_url_fopen); PG(allow_url_fopen) = 1; ctxt = xmlCreateFileParserCtxt(filename); PG(allow_url_fopen) = old_allow_url_fopen; if (ctxt) { zend_bool old; ctxt->keepBlanks = 0; ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace; ctxt->sax->comment = soap_Comment; ctxt->sax->warning = NULL; ctxt->sax->error = NULL; /*ctxt->sax->fatalError = NULL;*/ #if LIBXML_VERSION >= 20703 ctxt->options |= XML_PARSE_HUGE; #endif old = php_libxml_disable_entity_loader(1); xmlParseDocument(ctxt); php_libxml_disable_entity_loader(old); if (ctxt->wellFormed) { ret = ctxt->myDoc; if (ret->URL == NULL && ctxt->directory != NULL) { ret->URL = xmlCharStrdup(ctxt->directory); } } else { ret = NULL; xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL; } xmlFreeParserCtxt(ctxt); } else { ret = NULL; } /* xmlCleanupParser(); */ if (ret) { cleanup_xml_node((xmlNodePtr)ret); } return ret; }
int RS_XML(libXMLEventParse)(const char *fileName, RS_XMLParserData *parserData, RS_XML_ContentSourceType asText, int saxVersion) { xmlSAXHandlerPtr xmlParserHandler; xmlParserCtxtPtr ctx; int status; switch(asText) { case RS_XML_TEXT: ctx = xmlCreateDocParserCtxt(CHAR_TO_XMLCHAR(fileName)); break; case RS_XML_FILENAME: ctx = xmlCreateFileParserCtxt(fileName); break; case RS_XML_CONNECTION: ctx = RS_XML_xmlCreateConnectionParserCtxt((USER_OBJECT_) fileName); break; default: ctx = NULL; } if(ctx == NULL) { PROBLEM "Can't parse %s", fileName ERROR; } xmlParserHandler = (xmlSAXHandlerPtr) S_alloc(sizeof(xmlSAXHandler), 1); /* Make certain this is initialized so that we don't have any references to unwanted routines! */ memset(xmlParserHandler, '\0', sizeof(xmlSAXHandler)); RS_XML(initXMLParserHandler)(xmlParserHandler, saxVersion); parserData->ctx = ctx; ctx->userData = parserData; ctx->sax = xmlParserHandler; status = xmlParseDocument(ctx); ctx->sax = NULL; xmlFreeParserCtxt(ctx); return(status); /* Free(xmlParserHandler); */ }
/* * Read xmlDocument from server */ static xmlDoc * js_document_read (xmlParserCtxtPtr ctxt, js_session_t *jsp, const char *url, const char *encoding, int options) { xmlParserInputBufferPtr input; xmlParserInputPtr stream; xmlDoc *docp; if (jsp == NULL || ctxt == NULL || jsp->js_state == JSS_DEAD) return NULL; xmlCtxtReset(ctxt); input = js_buffer_create(jsp, XML_CHAR_ENCODING_NONE); if (input == NULL) return NULL; input->closecallback = NULL; stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); if (stream == NULL) { xmlFreeParserInputBuffer(input); return NULL; } inputPush(ctxt, stream); xmlCtxtUseOptions(ctxt, options); xmlCharEncodingHandlerPtr hdlr; if (encoding && ((hdlr = xmlFindCharEncodingHandler(encoding)) != NULL)) xmlSwitchToEncoding(ctxt, hdlr); if (url != NULL && ctxt->input != NULL && ctxt->input->filename == NULL) ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) url); /* * All right. The stage is set, time to open the curtain and let * the show begin. */ xmlParseDocument(ctxt); docp = ctxt->myDoc; ctxt->myDoc = NULL; if (docp && !ctxt->wellFormed) { xmlFreeDoc(docp); docp = NULL; } return docp; }
UT_Error UT_XML::parse (const char * buffer, UT_uint32 length) { if (!m_bSniffing) { UT_ASSERT (m_pListener || m_pExpertListener); if ((m_pListener == 0) && (m_pExpertListener == 0)) return UT_ERROR; } UT_ASSERT (buffer); if (buffer == 0 || length == 0) return UT_ERROR; if (!reset_all ()) return UT_OUTOFMEM; UT_Error ret = UT_OK; xmlParserCtxtPtr ctxt; xmlSAXHandler hdl; memset(&hdl, 0, sizeof(hdl)); hdl.getEntity = _getEntity; hdl.startElement = _startElement; hdl.endElement = _endElement; hdl.characters = _charData; hdl.error = _errorSAXFunc; hdl.fatalError = _fatalErrorSAXFunc; hdl.processingInstruction = _processingInstruction; hdl.comment = _comment; hdl.cdataBlock = _cdata; ctxt = xmlCreateMemoryParserCtxt (buffer, static_cast<int>(length)); if (ctxt == NULL) { UT_DEBUGMSG (("Unable to create libxml2 memory context!\n")); return UT_ERROR; } memcpy(ctxt->sax, &hdl, sizeof(hdl)); ctxt->userData = static_cast<void *>(this); m_bStopped = false; xmlParseDocument (ctxt); if (!ctxt->wellFormed) ret = UT_IE_IMPORTERROR; xmlDocPtr myXmlDoc = ctxt->myDoc; xmlFreeParserCtxt (ctxt); xmlFreeDoc(myXmlDoc); return ret; }
xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size) { xmlParserCtxtPtr ctxt = NULL; xmlDocPtr ret; /* xmlInitParser(); */ ctxt = xmlCreateMemoryParserCtxt(buf, buf_size); if (ctxt) { zend_bool old; ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace; ctxt->sax->comment = soap_Comment; ctxt->sax->warning = NULL; ctxt->sax->error = NULL; /*ctxt->sax->fatalError = NULL;*/ #if LIBXML_VERSION >= 20703 ctxt->options |= XML_PARSE_HUGE; #endif old = php_libxml_disable_entity_loader(1); xmlParseDocument(ctxt); php_libxml_disable_entity_loader(old); if (ctxt->wellFormed) { ret = ctxt->myDoc; if (ret->URL == NULL && ctxt->directory != NULL) { ret->URL = xmlCharStrdup(ctxt->directory); } } else { ret = NULL; xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL; } xmlFreeParserCtxt(ctxt); } else { ret = NULL; } /* xmlCleanupParser(); */ /* if (ret) { cleanup_xml_node((xmlNodePtr)ret); } */ return ret; }
static int ncXmlSAXParseFile(xmlSAXHandlerPtr sax, void *user_data, const char *filename) { int ret = 0; xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(filename); if (!ctxt) return -1; ctxt->sax = sax; ctxt->userData = user_data; xmlParseDocument(ctxt); ret = ctxt->wellFormed ? 0 : -1; if (sax) ctxt->sax = NULL; xmlFreeParserCtxt(ctxt); return ret; }
bool LibxmlSaxParser::parseBuffer( const char* uri, const char* buffer, int length ) { mParserContext = xmlCreateMemoryParserCtxt( buffer, length ); if ( !mParserContext ) { ParserError error(ParserError::SEVERITY_CRITICAL, ParserError::ERROR_COULD_NOT_OPEN_FILE, 0, 0, 0, 0, uri); IErrorHandler* errorHandler = getParser()->getErrorHandler(); if ( errorHandler ) { errorHandler->handleError(error); } return false; } // We let libxml replace the entities mParserContext->replaceEntities = 1; if (mParserContext->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) { xmlFree(mParserContext->sax); } mParserContext->sax = &SAXHANDLER; mParserContext->userData = (void*)this; initializeParserContext(); xmlParseDocument(mParserContext); mParserContext->sax = 0; if ( mParserContext->myDoc ) { xmlFreeDoc(mParserContext->myDoc); mParserContext->myDoc = 0; } xmlFreeParserCtxt(mParserContext); mParserContext = 0; return true; }
/* * call-seq: * parser.parse -> XML::Document * * Parse the input XML and create an XML::Document with * it's content. If an error occurs, XML::Parser::ParseError * is thrown. */ static VALUE rxml_parser_parse(VALUE self) { xmlParserCtxtPtr ctxt; VALUE context = rb_ivar_get(self, CONTEXT_ATTR); Data_Get_Struct(context, xmlParserCtxt, ctxt); if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery) { if (ctxt->myDoc) xmlFreeDoc(ctxt->myDoc); rxml_raise(&ctxt->lastError); } return rxml_document_wrap(ctxt->myDoc); }
HarvestResult processHarvestFromFd(int fd, HarvestProcessor* harvestProcessor, bool shouldProcessData) { MwsHarvest_SaxUserData user_data; xmlSAXHandler saxHandler; xmlParserCtxtPtr ctxtPtr; HarvestResult result; result.status = -1; user_data.harvestProcessor = harvestProcessor; user_data.shouldProcessData = shouldProcessData; memset(&saxHandler, 0, sizeof(xmlSAXHandler)); // Registering Sax callbacks saxHandler.endDocument = my_endDocument; saxHandler.startElement = my_startElement; saxHandler.endElement = my_endElement; saxHandler.characters = my_characters; saxHandler.warning = my_warning; saxHandler.error = my_error; saxHandler.fatalError = my_fatalError; // Locking libXML -- to allow multi-threaded use xmlLockLibrary(); // Creating the IOParser context if ((ctxtPtr = xmlCreateIOParserCtxt(&saxHandler, &user_data, fdXmlInputReadCallback, nullptr, &fd, XML_CHAR_ENCODING_UTF8)) == nullptr) { PRINT_WARN("Error while creating the ParserContext\n"); } // Parsing the document else if ((result.status = xmlParseDocument(ctxtPtr)) == -1) { PRINT_WARN("Parsing XML document failed\n"); } // Freeing the parser context if (ctxtPtr) { xmlFreeParserCtxt(ctxtPtr); } // Unlocking libXML -- to allow multi-threaded use xmlUnlockLibrary(); result.numExpressions = user_data.parsedExpr; return result; }
TEG_STATUS metaserver_get_servers( void ) { int s = -1; int ret; xmlParserCtxtPtr ctxt; xmlDocPtr doc = NULL; metaserver_flush_list(); s = net_connect_tcp("teg.game-server.cc",2002); if( s < 0 ) goto error; if( net_printf( s, "GET /listServers_xml HTTP/1.1\r\n\r\n") < 0 ) goto error; ctxt = xmlCreateIOParserCtxt(NULL, NULL, (xmlInputReadCallback) net_read, (xmlInputCloseCallback) net_close, (void *)s, XML_CHAR_ENCODING_NONE); xmlParseDocument(ctxt); ret = ctxt->wellFormed; doc = ctxt->myDoc; xmlFreeParserCtxt(ctxt); if (!ret) goto error; if( metaserver_parse_xml( doc ) != TEG_STATUS_SUCCESS ) goto error; return TEG_STATUS_SUCCESS; error: if( doc ) xmlFreeDoc(doc); if( s >= 0 ) net_close( s ); return TEG_STATUS_ERROR; }
xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size, bool skip_clean /*= true */) { xmlParserCtxtPtr ctxt = nullptr; xmlDocPtr ret; /* xmlInitParser(); */ ctxt = xmlCreateMemoryParserCtxt((const char *)buf, buf_size); if (ctxt) { ctxt->keepBlanks = 0; ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace; ctxt->sax->comment = soap_Comment; ctxt->sax->warning = nullptr; ctxt->sax->error = nullptr; /*ctxt->sax->fatalError = nullptr;*/ auto old = HHVM_FN(libxml_disable_entity_loader)(true); xmlParseDocument(ctxt); HHVM_FN(libxml_disable_entity_loader)(old); if (ctxt->wellFormed) { ret = ctxt->myDoc; if (ret->URL == nullptr && ctxt->directory != nullptr) { ret->URL = xmlCharStrdup(ctxt->directory); } } else { ret = nullptr; xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = nullptr; } xmlFreeParserCtxt(ctxt); } else { ret = nullptr; } /* xmlCleanupParser(); */ if (!skip_clean && ret) { cleanup_xml_node((xmlNodePtr)ret); } return ret; }
xmlDocPtr soap_xmlParseMemory(const void *buf, size_t buf_size) { xmlParserCtxtPtr ctxt = NULL; xmlDocPtr ret; /* xmlInitParser(); */ ctxt = xmlCreateMemoryParserCtxt((const char *)buf, buf_size); if (ctxt) { ctxt->keepBlanks = 0; ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace; ctxt->sax->comment = soap_Comment; ctxt->sax->warning = NULL; ctxt->sax->error = NULL; /*ctxt->sax->fatalError = NULL;*/ xmlParseDocument(ctxt); if (ctxt->wellFormed) { ret = ctxt->myDoc; if (ret->URL == NULL && ctxt->directory != NULL) { ret->URL = xmlCharStrdup(ctxt->directory); } } else { ret = NULL; xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL; } xmlFreeParserCtxt(ctxt); } else { ret = NULL; } /* xmlCleanupParser(); */ /* if (ret) { cleanup_xml_node((xmlNodePtr)ret); } */ return ret; }
bool LibxmlSaxParser::parseFile( const char* fileName ) { mParserContext = xmlCreateFileParserCtxt(fileName); if ( !mParserContext ) { ParserError error(ParserError::SEVERITY_CRITICAL, ParserError::ERROR_COULD_NOT_OPEN_FILE, 0, 0, 0, 0, fileName); getParser()->getErrorHandler()->handleError(error); return false; } if (mParserContext->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) { xmlFree(mParserContext->sax); } mParserContext->sax = &SAXHANDLER; mParserContext->userData = (void*)this; initializeParserContext(); xmlParseDocument(mParserContext); mParserContext->sax = 0; if ( mParserContext->myDoc ) { xmlFreeDoc(mParserContext->myDoc); mParserContext->myDoc = 0; } xmlFreeParserCtxt(mParserContext); mParserContext = 0; return true; }
bool HandlerBase::Parse( const iStringT& fname ) { // FName converted to the ascii CvtTA<> fnameAnsi( fname.CStr() ); context_ = xmlCreateFileParserCtxt( fnameAnsi ); if ( !context_ ) throw SaxError(); xmlSAXHandler sh = { 0,0,0,0,0, 0, //zGetEntity, 0,0,0,0,0,0, zStartDocument, zEndDocument, zStartElement, zEndElement, 0, zCharacters, 0,0, zComment, zWarning, zzError, zFatalError, 0, zCDATABlock, 0 }; context_->sax = &sh; context_->userData = this; xmlSubstituteEntitiesDefault( 1 ); xmlKeepBlanksDefault( 0 ); xmlParseDocument( context_ ); bool wellFormed = context_->wellFormed ? true : false; context_->sax = 0; xmlFreeParserCtxt( context_ ); return wellFormed; }
xmlDocPtr soap_xmlParseFile(const char *filename) { const char *url = strstr(filename, "://"); if (url) { xmlDocPtr ret; xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(filename); if (ctxt) { ctxt->keepBlanks = 0; ctxt->sax->ignorableWhitespace = soap_ignorableWhitespace; ctxt->sax->comment = soap_Comment; ctxt->sax->warning = NULL; ctxt->sax->error = NULL; /*ctxt->sax->fatalError = NULL;*/ xmlParseDocument(ctxt); if (ctxt->wellFormed) { ret = ctxt->myDoc; if (ret->URL == NULL && ctxt->directory != NULL) { ret->URL = xmlCharStrdup(ctxt->directory); } } else { ret = NULL; xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL; } xmlFreeParserCtxt(ctxt); } else { ret = NULL; } if (ret) { cleanup_xml_node((xmlNodePtr)ret); } return ret; } Variant content = f_file_get_contents(filename); if (!same(content, false)) { String scontent = content.toString(); return soap_xmlParseMemory(scontent.data(), scontent.size()); } return NULL; }
int main(int argc, char* argv[]) { xmlParserCtxtPtr ctxt=NULL; xmlsubsParseState state; int i; state.fontfilename=NULL; state.use_freetype=0; fprintf(stderr,"argc=%d\n",argc); i=1; while (i < argc) { if (strcmp(argv[i],"-freetype")==0) { state.use_freetype=1; } else if (strcmp(argv[i],"-font")==0) { i++; state.fontfilename=argv[i]; } else { if (ctxt==NULL) { ctxt = (xmlParserCtxtPtr)xmlCreateFileParserCtxt(argv[i]); } } i++; } if (ctxt == NULL) { fprintf(stderr,"Usage: %s [-freetype] [-font font.ttf] filename.xml\n",argv[0]); exit(1); } ctxt->sax = &xmlsubsSAXParser; ctxt->userData = &state; xmlParseDocument(ctxt); ctxt->sax = NULL; xmlFreeParserCtxt(ctxt); fprintf(stderr,"Finished!\n"); exit(0); }
static gboolean xml_read_context (xmlParserCtxt *ctxt, MrpProject *project, GError **error) { xmlDoc *doc; gboolean ret_val; xmlParseDocument (ctxt); doc = ctxt->myDoc; if (!doc) { g_warning ("Could not read XML."); return FALSE; } if (!ctxt->wellFormed) { g_warning ("Document not well formed."); xmlFreeDoc (doc); return FALSE; } switch (xml_locate_type (doc)) { case XML_TYPE_MRP_1: g_print ("Isn't implemented yet\n"); ret_val = FALSE; break; case XML_TYPE_MRP_0_6: case XML_TYPE_MRP_0_5_1: ret_val = mrp_old_xml_parse (project, doc, error); break; default: ret_val = FALSE; break; }; xmlFreeDoc (doc); return ret_val; }
// implementation of this function is inspired by the SAX documentation by James Henstridge. // (http://www.daa.com.au/~james/gnome/xml-sax/implementing.html) void SaxParser::parse() { //TODO If this is not the first parsing with this SaxParser, the xmlDoc object // in entity_resolver_doc_ should be deleted and replaced by a new one. // Otherwise entity declarations from a previous parsing may erroneously affect // this parsing. This would be much easier if entity_resolver_doc_ were a // std::auto_ptr<Document>, so the xmlpp::Document could be deleted and a new // one created. A good place for such code would be in an overridden // SaxParser::initialize_context(). It would be an ABI break. if(!context_) { throw internal_error("Parser context not created."); } xmlSAXHandlerPtr old_sax = context_->sax; context_->sax = sax_handler_.get(); xmlResetLastError(); initialize_context(); const int parseError = xmlParseDocument(context_); context_->sax = old_sax; Glib::ustring error_str = format_xml_parser_error(context_); if (error_str.empty() && parseError == -1) error_str = "xmlParseDocument() failed."; release_underlying(); // Free context_ check_for_exception(); if(!error_str.empty()) { throw parse_error(error_str); } }
bool HandlerBase::Parse( const char* buf, int size) { context_ = xmlCreateMemoryParserCtxt( buf, size ); if ( !context_ ) throw SaxError(); xmlSAXHandler sh = { 0,0,0,0,0, 0, //zGetEntity, 0,0,0,0,0,0, zStartDocument, zEndDocument, zStartElement, zEndElement, 0, zCharacters, 0,0, zComment, zWarning, zzError, zFatalError, 0, zCDATABlock, 0 }; context_->sax = &sh; context_->userData = this; xmlSubstituteEntitiesDefault( 1 ); xmlKeepBlanksDefault( 0 ); xmlParseDocument( context_ ); bool wellFormed = context_->wellFormed ? true : false; context_->sax = 0; xmlFreeParserCtxt( context_ ); return wellFormed; }
int main() { int fd; xmlParserCtxtPtr ctxt; xmlSAXHandler sax = { 0 }; // Affectation des fonctions de rappels sax.startElement = debut_element; // Ouverture du flux if ((fd = open("catalogue.xml", O_RDONLY)) == -1) { fprintf(stderr, "Echec sur open\n"); return EXIT_FAILURE; } // Création du contexte if ((ctxt = xmlCreateIOParserCtxt(&sax, NULL, sax_read, sax_close, &fd, XML_CHAR_ENCODING_NONE)) == NULL) { fprintf(stderr, "Erreur lors de la création du contexte\n"); return EXIT_FAILURE; } // Parsing du document xmlParseDocument(ctxt); // Libération de la mémoire xmlFreeParserCtxt(ctxt); return EXIT_SUCCESS; }
MwsQuery* readMwsQueryFromFd(int fd) { MwsQuery_SaxUserData user_data; xmlSAXHandler saxHandler; xmlParserCtxtPtr ctxtPtr; int ret; // Initializing the SAX Handler memset(&saxHandler, 0, sizeof(xmlSAXHandler)); // Registering Sax callbacks with defined ones //internalSubsetSAXFunc internalSubset; //isStandaloneSAXFunc isStandalone; //hasInternalSubsetSAXFunc hasInternalSubset; //hasExternalSubsetSAXFunc hasExternalSubset; //resolveEntitySAXFunc resolveEntity; saxHandler.getEntity = my_getEntity; // STUB //entityDeclSAXFunc entityDecl; //notationDeclSAXFunc notationDecl; //attributeDeclSAXFunc attributeDecl; //elementDeclSAXFunc elementDecl; //unparsedEntityDeclSAXFunc unparsedEntityDecl; //setDocumentLocatorSAXFunc setDocumentLocator; saxHandler.startDocument = my_startDocument; saxHandler.endDocument = my_endDocument; saxHandler.startElement = my_startElement; saxHandler.endElement = my_endElement; //referenceSAXFunc reference; saxHandler.characters = my_characters; //ignorableWhitespaceSAXFunc ignorableWhitespace; //processingInstructionSAXFunc processingInstruction; //commentSAXFunc comment; saxHandler.warning = my_warning; saxHandler.error = my_error; saxHandler.fatalError = my_fatalError; // Locking libXML -- to allow multi-threaded use xmlLockLibrary(); // Creating the IOParser context ctxtPtr = xmlCreateIOParserCtxt(&saxHandler, &user_data, fdXmlInputReadCallback, NULL, &fd, XML_CHAR_ENCODING_UTF8); if (ctxtPtr == NULL) { fprintf(stderr, "Error while creating the ParserContext\n"); xmlUnlockLibrary(); return NULL; } ret = xmlParseDocument(ctxtPtr); if (ret == -1) { fprintf(stderr, "Parsing failed\n"); } if (!ctxtPtr->wellFormed) { fprintf(stderr, "Bad XML document\n"); } // Freeing the parser context xmlFreeParserCtxt(ctxtPtr); // Unlocking libXML -- to allow multi-threaded use xmlUnlockLibrary(); return user_data.result; }