cxTypes cxHashRootReadArray(cxHashRoot root,xmlTextReaderPtr reader)
{
cxTypes types = cxArrayTypesCreate();
int depth = xmlTextReaderDepth(reader);
while(xmlTextReaderRead(reader) && depth != xmlTextReaderDepth(reader)){
if(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT){
continue;
}
cxAny value = NULL;
cxConstChars temp = cxXMLReadElementName(reader);
if(ELEMENT_IS_TYPE(cxString)){
cxTypes types = cxHashRootReadString(root, reader);
value = types != NULL ? types->any : NULL;
} else if(ELEMENT_IS_TYPE(cxHash)){
cxTypes types = cxHashRootReadHash(root, reader);
value = types != NULL ? types->any : NULL;
} else if(ELEMENT_IS_TYPE(cxArray)){
cxTypes types = cxHashRootReadArray(root, reader);
value = types != NULL ? types->any : NULL;
} else {
value = cxReadValues(root, temp, reader);
}
if(value != NULL){
cxArrayAppend(types->any, value);
}
}
return types;
}
/**
* Reads a SubnetConfigs from XML. The reader is assumed to be at the start element.
*
* @return the SubnetConfigs, or NULL in case of error.
*/
static struct full_ns0_subnetConfigs *xmlTextReaderReadNs0SubnetConfigsType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct full_ns0_subnetConfigs *_subnetConfigs = calloc(1, sizeof(struct full_ns0_subnetConfigs));
if (xmlTextReaderIsEmptyElement(reader) == 0) {
depth = xmlTextReaderDepth(reader);//track the depth.
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
while (xmlTextReaderDepth(reader) > depth) {
if (status < 1) {
//panic: XML read error.
#if DEBUG_ENUNCIATE
printf("Failure to advance to next child element.\n");
#endif
freeNs0SubnetConfigsType(_subnetConfigs);
free(_subnetConfigs);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "subnetConfig", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}subnetConfig of type {}subnetConfig.\n");
#endif
_child_accessor = xmlTextReaderReadNs0SubnetConfigType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}subnetConfig of type {}subnetConfig.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0SubnetConfigsType(_subnetConfigs);
free(_subnetConfigs);
return NULL;
}
_subnetConfigs->subnetConfig = realloc(_subnetConfigs->subnetConfig, (_subnetConfigs->_sizeof_subnetConfig + 1) * sizeof(struct full_ns0_subnetConfig));
memcpy(&(_subnetConfigs->subnetConfig[_subnetConfigs->_sizeof_subnetConfig++]), _child_accessor, sizeof(struct full_ns0_subnetConfig));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {}subnetConfigs. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {}subnetConfigs. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _subnetConfigs;
}
static int parse_properties(xmlTextReaderPtr reader, tmx_property **prop_headadr) {
tmx_property *res;
int curr_depth;
const char *name;
curr_depth = xmlTextReaderDepth(reader);
/* Parse each child */
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "property")) {
if (!(res = alloc_prop())) return 0;
res->next = *prop_headadr;
*prop_headadr = res;
if (!parse_property(reader, res)) return 0;
} else { /* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
/**
* Gets the title from the parser. Returns true if success, false if EOF
*/
bool getTitle (xmlTextReaderPtr xmlReader, int *moreWiki, GString* articleTitle) {
// loops until it finds the title tag or EOF
// one tree at a time, skips sub trees
while (1 == *moreWiki) {
// loops until xmlReader is back down to level 2
// one node at a time
while (1 == *moreWiki && 2 > xmlTextReaderDepth (xmlReader)) {
*moreWiki = xmlTextReaderRead (xmlReader);
}
// loops until it finds the title tag, end of subtree or EOF
// one tree at a time, skips sub trees
while (1 == *moreWiki && 2 <= xmlTextReaderDepth (xmlReader)) {
if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "title")) {
*moreWiki = xmlTextReaderRead(xmlReader);
articleTitle = g_string_assign(articleTitle, (gchar *) xmlTextReaderConstValue(xmlReader));
return (1 == *moreWiki);
}
*moreWiki = xmlTextReaderNext(xmlReader);
}
}
// this should only happen at the end of the document
return (1 == *moreWiki);
}
/* -1 error; 0 OK */
int oscap_parser_text_value(xmlTextReaderPtr reader, oscap_xml_value_consumer consumer, void *user)
{
int depth = xmlTextReaderDepth(reader);
bool has_value = false;
int ret = 0;
if (xmlTextReaderIsEmptyElement(reader)) {
return ret;
}
xmlTextReaderRead(reader);
while (xmlTextReaderDepth(reader) > depth) {
int nodetype = xmlTextReaderNodeType(reader);
if (nodetype == XML_READER_TYPE_CDATA || nodetype == XML_READER_TYPE_TEXT) {
char *value = (char *)xmlTextReaderValue(reader);
(*consumer) (value, user);
oscap_free(value);
has_value = true;
}
if (xmlTextReaderRead(reader) != 1) {
ret = -1;
break;
}
}
if (!has_value)
(*consumer) ("", user);
return ret;
}
int myProcessNode(xmlTextReaderPtr reader,int *lastdepth, int *readnext ,int *mode,char** savehere,int *i)
{
const xmlChar *name, *value;
name = xmlTextReaderConstName(reader);
if (name == NULL)
name = BAD_CAST "--";
value = xmlTextReaderConstValue(reader);
if(*readnext == 1 && *lastdepth == xmlTextReaderDepth(reader)-1)
{
if(*i <6)
{
sprintf(savehere[*i],"%s",value);
*i=*i + 1;
}
else
return 1;
}
else if(0==strncmp(name,"title",5) && *mode>0)
{
*readnext = 1;
*lastdepth = xmlTextReaderDepth(reader);
if(*mode==1)
*mode=0;//now look for items
}
else if(0==strncmp(name,"item",4)||0==strncmp(name,"entry",5))
{ //find some news feeds
*mode=2;
}
else
*readnext = 0;
return 0;
}
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;
}
/**
* processNode:
* @reader: the xmlReader
*
* Dump information about the current node
*/
static void
processNode(xmlTextReaderPtr reader) {
const xmlChar *name, *value;
int nodetype;
static char spaces[33]=" ";
name = xmlTextReaderConstName(reader);
if (name == NULL)
name = BAD_CAST "--";
value = xmlTextReaderConstValue(reader);
nodetype = xmlTextReaderNodeType(reader);
if (nodetype!=14 && nodetype!=15) // Skip all text bodies and "/" entities.
{
#ifdef DETAILS
printf("%s%d %d %s %d %d",
(spaces + (32-2*xmlTextReaderDepth(reader))),
xmlTextReaderDepth(reader),
nodetype,
name,
xmlTextReaderIsEmptyElement(reader),
xmlTextReaderHasValue(reader));
#else
printf("%s%s", (spaces + (32-2*xmlTextReaderDepth(reader))), name);
#endif
if (value == NULL)
printf("\n");
else {
if (xmlStrlen(value) > 40)
printf(" %.40s...\n", value);
else
printf(" %s\n", value);
}
}
if (nodetype==1) // Element - possibly has attributes
{
while (xmlTextReaderMoveToNextAttribute(reader))
printf("%s Attrib: %s=\"%s\"\n",
(spaces + (32-2*xmlTextReaderDepth(reader))),
xmlTextReaderConstName(reader),
xmlTextReaderConstValue(reader));
}
}
gint
xml_reader_get_depth (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER(reader), -1);
return xmlTextReaderDepth (reader->xml);
}
// Return value: -1 if "state end found", otherwise depth of node
int XMLReader::gobbleUntilStartElement(xmlTextReaderPtr &reader, const string &name)
{
bool state_begin_found = false;
bool state_end_found = false;
int depth = -1;
int r = xmlTextReaderRead(reader);
while ( (r==1) && (!state_begin_found) && (!state_end_found) ) {
const int type = xmlTextReaderNodeType( reader );
depth = xmlTextReaderDepth(reader);
xmlChar *localName = xmlTextReaderLocalName(reader);
if (type==1) {
state_begin_found = (xmlStrEqual(localName, BAD_CAST name.c_str()) != 0);
if (state_begin_found)
state_end_found = (xmlTextReaderIsEmptyElement(reader) != 0);
} else
if (type==15) {
state_end_found = (xmlStrEqual(localName, BAD_CAST name.c_str()) != 0);
}
xmlFree(localName);
r=xmlTextReaderRead(reader);
}
if ( r==0)
state_end_found = true; // It makes no sense to have gotten to the beginning with r==0 at the same time
return state_begin_found && (!state_end_found) ? depth : -1;
}
/**
* processNode:
* @reader: the xmlReader
*
* Dump information about the current node
*/
static void
processNode(xmlTextReaderPtr reader) {
const xmlChar *name, *value;
name = xmlTextReaderConstName(reader);
if (name == NULL)
name = BAD_CAST "--";
value = xmlTextReaderConstValue(reader);
printf("Depth: %d; Type: %d; Name: %s; %d|%d",
xmlTextReaderDepth(reader),
xmlTextReaderNodeType(reader),
name,
xmlTextReaderIsEmptyElement(reader),
xmlTextReaderHasValue(reader));
if (value == NULL)
printf("\n");
else {
if (xmlStrlen(value) > 40)
printf("|-> %.40s...\n", value);
else
printf(" %s\n", value);
}
}
bool oscap_to_start_element(xmlTextReaderPtr reader, int depth)
{
//int olddepth = xmlTextReaderDepth(reader);
while (xmlTextReaderDepth(reader) >= depth) {
switch (xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_ELEMENT:
if (xmlTextReaderDepth(reader) == depth)
return true;
default:
break;
}
if (xmlTextReaderRead(reader) != 1)
break;
}
return false;
}
static void cxHashRootReadDB(cxDBEnv env,cxHashRoot root,xmlTextReaderPtr reader)
{
cxReaderAttrInfo *info = cxReaderAttrInfoMake(reader, root, env);
int depth = xmlTextReaderDepth(reader);
while(xmlTextReaderRead(reader) && depth != xmlTextReaderDepth(reader)){
if(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT){
continue;
}
cxConstChars temp = cxXMLReadElementName(reader);
if(!ELEMENT_IS_TYPE(cxDB)){
continue;
}
cxConstChars file = cxXMLAttr(reader,"file");
cxConstChars table = cxXMLAttr(reader,"table");
cxConstChars type = cxXMLAttr(reader,"type");
cxConstChars sid = cxXMLAttr(reader,"id");
cxConstChars path = cxXMLAttr(reader,"path");
//assert file copy ->to document
cxBool copy = cxXMLReadBoolAttr(info, "copy", false);
if(copy && file != NULL){
cxCopyFile(file, NULL, NULL);
}
cxBool rdonly = cxXMLReadBoolAttr(info, "rdonly", false);
if(sid == NULL){
CX_WARN("db id not set,will can't add dataset");
}
cxString sfile = NULL;
if(cxConstCharsEqu(path, "assert")){
sfile = cxAssetsPath(file);
//assert must set true
rdonly = true;
}else if(cxConstCharsEqu(path, "document")){
sfile = cxDocumentPath(file);
}else{
CX_ERROR("must set path assert or document");
}
cxAny db = NULL;
if(file != NULL && table != NULL && type != NULL){
db = cxDBCreate(env, cxStringBody(sfile), table, type, rdonly);
}
if(db != NULL && sid != NULL){
cxHashSet(root->items, cxHashStrKey(sid), cxDBTypesCreate(db));
}else{
CX_ERROR("open dbenv type %s,db %s:%s failed",cxStringBody(env->type),file,table);
}
}
}
int BEXMLTextReader::depth()
{
int depth = xmlTextReaderDepth ( reader );
if ( depth == kBE_XMLReaderError ) {
throw BEXMLReaderInterface_Exception ( last_error() );
}
return depth;
}
static int parse_tile(xmlTextReaderPtr reader, tmx_tile **tile_headadr, const char *filename) {
tmx_tile *res = NULL;
int curr_depth;
const char *name;
char *value;
curr_depth = xmlTextReaderDepth(reader);
if (!(res = alloc_tile())) return 0;
while (*tile_headadr) {
tile_headadr = &((*tile_headadr)->next);
}
*tile_headadr = res;
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"id"))) { /* id */
res->id = atoi(value);
tmx_free_func(value);
}
else {
tmx_err(E_MISSEL, "xml parser: missing 'id' attribute in the 'tile' element");
return 0;
}
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(res->properties))) return 0;
}
else if (!strcmp(name, "image")) {
if (!parse_image(reader, &(res->image), 0, filename)) return 0;
}
else {
/* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
xmlNodePtr ProtoXml::IterParser::GetNext()
{
//TRACE("enter ProtoXml::IterParser::GetNext() prev_node:%s\n", prev_node ? (const char*)prev_node->name : "(null)");
int result;
// If we didn't just return a "prev_node", then read the
// very next sequential node w/ xmlTextReaderRead(), else
// skip entire "prev_node" sub-tree w/ xmlTextReaderNext()
if (NULL == prev_node)
result = xmlTextReaderRead(reader_ptr);
else
result = xmlTextReaderNext(reader_ptr);
prev_node = NULL;
switch (result)
{
case 0:
return NULL;
case -1:
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead error!\n");
return NULL;
default:
break;
}
do
{
int nodeType = xmlTextReaderNodeType(reader_ptr);
if (XML_READER_TYPE_ELEMENT != nodeType)
continue;
const char* nodeName = (const char*)xmlTextReaderConstLocalName(reader_ptr);
if (NULL == nodeName)
{
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderConstLocalName() error\n");
return NULL;
}
int nodeDepth = xmlTextReaderDepth(reader_ptr);
if (nodeDepth < 0)
{
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderDepth() error\n");
return NULL;
}
if (!IterFilterBase::UpdateCurrentPath(nodeDepth, nodeName))
{
PLOG(PL_WARN, "ProtoXml::IterParser::GetNext() error: unable to update current path\n");
continue;
}
if (!IterFilterBase::IsMatch())
continue; // no match, so continue
prev_node = xmlTextReaderExpand(reader_ptr);
if (NULL == prev_node)
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderExpand() error!\n");
return prev_node;
} while ((result = xmlTextReaderRead(reader_ptr)) > 0);
if (result < 0)
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead() error!\n");
return NULL;
} // end ProtoXml::IterParser::GetNext()
/*
* call-seq:
* depth
*
* Get the depth of the node
*/
static VALUE depth(VALUE self)
{
xmlTextReaderPtr reader;
Data_Get_Struct(self, xmlTextReader, reader);
int depth = xmlTextReaderDepth(reader);
if(depth == -1) return Qnil;
return INT2NUM(depth);
}
bool sc_xmltv_check_current_reader_node(xmlTextReaderPtr reader, int node_type, const char *node_name, int node_depth) {
xmlChar *name = NULL;
bool result;
name = xmlTextReaderName(reader);
result = !xmlTextReaderIsEmptyElement(reader) &&
xmlTextReaderNodeType(reader) == node_type &&
(!xmlStrcmp(name, (const xmlChar *) node_name)) &&
xmlTextReaderDepth(reader) == node_depth;
xmlFree(name);
return result;
}
/**
* processNode:
* @reader: the xmlReader
*
* Dump information about the current node
*/
static void processNode(xmlTextReaderPtr reader)
{
int depth, type;
type = xmlTextReaderNodeType(reader);
if ((type == XML_ELEMENT_DECL) || (type == XML_DTD_NODE))
return;
depth = xmlTextReaderDepth(reader);
if ((type == XML_ELEMENT_NODE) && (depth == 2))
printf("\n");
if (2 == depth)
printf("\t");
else if (3 == depth)
printf("\t\t");
xmlNodePtr node = xmlTextReaderCurrentNode(reader);
if (xmlTextReaderNodeType(reader) == XML_ELEMENT_NODE && node && node->properties) {
xmlAttr *attribute = node->properties;
while (attribute && attribute->name && attribute->children) {
tag = xmlNodeListGetString(node->doc, attribute->children, 1);
printf ("%s%c", tag, (depth == 2) ? '\n' : ':');
bdaddr = strtoba((const char *)tag);
if (bdaddr)
add_remote_device(bdaddr);
attribute = attribute->next;
/* tag name is what we need */
break;
}
}
if (xmlTextReaderNodeType(reader) == XML_TEXT_NODE) {
if (xmlStrstr((xmlChar *)"Service", tag))
parse_services(reader);
else if (xmlStrstr((xmlChar *)"HidDescriptor", tag))
parse_hid_descriptor(reader);
else if (xmlStrstr((xmlChar *)"HogpRpt", tag))
parse_hogp(reader);
else if (xmlStrstr((xmlChar *)"GattAttrs", tag))
parse_gatt_attribute(reader);
else if (xmlStrstr((xmlChar *)"DevClass", tag))
parse_dev_class(reader);
else if (xmlStrstr((xmlChar *)"Timestamp", tag))
parse_timestamp(reader);
else if (xmlStrstr((xmlChar *)"Address", tag))
parse_bdaddr(reader);
else
parse_text_node(reader);
}
}
int cDataMap::processData(xmlTextReaderPtr reader)
{
// element callback from read_xmlfile
// args: pointer to the xmlTextreader
xmlNodePtr node ;
xmlChar *content;
string value;
int epgdataid;
int retval;
// get name, type and depth in the xml structure
string name = string((char *)xmlTextReaderConstName(reader));
int type = xmlTextReaderNodeType(reader) ;
int depth = xmlTextReaderDepth(reader) ;
// get ca0/ca1 or g0/g1 depending which file we read
if (type == XML_READER_TYPE_ELEMENT && depth == 2 && (name.compare("ca0") == 0)) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
} else if (type == XML_READER_TYPE_ELEMENT && depth == 2 && ( name.compare("g0") == 0 )) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
}
return 0 ;
}
int oscap_element_depth(xmlTextReaderPtr reader)
{
int depth = xmlTextReaderDepth(reader);
switch (xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_ATTRIBUTE:
case XML_READER_TYPE_TEXT:
case XML_READER_TYPE_ENTITY_REFERENCE:
return depth - 1;
default:
return depth;
}
}
/* reader:depth() */
static int xmlreader_depth(lua_State *L) {
xmlreader xr = check_xmlreader(L, 1);
int ret = xmlTextReaderDepth(xr);
if (ret != -1) {
lua_pushinteger(L, ret);
return 1;
} else {
lua_pushnil(L);
xmlreader_pusherror(L);
return 2;
}
}
// Return value: true if next node has a sub-tree
bool XMLReader::nextTypeContainsChildren(xmlTextReaderPtr &reader, const string §ion_name, string &name, string &value,
bool &state_end_found, int &depth)
{
state_end_found = false;
depth = -1;
int r = 1;
bool done=false, subtree_found=false;
while ( (r==1) && (!state_end_found) && (!done) ) {
xmlChar *localName=xmlTextReaderLocalName(reader), *localValue=NULL;
depth = xmlTextReaderDepth(reader);
switch ( xmlTextReaderNodeType( reader ) ) {
case 15:
state_end_found = (xmlStrEqual(localName, BAD_CAST section_name.c_str()) != 0);
break;
case 1:
r = xmlTextReaderRead(reader);
if (r==1) {
switch ( xmlTextReaderNodeType(reader) ) {
case 3:
if (!xmlTextReaderHasValue(reader))
throw std::runtime_error("Huh?! Expected a value now. This xml should maybe not be valid?!");
localValue = xmlTextReaderValue(reader);
name = string((char *)localName);
value = string((char *)localValue);
r = xmlTextReaderRead(reader);
done = true;
break;
case 14:
if (!xmlTextReaderHasValue(reader))
throw std::runtime_error("Huh?! Expected a value now. This xml should maybe not be valid?!");
localValue = xmlTextReaderValue(reader);
name = string((char *)localName);
value = string((char *)localValue);
r = xmlTextReaderRead(reader);
done = true;
subtree_found = true;
}
}
} // end of switch (type)
xmlFree(localName);
if (localValue!=NULL)
xmlFree(localValue);
if (!done)
r=xmlTextReaderRead(reader);
}
if (r==0)
state_end_found = true; // If r==0, it makes no sense to scan for more stuff...
return subtree_found;
}
static response_element_t *
parse_propfind_response (xmlTextReaderPtr reader)
{
parser_strings_t strings;
response_element_t *elements;
/* get internalized versions of some strings to avoid strcmp while
* parsing */
strings.multistatus
= xmlTextReaderConstString (reader, BAD_CAST "multistatus");
strings.dav = xmlTextReaderConstString (reader, BAD_CAST "DAV:");
strings.href = xmlTextReaderConstString (reader, BAD_CAST "href");
strings.response = xmlTextReaderConstString (reader, BAD_CAST "response");
strings.propstat = xmlTextReaderConstString (reader, BAD_CAST "propstat");
strings.prop = xmlTextReaderConstString (reader, BAD_CAST "prop");
strings.getetag = xmlTextReaderConstString (reader, BAD_CAST "getetag");
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT) {
}
if (xmlTextReaderConstLocalName (reader) != strings.multistatus
|| xmlTextReaderConstNamespaceUri (reader) != strings.dav) {
g_warning ("webdav PROPFIND result is not <DAV:multistatus>");
return NULL;
}
elements = NULL;
/* parse all DAV:response tags */
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderDepth (reader) > 0) {
response_element_t *element;
if (xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT)
continue;
if (xmlTextReaderConstLocalName (reader) != strings.response
|| xmlTextReaderConstNamespaceUri (reader) != strings.dav)
continue;
element = parse_response_tag (&strings, reader);
if (element == NULL)
continue;
element->next = elements;
elements = element;
}
return elements;
}
static void
processTopLevelElement(xmlTextReaderPtr const xmlReaderP,
FILE * const ofP) {
const char * const nodeName = currentNodeName(xmlReaderP);
assert(xmlTextReaderNodeType(xmlReaderP) == XML_READER_TYPE_ELEMENT);
assert(xmlTextReaderDepth(xmlReaderP) == 0);
if (!streq(nodeName, "svg"))
pm_error("Not an SVG image. This XML document consists of "
"a <%s> element, whereas an SVG image is an <svg> "
"element.", nodeName);
else
processSvgElement(xmlReaderP, ofP);
}
static void
processTopLevelNode(xmlTextReaderPtr const xmlReaderP,
FILE * const ofP) {
unsigned int const depth = xmlTextReaderDepth(xmlReaderP);
xmlReaderTypes const nodeType = xmlTextReaderNodeType(xmlReaderP);
assert(depth == 0);
switch (nodeType) {
case XML_READER_TYPE_ELEMENT:
processTopLevelElement(xmlReaderP, ofP);
break;
default:
/* Just ignore whatever this is */
break;
}
}
void sc_xmltv_parse_credits(xmlTextReaderPtr reader, sc_list_t **list) {
sc_xmltv_credit_t *cred = NULL;
int ret;
xmlChar *val;
sc_xmltv_credit_type_t type;
sc_list_node_t *node = NULL;
for (ret = xmlTextReaderRead(reader); ret == 1; ret = xmlTextReaderRead(reader)) {
if (sc_xmltv_check_current_reader_node(reader, XML_READER_TYPE_END_ELEMENT, SC_XMLTV_CREDIT_NAME,
SC_XMLTV_CREDIT_DEPTH)) {
break;
}
val = xmlTextReaderName(reader);
type = SC_XMLTV_CREDIT_TYPE_UNKNOWN;
if ((!xmlStrcmp(val, (const xmlChar *) "actor"))) type = SC_XMLTV_CREDIT_TYPE_ACTOR;
if ((!xmlStrcmp(val, (const xmlChar *) "director"))) type = SC_XMLTV_CREDIT_TYPE_DIRECTOR;
if ((!xmlStrcmp(val, (const xmlChar *) "guest"))) type = SC_XMLTV_CREDIT_TYPE_GUEST;
if ((!xmlStrcmp(val, (const xmlChar *) "presenter"))) type = SC_XMLTV_CREDIT_TYPE_PRESENTER;
if ((!xmlStrcmp(val, (const xmlChar *) "producer"))) type = SC_XMLTV_CREDIT_TYPE_PRODUCER;
if ((!xmlStrcmp(val, (const xmlChar *) "writer"))) type = SC_XMLTV_CREDIT_TYPE_WRITER;
xmlFree(val);
if (!xmlTextReaderIsEmptyElement(reader) &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT &&
type > 0 &&
xmlTextReaderDepth(reader) == SC_XMLTV_CREDIT_DEPTH + 1) {
cred = (sc_xmltv_credit_t *) sc_xmltv_create(SC_XMLTV_CREDIT);
cred->type = type;
sc_xmltv_get_reader_element_value(reader, &cred->name);
node = sc_list_node_create(cred);
sc_list_node_append(*list, node);
}
}
// node = NULL;
}
static gboolean
gstyle_palette_xml_get_header (xmlTextReaderPtr reader,
gchar **id,
gchar **name,
gchar **domain)
{
g_assert (reader != NULL);
g_assert (id != NULL);
g_assert (name != NULL);
g_assert (domain != NULL);
*id = *name = *domain = NULL;
if (xmlTextReaderRead(reader) == 1 &&
xmlTextReaderNodeType (reader) == XML_READER_TYPE_ELEMENT &&
!g_strcmp0 (XML_TO_CHAR (xmlTextReaderConstName (reader)), "palette") &&
xmlTextReaderDepth (reader) == 0)
{
*id = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("id")));
*name = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("name")));
if (*name == NULL)
{
*name = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("_name")));
*domain = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("gettext-domain")));
}
if (gstyle_str_empty0 (*id) || gstyle_utf8_is_spaces (*id))
{
g_warning ("Palette '%s'has an empty or NULL id\n", *name);
return FALSE;
}
if (gstyle_utf8_is_spaces (*name))
g_clear_pointer (name, g_free);
}
return (*id != NULL);
}
static GstyleColor *
gstyle_palette_xml_get_color (xmlTextReaderPtr reader)
{
GstyleColor *color = NULL;
g_autofree gchar *name;
g_autofree gchar *value;
g_assert (reader != NULL);
if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_ELEMENT &&
!g_strcmp0 (XML_TO_CHAR (xmlTextReaderConstName (reader)), "color") &&
xmlTextReaderDepth (reader) == 1)
{
name = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("name")));
if (gstyle_utf8_is_spaces (name))
g_clear_pointer (&name, g_free);
value = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("value")));
if (!gstyle_str_empty0 (value))
color = gstyle_color_new_from_string (name, value);
}
return color;
}
// 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();
}
