//
// 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;
}
bool XMLConversion::GetContentDouble(double& value)
{
xmlTextReaderRead(_reader);
const xmlChar* pvalue = xmlTextReaderConstValue(_reader);
if(!pvalue)
return false;
value = strtod((const char*)pvalue,NULL);
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 xmlDocPtr
extractFile(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 void
process_properties (xmlTextReaderPtr reader,
GtkSourceLanguage *language)
{
xmlNodePtr child;
xmlNodePtr node = NULL;
while (node == NULL && xmlTextReaderRead (reader) == 1)
{
xmlChar *name;
if (xmlTextReaderNodeType (reader) != 1)
continue;
name = xmlTextReaderName (reader);
if (xmlStrcmp (name, BAD_CAST "metadata") != 0)
{
xmlFree (name);
continue;
}
xmlFree (name);
node = xmlTextReaderExpand (reader);
if (node == NULL)
return;
}
if (node == NULL)
return;
for (child = node->children; child != NULL; child = child->next)
{
xmlChar *name;
xmlChar *content;
if (child->type != XML_ELEMENT_NODE ||
xmlStrcmp (child->name, BAD_CAST "property") != 0)
continue;
name = xmlGetProp (child, BAD_CAST "name");
content = xmlNodeGetContent (child);
if (name != NULL && content != NULL)
g_hash_table_insert (language->priv->properties,
g_strdup ((gchar *) name),
g_strdup ((gchar *) content));
xmlFree (name);
xmlFree (content);
}
}
static void
biji_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;
}
void
PTXReader::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;
}
}
