/* {{{ 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 void
xml_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 void
parser_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 void
raptor_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(¤tContext);
error = EPUB3ParseXMLReaderNodeForNCX(epub, reader, ¤tContext);
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 void
streamFile(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;
}
int
main(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.c
void 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();
}
