/** * Sets the style file * * \param xsldoc Either a filename or source of XSL file */ void CXSLTransform::SetXSLDoc(CString xsldoc) { if (m_XSLDoc.Compare(xsldoc) != 0) { m_XSLDoc = xsldoc; Reset(); if (xsldoc.IsEmpty()) { return; } xmlErrorPtr err = NULL; xmlDocPtr xsl = NULL; CFileFind ff; if (xsldoc.GetLength() < MAX_PATH && ff.FindFile(xsldoc)) { // xsldoc is a filename ff.Close(); m_Style = xsltParseStylesheetFile((const xmlChar *)(LPCSTR)xsldoc); if (!m_Style || m_Style->errors > 0) { xmlFreeDoc(xsl); err = xmlGetLastError(); if (err != NULL) m_LastError.Format(AfxLoadString(IDS_STRING_XSLPARSEERR), err->file, err->line, err->int2, err->code, err->message); else m_LastError.LoadString(IDS_STRING_UNKNOWN_XSLERROR); xmlResetLastError(); #ifdef _DEBUG TRACE1("CXSLTransform::SetXSLDoc(): %s\n", m_LastError); #endif } } else { // xsldoc is a XSL source xsl = xmlParseMemory(xsldoc, xsldoc.GetLength()); if (xsl) { m_Style = xsltParseStylesheetDoc(xsl); if (!m_Style || m_Style->errors > 0) { xmlFreeDoc(xsl); err = xmlGetLastError(); if (err != NULL) m_LastError.Format(AfxLoadString(IDS_STRING_XSLPARSEERR), err->file, err->line, err->int2, err->code, err->message); else m_LastError.LoadString(IDS_STRING_UNKNOWN_XSLERROR); xmlResetLastError(); #ifdef _DEBUG TRACE1("CXSLTransform::SetXSLDoc(): %s\n", m_LastError); #endif } } else { // XML parsing error err = xmlGetLastError(); m_LastError.Format(AfxLoadString(IDS_STRING_XMLPARSEERR), err->file, err->line, err->int2, err->code, err->message); xmlResetLastError(); #ifdef _DEBUG TRACE1("CXSLTransform::SetXSLDoc(): %s\n", m_LastError); #endif } } } }
htmlDocPtr htmlParse(void *buffer, int buffer_len, void *url, void *encoding, int options, void *error_buffer, int error_buffer_len) { const char *c_buffer = (char*)buffer; const char *c_url = (char*)url; const char *c_encoding = (char*)encoding; xmlDoc *doc = NULL; xmlResetLastError(); doc = htmlReadMemory(c_buffer, buffer_len, c_url, c_encoding, options); if(doc == NULL) { xmlErrorPtr error; xmlFreeDoc(doc); error = xmlGetLastError(); if(error != NULL && error_buffer != NULL && error->level >= XML_ERR_ERROR) { char *c_error_buffer = (char*)error_buffer; if (error->message != NULL) { strncpy(c_error_buffer, error->message, error_buffer_len-1); c_error_buffer[error_buffer_len-1] = '\0'; } else { snprintf(c_error_buffer, error_buffer_len, "xml parsing error:%d", error->code); } } } return doc; }
/* * call-seq: * read_memory(string, url, encoding, options) * * Create a new document from a String */ static VALUE read_memory( VALUE klass, VALUE string, VALUE url, VALUE encoding, VALUE options ) { const char * c_buffer = StringValuePtr(string); const char * c_url = NIL_P(url) ? NULL : StringValuePtr(url); const char * c_enc = NIL_P(encoding) ? NULL : StringValuePtr(encoding); int len = (int)RSTRING_LEN(string); VALUE error_list = rb_ary_new(); xmlResetLastError(); xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher); xmlDocPtr doc = xmlReadMemory(c_buffer, len, c_url, c_enc, (int)NUM2INT(options)); xmlSetStructuredErrorFunc(NULL, NULL); if(doc == NULL) { xmlFreeDoc(doc); xmlErrorPtr error = xmlGetLastError(); if(error) rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)); else rb_raise(rb_eRuntimeError, "Could not parse document"); return Qnil; } VALUE document = Nokogiri_wrap_xml_document(klass, doc); rb_iv_set(document, "@errors", error_list); return document; }
gboolean parse_feed (gchar* data, gint64 length, GSList* parsers, KatzeArray* array, GError** error) { xmlDocPtr doc; xmlErrorPtr xerror; LIBXML_TEST_VERSION doc = xmlReadMemory ( data, length, "feedfile.xml", NULL, XML_PARSE_NOWARNING | XML_PARSE_NOERROR /*| XML_PARSE_RECOVER*/ ); if (doc) { feed_parse_doc (doc, parsers, array, error); xmlFreeDoc (doc); } else { xerror = xmlGetLastError (); *error = g_error_new (FEED_PARSE_ERROR, FEED_PARSE_ERROR_PARSE, _("Failed to parse XML feed: %s"), xerror->message); xmlResetLastError (); } xmlMemoryDump (); return *error ? FALSE : TRUE; }
PLIST_API void plist_cleanup(void) { /* free memory from parser initialization */ xmlCleanupCharEncodingHandlers(); xmlDictCleanup(); xmlResetLastError(); xmlCleanupGlobals(); xmlCleanupThreads(); xmlCleanupMemory(); }
void xml_throw_unless(bool condition) { if (!condition) { char const *message = "unknown XML error"; xmlErrorPtr xmlErr = xmlGetLastError(); if (xmlErr && xmlErr->message) { message = xmlErr->message; } error err("%s", message); xmlResetLastError(); throw err; } }
void RelaxNGSchema::parse_context(_xmlRelaxNGParserCtxt* context) { xmlResetLastError(); release_underlying(); if (!context) throw parse_error("RelaxNGSchema::parse_context(): Could not create parser context.\n" + format_xml_error()); RelaxNGSchemaParserContextHolder holder(context); pimpl_->schema = xmlRelaxNGParse(context); if (!pimpl_->schema) throw parse_error("RelaxNGSchema::parse_context(): Schema could not be parsed.\n" + format_xml_error()); }
//---------------------------------------------------------- void ParserXML::reiniciarParser(void) { elem_raiz=elem_atual=NULL; if(doc_xml) { xmlFreeDoc(doc_xml); doc_xml=NULL; } decl_dtd=buffer_xml=decl_xml=""; while(!pilha_elems.empty()) pilha_elems.pop(); xmlResetLastError(); nome_doc_xml=""; }
void XMLParser::restartParser(void) { root_elem=curr_elem=nullptr; if(xml_doc) { xmlFreeDoc(xml_doc); xml_doc=nullptr; } dtd_decl=xml_buffer=xml_decl=""; while(!elems_stack.empty()) elems_stack.pop(); xml_doc_filename=""; xmlResetLastError(); }
/* * call-seq: * read_io(io, url, encoding, options) * * Create a new document from an IO object */ static VALUE read_io( VALUE klass, VALUE io, VALUE url, VALUE encoding, VALUE options ) { const char * c_url = NIL_P(url) ? NULL : StringValuePtr(url); const char * c_enc = NIL_P(encoding) ? NULL : StringValuePtr(encoding); VALUE error_list = rb_ary_new(); VALUE document; xmlDocPtr doc; xmlResetLastError(); Nokogiri_install_error_catcher(error_list); doc = xmlReadIO( (xmlInputReadCallback)io_read_callback, (xmlInputCloseCallback)io_close_callback, (void *)io, c_url, c_enc, (int)NUM2INT(options) ); Nokogiri_remove_error_catcher(); if(doc == NULL) { xmlErrorPtr error; xmlFreeDoc(doc); error = xmlGetLastError(); if(error) rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error)); else rb_raise(rb_eRuntimeError, "Could not parse document"); return Qnil; } document = Nokogiri_wrap_xml_document(klass, doc); rb_iv_set(document, "@errors", error_list); return document; }
/* * call-seq: * read_io(io, url, encoding, options) * * Create a new document from an IO object */ static VALUE read_io( VALUE klass, VALUE io, VALUE url, VALUE encoding, VALUE options ) { const char * c_url = (url == Qnil) ? NULL : StringValuePtr(url); const char * c_enc = (encoding == Qnil) ? NULL : StringValuePtr(encoding); VALUE error_list = rb_ary_new(); xmlInitParser(); xmlResetLastError(); xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher); xmlDocPtr doc = xmlReadIO( (xmlInputReadCallback)io_read_callback, (xmlInputCloseCallback)io_close_callback, (void *)io, c_url, c_enc, NUM2INT(options) ); xmlSetStructuredErrorFunc(NULL, NULL); if(doc == NULL) { xmlFreeDoc(doc); xmlErrorPtr error = xmlGetLastError(); if(error) rb_funcall(rb_mKernel, rb_intern("raise"), 1, Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error) ); else rb_raise(rb_eRuntimeError, "Could not parse document"); return Qnil; } VALUE document = Nokogiri_wrap_xml_document(klass, doc); rb_funcall(document, rb_intern("errors="), 1, error_list); return document; }
int Document::ProcessXInclude(bool generateXIncludeNodes) { NodeMap nmap; xmlNodePtr root = xmlDocGetRootElement(xml()); find_wrappers(root, nmap); xmlResetLastError(); int substitutionCount = xmlXIncludeProcessTreeFlags(root, generateXIncludeNodes ? 0 : XML_PARSE_NOXINCNODE); prune_unchanged_wrappers(Node::xml(), nmap); for ( auto item : nmap ) { delete item.first; } if ( substitutionCount < 0 ) throw InternalError("Failed to process XInclude", xmlGetLastError()); return substitutionCount; }
void SaxParser::finish_chunk_parsing() { xmlResetLastError(); if(!context_) { context_ = xmlCreatePushParserCtxt( sax_handler_.get(), 0, // this, // user_data 0, // chunk 0, // size 0); // no filename for fetching external entities if(!context_) { throw internal_error("Could not create parser context\n" + format_xml_error()); } initialize_context(); } else xmlCtxtResetLastError(context_); int parseError = XML_ERR_OK; if(!exception_) //This is called just to terminate parsing. parseError = xmlParseChunk(context_, 0 /* chunk */, 0 /* size */, 1 /* terminate (1 or 0) */); Glib::ustring error_str = format_xml_parser_error(context_); if (error_str.empty() && parseError != XML_ERR_OK) error_str = "Error code from xmlParseChunk(): " + Glib::ustring::format(parseError); release_underlying(); // Free context_ check_for_exception(); if(!error_str.empty()) { throw parse_error(error_str); } }
// 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); } }
void SaxParser::parse_chunk_raw(const unsigned char* contents, size_type bytes_count) { KeepBlanks k(KeepBlanks::Default); xmlResetLastError(); if(!context_) { context_ = xmlCreatePushParserCtxt( sax_handler_.get(), 0, // user_data 0, // chunk 0, // size 0); // no filename for fetching external entities if(!context_) { throw internal_error("Could not create parser context\n" + format_xml_error()); } initialize_context(); } else xmlCtxtResetLastError(context_); int parseError = XML_ERR_OK; if(!exception_) parseError = xmlParseChunk(context_, (const char*)contents, bytes_count, 0 /* don't terminate */); check_for_exception(); Glib::ustring error_str = format_xml_parser_error(context_); if (error_str.empty() && parseError != XML_ERR_OK) error_str = "Error code from xmlParseChunk(): " + Glib::ustring::format(parseError); if(!error_str.empty()) { throw parse_error(error_str); } }
/* * call-seq: * dup * * Copy this Document. An optional depth may be passed in, but it defaults * to a deep copy. 0 is a shallow copy, 1 is a deep copy. */ static VALUE duplicate_document(int argc, VALUE *argv, VALUE self) { xmlDocPtr doc, dup; VALUE copy; VALUE level; VALUE error_list = rb_ary_new(); if(rb_scan_args(argc, argv, "01", &level) == 0) level = INT2NUM((long)1); Data_Get_Struct(self, xmlDoc, doc); xmlResetLastError(); xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher); dup = xmlCopyDoc(doc, (int)NUM2INT(level)); xmlSetStructuredErrorFunc(NULL, NULL); if(dup == NULL) return Qnil; dup->type = doc->type; copy = Nokogiri_wrap_xml_document(rb_obj_class(self), dup); rb_iv_set(copy, "@errors", error_list); return copy ; }
void requestInit() override { xmlResetLastError(); }
void HHVM_FUNCTION(libxml_clear_errors) { xmlResetLastError(); tl_libxml_request_data->m_errors.reset(); }
/* * call-seq: * evaluate(search_path, handler = nil) * * Evaluate the +search_path+ returning an XML::XPath object. */ static VALUE evaluate(int argc, VALUE *argv, VALUE self) { VALUE search_path, xpath_handler; VALUE thing = Qnil; xmlXPathContextPtr ctx; xmlXPathObjectPtr xpath; xmlChar *query; Data_Get_Struct(self, xmlXPathContext, ctx); if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1) xpath_handler = Qnil; query = (xmlChar *)StringValuePtr(search_path); if(Qnil != xpath_handler) { /* FIXME: not sure if this is the correct place to shove private data. */ ctx->userData = (void *)xpath_handler; xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler); } xmlResetLastError(); xmlSetStructuredErrorFunc(NULL, xpath_exception_handler); /* For some reason, xmlXPathEvalExpression will blow up with a generic error */ /* when there is a non existent function. */ xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler); xpath = xmlXPathEvalExpression(query, ctx); xmlSetStructuredErrorFunc(NULL, NULL); xmlSetGenericErrorFunc(NULL, NULL); if(xpath == NULL) { VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath")); VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError")); xmlErrorPtr error = xmlGetLastError(); rb_exc_raise(Nokogiri_wrap_xml_syntax_error(klass, error)); } assert(ctx->doc); assert(DOC_RUBY_OBJECT_TEST(ctx->doc)); switch(xpath->type) { case XPATH_STRING: thing = NOKOGIRI_STR_NEW2(xpath->stringval); break; case XPATH_NODESET: if(NULL == xpath->nodesetval) { thing = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), DOC_RUBY_OBJECT(ctx->doc)); } else { thing = Nokogiri_wrap_xml_node_set(xpath->nodesetval, DOC_RUBY_OBJECT(ctx->doc)); } break; case XPATH_NUMBER: thing = rb_float_new(xpath->floatval); break; case XPATH_BOOLEAN: thing = xpath->boolval == 1 ? Qtrue : Qfalse; break; default: thing = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), DOC_RUBY_OBJECT(ctx->doc)); } xmlXPathFreeNodeSetList(xpath); return thing; }
void SaxParser::parse_stream(std::istream& in) { if(context_) { throw parse_error("Attempt to start a second parse while a parse is in progress."); } KeepBlanks k(KeepBlanks::Default); xmlResetLastError(); context_ = xmlCreatePushParserCtxt( sax_handler_.get(), 0, // user_data 0, // chunk 0, // size 0); // no filename for fetching external entities if(!context_) { throw internal_error("Could not create parser context\n" + format_xml_error()); } initialize_context(); //TODO: Shouldn't we use a Glib::ustring here, and some alternative to std::getline()? int firstParseError = XML_ERR_OK; std::string line; while( ( ! exception_ ) && std::getline(in, line)) { // since getline does not get the line separator, we have to add it since the parser care // about layout in certain cases. line += '\n'; const int parseError = xmlParseChunk(context_, line.c_str(), line.size() /* This is a std::string, not a ustring, so this is the number of bytes. */, 0 /* don't terminate */); // Save the first error code if any, but read on. // More errors might be reported and then thrown by check_for_exception(). if (parseError != XML_ERR_OK && firstParseError == XML_ERR_OK) firstParseError = parseError; } if( ! exception_ ) { //This is called just to terminate parsing. const int parseError = xmlParseChunk(context_, 0 /* chunk */, 0 /* size */, 1 /* terminate (1 or 0) */); if (parseError != XML_ERR_OK && firstParseError == XML_ERR_OK) firstParseError = parseError; } Glib::ustring error_str = format_xml_parser_error(context_); if (error_str.empty() && firstParseError != XML_ERR_OK) error_str = "Error code from xmlParseChunk(): " + Glib::ustring::format(firstParseError); release_underlying(); // Free context_ check_for_exception(); if(!error_str.empty()) { throw parse_error(error_str); } }
/** * gxml_reset_last_error: * * Deprecated: 0.15 */ void gxml_reset_last_error () { xmlResetLastError (); }