自学教程：C++ xmlSetGenericErrorFunc函数代码示例

//---------------------------------------------------------------------------int Policy::import_schema_from_memory(const char* buffer, int len, const std::string& save_name){    if (!buffer || !len)    {        error = "The schema does not exist";        return -1;    }    Schema s(no_https);    xmlSetGenericErrorFunc(&s, &s.manage_generic_error);    xmlDocPtr doc = xmlParseMemory(buffer, len);    if (!doc)    {        // maybe put the errors from s.errors        error = "The schema given cannot be parsed";        xmlSetGenericErrorFunc(NULL, NULL);        return -1;    }    int ret = import_schema_from_doc(doc, save_name);    xmlFreeDoc(doc);    xmlSetGenericErrorFunc(NULL, NULL);    return ret;}

xmlDoc *XMLDocument::readDocument(const std::string & xmlCode, const char * encoding, bool validate, std::string * error){    xmlParserCtxt *ctxt = initContext(error, validate);    xmlDoc *doc = 0;    int options = XML_PARSE_NSCLEAN | XML_PARSE_NOBLANKS;    if (validate)    {        options |= XML_PARSE_DTDVALID;    }    if (!ctxt)    {        xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);        return 0;    }    doc = xmlCtxtReadDoc(ctxt, (const xmlChar *)xmlCode.c_str(), 0, encoding, options);    if (!doc || !ctxt->valid)    {        *error = errorBuffer;    }    xmlSetGenericErrorFunc(0, errorFunctionWithoutOutput);    xmlFreeParserCtxt(ctxt);    return doc;}

int get_filter_from_xml(const char *xml, struct acl_filter **filter){        xmlDoc *xmldoc = NULL;        int ret = 0;        if (xml == NULL || filter == NULL)                return 0;        xmlSetGenericErrorFunc(NULL, swallow_err_msg);        xmldoc = xmlParseMemory(xml, strlen(xml) + 1);        if (xmldoc == NULL)                goto err;        *filter = calloc(1, sizeof(**filter));        if (*filter == NULL)                goto err;        ret = parse_acl_filter(xmldoc->children, *filter);        if (ret == 0) {                free(*filter);                *filter = NULL;        } err:        xmlSetGenericErrorFunc(NULL, NULL);        xmlFreeDoc(xmldoc);        return ret;}

void Skeleton::LoadSkeletonDataFromXml(const char* xmlData, size_t xmlLength, std::string& xmlErrors){	xmlDoc* doc = NULL;	try	{		xmlSetGenericErrorFunc(&xmlErrors, &errorHandler);		doc = xmlParseMemory(xmlData, (int)xmlLength);		if (doc)		{			xmlNode* root = xmlDocGetRootElement(doc);			LoadSkeletonData(root);			xmlFreeDoc(doc);			doc = NULL;		}		xmlSetGenericErrorFunc(NULL, NULL);	}	catch (const ColladaException&)	{		if (doc)			xmlFreeDoc(doc);		xmlSetGenericErrorFunc(NULL, NULL);		throw;	}	if (! xmlErrors.empty())		throw ColladaException("XML parsing failed");}

ParseXML::ParseXML(void* session, startElementNsSAX2Func start)    : startElementNs(start)    , endElementNs(NULL)    , characters(NULL){    XmlError MyError;    MyError.Len = 0;    xmlSetGenericErrorFunc(&MyError, ErrorCallback);    xmlSAXHandler sax;    memset(&sax, 0, sizeof(sax));    sax.initialized = XML_SAX2_MAGIC;    sax.startElementNs = _start;    sax.endElementNs = _end;    sax.characters = _char;    mXmlContext = xmlCreatePushParserCtxt(&sax, this, NULL, 0, NULL);    if(mXmlContext == NULL)    {        xmlSetGenericErrorFunc(NULL, NULL);        throw std::runtime_error(MyError.Len != 0 ? MyError.Value : "XML Error");    }    curl_easy_setopt(session, CURLOPT_WRITEFUNCTION, ParseHandler);    curl_easy_setopt(session, CURLOPT_WRITEDATA, this);}

