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

/* {{{ xmlreader_free_resources */static void xmlreader_free_resources(xmlreader_object *intern) {	if (intern) {		if (intern->input) {			xmlFreeParserInputBuffer(intern->input);			intern->input = NULL;		}		if (intern->ptr) {			xmlFreeTextReader(intern->ptr);			intern->ptr = NULL;		}#ifdef LIBXML_SCHEMAS_ENABLED		if (intern->schema) {			xmlRelaxNGFree((xmlRelaxNGPtr) intern->schema);			intern->schema = NULL;		}#endif	}}

/*DEF*/void *XoReadObixMem(char *buf,int sz,void *unused,int flags,int *err){    xmlTextReaderPtr reader	= NULL;    void		 *obj;    flags	= flags | XOML_PARSE_OBIX;    *err	= 0;    reader = xmlReaderForMemory(buf,sz,"",NULL,0);    if (reader == NULL)    {        char	tmperr[256];        sprintf(tmperr,"XoReadObixMem():cannot create reader memory/n");        XOERR(tmperr,0);        return	NULL;    }    obj	= XoReadXmlReader(reader,NULL,flags,err);    xmlFreeTextReader(reader);    return	obj;}

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

/*DEF*/void *XoReadXmlEx(char *filename,char *roottype,int flags,int *err){	xmlTextReaderPtr reader	= NULL;	void		 *obj;	*err	= 0;	reader = xmlNewTextReaderFilename(filename);	if (reader == NULL) 	{		char	tmperr[256];		sprintf(tmperr,"XoReadXmlEx(%s) : cannot create reader file/n", 								filename);		XOERR(tmperr,0);		return	NULL;	}	obj	= XoReadXmlReader(reader,roottype,flags,err);	xmlFreeTextReader(reader);	return	obj;}

static voidxml_reader_clear (XmlReader *reader){   g_return_if_fail(XML_IS_READER(reader));   g_free (reader->cur_name);   reader->cur_name = NULL;   if (reader->xml) {      xmlTextReaderClose(reader->xml);      xmlFreeTextReader(reader->xml);      reader->xml = NULL;   }   if (reader->stream) {      g_object_unref(reader->stream);      reader->stream = NULL;   }}

void XMLReader::close() {  SYNC_VM_REGS_SCOPED();  if (m_stream) {    m_stream->close();    m_stream = nullptr;  }  if (m_ptr) {    xmlFreeTextReader(m_ptr);    m_ptr = nullptr;  }  if (m_input) {    xmlFreeParserInputBuffer(m_input);    m_input = nullptr;  }  if (m_schema) {    xmlRelaxNGFree((xmlRelaxNGPtr) m_schema);    m_schema = nullptr;  }}

/*DEF*/void *XoReadObixEx(char *filename,void *unused,int flags,int *err){    xmlTextReaderPtr reader	= NULL;    void		 *obj;    flags	= flags | XOML_PARSE_OBIX;    *err	= 0;    reader = xmlNewTextReaderFilename(filename);    if (reader == NULL)    {        char	tmperr[256];        sprintf(tmperr,"XoReadObixEx(%s):cannot create reader file/n",                filename);        XOERR(tmperr,0);        return	NULL;    }    obj	= XoReadXmlReader(reader,NULL,flags,err);    xmlFreeTextReader(reader);    return	obj;}

static voidparser_state_destroy (ParserState *parser_state){	if (parser_state->reader != NULL)		xmlFreeTextReader (parser_state->reader);	if (parser_state->error != NULL)		g_error_free (parser_state->error);	g_queue_free (parser_state->curr_parents);	g_free (parser_state->current_lang_id);	g_free (parser_state->opening_delimiter);	g_free (parser_state->closing_delimiter);	g_free (parser_state->language_decoration);	g_free (parser_state->filename);	g_slice_free (ParserState, parser_state);}

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

int xml_label_from_file(const char *filename, struct ltfs_label *label){	int ret;	xmlTextReaderPtr reader;	CHECK_ARG_NULL(filename, -LTFS_NULL_ARG);	CHECK_ARG_NULL(label, -LTFS_NULL_ARG);	reader = xmlReaderForFile(filename, NULL, XML_PARSE_NOERROR | XML_PARSE_NOWARNING);	if (! reader) {		ltfsmsg(LTFS_ERR, "17007E", filename);		return -1;	}	ret = _xml_parse_label(reader, label);	if (ret < 0)		ltfsmsg(LTFS_ERR, "17008E", filename);	xmlFreeTextReader(reader);	return ret;}

static gboolean_ag_service_load_from_file (AgService *service){    xmlTextReaderPtr reader;    gchar *filepath;    gboolean ret;    GError *error = NULL;    gsize len;    g_return_val_if_fail (service->name != NULL, FALSE);    DEBUG_REFS ("Loading service %s", service->name);    filepath = _ag_find_libaccounts_file (service->name,                                          ".service",                                          "AG_SERVICES",                                          SERVICE_FILES_DIR);    if (G_UNLIKELY (!filepath)) return FALSE;    g_file_get_contents (filepath, &service->file_data,                         &len, &error);    if (G_UNLIKELY (error))    {        g_warning ("Error reading %s: %s", filepath, error->message);        g_error_free (error);        g_free (filepath);        return FALSE;    }    /* TODO: cache the xmlReader */    reader = xmlReaderForMemory (service->file_data, len,                                 filepath, NULL, 0);    g_free (filepath);    if (G_UNLIKELY (reader == NULL))        return FALSE;    ret = read_service_file (reader, service);    xmlFreeTextReader (reader);    return ret;}

static voidraptor_rss_parse_terminate(raptor_parser *rdf_parser) {  raptor_rss_parser_context *rss_parser=(raptor_rss_parser_context*)rdf_parser->context;  int i;    if(rss_parser->reader)    xmlFreeTextReader(rss_parser->reader);  if(rss_parser->input)    xmlFreeParserInputBuffer(rss_parser->input);  raptor_rss_items_free(rss_parser);  for(i=0; i< RAPTOR_RSS_COMMON_SIZE; i++)    raptor_item_free(&rss_parser->common[i]);  for(i=0; i<RSS_NAMESPACES_SIZE;i++) {    if(rss_parser->namespace_uris[i])      raptor_free_uri(rss_parser->namespace_uris[i]);  }  for(i=0; i< RAPTOR_RSS_N_CONCEPTS; i++) {    raptor_uri* concept_uri=rss_parser->concepts[i];    if(concept_uri) {      raptor_free_uri(concept_uri);      rss_parser->concepts[i]=NULL;    }  }  for(i=0; i< RAPTOR_RSS_COMMON_SIZE; i++) {    if(raptor_rss_types_info[i].uri)      raptor_free_uri(raptor_rss_types_info[i].uri);  }  for(i=0; i< RAPTOR_RSS_FIELDS_SIZE; i++) {    if(raptor_rss_fields_info[i].uri)      raptor_free_uri(raptor_rss_fields_info[i].uri);  }}

struct xccdf_benchmark *xccdf_benchmark_import(const char *file){	xmlTextReaderPtr reader = xmlReaderForFile(file, NULL, 0);	if (!reader) {		oscap_seterr(OSCAP_EFAMILY_GLIBC, "Unable to open file: '%s'", file);		return NULL;	}	xmlTextReaderSetErrorHandler(reader, &libxml_error_handler, NULL);	while (xmlTextReaderRead(reader) == 1 && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT) ;	struct xccdf_benchmark *benchmark = xccdf_benchmark_new();	const bool parse_result = xccdf_benchmark_parse(XITEM(benchmark), reader);	xmlFreeTextReader(reader);	if (!parse_result) { // parsing fatal error		oscap_seterr(OSCAP_EFAMILY_XML, "Failed to parse '%s'.", file);		xccdf_benchmark_free(benchmark);		return NULL;	}	// This is sadly the only place where we can pass origin file information	// to the CPE1 embedded dictionary (if any). It is necessary to figure out	// proper paths to OVAL files referenced from CPE1 dictionaries.	// FIXME: Refactor and move this somewhere else	struct cpe_dict_model* embedded_dict = xccdf_benchmark_get_cpe_list(benchmark);	if (embedded_dict != NULL) {		cpe_dict_model_set_origin_file(embedded_dict, file);	}	// same situation with embedded CPE2 lang model	// FIXME: Refactor and move this somewhere else	struct cpe_lang_model* embedded_lang_model = xccdf_benchmark_get_cpe_lang_model(benchmark);	if (embedded_lang_model != NULL) {		cpe_lang_model_set_origin_file(embedded_lang_model, file);	}	return benchmark;}

struct xccdf_tailoring *xccdf_tailoring_import(const char *file, struct xccdf_benchmark *benchmark){	xmlTextReaderPtr reader = xmlReaderForFile(file, NULL, 0);	if (!reader) {		oscap_seterr(OSCAP_EFAMILY_GLIBC, "Unable to open file: '%s'", file);		return NULL;	}	xmlTextReaderSetErrorHandler(reader, &libxml_error_handler, NULL);	while (xmlTextReaderRead(reader) == 1 && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT) ;	struct xccdf_tailoring *tailoring = xccdf_tailoring_parse(reader, XITEM(benchmark));	xmlFreeTextReader(reader);	if (!tailoring) { // parsing fatal error		oscap_seterr(OSCAP_EFAMILY_XML, "Failed to parse '%s'.", file);		xccdf_tailoring_free(tailoring);		return NULL;	}	return tailoring;}

// TODO: Refactor: This function differs from EPUB3ParseOPFFromData by 1 line.EPUB3Error EPUB3ParseNCXFromData(EPUB3Ref epub, void * buffer, uint32_t bufferSize){  assert(epub != NULL);  assert(buffer != NULL);  assert(bufferSize > 0);  EPUB3Error error = kEPUB3Success;  xmlInitParser();  xmlTextReaderPtr reader = NULL;  reader = xmlReaderForMemory(buffer, bufferSize, NULL, NULL, XML_PARSE_RECOVER | XML_PARSE_NONET);  if(reader != NULL) {    EPUB3XMLParseContext contextStack[PARSE_CONTEXT_NCX_STACK_DEPTH];    EPUB3XMLParseContextPtr currentContext = &contextStack[0];    int retVal = xmlTextReaderRead(reader);    currentContext->state = kEPUB3NCXStateRoot;    currentContext->tagName = xmlTextReaderConstName(reader);    while(retVal == 1)    {//      _EPUB3DumpXMLParseContextStack(&currentContext);        error = EPUB3ParseXMLReaderNodeForNCX(epub, reader, &currentContext);        if (error != kEPUB3NCXNavMapEnd && reader != NULL) {            retVal = xmlTextReaderRead(reader);        }        else {            retVal = 0;            error = kEPUB3Success;        }    }    if(retVal < 0) {      error = kEPUB3XMLParseError;    }  } else {    error = kEPUB3XMLReadFromBufferError;  }  xmlFreeTextReader(reader);  xmlCleanupParser();  return error;}

	void CInterfaceDefinitionLoader::cleanup()	{		if( m_reader )		{			xmlFreeTextReader( m_reader );			m_reader = NULL;		}		if( m_interface_definition )		{			delete m_interface_definition;			m_interface_definition = NULL;		}		if( m_last_state_label_value )		{			delete m_last_state_label_value;			m_last_state_label_value = NULL;		}		m_element_path.clear();	}

/** * Parse an extent list from a file and populate provided dentry with the extents read during * the scanning. * * @param filename File name from where to read the extent list from. * @param d Dentry where the extents are to be appended to. * @return 0 on success or a negative value on error. */static int xml_extentlist_from_file(const char *filename, struct dentry *d){	declare_extent_parser_vars("extentinfo");	xmlTextReaderPtr reader;	xmlDocPtr doc;	int ret = 0;	CHECK_ARG_NULL(filename, -LTFS_NULL_ARG);	CHECK_ARG_NULL(d, -LTFS_NULL_ARG);	reader = xmlReaderForFile(filename, NULL, XML_PARSE_NOERROR | XML_PARSE_NOWARNING);	if (! reader) {		ltfsmsg(LTFS_ERR, "17011E", filename);		return -1;	}	/* Workaround for old libxml2 version on OS X 10.5: the method used to preserve	 * unknown tags modifies the behavior of xmlFreeTextReader so that an additional	 * xmlDocFree call is required to free all memory. */	doc = xmlTextReaderCurrentDoc(reader);	while (true) { /* BEAM: loop doesn't iterate - Because get_next_tag() macro uses "break", at most once loop is needed here. */		get_next_tag();		if (! strcmp(name, "extentinfo")) {			ret = _xml_parse_extents(reader, IDX_VERSION_SPARSE, d);			if (ret < 0) {				/* XML parser: failed to read extent list from file (%d) */				ltfsmsg(LTFS_ERR, "17084E", ret);			}		}		break;	}	if (doc)		xmlFreeDoc(doc);	xmlFreeTextReader(reader);	return ret;}

sc_list_t *sc_xmltv_parse(const char *filename) {    xmlTextReaderPtr reader = NULL;    sc_list_t *channels = NULL;    sc_list_t *programmes = NULL;    int ret;    sc_list_node_t *node = NULL;    reader = xmlNewTextReaderFilename(filename);    if (!reader)        return NULL;    channels = sc_list_create();    programmes = sc_list_create();    for (ret = xmlTextReaderRead(reader); ret == 1; ret = xmlTextReaderRead(reader)) {        if (sc_xmltv_check_current_reader_node(reader, XML_READER_TYPE_ELEMENT, SC_XMLTV_CHANNEL_NAME,                                               SC_XMLTV_CHANNEL_DEPTH)) {            node = sc_list_node_create(sc_xmltv_parse_channel(reader));            sc_list_node_append(channels, node);        }        if (sc_xmltv_check_current_reader_node(reader, XML_READER_TYPE_ELEMENT, SC_XMLTV_PROGRAMME_NAME,                                               SC_XMLTV_PROGRAMME_DEPTH)) {            node = sc_list_node_create(sc_xmltv_parse_programme(reader));            sc_list_node_append(programmes, node);        }    }    xmlFreeTextReader(reader);    node = channels->first;    while (node) {        sc_xmltv_link_progs_to_chan(programmes, (sc_xmltv_channel_t *) node->data);        node = node->next;    }    sc_xmltv_list_free(SC_XMLTV_PROGRAMME, &programmes);    return channels;}

/** * streamFile: * @filename: the file name to parse * * Parse, validate and print information about an XML file. */static voidstreamFile(const char *filename) {    xmlTextReaderPtr reader;    int ret;    /*     * Pass some special parsing options to activate DTD attribute defaulting,     * entities substitution and DTD validation     */    reader = xmlReaderForFile(filename, NULL,                 XML_PARSE_DTDATTR |  /* default DTD attributes */         XML_PARSE_NOENT |            /* substitute entities */         XML_PARSE_DTDVALID); /* validate with the DTD */    if (reader != NULL) {        ret = xmlTextReaderRead(reader);        while (ret == 1) {            // processNode(reader);            ret = xmlTextReaderRead(reader);        }        /*         * Once the document has been fully parsed check the validation results         */        if (xmlTextReaderIsValid(reader) != 1) {            fprintf(stderr, "Document %s does not validate/n", filename);        } else {            printf("Look nice./n");        }        xmlFreeTextReader(reader);        if (ret != 0) {            fprintf(stderr, "%s : failed to parse/n", filename);        }    } else {        fprintf(stderr, "Unable to open %s/n", filename);    }}

int xmlconfig_load( const char *filename ){	int rc = -1;	int ret;	xmlTextReaderPtr reader;	const xmlChar *name;        	reader = xmlReaderForFile( filename, NULL, 0 );	if ( reader != NULL ) {		ret = xmlTextReaderRead( reader );		while (ret == 1) {			name = xmlTextReaderConstName( reader );			if ( name &&                            (XML_READER_TYPE_ELEMENT == xmlTextReaderNodeType( reader )) &&                            ( 0 == xmlStrncmp( name, (const xmlChar *)"NodeConfig", 10 ) ) )			{				xmlconfig_load_node( reader );			}			else if ( name &&                            (XML_READER_TYPE_ELEMENT == xmlTextReaderNodeType( reader )) &&                            ( 0 == xmlStrncmp( name, (const xmlChar *)"TimerConfig", 10 ) ) )			{				xmlconfig_load_timer( reader );			}			ret = xmlTextReaderRead( reader );		}		xmlFreeTextReader( reader );		if (ret != 0) {			fprintf( stderr, "%s : failed to parse/n", filename );			goto out;		}		rc = 0;	} else {		fprintf( stderr, "Unable to open %s/n", filename );	}out:	return rc;}

/* * call-seq: *   from_io(io, url = nil, encoding = nil, options = 0) * * Create a new reader that parses +io+ */static VALUE from_io(int argc, VALUE *argv, VALUE klass){  VALUE rb_io, rb_url, encoding, rb_options;  xmlTextReaderPtr reader;  const char * c_url      = NULL;  const char * c_encoding = NULL;  int c_options           = 0;  VALUE rb_reader, args[3];  rb_scan_args(argc, argv, "13", &rb_io, &rb_url, &encoding, &rb_options);  if (!RTEST(rb_io)) rb_raise(rb_eArgError, "io cannot be nil");  if (RTEST(rb_url)) c_url = StringValuePtr(rb_url);  if (RTEST(encoding)) c_encoding = StringValuePtr(encoding);  if (RTEST(rb_options)) c_options = (int)NUM2INT(rb_options);  reader = xmlReaderForIO(      (xmlInputReadCallback)io_read_callback,      (xmlInputCloseCallback)io_close_callback,      (void *)rb_io,      c_url,      c_encoding,      c_options  );  if(reader == NULL) {    xmlFreeTextReader(reader);    rb_raise(rb_eRuntimeError, "couldn't create a parser");  }  rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);  args[0] = rb_io;  args[1] = rb_url;  args[2] = encoding;  rb_obj_call_init(rb_reader, 3, args);  return rb_reader;}

int xml_label_from_mem(const char *buf, int buf_size, struct ltfs_label *label){	int ret;	xmlTextReaderPtr reader;	CHECK_ARG_NULL(buf, -LTFS_NULL_ARG);	CHECK_ARG_NULL(label, -LTFS_NULL_ARG);	reader = xmlReaderForMemory(buf, buf_size, NULL, NULL, XML_PARSE_NOERROR | XML_PARSE_NOWARNING);	if (! reader) {		ltfsmsg(LTFS_ERR, "17009E");		return -LTFS_LIBXML2_FAILURE;	}	ret = _xml_parse_label(reader, label);	if (ret < 0) {		ltfsmsg(LTFS_ERR, "17010E");		ret = -LTFS_LABEL_INVALID;	}	xmlFreeTextReader(reader);	return ret;}

bool ddDatabaseDesign::readXmlModel(wxString file, ctlAuiNotebook *notebook){	emptyModel();	mappingIdToName.clear();	//Initial Parse Model	xmlTextReaderPtr reader = xmlReaderForFile(file.mb_str(wxConvUTF8), NULL, 0);	ddXmlStorage::setModel(this);	ddXmlStorage::setModel(this);	ddXmlStorage::initialModelParse(reader);	//Parse Model	xmlReaderNewFile(reader, file.mb_str(wxConvUTF8), NULL, 0);	ddXmlStorage::setModel(this);	ddXmlStorage::setNotebook(notebook);	if(!ddXmlStorage::Read(reader))	{		return false;	}	xmlFreeTextReader(reader);	return true;}

int streamXmlFile(const char *filename, Q3ListViewItem* item) {	xmlTextReaderPtr reader;	int ret;	reader = xmlNewTextReaderFilename(filename);	if (reader != NULL) {		ret = xmlTextReaderRead(reader);		while (ret == 1) {			processNode(reader, &item);			ret = xmlTextReaderRead(reader);		}		xmlFreeTextReader(reader);		if (ret != 0) {			printf("%s : failed to parse/n", filename);			return 0;		}	} else {		printf("Unable to open %s/n", filename);		return 0;	}	return 1;}

/* * call-seq: *   from_memory(string, url = nil, encoding = nil, options = 0) * * Create a new reader that parses +string+ */static VALUE from_memory(int argc, VALUE *argv, VALUE klass){  VALUE rb_buffer, rb_url, encoding, rb_options;  xmlTextReaderPtr reader;  const char * c_url      = NULL;  const char * c_encoding = NULL;  int c_options           = 0;  VALUE rb_reader, args[3];  rb_scan_args(argc, argv, "13", &rb_buffer, &rb_url, &encoding, &rb_options);  if (!RTEST(rb_buffer)) rb_raise(rb_eArgError, "string cannot be nil");  if (RTEST(rb_url)) c_url = StringValuePtr(rb_url);  if (RTEST(encoding)) c_encoding = StringValuePtr(encoding);  if (RTEST(rb_options)) c_options = (int)NUM2INT(rb_options);  reader = xmlReaderForMemory(      StringValuePtr(rb_buffer),      (int)RSTRING_LEN(rb_buffer),      c_url,      c_encoding,      c_options  );  if(reader == NULL) {    xmlFreeTextReader(reader);    rb_raise(rb_eRuntimeError, "couldn't create a parser");  }  rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);  args[0] = rb_buffer;  args[1] = rb_url;  args[2] = encoding;  rb_obj_call_init(rb_reader, 3, args);  return rb_reader;}

static int ooxml_parse_document(int fd, cli_ctx *ctx){    int ret = CL_SUCCESS;    xmlTextReaderPtr reader = NULL;    cli_dbgmsg("in ooxml_parse_document/n");    reader = xmlReaderForFd(fd, "properties.xml", NULL, 0);    if (reader == NULL) {        cli_dbgmsg("ooxml_parse_document: xmlReaderForFd error/n");        return CL_SUCCESS; // internal error from libxml2    }    /* move reader to first element */    if (xmlTextReaderRead(reader) != 1) {        return CL_SUCCESS; /* libxml2 failed */    }    ret = ooxml_parse_element(reader, ctx->wrkproperty, 0, 0);    xmlTextReaderClose(reader);    xmlFreeTextReader(reader);    return ret;}

static Pvoid_t tokenize_uris(htmlDocPtr doc, Pvoid_t features) {	xmlTextReaderPtr reader = xmlReaderWalker(doc);	while (xmlTextReaderRead(reader)) {		int type = xmlTextReaderNodeType(reader);		if (type == XML_ELEMENT_NODE) {			char *uri = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST "href");			if (uri) {				features = tokenize_uri(uri, features);				free(uri);			}			uri = (char*) xmlTextReaderGetAttribute(reader, BAD_CAST "src");			if (uri) {				features = tokenize_uri(uri, features);				free(uri);			}		}	}	xmlFreeTextReader(reader);	return features;}

  ///Returns the extended form of the OBConversion object with an xml reader or writer,  /// if this has not already been done.  XMLConversion* XMLConversion::GetDerived(OBConversion* pConv, bool ForReading)  {    XMLConversion* pxmlConv;    if(!pConv->GetAuxConv())      //Need to make an extended copy. It will be deleted by pConv's destructor      pxmlConv =  new XMLConversion(pConv);    else      {        //pConv has already had an extended copy made        *pConv->GetAuxConv() = *pConv; //ensure they have the same OBConversion data        pxmlConv = dynamic_cast<XMLConversion*>(pConv->GetAuxConv());        if (!pxmlConv)          return NULL;      }    if(ForReading)      {        streampos pos = pConv->GetInStream()->tellg();        if(pos < pxmlConv->_lastpos || pxmlConv->_lastpos<0)          {            //Probably a new file; copy some member vars and renew the current reader            xmlFreeTextReader(pxmlConv->_reader); //need a new reader to read files with <?xml?>            pxmlConv->_reader = NULL;            pxmlConv->InFilename = pConv->GetInFilename();            pxmlConv->pInFormat = pConv->GetInFormat();          }        pxmlConv->SetupReader();      }    else    {      pxmlConv->SetupWriter();      pxmlConv->SetLast(pConv->IsLast()); //Copy IsLast flag to the extended object    }    return pxmlConv;  }

intmain(int argc, char **argv) {    struct cmdlineInfo cmdline;    FILE * ifP;    xmlTextReaderPtr xmlReaderP;    pnm_init(&argc, argv);    xmlInitParser();    LIBXML_TEST_VERSION;    parseCommandLine(argc, argv, &cmdline);        traceDraw = cmdline.trace;    ifP = pm_openr(cmdline.inputFileName);    xmlReaderP = xmlReaderForFd(fileno(ifP), "SVG_IMAGE", NULL, 0);    if (xmlReaderP) {        processDocument(xmlReaderP, stdout);        /* xmlTextReaderIsValid() does not appear to work.  It always says           the document is invalid        */        xmlFreeTextReader(xmlReaderP);    } else        pm_error("Failed to create xmlReader");    xmlCleanupParser();    return 0;}

// ref: http://xmlsoft.org/examples/index.html#reader1.cvoid xml::xmlreader(const  char *filename) {	LIBXML_TEST_VERSION	xmlTextReaderPtr reader;	if((reader = xmlReaderForFile(filename, NULL, 0)) != NULL) {		while(xmlTextReaderRead(reader) == 1) {			const xmlChar *name;			const xmlChar *value;			if((name = xmlTextReaderConstName(reader)) != NULL) {				value = xmlTextReaderConstValue(reader);				cout << xmlTextReaderDepth(reader)					<< " " << xmlTextReaderNodeType(reader)					<< " " << name					<< " " << xmlTextReaderIsEmptyElement(reader)					<< " " << xmlTextReaderHasValue(reader);				if(value != NULL)					cout << endl;				cout.flush();			}		}		xmlFreeTextReader(reader);	}	xmlCleanupParser();}