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

bool CSpmXml::LoadXML(const QString& strXML, bool bDTDValidation){	xmlParserCtxtPtr pXMLParser = xmlNewParserCtxt();	if (0 == pXMLParser)		return false;	int nOptions = XML_PARSE_NOBLANKS;	if (bDTDValidation)		nOptions |= XML_PARSE_DTDVALID;	m_pXMLDoc = xmlCtxtReadDoc(pXMLParser, (xmlChar*)strXML.toUtf8().data(), "", NULL, nOptions);	if (0 == m_pXMLDoc)	{		xmlFreeParserCtxt(pXMLParser);		return false;	}	// Проверка корректности структуры	if (bDTDValidation && (false == pXMLParser->valid))	{		xmlFreeParserCtxt(pXMLParser);		return false;	}	m_pCurNode = xmlDocGetRootElement(m_pXMLDoc);	if (0 == m_pCurNode)		return false;	SetModified(false);	xmlFreeParserCtxt(pXMLParser);	return true;}

	XDocument* XParser::ParseMemory(const char* content, bool keep_blank/*=false*/)	{		xmlParserCtxtPtr pxParseCtxt = NULL;		xmlKeepBlanksDefault(keep_blank?1:0);		xmlDoValidityCheckingDefaultValue =0;		pxParseCtxt = xmlCreateMemoryParserCtxt((const char*)content, strlen(content));		if(pxParseCtxt==NULL)		{			return NULL;		}		if(!ParseContext(pxParseCtxt))		{			xmlFreeParserCtxt(pxParseCtxt);			return NULL;		}		XDocument* pagXmlDoc = NULL;		pagXmlDoc = new XDocument(pxParseCtxt->myDoc);		xmlFreeParserCtxt(pxParseCtxt);		return pagXmlDoc;	}

void Vpz::validateFile(const std::string& filename){    xmlParserCtxtPtr ctxt;    xmlDocPtr doc;    ctxt = xmlNewParserCtxt();    if (ctxt == NULL) {        throw utils::SaxParserError(_("Failed to allocate parser context/n"));    }    doc = xmlCtxtReadFile(ctxt, filename.c_str(), NULL, XML_PARSE_DTDVALID);    if (not doc) {        std::string msg((fmt(_("Failed to parse '%1%': %2%")) % filename %                         (ctxt->lastError.message ? ctxt->lastError.message :                          "")).str());        xmlFreeParserCtxt(ctxt);        throw utils::SaxParserError(msg);    }    if (ctxt->valid == 0) {        std::string msg((fmt(_("Failed to validate '%1%': %2%")) % filename %                         (ctxt->lastError.message ? ctxt->lastError.message :                          "")).str());        xmlFreeDoc(doc);        xmlFreeParserCtxt(ctxt);        throw utils::SaxParserError(msg);    }    xmlFreeParserCtxt(ctxt);}

bool MainWindow::OpenXMLDocument(const QString &file_name) {  FreeXMLDocument();  xmlParserCtxtPtr parser = xmlNewParserCtxt();  if (0 == parser)    return false;  xml_doc_ptr_ = xmlCtxtReadFile(parser,                                 file_name.toLocal8Bit().data(),                                 NULL,                                 XML_PARSE_NOBLANKS);// | XML_PARSE_DTDVALID);  if (false == parser->valid) {    QMessageBox::critical(this, tr("Открытие XML документа"),                          tr("Структура файла %1 не соответствует "                          "DTD-диаграмме").arg(file_name),                          QMessageBox::Ok);    SetCurrentFileName("", false);    xmlFreeParserCtxt(parser);    FreeXMLDocument();    return false;  }  AddItem(xmlDocGetRootElement(xml_doc_ptr_));  xmlFreeParserCtxt(parser);  UpdateButtons();  return true;}

static dpl_status_t_multipart_parse_init(const dpl_ctx_t *ctx,                      const char *buf, int len,                      const char **uploadidp){    dpl_status_t          ret = DPL_SUCCESS;    xmlParserCtxtPtr      ctxt;    xmlDocPtr             doc;    xmlNode               *elem;    ctxt = xmlNewParserCtxt();    if (ctxt == NULL)        return DPL_FAILURE;    doc = xmlCtxtReadMemory(ctxt, buf, len, NULL, NULL, 0u);    if (doc == NULL) {        xmlFreeParserCtxt(ctxt);        return DPL_FAILURE;    }    elem = xmlDocGetRootElement(doc);    while (elem != NULL)    {        if (elem->type == XML_ELEMENT_NODE)        {            if (!strcmp((char *) elem->name, "InitiateMultipartUploadResult"))            {                elem = elem->children;                ret = DPL_FAILURE;                while (elem != NULL)                {                    if (elem->type == XML_ELEMENT_NODE)                    {                        if (!strcmp((char *) elem->name, "UploadId"))                        {                            ret = DPL_SUCCESS;                            *uploadidp = strdup((char *) elem->children->content);                            if (NULL == *uploadidp)                                ret = DPL_ENOMEM;                            break;                        }                    }                    elem = elem->next;                }                // Reaching here means that we already browsed                // the InitiateMultipartUploadResult xml subtree,                // whether we found UploadId or not.                break;            }        }        elem = elem->next;    }    xmlFreeDoc(doc);    xmlFreeParserCtxt(ctxt);    return ret;}

  /* 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 gbooleanxmms_xspf_browse (xmms_xform_t *xform, const gchar *url, xmms_error_t *error){	int ret;	char buf[4096];	xmlParserCtxtPtr ctx;	xmlDocPtr doc;	g_return_val_if_fail (xform, FALSE);	xmms_error_reset (error);	ctx = xmlCreatePushParserCtxt (NULL, NULL, buf, 0, NULL);	if (!ctx) {		xmms_error_set (error, XMMS_ERROR_OOM, "Could not allocate xml parser");		return FALSE;	}	while ((ret = xmms_xform_read (xform, buf, sizeof (buf), error)) > 0) {		if ((xmlParseChunk (ctx, buf, ret, 0)) != 0) {			break;		}	}	if (ret < 0) {		xmms_error_set (error, XMMS_ERROR_GENERIC,		                "failed to read data from previous xform");		xmlFreeParserCtxt (ctx);		return FALSE;	}	xmlParseChunk (ctx, buf, 0, 1);	if (ctx->lastError.message) {		xmms_error_set (error, XMMS_ERROR_INVAL, ctx->lastError.message);		xmlFreeParserCtxt (ctx);		return FALSE;	}	doc = ctx->myDoc;	if (!xmms_xspf_browse_add_entries (xform, doc, error)) {		xmlFreeParserCtxt (ctx);		return FALSE;	}	xmms_error_reset (error);	xmlFreeParserCtxt (ctx);	return TRUE;}

static gbooleanchatroom_manager_file_parse (EmpathyChatroomManager *manager,    const gchar *filename){  EmpathyChatroomManagerPriv *priv;  xmlParserCtxtPtr ctxt;  xmlDocPtr doc;  xmlNodePtr chatrooms;  xmlNodePtr node;  priv = GET_PRIV (manager);  DEBUG ("Attempting to parse file:'%s'...", filename);  ctxt = xmlNewParserCtxt ();  /* Parse and validate the file. */  doc = xmlCtxtReadFile (ctxt, filename, NULL, 0);  if (doc == NULL)    {      g_warning ("Failed to parse file:'%s'", filename);      xmlFreeParserCtxt (ctxt);      return FALSE;    }  if (!empathy_xml_validate (doc, CHATROOMS_DTD_FILENAME))    {      g_warning ("Failed to validate file:'%s'", filename);      xmlFreeDoc (doc);      xmlFreeParserCtxt (ctxt);      return FALSE;    }  /* The root node, chatrooms. */  chatrooms = xmlDocGetRootElement (doc);  for (node = chatrooms->children; node; node = node->next)    {      if (strcmp ((gchar *) node->name, "chatroom") == 0)        chatroom_manager_parse_chatroom (manager, node);    }  DEBUG ("Parsed %d chatrooms", g_list_length (priv->chatrooms));  xmlFreeDoc (doc);  xmlFreeParserCtxt (ctxt);  return TRUE;}

rss_file *rss_open_file(const char *filename){  xmlParserCtxtPtr ctxt;  xmlDocPtr doc;  rss_file *f;  xmlNode *root_element = NULL;  gchar *fetched_time;  ctxt = xmlNewParserCtxt();  ctxt->sax->getEntity = _get_entity;  doc = xmlSAXParseFile(ctxt->sax, filename, 0);  if (!doc) {    fprintf(stderr, "Error parsing RSS file %s./n", filename);    xmlFreeParserCtxt(ctxt);    return NULL;  }  root_element = xmlDocGetRootElement(doc);  if (!root_element)  {    xmlFreeDoc(doc);    xmlFreeParserCtxt(ctxt);    fprintf(stderr, "Error parsing RSS file %s./n", filename);    return NULL;  }  /* Establish the time the RSS file was 'fetched'. */  fetched_time = get_rfc822_time();  if (!fetched_time) {    xmlFreeDoc(doc);    xmlFreeParserCtxt(ctxt);    g_fprintf(stderr, "Error retrieving current time./n");    return NULL;  }  f = rss_parse(filename, root_element, fetched_time);  xmlFreeDoc(doc);  xmlFreeParserCtxt(ctxt);  g_free(fetched_time);  return f;}

bool XMLReader::isValid(const QString &_inFile){    LIBXML_TEST_VERSION    //reset the generic error handler    initGenericErrorDefaultFunc(NULL);    QString ErrorString;    //supply custom error handler    xmlSetStructuredErrorFunc(&ErrorString, XMLReader::xmlErrorHandler);    xmlParserCtxtPtr Context; /* the parser context */    xmlDocPtr Doc; /* the resulting document tree */    /* create a parser context */    Context = xmlNewParserCtxt();    if (Context == NULL)      throw exInvalidXML("Failed to allocate parser context");    QFile File(_inFile);    File.open(QIODevice::ReadOnly);    int FD = File.handle();    /* parse the file, activating the DTD validation option */    Doc = xmlCtxtReadFd(Context, FD, ".", NULL, XML_PARSE_DTDVALID);    /* check if parsing suceeded */    if (Doc == NULL)        throw exInvalidXML("Unable to read XML Buffer");    else      xmlFreeDoc(Doc);    /* free up the parser context */    xmlFreeParserCtxt(Context);    return true;}

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

/**  * Parses a descriptor that contains the last  part of a document.  */void CXMLEngineSAXPlugin::ParseLastChunkL(const TDesC8& /*aDescriptor*/)	{	if (!iParserContext)		{		User::Leave(EXmlParserError);		}	//parsing process	TInt result(KErrNone);	result = xmlParseChunk(iParserContext, NULL, 0, 1);	if ((result == XML_ERR_NO_MEMORY) || (iParserContext->lastError.level == XML_ERR_FATAL)	        || (result < 0))		{		CleanupAndLeaveL(GetErrorNum(result));					}						//releasing context to the parser    xmlParserCtxtPtr ctxt = reinterpret_cast<xmlParserCtxtPtr>(iParserContext);    if(ctxt->myDoc)                            {       xmlFreeDoc(ctxt->myDoc);        }    xmlFreeParserCtxt(ctxt);	iParserContext = NULL;			}

 ~libxml2_loader() {     if (ctx_)     {         xmlFreeParserCtxt(ctx_);     } }

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

/* call-seq: *    XML::Parser::Context.io(io) -> XML::Parser::Context * * Creates a new parser context based on the specified io object. * * Parameters: * *  io - A ruby IO object.*/static VALUE rxml_parser_context_io(VALUE klass, VALUE io){  xmlParserCtxtPtr ctxt;  xmlParserInputBufferPtr input;  xmlParserInputPtr stream;  input = xmlParserInputBufferCreateIO((xmlInputReadCallback) rxml_read_callback, NULL,                                       (void*)io, XML_CHAR_ENCODING_NONE);      ctxt = xmlNewParserCtxt();  if (!ctxt)  {    xmlFreeParserInputBuffer(input);    rxml_raise(&xmlLastError);  }  stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);  if (!stream)  {    xmlFreeParserInputBuffer(input);    xmlFreeParserCtxt(ctxt);    rxml_raise(&xmlLastError);  }  inputPush(ctxt, stream);  return rxml_parser_context_wrap(ctxt);}

void CXMLEngineSAXPlugin::CleanupAndLeaveL(TInt aError)	{	// reseting OOM flag	if((aError == KErrNoMemory) && xmlOOMFlag())	    {	    xmlResetOOM();	    }	//releasing context to the parser	if(iParserContext)	    {	            xmlParserCtxtPtr ctxt = reinterpret_cast<xmlParserCtxtPtr>(iParserContext);        if(ctxt->myDoc)                                 {            xmlFreeDoc(ctxt->myDoc);             }        xmlFreeParserCtxt(ctxt);			    }    iParserContext = NULL;		if (aError)		{		User::Leave(aError);					}	else		{		User::Leave(EXmlParserError);		}	}

/** * e_soap_message_parse_response: * @msg: the #ESoapMessage. * * Parses the response returned by the server. * * Returns: a #ESoapResponse representing the response from * the server, or %NULL if there was an error. * * Since: 2.92 */ESoapResponse *e_soap_message_parse_response (ESoapMessage *msg){	ESoapMessagePrivate *priv;	xmlDocPtr xmldoc;	g_return_val_if_fail (E_IS_SOAP_MESSAGE (msg), NULL);	priv = E_SOAP_MESSAGE_GET_PRIVATE (msg);	if (!priv->ctxt)		return NULL;	xmlParseChunk (priv->ctxt, 0, 0, 1);	xmldoc = priv->ctxt->myDoc;	xmlFreeParserCtxt (priv->ctxt);	priv->ctxt = NULL;	if (!xmldoc)		return NULL;	return e_soap_response_new_from_xmldoc (xmldoc);}

static gbooleanlj_entry_load_from_xml(LJEntry *entry, const char *data, int len, GError **err) {	xmlNodePtr cur;	xmlDocPtr  doc = NULL;	xmlParserCtxtPtr ctxt;	ctxt = xmlCreatePushParserCtxt(NULL, NULL,				data, 4,				NULL /* XXX why does this want a filename? */);	/* suppress error messages */	ctxt->sax->warning = NULL;	ctxt->sax->error   = NULL;	xmlParseChunk(ctxt, data+4, len-4, 0);	xmlParseChunk(ctxt, data, 0, 1);	if (!ctxt->errNo)		doc = ctxt->myDoc;	xmlFreeParserCtxt(ctxt);	if (!doc) {		/* XXX better error message. */		g_set_error(err, 0, 0, "Error parsing XML");		return FALSE;	}	cur = xmlDocGetRootElement(doc);	lj_entry_load_from_xml_node(entry, doc, cur);	xmlFreeDoc(doc);	return TRUE;}

/** * Finalise XML parsing. */int xml_complete(modsec_rec *msr, char **error_msg) {    if (error_msg == NULL) return -1;    *error_msg = NULL;    /* Only if we have a context, meaning we've done some work. */    if (msr->xml->parsing_ctx != NULL) {        /* This is how we signalise the end of parsing to libxml. */        xmlParseChunk(msr->xml->parsing_ctx, NULL, 0, 1);        /* Preserve the results for our reference. */        msr->xml->well_formed = msr->xml->parsing_ctx->wellFormed;        msr->xml->doc = msr->xml->parsing_ctx->myDoc;        /* Clean up everything else. */        xmlFreeParserCtxt(msr->xml->parsing_ctx);        msr->xml->parsing_ctx = NULL;        msr_log(msr, 4, "XML: Parsing complete (well_formed %u).", msr->xml->well_formed);        if (msr->xml->well_formed != 1) {            *error_msg = ngx_pstrndup(msr->mp, "XML: Failed parsing document.");            return -1;        }    }    return 1;}

static voidfinalize (GObject *object){	ESoapMessagePrivate *priv = E_SOAP_MESSAGE_GET_PRIVATE (object);	if (priv->ctxt) {		if (priv->ctxt->myDoc)			xmlFreeDoc (priv->ctxt->myDoc);		xmlFreeParserCtxt (priv->ctxt);	}	if (priv->doc)		xmlFreeDoc (priv->doc);	if (priv->action)		g_free (priv->action);	if (priv->env_uri)		xmlFree (priv->env_uri);	if (priv->env_prefix)		xmlFree (priv->env_prefix);	g_free (priv->steal_node);	g_free (priv->steal_dir);	if (priv->steal_fd != -1)		close (priv->steal_fd);	G_OBJECT_CLASS (e_soap_message_parent_class)->finalize (object);}

int main(void){	FILE *f;	int ret;	char chars[10];	xmlParserCtxtPtr ctxt;	xdebug_str message = {0, 0, NULL};	xdebug_xml_reader_priv data;	data.level   = 0;	data.xml     = NULL;	data.current = NULL;	f = fopen("test.xml", "r");		ctxt = xmlCreatePushParserCtxt(sax_handler_ptr, NULL, NULL, 0, "test");	ctxt->_private = &data;	while ((ret = fread(chars, 1, 3, f)) > 0) {		xmlParseChunk(ctxt, chars, ret, 0);	}	xmlParseChunk(ctxt, chars, 0, 1);	xdebug_xml_return_node(data.xml, &message);	xdebug_xml_node_dtor(data.xml);	printf("%s/n", message.d);	xdebug_str_dtor(message);		xmlFreeParserCtxt(ctxt);	fclose(f);	xmlCleanupParser();	xmlMemoryDump();	return 0;}

static void ocr_callback(ocr_t *ocr, char *buf, int size){  if ( buf != NULL ) {    dprintf("READ '%s'/n", buf);    /* Create XML parser context if a new page is coming */    if ( ocr->xml == NULL )      ocr->xml = xmlCreatePushParserCtxt(&handlers, &(ocr->ctx), buf, size, "ocr-output");    else      xmlParseChunk(ocr->xml, buf, size, 0);    if ( (ocr->xml != NULL) && (ocr->ctx.state == OCR_STATE_END) ) {      /* End document parsing */      xmlParseChunk(ocr->xml, buf, 0, 1);      /* Free XML SAX parser */      xmlFreeParserCtxt(ocr->xml);      ocr->xml = NULL;      ocr->ctx.state = OCR_STATE_IDLE;    }  }  else {    ocr_terminate(ocr);  }}

static voideupnp_service_parser_free(Eupnp_Service_Parser *p){   if (!p) return;   if (p->ctx) xmlFreeParserCtxt(p->ctx);   free(p);}

// 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;}

xmlDocPtr _waitForAnswer(int sockfd) {	xmlParserCtxtPtr requestParserCtxt;	xmlDocPtr parsedDoc = NULL;    int resRead = 0;    int bytesRead = 0;    int readTries = 0;    int chunkParseResult = 0;	    char buffer[XMLBUS_CHUNK_READLENGTH + 1];    resRead = recv(sockfd, buffer, XMLBUS_CHUNK_INITIAL_READLENGTH, 0);    if (resRead > 0) {        buffer[resRead] = '/0';        requestParserCtxt = xmlCreatePushParserCtxt(NULL, NULL, buffer, resRead, NULL);        bytesRead += resRead;    } else {        printf("Read failed socket readerror:%d -> closing clientsocket", resRead);        return NULL;    }    xmlCtxtUseOptions(requestParserCtxt,XML_PARSE_NOWARNING); 	    while(1) {        resRead = recv(sockfd, buffer, XMLBUS_CHUNK_READLENGTH, 0);        buffer[resRead] = '/0';        if (resRead > 0) {            chunkParseResult = xmlParseChunk(requestParserCtxt,buffer,resRead,0);            if (chunkParseResult != 0) {                xmlErrorPtr xmlErr = xmlGetLastError();                printf("request parsing found error %d: %s", chunkParseResult, xmlErr->message);                //@TODO recover or bail out            }            if (requestParserCtxt->instate == XML_PARSER_EPILOG) {                break;            }            bytesRead += resRead;            continue;                             // don't need to parse it another time... it is done already        }                                         // end of reading (no data received)        else {            // Closed connection or error (in this case there is no buffer content, is it ?)            if (readTries < 5) {                readTries++;                continue;            }            else {                // end of parsing (check if the xml is valid)                if (bytesRead > 0) {                    // end of reading, try to parse the message so far                    break;                }                //log4c_category_error(loggerCategory, "thread %d read: data read failed, bailing out", threadId);                //close(request->clientSocket);                return NULL;            }        }                                         // end resRead > 0 .. else    }                                             // end while(1)    chunkParseResult = xmlParseChunk(requestParserCtxt, NULL, 0, 1);	parsedDoc = requestParserCtxt->myDoc;    xmlFreeParserCtxt(requestParserCtxt);	return parsedDoc;	}