/* str_unref() returned string */static char *scrape_uri_from_lyricwiki_search_result(const char *buf, int64_t len){	xmlDocPtr doc;	gchar *uri = NULL;	/*	 * workaround buggy lyricwiki search output where it cuts the lyrics	 * halfway through the UTF-8 symbol resulting in invalid XML.	 */	GRegex *reg;	reg = g_regex_new("<(lyrics?)>.*<///1>", (G_REGEX_MULTILINE | G_REGEX_DOTALL | G_REGEX_UNGREEDY), 0, NULL);	gchar *newbuf = g_regex_replace_literal(reg, buf, len, 0, "", G_REGEX_MATCH_NEWLINE_ANY, NULL);	g_regex_unref(reg);	/*	 * temporarily set our error-handling functor to our suppression function,	 * but we have to set it back because other components of Audacious depend	 * on libxml and we don't want to step on their code paths.	 *	 * unfortunately, libxml is anti-social and provides us with no way to get	 * the previous error functor, so we just have to set it back to default after	 * parsing and hope for the best.	 */	xmlSetGenericErrorFunc(NULL, libxml_error_handler);	doc = xmlParseMemory(newbuf, strlen(newbuf));	xmlSetGenericErrorFunc(NULL, NULL);	if (doc != NULL)	{		xmlNodePtr root, cur;		root = xmlDocGetRootElement(doc);		for (cur = root->xmlChildrenNode; cur; cur = cur->next)		{			if (xmlStrEqual(cur->name, (xmlChar *) "url"))			{				xmlChar *lyric;				gchar *basename;				lyric = xmlNodeGetContent(cur);				basename = g_path_get_basename((gchar *) lyric);				uri = str_printf("http://lyrics.wikia.com/index.php?action=edit"				 "&title=%s", basename);				g_free(basename);				xmlFree(lyric);			}		}		xmlFreeDoc(doc);	}	g_free(newbuf);	return uri;}

