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

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 voidprocessNode(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));    }}

gintxml_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 voidprocessNode(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 &section_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 voidprocessTopLevelElement(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 voidprocessTopLevelNode(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;}

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