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

//// libxml convenience function//static void SkipToEndElement(xmlTextReaderPtr reader){	while (xmlTextReaderRead(reader) == 1)	{		if (xmlTextReaderNodeType(reader) == 15)			return;	}}

bool XmlReader::Read() {  end_element = false;  bool r(xmlTextReaderRead(libxml_stuff->reader) == 1);  while (r) {    int const node_type = xmlTextReaderNodeType(libxml_stuff->reader);    end_element = (node_type == XML_READER_TYPE_END_ELEMENT);    if ((node_type == XML_READER_TYPE_END_ELEMENT)      || (node_type == XML_READER_TYPE_ELEMENT)      || (node_type == XML_READER_TYPE_TEXT))      break;    r = (xmlTextReaderRead(libxml_stuff->reader) == 1);  }  return r;}

libvisio::VSDXRelationships::VSDXRelationships(librevenge::RVNGInputStream *input)  : m_relsByType(), m_relsById(){  if (input)  {    const std::shared_ptr<xmlTextReader> reader(      xmlReaderForStream(input, nullptr, nullptr, XML_PARSE_NOBLANKS|XML_PARSE_NOENT|XML_PARSE_NONET|XML_PARSE_RECOVER),      xmlFreeTextReader);    if (reader)    {      bool inRelationships = false;      int ret = xmlTextReaderRead(reader.get());      while (ret == 1)      {        const xmlChar *name = xmlTextReaderConstName(reader.get());        if (name)        {          if (xmlStrEqual(name, BAD_CAST("Relationships")))          {            if (xmlTextReaderNodeType(reader.get()) == 1)            {              // VSD_DEBUG_MSG(("Relationships ON/n"));              inRelationships = true;            }            else if (xmlTextReaderNodeType(reader.get()) == 15)            {              // VSD_DEBUG_MSG(("Relationships OFF/n"));              inRelationships = false;            }          }          else if (xmlStrEqual(name, BAD_CAST("Relationship")))          {            if (inRelationships)            {              VSDXRelationship relationship(reader.get());              m_relsByType[relationship.getType()] = relationship;              m_relsById[relationship.getId()] = relationship;            }          }        }        ret = xmlTextReaderRead(reader.get());      }    }  }}

char *xccdf_detect_version_priv(xmlTextReader *reader){	while (xmlTextReaderRead(reader) == 1 && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT);	const struct xccdf_version_info *ver_info = xccdf_detect_version_parser(reader);	if (ver_info == NULL) {		return NULL;	}	return oscap_strdup(xccdf_version_info_get_version(ver_info));}

static int _exml_read(EXML *xml, xmlTextReaderPtr reader){	int empty;	xmlChar *name, *value;	if (!reader)		return -1;	exml_clear( xml );	while( xmlTextReaderRead( reader ) == 1 ) {		name = xmlTextReaderName(reader);		value = xmlTextReaderValue(reader);		empty = xmlTextReaderIsEmptyElement(reader);		switch( xmlTextReaderNodeType(reader) ) {			case XML_READER_TYPE_ELEMENT:				exml_start(xml);				exml_tag_set(xml, (char *) name);						if (xmlTextReaderHasAttributes(reader)) {					xmlTextReaderMoveToFirstAttribute(reader);					do {						xmlChar *attr_name, *attr_value;						attr_name = xmlTextReaderName(reader);						attr_value = xmlTextReaderValue(reader);						exml_attribute_set(xml, (char *) attr_name, (char *) attr_value);						xmlFree(attr_name);						xmlFree(attr_value);					} while( xmlTextReaderMoveToNextAttribute(reader) == 1 );				}				if (!empty)					break;			case XML_READER_TYPE_END_ELEMENT:				exml_end(xml);				break;			case XML_READER_TYPE_WHITESPACE:				break;			case XML_READER_TYPE_TEXT:				exml_value_set(xml, (char *) value);				break;		}		xmlFree(name);		xmlFree(value);	}	xmlTextReaderClose(reader);	xmlFreeTextReader(reader);	exml_goto_top( xml );	return TRUE;}

static xmlChar *xmlTextReaderReadEntireNodeValue(xmlTextReaderPtr reader) {  xmlChar *buffer = calloc(1, sizeof(xmlChar));  const xmlChar *snippet;  int status;  if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE) {    return xmlTextReaderValue(reader);  }  else if (xmlTextReaderIsEmptyElement(reader) == 0) {    status = xmlTextReaderRead(reader);    while (status && (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT || xmlTextReaderNodeType(reader) == XML_READER_TYPE_CDATA || xmlTextReaderNodeType(reader) == XML_READER_TYPE_ENTITY_REFERENCE)) {      snippet = xmlTextReaderConstValue(reader);      buffer = realloc(buffer, (xmlStrlen(buffer) + xmlStrlen(snippet) + 1) * sizeof(xmlChar));      xmlStrcat(buffer, snippet);      status = xmlTextReaderRead(reader);    }  }  return buffer;}

const char *oscap_element_string_get(xmlTextReaderPtr reader){	if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT ||			xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE)		xmlTextReaderRead(reader);	if (xmlTextReaderHasValue(reader))		return (const char *)xmlTextReaderConstValue(reader);	return NULL;}

 bool XMLConversion::GetContentInt(int& value) {   xmlTextReaderRead(_reader);   const xmlChar* pvalue = xmlTextReaderConstValue(_reader);   if(!pvalue)     return false;   value = atoi((const char*)pvalue);   return true; }

/* @method Boolean XmlReader.read() */METHOD XmlReader_read(Ctx *ctx, knh_sfp_t *sfp){    xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);     if(reader == NULL) {        KNH_THROWs(ctx, "XmlReader.read(): xmlReader is not readable");    }    int ret = xmlTextReaderRead(reader);    KNH_RETURN_Int(ctx,sfp,ret);}

//## @Native boolean XmlReader.read();static KMETHOD XmlReader_read(KonohaContext *kctx, KonohaStack *sfp){	xmlTextReaderPtr reader = getRawXmlReader(sfp[0]);	int ret = 0;	if(reader != NULL) {		ret = xmlTextReaderRead(reader);	}	KReturnUnboxValue(ret);}

/** * streamFile: * @filename: the file name to parse * * Parse and print information about an XML file. * * Returns the resulting doc with just the elements preserved. */static xmlDocPtrextractFile(const char *filename, const xmlChar *pattern) {    xmlDocPtr doc;    xmlTextReaderPtr reader;    int ret;    /*     * build an xmlReader for that file     */    reader = xmlReaderForFile(filename, NULL, 0);    if (reader != NULL) {        /*	 * add the pattern to preserve	 */        if (xmlTextReaderPreservePattern(reader, pattern, NULL) < 0) {            fprintf(stderr, "%s : failed add preserve pattern %s/n",	            filename, (const char *) pattern);	}	/*	 * Parse and traverse the tree, collecting the nodes in the process	 */        ret = xmlTextReaderRead(reader);        while (ret == 1) {            ret = xmlTextReaderRead(reader);        }        if (ret != 0) {            fprintf(stderr, "%s : failed to parse/n", filename);	    xmlFreeTextReader(reader);	    return(NULL);        }	/*	 * get the resulting nodes	 */	doc = xmlTextReaderCurrentDoc(reader);	/*	 * Free up the reader	 */        xmlFreeTextReader(reader);    } else {        fprintf(stderr, "Unable to open %s/n", filename);	return(NULL);    }    return(doc);}

/*Read values from XML22 file 读取XML22，虚拟机之间的流量信息文件*/int get_vm2vm_from_xml22(char *filename) {    xmlTextReaderPtr reader;	xmlChar *name;    	int vd=-1,ret=0;	    reader = xmlNewTextReaderFilename(filename);	    if (reader != NULL) {        ret = xmlTextReaderRead(reader);				name = xmlTextReaderName(reader);/*获取reader的元素名称*/		if (name == NULL)			name = xmlStrdup(BAD_CAST "--");				/*在这个例子中，我们需要确认文档是正确的类型。“DATA”是在这个示例中使用文档的根类型。*/		if (xmlStrcmp(name, (xmlChar *) "DATA")) {			fprintf(stderr,"document of the wrong type, root node != DATA");			xmlFree(name);			xmlFreeTextReader(reader);			return ret;		}				        while (ret == 1) {            process_XML22_Node(reader,&vd);			            ret = xmlTextReaderRead(reader);	    }        		xmlFreeTextReader(reader);        if (ret != 0) {            printf("%s : failed to parse/n", filename);        }    	} 	else 	    printf("Unable to open %s/n", filename);    	_xpthis->sd->v2v_total=vd+1;/*在全局共享数据区记录v2v的总数*/		return ret;}

/** * streamFile: * @filename: the file name to parse * * Parse and print information about an XML file. */static void streamFile (const char *filename) {	xmlTextReaderPtr reader;	int ret;	reader = xmlReaderForFile (filename, NULL, 0);	if (reader != NULL) {		ret = xmlTextReaderRead (reader);		while (ret == 1) {			processNode (reader);			ret = xmlTextReaderRead (reader);		}		xmlFreeTextReader (reader);		if (ret != 0) {			fprintf (stderr, "%s : failed to parse/n", filename);		}	} else {		fprintf (stderr, "Unable to open %s/n", filename);	}}

void BEXMLTextReader::read ( ){	int ok = xmlTextReaderRead ( reader );	if ( ok == 0 ) {		last_node = true;	} else if ( ok == kBE_XMLReaderError ) {		throw BEXMLReaderInterface_Exception ( last_error() );	}	}

EXPORT EPUB3Error EPUB3CopyRootFilePathFromContainer(EPUB3Ref epub, char ** rootPath){  assert(epub != NULL);  if(epub->archive == NULL) return kEPUB3ArchiveUnavailableError;  static const char *containerFilename = "META-INF/container.xml";  void *buffer = NULL;  uint32_t bufferSize = 0;  uint32_t bytesCopied;  xmlTextReaderPtr reader = NULL;  EPUB3Bool foundPath = kEPUB3_NO;  EPUB3Error error = kEPUB3Success;  error = EPUB3CopyFileIntoBuffer(epub, &buffer, &bufferSize, &bytesCopied, containerFilename);  if(error == kEPUB3Success) {    reader = xmlReaderForMemory(buffer, bufferSize, "", NULL, XML_PARSE_RECOVER);    if(reader != NULL) {      int retVal;      while((retVal = xmlTextReaderRead(reader)) == 1)      {        const char *rootFileName = "rootfile";        const xmlChar *name = xmlTextReaderConstLocalName(reader);        if(xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT && xmlStrcmp(name, BAD_CAST rootFileName) == 0) {          xmlChar *fullPath = xmlTextReaderGetAttribute(reader, BAD_CAST "full-path");          if(fullPath != NULL) {            // TODD: validate that the full-path attribute is of the form path-rootless            //       see http://idpf.org/epub/30/spec/epub30-ocf.html#sec-container-metainf-container.xml            foundPath = kEPUB3_YES;            *rootPath = strdup((char *)fullPath);          } else {            // The spec requires the full-path attribute            error = kEPUB3XMLXDocumentInvalidError;          }          break;        }      }      if(retVal < 0) {        error = kEPUB3XMLParseError;      }      if(!foundPath) {        error = kEPUB3XMLXElementNotFoundError;      }    } else {      error = kEPUB3XMLReadFromBufferError;    }    EPUB3_FREE_AND_NULL(buffer);  }  xmlFreeTextReader(reader);  return error;}

static xmlChar* get_xml_text (    xmlTextReaderPtr reader    ){    while(xmlTextReaderRead(reader)){        xmlChar  *ret;            xmlChar  *text;        xmlChar  *begin_ptr;        xmlChar  *end_ptr;        int type;                type = xmlTextReaderNodeType(reader);        if (type == XML_READER_TYPE_ELEMENT){            xmlChar *name;            name = xmlTextReaderName(reader);            rrd_set_error("line %d: expected a value but found a <%s> element",                          xmlTextReaderGetParserLineNumber(reader),                          name);            xmlFree(name);                        return NULL;                    }        /* trying to read text from <a></a> we end up here           lets return an empty string instead. This is a tad optimistic           since we do not check if it is actually </a> and not </b>           we got, but first we do not know if we expect </a> and second           we the whole implementation is on the optimistic side. */        if (type == XML_READER_TYPE_END_ELEMENT){            return  xmlStrdup(BAD_CAST "");        }                /* skip all other non-text */        if (type != XML_READER_TYPE_TEXT)            continue;                text = xmlTextReaderValue(reader);        begin_ptr = text;        while ((begin_ptr[0] != 0) && (isspace(begin_ptr[0])))            begin_ptr++;        if (begin_ptr[0] == 0) {            xmlFree(text);            return xmlStrdup(BAD_CAST "");        }                end_ptr = begin_ptr;        while ((end_ptr[0] != 0) && (!isspace(end_ptr[0])))            end_ptr++;        end_ptr[0] = 0;                ret = xmlStrdup(begin_ptr);        xmlFree(text);        return ret;    }    rrd_set_error("file ended while looking for text");    return NULL;}  /* get_xml_text */ 

	/**	 * Streams XML file using callback	**/	int streamFile(char *filename, char *objPath, ruleExecInfo_t* rei) {		xmlTextReaderPtr reader;		int ret;		rodsLog( LOG_NOTICE, "Calling streamFile()/n");				reader = xmlNewTextReaderFilename(filename);		if (reader != NULL) {			ret = xmlTextReaderRead(reader);			while (ret == 1 && end == 0) {				processNode(reader, objPath, rei);				ret = xmlTextReaderRead(reader);			}			xmlFreeTextReader(reader);			end = 0;		} else {			printf("Unable to open %s/n", filename);		}		return 0;	}

static voidbiji_parse_file (BijiLazyDeserializer *self){  while ( xmlTextReaderRead(self->priv->r) == 1 )  {    if ( xmlTextReaderNodeType(self->priv->r) == 1 )    {      processNode(self);    }  }}

static Buffer *extractText(htmlDocPtr doc) {		char * term = "/0";    Buffer *buf = new_buffer(256);    xmlTextReaderPtr reader = xmlReaderWalker(doc);    while(xmlTextReaderRead(reader)){        processNode(reader, buf);    }    xmlFreeTextReader(reader);    buffer_in(buf, term, 1);    return buf;}

		void Parse()		{			ReadNextNode();			WriteElement();			int nDepth = GetDepth();			if ( 0 == xmlTextReaderIsEmptyElement(reader) )			{				XmlNodeType eNodeType = XmlNodeType_None;				int nCurDepth = -1;				// У закрывающего тэга глубина на 1 больше, чем у открывающего                while( true )				{					if ( 1 != xmlTextReaderRead(reader) )						break;					int nTempType = xmlTextReaderNodeType(reader);					if(-1 == nTempType)						break;					eNodeType = (XmlNodeType)nTempType;					nCurDepth = GetDepth();					if ( eNodeType == XmlNodeType_Text || eNodeType == XmlNodeType_Whitespace || eNodeType == XmlNodeType_SIGNIFICANT_WHITESPACE )						m_pCurrentNode->m_sText += GetText();					else if (eNodeType == XmlNodeType_Element)						WriteElement();					else if (eNodeType == XmlNodeType_EndElement)					{						m_list.pop_back();												if (0 != m_list.size())						{							std::list<CXmlNodeBase*>::iterator iter = m_list.end();							--iter;							m_pCurrentNode = *iter;						}						else						{							m_pCurrentNode = m_pNode;						}					}					nCurDepth = GetDepth();					if ( nCurDepth < nDepth )						break;					if ( XmlNodeType_EndElement == eNodeType && nCurDepth == nDepth )						break;				}			}		}

static const xmlChar * openioc_read(xmlTextReaderPtr reader){    const xmlChar * name;    if (xmlTextReaderRead(reader) != 1)        return NULL;    name = xmlTextReaderConstLocalName(reader);    if (name != NULL) {        cli_dbgmsg("openioc_parse: xmlTextReaderRead read %s%s/n", name,                   xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT?" end tag":"");    }    return name;   }

/*  xar_process_subdocument - check TOC for xml subdocument. If found, extract and                            scan in memory.  Parameters:     reader - xmlTextReaderPtr     ctx - pointer to cli_ctx  Returns:     CL_SUCCESS - subdoc found and clean scan (or virus found and SCAN_ALL), or no subdocument     other - error return code from cli_mem_scandesc()*/static int xar_scan_subdocuments(xmlTextReaderPtr reader, cli_ctx *ctx){    int rc = CL_SUCCESS, subdoc_len, fd;    xmlChar * subdoc;    const xmlChar *name;    char * tmpname;    while (xmlTextReaderRead(reader) == 1) {        name = xmlTextReaderConstLocalName(reader);        if (name == NULL) {            cli_dbgmsg("cli_scanxar: xmlTextReaderConstLocalName() no name./n");            rc = CL_EFORMAT;            break;        }        if (xmlStrEqual(name, (const xmlChar *)"toc") &&                xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)            return CL_SUCCESS;        if (xmlStrEqual(name, (const xmlChar *)"subdoc") &&                xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {            subdoc = xmlTextReaderReadInnerXml(reader);            if (subdoc == NULL) {                cli_dbgmsg("cli_scanxar: no content in subdoc element./n");                xmlTextReaderNext(reader);                continue;            }            subdoc_len = xmlStrlen(subdoc);            cli_dbgmsg("cli_scanxar: in-memory scan of xml subdocument, len %i./n", subdoc_len);            rc = cli_mem_scandesc(subdoc, subdoc_len, ctx);            if (rc == CL_VIRUS && SCAN_ALL)                rc = CL_SUCCESS;            /* make a file to leave if --leave-temps in effect */            if(ctx->engine->keeptmp) {                if ((rc = cli_gentempfd(ctx->engine->tmpdir, &tmpname, &fd)) != CL_SUCCESS) {                    cli_dbgmsg("cli_scanxar: Can't create temporary file for subdocument./n");                } else {                    cli_dbgmsg("cli_scanxar: Writing subdoc to temp file %s./n", tmpname);                    if (cli_writen(fd, subdoc, subdoc_len) < 0) {                        cli_dbgmsg("cli_scanxar: cli_writen error writing subdoc temporary file./n");                        rc = CL_EWRITE;                    }                    rc = xar_cleanup_temp_file(ctx, fd, tmpname);                }            }            xmlFree(subdoc);            if (rc != CL_SUCCESS)                return rc;            xmlTextReaderNext(reader);        }    }    return rc;}

voidPTXReader::step() {  int retval = xmlTextReaderRead(reader);  if(retval != 1)  {    parseError(L"unexpected EOF");  }  name = XMLParseUtil::towstring(xmlTextReaderConstName(reader));  type = xmlTextReaderNodeType(reader);  //cerr<<"In PTXReader::step: name='"<<name<<"', type="<<type<<"/n";}

ExtractionWay XMLParser::_ReadXMLWay() {	ExtractionWay way;	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {		const int depth = xmlTextReaderDepth( inputReader );		while ( xmlTextReaderRead( inputReader ) == 1 ) {			const int childType = xmlTextReaderNodeType( inputReader );			if ( childType != 1 && childType != 15 ) {				continue;			}			const int childDepth = xmlTextReaderDepth( inputReader );			xmlChar* childName = xmlTextReaderName( inputReader );			if ( childName == NULL ) {				continue;			}			if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {				xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );				way.id = stringToUint((char*)id);				xmlFree(id);				xmlFree( childName );				break;			}			if ( childType != 1 ) {				xmlFree( childName );				continue;			}			if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {				xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );				xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );				//				cout << "->k=" << k << ", v=" << value << endl;				if ( k != NULL && value != NULL ) {					way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));				}				if ( k != NULL ) {					xmlFree( k );				}				if ( value != NULL ) {					xmlFree( value );				}			} else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {				xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );				if ( ref != NULL ) {					way.path.push_back( stringToUint(( const char* ) ref ) );					xmlFree( ref );				}			}			xmlFree( childName );		}	}	return way;}

/* * Parse the configuration file and initialize ows struct */static void ows_parse_config_xml(ows * o, const char *filename){    xmlTextReaderPtr r;    const xmlChar *name;    int ret;    assert(o);    assert(filename);    r = xmlReaderForFile(filename, "UTF-8", 0);    if (!r) {        ows_error(o, OWS_ERROR_CONFIG_FILE, "Unable to open config file !", "parse_config_file");        return;    }    if (!o->layers) o->layers = ows_layer_list_init();    while ((ret = xmlTextReaderRead(r)) == 1) {        if (xmlTextReaderNodeType(r) == XML_READER_TYPE_ELEMENT) {            name = xmlTextReaderConstLocalName(r);            if (!strcmp((char *) name, "tinyows"))                ows_parse_config_tinyows(o, r);            if (!strcmp((char *) name, "metadata"))                ows_parse_config_metadata(o, r);            if (!strcmp((char *) name, "abstract"))                ows_parse_config_abstract(o, r);            if (!strcmp((char *) name, "contact"))                ows_parse_config_contact(o, r);            if (!strcmp((char *) name, "pg"))                ows_parse_config_pg(o, r);            if (!strcmp((char *) name, "limits"))                ows_parse_config_limits(o, r);            if (!strcmp((char *) name, "layer"))                ows_parse_config_layer(o, r);        }    }    if (ret != 0) {        xmlFreeTextReader(r);        ows_error(o, OWS_ERROR_CONFIG_FILE, "Unable to open config file !", "parse_config_file");        return;    }    xmlFreeTextReader(r);}

/* * This is the workhorse behind for ksFromXML() and ksFromXMLfile(). * It will process the entire XML document in reader and convert and * save it in ks KeySet. Each node is processed by the processNode() function. * * This function is completely dependent on libxml. */static int ksFromXMLReader(KeySet *ks,xmlTextReaderPtr reader){	int ret = 0;	xmlChar *nodeName=0;	ret = xmlTextReaderRead(reader); /* go to first node */	while (ret == 1) {		/* walk node per node until the end of the stream */		nodeName=xmlTextReaderName(reader);				if (!strcmp((char *)nodeName,"key"))			consumeKeyNode(ks, 0, reader);		else if (!strcmp((char *)nodeName,"keyset"))			consumeKeySetNode(ks, 0, reader);				ret = xmlTextReaderRead(reader);		xmlFree (nodeName);	}	return ret;}

bool c_XMLReader::t_read() {  if (m_ptr) {    int ret = xmlTextReaderRead(m_ptr);    if (ret == -1) {      raise_warning("An Error Occured while reading");      return false;    } else {      return ret;    }  }  raise_warning("Load Data before trying to read");  return false;}

/* reader:read() */static int xmlreader_read(lua_State *L) {  xmlreader xr = check_xmlreader(L, 1);  int ret = xmlTextReaderRead(xr);  if (ret != -1) {    lua_pushboolean(L, ret);    return 1;  } else {    lua_pushnil(L);    xmlreader_pusherror(L);    return 2;  }}