static xmlDocPtr docLoaderFunc(const xmlChar* uri,                               xmlDictPtr,                               int options,                               void* ctxt,                               xsltLoadType type){    if (!globalProcessor)        return 0;    switch (type) {    case XSLT_LOAD_DOCUMENT: {        xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;        xmlChar* base = xmlNodeGetBase(context->document->doc, context->node);        URL url(URL(ParsedURLString, reinterpret_cast<const char*>(base)), reinterpret_cast<const char*>(uri));        xmlFree(base);        ResourceError error;        ResourceResponse response;        Vector<char> data;        bool requestAllowed = globalCachedResourceLoader->frame() && globalCachedResourceLoader->document()->securityOrigin()->canRequest(url);        if (requestAllowed) {            globalCachedResourceLoader->frame()->loader().loadResourceSynchronously(url, AllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, error, response, data);            if (error.isNull())                requestAllowed = globalCachedResourceLoader->document()->securityOrigin()->canRequest(response.url());            else                data.clear();        }        if (!requestAllowed) {            data.clear();            globalCachedResourceLoader->printAccessDeniedMessage(url);        }        PageConsole* console = 0;        Frame* frame = globalProcessor->xslStylesheet()->ownerDocument()->frame();        if (frame && frame->page())            console = &frame->page()->console();        xmlSetStructuredErrorFunc(console, XSLTProcessor::parseErrorFunc);        xmlSetGenericErrorFunc(console, XSLTProcessor::genericErrorFunc);        // We don't specify an encoding here. Neither Gecko nor WinIE respects        // the encoding specified in the HTTP headers.        xmlDocPtr doc = xmlReadMemory(data.data(), data.size(), (const char*)uri, 0, options);        xmlSetStructuredErrorFunc(0, 0);        xmlSetGenericErrorFunc(0, 0);        return doc;    }    case XSLT_LOAD_STYLESHEET:        return globalProcessor->xslStylesheet()->locateStylesheetSubResource(((xsltStylesheetPtr)ctxt)->doc, uri);    default:        break;    }    return 0;}

/* *  call-seq: *    transform(document, params = []) * *  Apply an XSLT stylesheet to an XML::Document. *  +params+ is an array of strings used as XSLT parameters. *  returns Nokogiri::XML::Document * *  Example: *  *    doc   = Nokogiri::XML(File.read(ARGV[0])) *    xslt  = Nokogiri::XSLT(File.read(ARGV[1])) *    puts xslt.transform(doc, ['key', 'value']) * */static VALUE transform(int argc, VALUE* argv, VALUE self){    VALUE xmldoc, paramobj, errstr, exception ;    xmlDocPtr xml ;    xmlDocPtr result ;    nokogiriXsltStylesheetTuple *wrapper;    const char** params ;    long param_len, j ;    int parse_error_occurred ;    rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);    if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0L) ; }    if (!rb_obj_is_kind_of(xmldoc, cNokogiriXmlDocument))      rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::Document");    /* handle hashes as arguments. */    if(T_HASH == TYPE(paramobj)) {      paramobj = rb_funcall(paramobj, rb_intern("to_a"), 0);      paramobj = rb_funcall(paramobj, rb_intern("flatten"), 0);    }    Check_Type(paramobj, T_ARRAY);    Data_Get_Struct(xmldoc, xmlDoc, xml);    Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);    param_len = RARRAY_LEN(paramobj);    params = calloc((size_t)param_len+1, sizeof(char*));    for (j = 0 ; j < param_len ; j++) {      VALUE entry = rb_ary_entry(paramobj, j);      const char * ptr = StringValuePtr(entry);      params[j] = ptr;    }    params[param_len] = 0 ;    errstr = rb_str_new(0, 0);    xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);    xmlSetGenericErrorFunc(NULL, (xmlGenericErrorFunc)&swallow_superfluous_xml_errors);    result = xsltApplyStylesheet(wrapper->ss, xml, params);    free(params);    xsltSetGenericErrorFunc(NULL, NULL);    xmlSetGenericErrorFunc(NULL, NULL);    parse_error_occurred = (Qfalse == rb_funcall(errstr, rb_intern("empty?"), 0));    if (parse_error_occurred) {      exception = rb_exc_new3(rb_eRuntimeError, errstr);      rb_exc_raise(exception);    }    return Nokogiri_wrap_xml_document((VALUE)0, result) ;}

bool XSLStyleSheet::parseString(const String& string, bool){    // Parse in a single chunk into an xmlDocPtr    const UChar BOM = 0xFEFF;    const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char*>(&BOM);    setLoaderForLibXMLCallbacks(docLoader());    if (!m_stylesheetDocTaken)        xmlFreeDoc(m_stylesheetDoc);    m_stylesheetDocTaken = false;#if ENABLE(INSPECTOR)    Console* console = 0;    if (Frame* frame = ownerDocument()->frame())        console = frame->domWindow()->console();    xmlSetStructuredErrorFunc(console, XSLTProcessor::parseErrorFunc);    xmlSetGenericErrorFunc(console, XSLTProcessor::genericErrorFunc);#endif    const char* buffer = reinterpret_cast<const char*>(string.characters());    int size = string.length() * sizeof(UChar);    xmlParserCtxtPtr ctxt = xmlCreateMemoryParserCtxt(buffer, size);    if (m_parentStyleSheet) {        // The XSL transform may leave the newly-transformed document        // with references to the symbol dictionaries of the style sheet        // and any of its children. XML document disposal can corrupt memory        // if a document uses more than one symbol dictionary, so we        // ensure that all child stylesheets use the same dictionaries as their        // parents.        xmlDictFree(ctxt->dict);        ctxt->dict = m_parentStyleSheet->m_stylesheetDoc->dict;        xmlDictReference(ctxt->dict);    }    m_stylesheetDoc = xmlCtxtReadMemory(ctxt, buffer, size,                                        href().utf8().data(),                                        BOMHighByte == 0xFF ? "UTF-16LE" : "UTF-16BE",                                        XML_PARSE_NOENT | XML_PARSE_DTDATTR | XML_PARSE_NOWARNING | XML_PARSE_NOCDATA);    xmlFreeParserCtxt(ctxt);    loadChildSheets();    xmlSetStructuredErrorFunc(0, 0);    xmlSetGenericErrorFunc(0, 0);    setLoaderForLibXMLCallbacks(0);    return m_stylesheetDoc;}

static xmlDocPtr docLoaderFunc(const xmlChar* uri,                               xmlDictPtr,                               int options,                               void* ctxt,                               xsltLoadType type){    if (!globalProcessor)        return 0;    switch (type) {    case XSLT_LOAD_DOCUMENT: {        xsltTransformContextPtr context = (xsltTransformContextPtr)ctxt;        xmlChar* base = xmlNodeGetBase(context->document->doc, context->node);        KURL url(KURL(ParsedURLString, reinterpret_cast<const char*>(base)), reinterpret_cast<const char*>(uri));        xmlFree(base);        ResourceLoaderOptions fetchOptions(ResourceFetcher::defaultResourceOptions());        FetchRequest request(ResourceRequest(url), FetchInitiatorTypeNames::xml, fetchOptions);        request.setOriginRestriction(FetchRequest::RestrictToSameOrigin);        ResourcePtr<Resource> resource = globalResourceFetcher->fetchSynchronously(request);        if (!resource || !globalProcessor)            return 0;        PageConsole* console = 0;        Frame* frame = globalProcessor->xslStylesheet()->ownerDocument()->frame();        if (frame && frame->page())            console = &frame->page()->console();        xmlSetStructuredErrorFunc(console, XSLTProcessor::parseErrorFunc);        xmlSetGenericErrorFunc(console, XSLTProcessor::genericErrorFunc);        // We don't specify an encoding here. Neither Gecko nor WinIE respects        // the encoding specified in the HTTP headers.        SharedBuffer* data = resource->resourceBuffer();        xmlDocPtr doc = data ? xmlReadMemory(data->data(), data->size(), (const char*)uri, 0, options) : 0;        xmlSetStructuredErrorFunc(0, 0);        xmlSetGenericErrorFunc(0, 0);        return doc;    }    case XSLT_LOAD_STYLESHEET:        return globalProcessor->xslStylesheet()->locateStylesheetSubResource(((xsltStylesheetPtr)ctxt)->doc, uri);    default:        break;    }    return 0;}

int init(void){  daemonize = TRUE;  every = EVERY_5SECS;  xmlSetGenericErrorFunc(NULL, UpwatchXmlGenericErrorFunc);  return(1);}

int lpc2xml_convert_string(lpc2xml_context* context, char **content) {	int ret = -1;	xmlBufferPtr buffer = xmlBufferCreate();	xmlSaveCtxtPtr save_ctx;	lpc2xml_context_clear_logs(context);	xmlSetGenericErrorFunc(context, lpc2xml_genericxml_error);	save_ctx = xmlSaveToBuffer(buffer, "UTF-8", XML_SAVE_FORMAT);	if(save_ctx != NULL) {		ret = internal_convert_lpc2xml(context);		if(ret == 0) {			ret = xmlSaveDoc(save_ctx, context->doc);			if(ret != 0) {				lpc2xml_log(context, LPC2XML_ERROR, "Can't save document");				lpc2xml_log(context, LPC2XML_ERROR, "%s", context->errorBuffer);			}		}		xmlSaveClose(save_ctx);	} else {		lpc2xml_log(context, LPC2XML_ERROR, "Can't initialize internal buffer");		lpc2xml_log(context, LPC2XML_ERROR, "%s", context->errorBuffer);	}	if(ret == 0) {#if LIBXML_VERSION >= 20800		*content = (char *)xmlBufferDetach(buffer);#else		*content = strdup((const char *)xmlBufferContent(buffer));#endif	}	xmlBufferFree(buffer);	return ret;}

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();}

int irislwz_Validate(IRISLWZ_HANDLE *handle, const char *xml, char **beautified)/*!/brief Do an XML validation against a text * * This function takes the given /p xml test an tries to validate it with the XML * library (xmlReadMemory). If the XML is valid, a /p beautified version, which can * be better read by humans, can be stored optionally. * * /param[in] handle pointer to an IRISLWZ_HANDLE object * /param[in] xml pointer to the text which should be validated * /param[out] beautified optional pointer to which a beautified version of the xml * is written. The Memory for this is allocated by the library, but must be freed by the * client using /p free. * * /returns If the XML is valid, the function returns 1, otherwise 0. * * /example/codeconst char *xml="<iris1:request xmlns:iris1=/"urn:ietf:params:xml:ns:iris1/">"		"<iris1:searchSet><iris1:lookupEntity registryType=/"dchk1/" "		"entityClass=/"domain-name/" entityName=/"denic.de/"/>"		"</iris1:searchSet></iris1:request>";char *beautified=NULL;if (irislwz_Validate(handle,xml,&beautified)) {	printf ("Original XML code:/n");	printf ("%s/n",xml);	printf ("Beautified version:/n");	printf ("%s/n",beautified);}if (beautified) free(beautified);/endcode * * /ingroup DCHK_API_IRISLWZ */{	xmlSetGenericErrorFunc(handle,irislwz_xmlGenericErrorFunc);    xmlDoc *doc = NULL;	//xmlNode *root_element = NULL;    int size=(int)strlen(xml);    //printf ("Query: >>%s<</n",xml);    //printf ("Size: %i Bytes/n",size);    doc = xmlReadMemory (xml, size,				 NULL,				 "UTF-8",				 XML_PARSE_NONET);	if (doc == NULL) {		irislwz_SetError(handle,74044,NULL);		return 0;	}	if (beautified) {		xmlChar *mem;		int size;		xmlKeepBlanksDefault(0);		xmlDocDumpFormatMemoryEnc(doc, &mem, &size, handle->localcharset,1);		*beautified=strdup((char*)mem);		xmlFree(mem);	}	xmlFreeDoc(doc);	return 1;}

// [[Rcpp::export]]void init_libxml2() {  // Check that header and libs are compatible  LIBXML_TEST_VERSION  xmlInitParser();  xmlSetStructuredErrorFunc(NULL, handleStructuredError);  xmlSetGenericErrorFunc(NULL, handleGenericError);}

int MOD_CLS_NAME::preload() {  DBG("initializing libxml2.../n");  xmlInitParser();  initGenericErrorDefaultFunc(&handler);  handler = (xmlGenericErrorFunc)xml_err_func;  xmlSetGenericErrorFunc(NULL, &xml_err_func);  return 0;}

voidraptor_www_libxml_init(raptor_www *www){    www->error_handlers.handlers[RAPTOR_LOG_LEVEL_NONE].user_data=www;    www->old_xmlGenericErrorContext=xmlGenericErrorContext;    xmlSetGenericErrorFunc(&www->error_handlers, raptor_libxml_generic_error);    www->ctxt=NULL;}

void initErrorHandler (){    xmlSecErrorsSetCallback(secErrorCallback);    xmlSetGenericErrorFunc(xml_error_str, xmlErrorCallback);#ifndef XMLSEC_NO_XSLT    xsltSetGenericErrorFunc(xslt_error_str, xmlErrorCallback);#endif}

static voidhwloc_libxml2_disable_stderrwarnings(void){  static int first = 1;  if (first) {    xmlSetGenericErrorFunc(NULL, hwloc__xml_verbose() ? xmlGenericError : hwloc_libxml2_error_callback);    first = 0;  }}

// Initialize libxml2 and check for potential ABI mismatches between// compiled version and the shared library actually used.void initXML(){    console.log(CON_LOG, CON_ALWAYS, "Initializing libxml2...");    xmlInitParser();    LIBXML_TEST_VERSION;    // Suppress libxml2 error messages    xmlSetGenericErrorFunc(NULL, xmlNullLogger);}

voidraptor_www_libxml_init(raptor_www *www){  initGenericErrorDefaultFunc(&www->old_handler);  /* This will destroy the generic error default context:   * there is no way to query and save it (xmlGenericErrorContext)   */  xmlSetGenericErrorFunc(www, raptor_www_libxml_http_error);  www->ctxt=NULL;}

void event_config_read (void){    int ret;    ice_config_t *config;    ice_config_t new_config, old_config;    /* reread config file */    INFO0("Re-reading XML");    config = config_grab_config(); /* Both to get the lock, and to be able                                     to find out the config filename */    xmlSetGenericErrorFunc (config->config_filename, log_parse_failure);    xmlSetStructuredErrorFunc ("conf/file", config_xml_parse_failure);    ret = config_parse_file(config->config_filename, &new_config);    if(ret < 0) {        ERROR0("Error parsing config, not replacing existing config");        switch(ret) {            case CONFIG_EINSANE:                ERROR0("Config filename null or blank");                break;            case CONFIG_ENOROOT:                ERROR1("Root element not found in %s", config->config_filename);                break;            case CONFIG_EBADROOT:                ERROR1("Not an icecast2 config file: %s",                        config->config_filename);                break;            default:                ERROR1("Parse error in reading %s", config->config_filename);                break;        }        config_release_config();    }    else {        restart_logging (&new_config);        config_set_config (&new_config, &old_config);        config_release_config();        connection_thread_shutdown();        redirector_clearall();        fserve_scan ((time_t)0);        config = config_get_config();        yp_recheck_config (config);        fserve_recheck_mime_types (config);        stats_global (config);        workers_adjust (config->workers_count);        connection_listen_sockets_close (config, 0);        redirector_setup (config);        update_relays (config);        config_release_config();        slave_restart();        config_clear (&old_config);    }}

int init(void){  if (!HAVE_OPT(OUTPUT)) {    LOG(LOG_ERR, "missing output option");    return 0;  }  daemonize = TRUE;  every = EVERY_MINUTE;  xmlSetGenericErrorFunc(NULL, UpwatchXmlGenericErrorFunc);  return(1);}

XMLParser::XMLParser()    : m_SchemaParserCtxt(0),      m_Schema(0),      m_SchemaValidCtxt(0),      m_DTD(0),      m_DTDValidCtxt(0),      m_Doc(0){    xmlPedanticParserDefault(1);    xmlSetGenericErrorFunc(this, errorOutputFunc);    xmlDoValidityCheckingDefaultValue = 0;}

XMLDocumentParserScope::XMLDocumentParserScope(Document* document, xmlGenericErrorFunc genericErrorFunc, xmlStructuredErrorFunc structuredErrorFunc, void* errorContext)    : m_oldDocument(currentDocument)    , m_oldGenericErrorFunc(xmlGenericError)    , m_oldStructuredErrorFunc(xmlStructuredError)    , m_oldErrorContext(xmlGenericErrorContext){    currentDocument = document;    if (genericErrorFunc)        xmlSetGenericErrorFunc(errorContext, genericErrorFunc);    if (structuredErrorFunc)        xmlSetStructuredErrorFunc(errorContext, structuredErrorFunc);}

//---------------------------------------------------------------------------int XsltPolicy::create_policy_from_mi(const std::string& report){    Xslt s(no_https);    xmlSetGenericErrorFunc(&s, &s.manage_generic_error);    xmlDocPtr doc = xmlParseMemory(report.c_str(), report.length());    xmlSetGenericErrorFunc(NULL, NULL);    if (!doc)    {        // maybe put the errors from s.errors        error = "The MediaInfo report given cannot be parsed";        return -1;    }    xmlNodePtr root = xmlDocGetRootElement(doc);    if (!root)    {        error = "No root node, leaving";        xmlFreeDoc(doc);        return 0;    }    for (xmlNodePtr child = root->children; child; child = child->next)    {        std::string def("media");        if (child->type == XML_TEXT_NODE || !child->name || def.compare((const char*)child->name))            continue;        if (find_media_track_node(child) < 0)        {            xmlFreeDoc(doc);            return -1;        }        break;    }    xmlFreeDoc(doc);    return 0;}

void wi_error_enter_thread(void) {	wi_error_t		*error;	error = _wi_error_init(_wi_error_alloc());	wi_mutable_dictionary_set_data_for_key(wi_thread_dictionary(), error, WI_STR(_WI_ERROR_THREAD_KEY));	wi_release(error);		wi_error_set_error(WI_ERROR_DOMAIN_NONE, WI_ERROR_NONE);	#ifdef WI_LIBXML2	xmlSetGenericErrorFunc(NULL, _wi_error_xml_error_handler);#endif}

voidraptor_libxml_finish(raptor_world* world){  if(world->libxml_flags & RAPTOR_WORLD_FLAG_LIBXML_STRUCTURED_ERROR_SAVE)    xmlSetStructuredErrorFunc(world->libxml_saved_structured_error_context,                              world->libxml_saved_structured_error_handler);  if(world->libxml_flags & RAPTOR_WORLD_FLAG_LIBXML_GENERIC_ERROR_SAVE)    xmlSetGenericErrorFunc(world->libxml_saved_generic_error_context,                           world->libxml_saved_generic_error_handler);  xmlCleanupParser();}