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