XMLParser::XMLParser(ReadStream &stream, bool makeLower) : _rootNode(0) { xmlDocPtr xml = 0; try { const int options = XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS | XML_PARSE_NONET | XML_PARSE_NSCLEAN | XML_PARSE_NOCDATA; xml = xmlReadIO(readStream, closeStream, static_cast<void *>(&stream), "stream.xml", 0, options); if (!xml) throw Exception("XML document failed to parse"); xmlNodePtr root = xmlDocGetRootElement(xml); if (!root) throw Exception("XML document has no root node"); _rootNode = new XMLNode(*root, makeLower); } catch (...) { delete _rootNode; xmlFreeDoc(xml); throw; } xmlFreeDoc(xml); }
Bool compAddMetadataFromIO (CompMetadata *metadata, xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, void *ioctx) { xmlDoc **d, *doc; doc = xmlReadIO (ioread, ioclose, ioctx, NULL, NULL, 0); if (!doc) { compLogMessage ("core", CompLogLevelWarn, "Unable to parse XML metadata"); return FALSE; } d = realloc (metadata->doc, (metadata->nDoc + 1) * sizeof (xmlDoc *)); if (!d) { xmlFreeDoc (doc); return FALSE; } d[metadata->nDoc++] = doc; metadata->doc = d; return TRUE; }
/* * 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); xmlInitParser(); xmlDocPtr doc = xmlReadIO( (xmlInputReadCallback)io_read_callback, (xmlInputCloseCallback)io_close_callback, (void *)io, c_url, c_enc, NUM2INT(options) ); if(doc == NULL) { xmlFreeDoc(doc); rb_raise(rb_eRuntimeError, "Couldn't create a document"); return Qnil; } return Nokogiri_wrap_xml_document(klass, doc); }
XMLParser::XMLParser(Common::ReadStream &stream, bool makeLower, const Common::UString &fileName) { initXML(); Common::UString parseError; xmlSetGenericErrorFunc(static_cast<void *>(&parseError), errorFuncUString); const int options = XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS | XML_PARSE_NONET | XML_PARSE_NSCLEAN | XML_PARSE_NOCDATA; xmlDocPtr xml = xmlReadIO(readStream, closeStream, static_cast<void *>(&stream), fileName.c_str(), 0, options); if (!xml) { Common::Exception e; if (!parseError.empty()) e.add("%s", parseError.c_str()); e.add("XML document failed to parse"); throw e; } BOOST_SCOPE_EXIT( (&xml) ) { xmlFreeDoc(xml); } BOOST_SCOPE_EXIT_END xmlNodePtr root = xmlDocGetRootElement(xml); if (!root) throw Common::Exception("XML document has no root node"); _rootNode.reset(new XMLNode(*root, makeLower)); deinitXML(); }
xmlDoc *bz2_fd_read_doc(int fd) { struct bz2_file *bzfile = bz2_fd_open(fd); if (bzfile == NULL) { return NULL; } return xmlReadIO((xmlInputReadCallback) bz2_file_read, bz2_file_close, bzfile, "url", NULL, XML_PARSE_PEDANTIC); }
xmlDoc *bz2_mem_read_doc(const char *buffer, size_t size) { struct bz2_mem *bzmem = bz2_mem_open(buffer, size); if (bzmem == NULL) { return NULL; } return xmlReadIO((xmlInputReadCallback) bz2_mem_read, bz2_mem_close, bzmem, "url", NULL, XML_PARSE_PEDANTIC); }
herror_t soap_env_new_from_stream(http_input_stream_t * in, SoapEnv ** out, int gbk) { xmlDocPtr doc; if (gbk) doc = xmlReadIO(_soap_env_xml_io_read_gbk, _soap_env_xml_io_close, in, "", NULL, 0); else doc = xmlReadIO(_soap_env_xml_io_read, _soap_env_xml_io_close, in, "", NULL, 0); if (in->err != H_OK) return in->err; if (doc == NULL) return herror_new("soap_env_new_from_stream", XML_ERROR_PARSE, "Trying to parse not valid xml"); return soap_env_new_from_doc(doc, out); }
static gboolean xspf_playlist_load (const gchar * filename, VFSFile * file, gchar * * title, Index * filenames, Index * tuples) { xmlDoc * doc = xmlReadIO (read_cb, close_cb, file, filename, NULL, XML_PARSE_RECOVER); if (! doc) return FALSE; * title = NULL; xmlNode *nptr, *nptr2; // find trackList for (nptr = doc->children; nptr != NULL; nptr = nptr->next) { if (nptr->type == XML_ELEMENT_NODE && !xmlStrcmp(nptr->name, (xmlChar *)"playlist")) { gchar * base; base = (gchar *)xmlNodeGetBase(doc, nptr); for (nptr2 = nptr->children; nptr2; nptr2 = nptr2->next) { if (nptr2->type != XML_ELEMENT_NODE) continue; if (! xmlStrcmp (nptr2->name, (xmlChar *) "title")) { xmlChar * xml_title = xmlNodeGetContent (nptr2); if (xml_title && xml_title[0]) { str_unref (* title); * title = str_get ((gchar *) xml_title); } xmlFree (xml_title); } else if (! xmlStrcmp (nptr2->name, (xmlChar *) "trackList")) xspf_find_track (nptr2, filename, base, filenames, tuples); } xmlFree (base); } } xmlFreeDoc(doc); return TRUE; }
Core::BaseObject *Importer::get(std::streambuf* buf) { if ( _typemap == NULL ) return NULL; if ( buf == NULL ) return NULL; _result = NULL; xmlDocPtr doc; doc = xmlReadIO(streamBufReadCallback, streamBufCloseCallback, buf, NULL, NULL, 0); if ( doc == NULL ) return NULL; xmlNodePtr cur = xmlDocGetRootElement(doc); if ( cur == NULL ) { xmlFreeDoc(doc); return NULL; } _any.mapper = _typemap; bool saveStrictNsCheck = NodeHandler::strictNsCheck; if ( !_headerNode.empty() ) { // Check the root tag matching "seiscomp" if ( xmlStrcmp(cur->name, (const xmlChar*)_headerNode.c_str()) ) { SEISCOMP_WARNING("Invalid root tag: %s, expected: %s", cur->name, _headerNode.c_str()); xmlFreeDoc(doc); return NULL; } NodeHandler::strictNsCheck = _strictNamespaceCheck; _hasErrors = traverse(&_any, cur, cur->children, NULL) == false; } else { NodeHandler::strictNsCheck = _strictNamespaceCheck; _hasErrors = traverse(&_any, NULL, cur, NULL) == false; } NodeHandler::strictNsCheck = saveStrictNsCheck; xmlFreeDoc(doc); return _result; }
/* * 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; }
xmlDocPtr InputBuffer::xmlReadDocument(const char * url, const char * encoding, int options) { return xmlReadIO(_buf->readcallback, _buf->closecallback, _buf->context, url, encoding, options); }
std::shared_ptr<Document> InputBuffer::xmlReadDocument(const char * url, const char * encoding, int options) { xmlDocPtr raw = xmlReadIO(_buf->readcallback, _buf->closecallback, _buf->context, url, encoding, options); return Wrapped<Document>(raw); }
static InfSession* infd_note_plugin_text_session_read(InfdStorage* storage, InfIo* io, InfCommunicationManager* manager, const gchar* path, gpointer user_data, GError** error) { InfUserTable* user_table; InfTextBuffer* buffer; InfTextSession* session; FILE* stream; xmlDocPtr doc; xmlErrorPtr xmlerror; xmlNodePtr root; xmlNodePtr child; gboolean result; g_assert(INFD_IS_FILESYSTEM_STORAGE(storage)); user_table = inf_user_table_new(); buffer = INF_TEXT_BUFFER(inf_text_default_buffer_new("UTF-8")); /* TODO: Use a SAX parser for better performance */ stream = infd_filesystem_storage_open( INFD_FILESYSTEM_STORAGE(storage), "InfText", path, "r", error ); if(stream == NULL) return FALSE; doc = xmlReadIO( infd_note_plugin_text_session_read_read_func, infd_note_plugin_text_sesison_read_close_func, stream, path, /* TODO: Get some "infinote-filesystem-storage://" URL? */ "UTF-8", XML_PARSE_NOWARNING | XML_PARSE_NOERROR ); if(doc == NULL) { xmlerror = xmlGetLastError(); g_set_error( error, g_quark_from_static_string("LIBXML2_PARSER_ERROR"), xmlerror->code, "Error parsing XML in file '%s': [%d]: %s", path, xmlerror->line, xmlerror->message ); result = FALSE; } else { root = xmlDocGetRootElement(doc); if(strcmp((const char*)root->name, "inf-text-session") != 0) { g_set_error( error, g_quark_from_static_string("INF_NOTE_PLUGIN_TEXT_ERROR"), INFD_NOTE_PLUGIN_TEXT_ERROR_NOT_A_TEXT_SESSION, "Error processing file '%s': %s", path, "The document is not a text session" ); result = FALSE; } else { for(child = root->children; child != NULL; child = child->next) { if(child->type != XML_ELEMENT_NODE) continue; if(strcmp((const char*)child->name, "user") == 0) { if(!infd_note_plugin_text_read_user(user_table, child, error)) { g_prefix_error(error, "Error processing file '%s': ", path); result = FALSE; break; } } else if(strcmp((const char*)child->name, "buffer") == 0) { if(!infd_note_plugin_text_read_buffer(buffer, user_table, child, error)) { g_prefix_error(error, "Error processing file '%s': ", path); result = FALSE; break; } } else { infd_note_plugin_text_session_unexpected_node(child, error); g_prefix_error(error, "Error processing file '%s': ", path); result = FALSE; break; } } if(child == NULL) result = TRUE; } xmlFreeDoc(doc); } if(result == FALSE) return NULL; session = inf_text_session_new_with_user_table( manager, buffer, io, user_table, INF_SESSION_RUNNING, NULL, NULL ); return INF_SESSION(session); }
/** * infd_chat_filesystem_format_read: * @storage: A #InfdFilesystemStorage. * @path: Storage path to retrieve the session from. * @buffer: An empty #InfTextBuffer to use as the new session's buffer. * @error: Location to store error information, if any, or %NULL. * * Reads a chat session from @path in @storage. The file is expected to have * been saved with infd_chat_filesystem_format_write() before. The @buffer * parameter should be an empty #InfChatBuffer, and the document will be * written into this buffer. If the function succeeds, the buffer can be used * to create an #InfChatSession with inf_chat_session_new(). If the function * fails, %FALSE is returned and @error is set. * * Returns: %TRUE on success or %FALSE on error. */ gboolean infd_chat_filesystem_format_read(InfdFilesystemStorage* storage, const gchar* path, InfChatBuffer* buffer, GError** error) { FILE* stream; gchar* full_path; gchar* uri; xmlDocPtr doc; xmlErrorPtr xmlerror; xmlNodePtr root; xmlNodePtr child; gboolean result; g_return_val_if_fail(INFD_IS_FILESYSTEM_STORAGE(storage), FALSE); g_return_val_if_fail(path != NULL, FALSE); g_return_val_if_fail(INF_IS_CHAT_BUFFER(buffer), FALSE); g_return_val_if_fail(error == NULL || *error == NULL, FALSE); /* TODO: Use a SAX parser for better performance */ full_path = NULL; stream = infd_filesystem_storage_open( INFD_FILESYSTEM_STORAGE(storage), "InfChat", path, "r", &full_path, error ); if(stream == NULL) { g_free(full_path); return FALSE; } uri = g_filename_to_uri(full_path, NULL, error); g_free(full_path); if(uri == NULL) return FALSE; doc = xmlReadIO( infd_chat_filesystem_format_read_read_func, infd_chat_filesystem_format_read_close_func, stream, uri, "UTF-8", XML_PARSE_NOWARNING | XML_PARSE_NOERROR ); g_free(uri); if(doc == NULL) { xmlerror = xmlGetLastError(); g_set_error( error, g_quark_from_static_string("LIBXML2_PARSER_ERROR"), xmlerror->code, _("Error parsing XML in file \"%s\": [%d]: %s"), path, xmlerror->line, xmlerror->message ); result = FALSE; } else { root = xmlDocGetRootElement(doc); if(strcmp((const char*)root->name, "inf-chat-session") != 0) { g_set_error( error, infd_chat_filesystem_format_error_quark(), INFD_CHAT_FILESYSTEM_FORMAT_ERROR_NOT_A_CHAT_SESSION, _("Error processing file \"%s\": %s"), path, _("The document is not a chat session") ); result = FALSE; } else { result = TRUE; } xmlFreeDoc(doc); } if(result == FALSE) return FALSE; return TRUE; }