/* {{{ proto bool XMLReader::next([string localname]) Moves the position of the current instance to the next node in the stream. */ PHP_METHOD(xmlreader, next) { zval *id; int retval; size_t name_len=0; xmlreader_object *intern; char *name = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &name, &name_len) == FAILURE) { return; } id = ZEND_THIS; intern = Z_XMLREADER_P(id); if (intern != NULL && intern->ptr != NULL) { retval = xmlTextReaderNext(intern->ptr); while (name != NULL && retval == 1) { if (xmlStrEqual(xmlTextReaderConstLocalName(intern->ptr), (xmlChar *)name)) { RETURN_TRUE; } retval = xmlTextReaderNext(intern->ptr); } if (retval == -1) { RETURN_FALSE; } else { RETURN_BOOL(retval); } } php_error_docref(NULL, E_WARNING, "Load Data before trying to read"); RETURN_FALSE; }
bool HHVM_METHOD(XMLReader, next, const Variant& localname /*= null_variant*/) { auto* data = Native::data<XMLReader>(this_); const String& str_localname = localname.isNull() ? null_string : localname.toString(); SYNC_VM_REGS_SCOPED(); if (data->m_ptr) { int ret = xmlTextReaderNext(data->m_ptr); while (!str_localname.empty() && ret == 1) { if (xmlStrEqual(xmlTextReaderConstLocalName(data->m_ptr), (xmlChar *)str_localname.data())) { return true; } ret = xmlTextReaderNext(data->m_ptr); } if (ret == -1) { raise_warning("An Error Occurred while reading"); return false; } else { return ret; } } raise_warning("Load Data before trying to read"); return false; }
static GWeatherTimezone * parse_timezone (GWeatherParser *parser) { GWeatherTimezone *zone = NULL; char *id = NULL; char *name = NULL; int offset = 0, dst_offset = 0; gboolean has_dst = FALSE; id = (char *) xmlTextReaderGetAttribute (parser->xml, (xmlChar *) "id"); if (!id) { xmlTextReaderNext (parser->xml); return NULL; } if (!xmlTextReaderIsEmptyElement (parser->xml)) { if (xmlTextReaderRead (parser->xml) != 1) { xmlFree (id); return NULL; } while (xmlTextReaderNodeType (parser->xml) != XML_READER_TYPE_END_ELEMENT) { if (xmlTextReaderNodeType (parser->xml) != XML_READER_TYPE_ELEMENT) { if (xmlTextReaderRead (parser->xml) != 1) break; continue; } if (!strcmp ((const char *) xmlTextReaderConstName (parser->xml), "name")) name = _gweather_parser_get_localized_value (parser); else { if (xmlTextReaderNext (parser->xml) != 1) break; } } } if (parse_tzdata (id, parser->year_start, parser->year_end, &offset, &has_dst, &dst_offset)) { zone = g_slice_new0 (GWeatherTimezone); zone->ref_count = 1; zone->id = g_strdup (id); zone->name = name; zone->offset = offset; zone->has_dst = has_dst; zone->dst_offset = dst_offset; g_hash_table_insert (parser->timezone_cache, zone->id, zone); name = NULL; } g_free (name); xmlFree (id); return zone; }
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 ; }
/* 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; }
static int xmlTextReaderSkipElement(xmlTextReaderPtr reader) { int status = xmlTextReaderNext(reader); while (status && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT && xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT) { status = xmlTextReaderRead(reader); } return status; }
gboolean xml_reader_read_to_next (XmlReader *reader) { g_return_val_if_fail (XML_IS_READER (reader), FALSE); return (xmlTextReaderNext (reader->xml) == 1); }
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); }
void XmlTextReader::Skip() const { XmlCheck(xmlTextReaderNext(ToReader(m_p))); /*!!! int depth = Depth(); while (Read() && Depth()>depth) ; if (Depth() > depth) throw runtime_error("invalid XML");*/ }
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()
//Parse dl values void parse_ac_settings(int DevNameIndex, char *filename) { xmlTextReaderPtr reader; int ret; reader = xmlReaderForFile(filename, NULL, XML_PARSE_NOWARNING | XML_PARSE_NOERROR); /* Dont validate with the DTD */ // Init some variables (-1 means no settings in xml file) DevNames[DevNameIndex].dl_launch_ind = -1; DevNames[DevNameIndex].kill_thr_ind = -1; DevNames[DevNameIndex].flight_altitude_ind = -1; xmlChar *name, *value; if (reader != NULL) { ret = xmlTextReaderRead(reader); int valind = 0; while (ret == 1) { name = xmlTextReaderName(reader); if (name == NULL) { name = xmlStrdup(BAD_CAST "--"); } if (xmlStrEqual(name, (const xmlChar *)"dl_setting")) { xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"var"); value = xmlTextReaderValue(reader); if (xmlStrEqual(value, (const xmlChar *)"launch")) { DevNames[DevNameIndex].dl_launch_ind=valind; } if (xmlStrEqual(value, (const xmlChar *)"kill_throttle")) { DevNames[DevNameIndex].kill_thr_ind=valind; } if (xmlStrEqual(value, (const xmlChar *)"flight_altitude")) { DevNames[DevNameIndex].flight_altitude_ind=valind; } xmlTextReaderNext(reader); valind+=1; } ret = xmlTextReaderRead(reader); } xmlFreeTextReader(reader); if (ret != 0) { if (verbose) { printf("App Server: %s : failed to parse\n", filename); fflush(stdout); } } } else { if (verbose) { printf("App Server: Unable to open %s\n", filename); fflush(stdout); } } }
bool c_XMLReader::t_next(const String& localname /*= null_string*/) { if (m_ptr) { int ret = xmlTextReaderNext(m_ptr); while (!localname.empty() && ret == 1) { if (xmlStrEqual(xmlTextReaderConstLocalName(m_ptr), (xmlChar *)localname.data())) { return true; } ret = xmlTextReaderNext(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; }
/** * Parses the XML tree until it finds an article body, and sets the article body to what is found in the XML */ void getArticleBody (xmlTextReaderPtr xmlReader, int *moreWiki, GString* articleBody) { *moreWiki = xmlTextReaderRead(xmlReader); // at level 2, need to drop to 3 // loops until it finds the text tag or EOF // one tree at a time, skips sub trees do {*moreWiki = xmlTextReaderNext(xmlReader);} while (1 == *moreWiki && !(xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "text"))); *moreWiki = xmlTextReaderRead(xmlReader); articleBody = g_string_assign(articleBody, (gchar *) xmlTextReaderConstValue(xmlReader)); }
/* {{{ proto boolean XMLReader::next([string localname]) Moves the position of the current instance to the next node in the stream. */ PHP_METHOD(xmlreader, next) { zval *id; int retval; size_t name_len=0; xmlreader_object *intern; char *name = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &name, &name_len) == FAILURE) { return; } id = getThis(); intern = Z_XMLREADER_P(id); if (intern != NULL && intern->ptr != NULL) { #if LIBXML_VERSION <= 20617 /* Bug in libxml prevents a next in certain cases when positioned on end of element */ if (xmlTextReaderNodeType(intern->ptr) == XML_READER_TYPE_END_ELEMENT) { retval = xmlTextReaderRead(intern->ptr); } else #endif retval = xmlTextReaderNext(intern->ptr); while (name != NULL && retval == 1) { if (xmlStrEqual(xmlTextReaderConstLocalName(intern->ptr), (xmlChar *)name)) { RETURN_TRUE; } retval = xmlTextReaderNext(intern->ptr); } if (retval == -1) { RETURN_FALSE; } else { RETURN_BOOL(retval); } } php_error_docref(NULL, E_WARNING, "Load Data before trying to read"); RETURN_FALSE; }
/** * Determines if the page is a redirect * returns true if the page is a redirect */ bool isNotRedirect (xmlTextReaderPtr xmlReader, int *moreWiki) { // loops until it finds the redirect tag, revision tag, or EOF // one tree at a time, skips sub trees while (1 == *moreWiki) { // printf("loc31\n"); if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "revision")) { return TRUE;} // drop out of loop, assign body else if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "redirect")) { return FALSE;} //redirect tag, to to next page *moreWiki = xmlTextReaderNext(xmlReader); } // this should never happen return FALSE; }
/** * Determines if the namespace is 0 (namespace of articles) * returns true if the NS is 0 */ bool isNameSpaceZero (xmlTextReaderPtr xmlReader, int *moreWiki) { // loops until it finds the NS tag or EOF // one tree at a time, skips sub trees while (1 == *moreWiki) { *moreWiki = xmlTextReaderNext(xmlReader); //printf("loc21\n"); if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "ns")) { break;} } *moreWiki = xmlTextReaderRead(xmlReader); return (xmlStrEqual(xmlTextReaderConstValue(xmlReader), (const unsigned char *) "0") && (1 == *moreWiki)); }
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; }
static gboolean read_service_file (xmlTextReaderPtr reader, AgService *service) { const xmlChar *name; int ret; ret = xmlTextReaderRead (reader); while (ret == 1) { name = xmlTextReaderConstName (reader); if (G_LIKELY (name && strcmp ((const gchar *)name, "service") == 0)) { return parse_service (reader, service); } ret = xmlTextReaderNext (reader); } return FALSE; }
daeElementRef daeLIBXMLPlugin::nextElement(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader) { int ret; // Process the current element // Skip over things we don't understand while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT) { ret = xmlTextReaderRead(reader); if(ret != 1) return(NULL); } // Create the element that we found daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader)); if(!element) { const xmlChar * mine =xmlTextReaderConstName(reader); char err[256]; memset( err, 0, 256 ); #if LIBXML_VERSION >= 20620 sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine); #endif daeErrorHandler::get()->handleWarning( err ); if ( xmlTextReaderNext(reader) == -1 ) { int x = 12312412; } return NULL; } int currentDepth = xmlTextReaderDepth(reader); //try and read attributes readAttributes( element, reader ); ret = xmlTextReaderRead(reader); // If we're out of data, return the element if(ret != 1) return(element); // Read all the tags that are part of this tag bool trew = true; while(trew) { int thisType = xmlTextReaderNodeType(reader); if(thisType == XML_READER_TYPE_ELEMENT) { // Is the new element at the same depth as this one? if(currentDepth == xmlTextReaderDepth(reader)) { // Same depth means the current element ended in a /> so this is a sibling // so we return and let our parent process it. return(element); } else { // The element is a child of this one, so we recurse if(!element->placeElement(nextElement(element->getMeta(), reader))) { char err[256]; memset( err, 0, 256 ); #if LIBXML_VERSION >= 20620 sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"placeElement failed\n"); #endif daeErrorHandler::get()->handleWarning( err ); ret = xmlTextReaderRead(reader); if ( ret != 1 ) { return element; } } } } else if(thisType == XML_READER_TYPE_TEXT) { readValue( element, reader ); } else if(thisType == XML_READER_TYPE_END_ELEMENT) { // Done with this element so read again and return ret = xmlTextReaderRead(reader); return(element); } else { // Skip element types we don't care about ret = xmlTextReaderRead(reader); // If we're out of data, return the element if(ret != 1) return(element); } } //program will never get here but this line is needed to supress a warning return NULL; }
static tmx_map *parse_root_map(xmlTextReaderPtr reader, const char *filename) { tmx_map *res = NULL; int curr_depth; const char *name; char *value; name = (char*) xmlTextReaderConstName(reader); curr_depth = xmlTextReaderDepth(reader); if (strcmp(name, "map")) { tmx_err(E_XDATA, "xml parser: root is not a 'map' element"); return NULL; } if (!(res = alloc_map())) return NULL; /* parses each attribute */ if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"orientation"))) { /* orientation */ if (res->orient = parse_orient(value), res->orient == O_NONE) { tmx_err(E_XDATA, "xml parser: unsupported 'orientation' '%s'", value); goto cleanup; } tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'orientation' attribute in the 'map' element"); goto cleanup; } value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"renderorder"); /* renderorder */ if (res->renderorder = parse_renderorder(value), res->renderorder == R_NONE) { tmx_err(E_XDATA, "xml parser: unsupported 'renderorder' '%s'", value); goto cleanup; } tmx_free_func(value); if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"height"))) { /* height */ res->height = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'height' attribute in the 'map' element"); goto cleanup; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"width"))) { /* width */ res->width = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'width' attribute in the 'map' element"); goto cleanup; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tileheight"))) { /* tileheight */ res->tile_height = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'tileheight' attribute in the 'map' element"); goto cleanup; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tilewidth"))) { /* tilewidth */ res->tile_width = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'tilewidth' attribute in the 'map' element"); goto cleanup; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"backgroundcolor"))) { /* backgroundcolor */ res->backgroundcolor = get_color_rgb(value); tmx_free_func(value); } /* Parse each child */ do { if (xmlTextReaderRead(reader) != 1) goto cleanup; /* error_handler has been called */ if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) { name = (char*)xmlTextReaderConstName(reader); if (!strcmp(name, "tileset")) { if (!parse_tileset(reader, &(res->ts_head), filename)) goto cleanup; } else if (!strcmp(name, "layer")) { if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_LAYER, filename)) goto cleanup; } else if (!strcmp(name, "objectgroup")) { if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_OBJGR, filename)) goto cleanup; } else if (!strcmp(name, "imagelayer")) { if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_IMAGE, filename)) goto cleanup; } else if (!strcmp(name, "properties")) { if (!parse_properties(reader, &(res->properties))) goto cleanup; } else { /* Unknow element, skip its tree */ if (xmlTextReaderNext(reader) != 1) goto cleanup; } } } while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT || xmlTextReaderDepth(reader) != curr_depth); return res; cleanup: tmx_map_free(res); return NULL; }
/* Parse the configuration file. */ int sechk_lib_parse_xml_file(const char *filename, sechk_lib_t * lib) { xmlTextReaderPtr reader = NULL; xmlDtdPtr dtd = NULL; xmlDocPtr xml = NULL; xmlValidCtxtPtr ctxt = NULL; int tmp, ret = 0; char *dtd_path = NULL; /* this initializes the XML library and checks potential ABI mismatches * between the version it was compiled for and the actual shared * library used. */ LIBXML_TEST_VERSION; reader = xmlReaderForFile(filename, NULL, 0); if (!reader) { ret = errno; if (ret != ENOENT) fprintf(stderr, "Error: Could not create xmlReader.\n"); goto exit_err; } dtd_path = build_dtd_path(); if (!dtd_path) { fprintf(stderr, "Error: getting DTD path\n"); goto exit_err; } dtd = xmlParseDTD(NULL, (const xmlChar *)dtd_path); free(dtd_path); if (!dtd) { fprintf(stderr, "Error: parsing DTD\n"); goto exit_err; } xml = xmlParseFile(filename); if (!xml) { fprintf(stderr, "Error: parsing sechecker profile\n"); goto exit_err; } ctxt = xmlNewValidCtxt(); if (!ctxt) { fprintf(stderr, "Error: out of memory\n"); goto exit_err; } /* validate profile against the DTD */ if (xmlValidateDtd(ctxt, xml, dtd) == 0) { fprintf(stderr, "Error: SEChecker profile contains invalid XML. Aborting.\n"); goto exit_err; } xmlFreeValidCtxt(ctxt); xmlFreeDoc(xml); xmlFreeDtd(dtd); while (1) { ret = xmlTextReaderRead(reader); if (ret == -1) { ret = errno; fprintf(stderr, "Error: Error reading xml.\n"); goto exit_err; } if (ret == 0) /* no more nodes to read */ break; tmp = sechk_lib_process_xml_node(reader, lib); if (tmp == -1) goto exit_err; if (tmp == 1) { ret = xmlTextReaderNext(reader); if (ret == 0) break; if (ret == -1) { ret = errno; fprintf(stderr, "Error in xmlTextReaderNext()\n"); goto exit_err; } } } /* cleanup function for the XML library */ xmlCleanupParser(); xmlFreeTextReader(reader); return 0; exit_err: xmlCleanupParser(); if (reader) xmlFreeTextReader(reader); if (ret) errno = ret; return -1; }
daeElementRef daeLIBXMLPlugin::startParse(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader) { // The original parsing system would drop everything up to the first element open, usually <COLLADA> // This behavior will have to be replicated here till we have someplace to put the headers/comments int ret = xmlTextReaderRead(reader); if(ret != 1) { // empty or hit end of file return NULL; } //printf("xmlTextReaderConstBaseUri is %s\n",xmlTextReaderConstBaseUri(reader)); //printf("xmlTextReaderConstNamespaceUri is %s\n",xmlTextReaderConstNamespaceUri(reader)); //printf("xmlTextReaderConstPrefix is %s\n",xmlTextReaderConstPrefix(reader)); //printf("xmlTextReaderName is %s\n",xmlTextReaderName(reader)); // Process the current element // Skip over things we don't understand while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT) { ret = xmlTextReaderRead(reader); if(ret != 1) return(NULL); } // Create the element that we found daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader)); if(!element) { char err[256]; memset( err, 0, 256 ); const xmlChar * mine =xmlTextReaderConstName(reader); #if LIBXML_VERSION >= 20620 sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine); #endif daeErrorHandler::get()->handleWarning( err ); xmlTextReaderNext(reader); return NULL; } int currentDepth = xmlTextReaderDepth(reader); //try and read attributes readAttributes( element, reader ); //Check COLLADA Version if ( strcmp( element->getTypeName(), "COLLADA" ) != 0 ) { //invalid root daeErrorHandler::get()->handleError("Loading document with invalid root element!"); return NULL; } daeURI *xmlns = (daeURI*)(element->getMeta()->getMetaAttribute( "xmlns" )->getWritableMemory( element )); if ( strcmp( xmlns->getURI(), COLLADA_NAMESPACE ) != 0 ) { //invalid COLLADA version daeErrorHandler::get()->handleError("Trying to load an invalid COLLADA version for this DOM build!"); return NULL; } ret = xmlTextReaderRead(reader); // If we're out of data, return the element if(ret != 1) return(element); // Read all the tags that are part of this tag bool trew = true; while(trew) { int thisType = xmlTextReaderNodeType(reader); if(thisType == XML_READER_TYPE_ELEMENT) { // Is the new element at the same depth as this one? if(currentDepth == xmlTextReaderDepth(reader)) { // Same depth means the current element ended in a /> so this is a sibling // so we return and let our parent process it. return(element); } else { // The element is a child of this one, so we recurse if(!element->placeElement(nextElement(element->getMeta(), reader))) { char err[256]; memset( err, 0, 256 ); #if LIBXML_VERSION >= 20620 sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"placeElement failed\n"); #endif daeErrorHandler::get()->handleWarning(err); ret = xmlTextReaderRead(reader); if ( ret != 1 ) { return element; } } } } else if(thisType == XML_READER_TYPE_TEXT) { readValue( element, reader ); } else if(thisType == XML_READER_TYPE_END_ELEMENT) { // Done with this element so read again and return ret = xmlTextReaderRead(reader); return(element); } else { // Skip element types we don't care about ret = xmlTextReaderRead(reader); // If we're out of data, return the element if(ret != 1) return(element); } } // Return NULL on an error return NULL; }
void nextNode() { xmlTextReaderNext(reader); }
/* * call-seq: * reader.next -> code * * Skip to the node following the current one in document order while avoiding * the subtree if any. */ static VALUE rxml_reader_next(VALUE self) { return INT2FIX(xmlTextReaderNext(rxml_text_reader_get(self))); }
/* * call-seq: * reader.next -> code * * Skip to the node following the current one in document order while avoiding * the subtree if any. */ static VALUE rxml_reader_next(VALUE self) { xmlTextReaderPtr xreader = rxml_text_reader_get(self); return INT2FIX(xmlTextReaderNext(xreader)); }
/* reader:next_node() */ static int xmlreader_next_node(lua_State *L) { xmlreader xr = check_xmlreader(L, 1); int ret = xmlTextReaderNext(xr); BOOL_OR_ERROR(L, ret); }
static int parse_object(xmlTextReaderPtr reader, tmx_object *obj) { int curr_depth; const char *name; char *value; /* parses each attribute */ if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"x"))) { /* x */ obj->x = atof(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'x' attribute in the 'object' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"y"))) { /* y */ obj->y = atof(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'y' attribute in the 'object' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */ obj->name = value; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"visible"))) { /* visible */ obj->visible = (char)atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"height"))) { /* height */ obj->shape = S_SQUARE; obj->height = atof(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"width"))) { /* width */ obj->width = atof(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"gid"))) { /* gid */ obj->shape = S_TILE; obj->gid = atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"rotation"))) { /* rotation */ obj->rotation = atof(value); tmx_free_func(value); } /* If it has a child, then it's a polygon or a polyline or an ellipse */ curr_depth = xmlTextReaderDepth(reader); if (!xmlTextReaderIsEmptyElement(reader)) { 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, &(obj->properties))) return 0; } else if (!strcmp(name, "ellipse")) { obj->shape = S_ELLIPSE; } else { if (!strcmp(name, "polygon")) { obj->shape = S_POLYGON; } else if (!strcmp(name, "polyline")) { obj->shape = S_POLYLINE; } /* Unknow element, skip its tree */ else if (xmlTextReaderNext(reader) != 1) return 0; if (!parse_points(reader, &(obj->points), &(obj->points_len))) return 0; } } } while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT || xmlTextReaderDepth(reader) != curr_depth); } return 1; }
/* parse layers and objectgroups */ static int parse_layer(xmlTextReaderPtr reader, tmx_layer **layer_headadr, int map_h, int map_w, enum tmx_layer_type type, const char *filename) { tmx_layer *res; tmx_object *obj; int curr_depth; const char *name; char *value; curr_depth = xmlTextReaderDepth(reader); if (!(res = alloc_layer())) return 0; res->type = type; while(*layer_headadr) { layer_headadr = &((*layer_headadr)->next); } *layer_headadr = res; /* parses each attribute */ if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */ res->name = value; } else { tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'layer' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"visible"))) { /* visible */ res->visible = (char)atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"opacity"))) { /* opacity */ res->opacity = (float)strtod(value, NULL); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"color"))) { /* color */ res->color = get_color_rgb(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"x"))) { /* x_offset */ res->x_offset = (int)atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"y"))) { /* y_offset */ res->y_offset = (int)atoi(value); tmx_free_func(value); } 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, "data")) { if (!parse_data(reader, &(res->content.gids), map_h * map_w)) return 0; } else if (!strcmp(name, "image")) { if (!parse_image(reader, &(res->content.image), 0, filename)) return 0; } else if (!strcmp(name, "object")) { if (!(obj = alloc_object())) return 0; obj->next = res->content.head; res->content.head = obj; if (!parse_object(reader, obj)) 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; }
/* parses a tileset within the tmx file or in a dedicated tsx file */ static int parse_tileset_sub(xmlTextReaderPtr reader, tmx_tileset *ts_addr, const char *filename) { int curr_depth; const char *name; char *value; curr_depth = xmlTextReaderDepth(reader); /* parses each attribute */ if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */ ts_addr->name = value; } else { tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'tileset' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tilewidth"))) { /* tile_width */ ts_addr->tile_width = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'tilewidth' attribute in the 'tileset' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tileheight"))) { /* tile_height */ ts_addr->tile_height = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'tileheight' attribute in the 'tileset' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"spacing"))) { /* spacing */ ts_addr->spacing = atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"margin"))) { /* margin */ ts_addr->margin = atoi(value); tmx_free_func(value); } /* 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, "image")) { if (!parse_image(reader, &(ts_addr->image), 1, filename)) return 0; } else if (!strcmp(name, "tileoffset")) { if (!parse_tileoffset(reader, &(ts_addr->x_offset), &(ts_addr->y_offset))) return 0; } else if (!strcmp(name, "properties")) { if (!parse_properties(reader, &(ts_addr->properties))) return 0; } else if (!strcmp(name, "tile")) { if (!parse_tile(reader, &(ts_addr->tiles), filename)) return 0; } else { /* Unknown element, skip its tree */ if (xmlTextReaderNext(reader) != 1) return 0; } } } while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT || xmlTextReaderDepth(reader) != curr_depth); return 1; }