// // libxml convenience function // static void SkipToEndElement(xmlTextReaderPtr reader) { while (xmlTextReaderRead(reader) == 1) { if (xmlTextReaderNodeType(reader) == 15) return; } }
bool XmlReader::Read() { end_element = false; bool r(xmlTextReaderRead(libxml_stuff->reader) == 1); while (r) { int const node_type = xmlTextReaderNodeType(libxml_stuff->reader); end_element = (node_type == XML_READER_TYPE_END_ELEMENT); if ((node_type == XML_READER_TYPE_END_ELEMENT) || (node_type == XML_READER_TYPE_ELEMENT) || (node_type == XML_READER_TYPE_TEXT)) break; r = (xmlTextReaderRead(libxml_stuff->reader) == 1); } return r; }
libvisio::VSDXRelationships::VSDXRelationships(librevenge::RVNGInputStream *input) : m_relsByType(), m_relsById() { if (input) { const std::shared_ptr<xmlTextReader> reader( xmlReaderForStream(input, nullptr, nullptr, XML_PARSE_NOBLANKS|XML_PARSE_NOENT|XML_PARSE_NONET|XML_PARSE_RECOVER), xmlFreeTextReader); if (reader) { bool inRelationships = false; int ret = xmlTextReaderRead(reader.get()); while (ret == 1) { const xmlChar *name = xmlTextReaderConstName(reader.get()); if (name) { if (xmlStrEqual(name, BAD_CAST("Relationships"))) { if (xmlTextReaderNodeType(reader.get()) == 1) { // VSD_DEBUG_MSG(("Relationships ON\n")); inRelationships = true; } else if (xmlTextReaderNodeType(reader.get()) == 15) { // VSD_DEBUG_MSG(("Relationships OFF\n")); inRelationships = false; } } else if (xmlStrEqual(name, BAD_CAST("Relationship"))) { if (inRelationships) { VSDXRelationship relationship(reader.get()); m_relsByType[relationship.getType()] = relationship; m_relsById[relationship.getId()] = relationship; } } } ret = xmlTextReaderRead(reader.get()); } } } }
char *xccdf_detect_version_priv(xmlTextReader *reader) { while (xmlTextReaderRead(reader) == 1 && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT); const struct xccdf_version_info *ver_info = xccdf_detect_version_parser(reader); if (ver_info == NULL) { return NULL; } return oscap_strdup(xccdf_version_info_get_version(ver_info)); }
static int _exml_read(EXML *xml, xmlTextReaderPtr reader) { int empty; xmlChar *name, *value; if (!reader) return -1; exml_clear( xml ); while( xmlTextReaderRead( reader ) == 1 ) { name = xmlTextReaderName(reader); value = xmlTextReaderValue(reader); empty = xmlTextReaderIsEmptyElement(reader); switch( xmlTextReaderNodeType(reader) ) { case XML_READER_TYPE_ELEMENT: exml_start(xml); exml_tag_set(xml, (char *) name); if (xmlTextReaderHasAttributes(reader)) { xmlTextReaderMoveToFirstAttribute(reader); do { xmlChar *attr_name, *attr_value; attr_name = xmlTextReaderName(reader); attr_value = xmlTextReaderValue(reader); exml_attribute_set(xml, (char *) attr_name, (char *) attr_value); xmlFree(attr_name); xmlFree(attr_value); } while( xmlTextReaderMoveToNextAttribute(reader) == 1 ); } if (!empty) break; case XML_READER_TYPE_END_ELEMENT: exml_end(xml); break; case XML_READER_TYPE_WHITESPACE: break; case XML_READER_TYPE_TEXT: exml_value_set(xml, (char *) value); break; } xmlFree(name); xmlFree(value); } xmlTextReaderClose(reader); xmlFreeTextReader(reader); exml_goto_top( xml ); return TRUE; }
static xmlChar *xmlTextReaderReadEntireNodeValue(xmlTextReaderPtr reader) { xmlChar *buffer = calloc(1, sizeof(xmlChar)); const xmlChar *snippet; int status; if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE) { return xmlTextReaderValue(reader); } else if (xmlTextReaderIsEmptyElement(reader) == 0) { status = xmlTextReaderRead(reader); while (status && (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT || xmlTextReaderNodeType(reader) == XML_READER_TYPE_CDATA || xmlTextReaderNodeType(reader) == XML_READER_TYPE_ENTITY_REFERENCE)) { snippet = xmlTextReaderConstValue(reader); buffer = realloc(buffer, (xmlStrlen(buffer) + xmlStrlen(snippet) + 1) * sizeof(xmlChar)); xmlStrcat(buffer, snippet); status = xmlTextReaderRead(reader); } } return buffer; }
const char *oscap_element_string_get(xmlTextReaderPtr reader) { if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT || xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE) xmlTextReaderRead(reader); if (xmlTextReaderHasValue(reader)) return (const char *)xmlTextReaderConstValue(reader); return NULL; }
bool XMLConversion::GetContentInt(int& value) { xmlTextReaderRead(_reader); const xmlChar* pvalue = xmlTextReaderConstValue(_reader); if(!pvalue) return false; value = atoi((const char*)pvalue); return true; }
bool XMLConversion::GetContentDouble(double& value) { xmlTextReaderRead(_reader); const xmlChar* pvalue = xmlTextReaderConstValue(_reader); if(!pvalue) return false; value = strtod((const char*)pvalue,NULL); return true; }
/* @method Boolean XmlReader.read() */ METHOD XmlReader_read(Ctx *ctx, knh_sfp_t *sfp) { xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]); if(reader == NULL) { KNH_THROWs(ctx, "XmlReader.read(): xmlReader is not readable"); } int ret = xmlTextReaderRead(reader); KNH_RETURN_Int(ctx,sfp,ret); }
//## @Native boolean XmlReader.read(); static KMETHOD XmlReader_read(KonohaContext *kctx, KonohaStack *sfp) { xmlTextReaderPtr reader = getRawXmlReader(sfp[0]); int ret = 0; if(reader != NULL) { ret = xmlTextReaderRead(reader); } KReturnUnboxValue(ret); }
/** * streamFile: * @filename: the file name to parse * * Parse and print information about an XML file. * * Returns the resulting doc with just the elements preserved. */ static xmlDocPtr extractFile(const char *filename, const xmlChar *pattern) { xmlDocPtr doc; xmlTextReaderPtr reader; int ret; /* * build an xmlReader for that file */ reader = xmlReaderForFile(filename, NULL, 0); if (reader != NULL) { /* * add the pattern to preserve */ if (xmlTextReaderPreservePattern(reader, pattern, NULL) < 0) { fprintf(stderr, "%s : failed add preserve pattern %s\n", filename, (const char *) pattern); } /* * Parse and traverse the tree, collecting the nodes in the process */ ret = xmlTextReaderRead(reader); while (ret == 1) { ret = xmlTextReaderRead(reader); } if (ret != 0) { fprintf(stderr, "%s : failed to parse\n", filename); xmlFreeTextReader(reader); return(NULL); } /* * get the resulting nodes */ doc = xmlTextReaderCurrentDoc(reader); /* * Free up the reader */ xmlFreeTextReader(reader); } else { fprintf(stderr, "Unable to open %s\n", filename); return(NULL); } return(doc); }
/*Read values from XML22 file 读取XML22,虚拟机之间的流量信息文件*/ int get_vm2vm_from_xml22(char *filename) { xmlTextReaderPtr reader; xmlChar *name; int vd=-1,ret=0; reader = xmlNewTextReaderFilename(filename); if (reader != NULL) { ret = xmlTextReaderRead(reader); name = xmlTextReaderName(reader);/*获取reader的元素名称*/ if (name == NULL) name = xmlStrdup(BAD_CAST "--"); /*在这个例子中,我们需要确认文档是正确的类型。“DATA”是在这个示例中使用文档的根类型。*/ if (xmlStrcmp(name, (xmlChar *) "DATA")) { fprintf(stderr,"document of the wrong type, root node != DATA"); xmlFree(name); xmlFreeTextReader(reader); return ret; } while (ret == 1) { process_XML22_Node(reader,&vd); ret = xmlTextReaderRead(reader); } xmlFreeTextReader(reader); if (ret != 0) { printf("%s : failed to parse\n", filename); } } else printf("Unable to open %s\n", filename); _xpthis->sd->v2v_total=vd+1;/*在全局共享数据区记录v2v的总数*/ return ret; }
/** * streamFile: * @filename: the file name to parse * * Parse and print information about an XML file. */ static void streamFile (const char *filename) { xmlTextReaderPtr reader; int ret; reader = xmlReaderForFile (filename, NULL, 0); if (reader != NULL) { ret = xmlTextReaderRead (reader); while (ret == 1) { processNode (reader); ret = xmlTextReaderRead (reader); } xmlFreeTextReader (reader); if (ret != 0) { fprintf (stderr, "%s : failed to parse\n", filename); } } else { fprintf (stderr, "Unable to open %s\n", filename); } }
void BEXMLTextReader::read ( ) { int ok = xmlTextReaderRead ( reader ); if ( ok == 0 ) { last_node = true; } else if ( ok == kBE_XMLReaderError ) { throw BEXMLReaderInterface_Exception ( last_error() ); } }
EXPORT EPUB3Error EPUB3CopyRootFilePathFromContainer(EPUB3Ref epub, char ** rootPath) { assert(epub != NULL); if(epub->archive == NULL) return kEPUB3ArchiveUnavailableError; static const char *containerFilename = "META-INF/container.xml"; void *buffer = NULL; uint32_t bufferSize = 0; uint32_t bytesCopied; xmlTextReaderPtr reader = NULL; EPUB3Bool foundPath = kEPUB3_NO; EPUB3Error error = kEPUB3Success; error = EPUB3CopyFileIntoBuffer(epub, &buffer, &bufferSize, &bytesCopied, containerFilename); if(error == kEPUB3Success) { reader = xmlReaderForMemory(buffer, bufferSize, "", NULL, XML_PARSE_RECOVER); if(reader != NULL) { int retVal; while((retVal = xmlTextReaderRead(reader)) == 1) { const char *rootFileName = "rootfile"; const xmlChar *name = xmlTextReaderConstLocalName(reader); if(xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT && xmlStrcmp(name, BAD_CAST rootFileName) == 0) { xmlChar *fullPath = xmlTextReaderGetAttribute(reader, BAD_CAST "full-path"); if(fullPath != NULL) { // TODD: validate that the full-path attribute is of the form path-rootless // see http://idpf.org/epub/30/spec/epub30-ocf.html#sec-container-metainf-container.xml foundPath = kEPUB3_YES; *rootPath = strdup((char *)fullPath); } else { // The spec requires the full-path attribute error = kEPUB3XMLXDocumentInvalidError; } break; } } if(retVal < 0) { error = kEPUB3XMLParseError; } if(!foundPath) { error = kEPUB3XMLXElementNotFoundError; } } else { error = kEPUB3XMLReadFromBufferError; } EPUB3_FREE_AND_NULL(buffer); } xmlFreeTextReader(reader); return error; }
static xmlChar* get_xml_text ( xmlTextReaderPtr reader ) { while(xmlTextReaderRead(reader)){ xmlChar *ret; xmlChar *text; xmlChar *begin_ptr; xmlChar *end_ptr; int type; type = xmlTextReaderNodeType(reader); if (type == XML_READER_TYPE_ELEMENT){ xmlChar *name; name = xmlTextReaderName(reader); rrd_set_error("line %d: expected a value but found a <%s> element", xmlTextReaderGetParserLineNumber(reader), name); xmlFree(name); return NULL; } /* trying to read text from <a></a> we end up here lets return an empty string instead. This is a tad optimistic since we do not check if it is actually </a> and not </b> we got, but first we do not know if we expect </a> and second we the whole implementation is on the optimistic side. */ if (type == XML_READER_TYPE_END_ELEMENT){ return xmlStrdup(BAD_CAST ""); } /* skip all other non-text */ if (type != XML_READER_TYPE_TEXT) continue; text = xmlTextReaderValue(reader); begin_ptr = text; while ((begin_ptr[0] != 0) && (isspace(begin_ptr[0]))) begin_ptr++; if (begin_ptr[0] == 0) { xmlFree(text); return xmlStrdup(BAD_CAST ""); } end_ptr = begin_ptr; while ((end_ptr[0] != 0) && (!isspace(end_ptr[0]))) end_ptr++; end_ptr[0] = 0; ret = xmlStrdup(begin_ptr); xmlFree(text); return ret; } rrd_set_error("file ended while looking for text"); return NULL; } /* get_xml_text */
/** * Streams XML file using callback **/ int streamFile(char *filename, char *objPath, ruleExecInfo_t* rei) { xmlTextReaderPtr reader; int ret; rodsLog( LOG_NOTICE, "Calling streamFile()\n"); reader = xmlNewTextReaderFilename(filename); if (reader != NULL) { ret = xmlTextReaderRead(reader); while (ret == 1 && end == 0) { processNode(reader, objPath, rei); ret = xmlTextReaderRead(reader); } xmlFreeTextReader(reader); end = 0; } else { printf("Unable to open %s\n", filename); } return 0; }
static void process_properties (xmlTextReaderPtr reader, GtkSourceLanguage *language) { xmlNodePtr child; xmlNodePtr node = NULL; while (node == NULL && xmlTextReaderRead (reader) == 1) { xmlChar *name; if (xmlTextReaderNodeType (reader) != 1) continue; name = xmlTextReaderName (reader); if (xmlStrcmp (name, BAD_CAST "metadata") != 0) { xmlFree (name); continue; } xmlFree (name); node = xmlTextReaderExpand (reader); if (node == NULL) return; } if (node == NULL) return; for (child = node->children; child != NULL; child = child->next) { xmlChar *name; xmlChar *content; if (child->type != XML_ELEMENT_NODE || xmlStrcmp (child->name, BAD_CAST "property") != 0) continue; name = xmlGetProp (child, BAD_CAST "name"); content = xmlNodeGetContent (child); if (name != NULL && content != NULL) g_hash_table_insert (language->priv->properties, g_strdup ((gchar *) name), g_strdup ((gchar *) content)); xmlFree (name); xmlFree (content); } }
static void biji_parse_file (BijiLazyDeserializer *self) { while ( xmlTextReaderRead(self->priv->r) == 1 ) { if ( xmlTextReaderNodeType(self->priv->r) == 1 ) { processNode(self); } } }
static Buffer *extractText(htmlDocPtr doc) { char * term = "\0"; Buffer *buf = new_buffer(256); xmlTextReaderPtr reader = xmlReaderWalker(doc); while(xmlTextReaderRead(reader)){ processNode(reader, buf); } xmlFreeTextReader(reader); buffer_in(buf, term, 1); return buf; }
void Parse() { ReadNextNode(); WriteElement(); int nDepth = GetDepth(); if ( 0 == xmlTextReaderIsEmptyElement(reader) ) { XmlNodeType eNodeType = XmlNodeType_None; int nCurDepth = -1; // У закрывающего тэга глубина на 1 больше, чем у открывающего while( true ) { if ( 1 != xmlTextReaderRead(reader) ) break; int nTempType = xmlTextReaderNodeType(reader); if(-1 == nTempType) break; eNodeType = (XmlNodeType)nTempType; nCurDepth = GetDepth(); if ( eNodeType == XmlNodeType_Text || eNodeType == XmlNodeType_Whitespace || eNodeType == XmlNodeType_SIGNIFICANT_WHITESPACE ) m_pCurrentNode->m_sText += GetText(); else if (eNodeType == XmlNodeType_Element) WriteElement(); else if (eNodeType == XmlNodeType_EndElement) { m_list.pop_back(); if (0 != m_list.size()) { std::list<CXmlNodeBase*>::iterator iter = m_list.end(); --iter; m_pCurrentNode = *iter; } else { m_pCurrentNode = m_pNode; } } nCurDepth = GetDepth(); if ( nCurDepth < nDepth ) break; if ( XmlNodeType_EndElement == eNodeType && nCurDepth == nDepth ) break; } } }
static const xmlChar * openioc_read(xmlTextReaderPtr reader) { const xmlChar * name; if (xmlTextReaderRead(reader) != 1) return NULL; name = xmlTextReaderConstLocalName(reader); if (name != NULL) { cli_dbgmsg("openioc_parse: xmlTextReaderRead read %s%s\n", name, xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT?" end tag":""); } return name; }
/* xar_process_subdocument - check TOC for xml subdocument. If found, extract and scan in memory. Parameters: reader - xmlTextReaderPtr ctx - pointer to cli_ctx Returns: CL_SUCCESS - subdoc found and clean scan (or virus found and SCAN_ALL), or no subdocument other - error return code from cli_mem_scandesc() */ static int xar_scan_subdocuments(xmlTextReaderPtr reader, cli_ctx *ctx) { int rc = CL_SUCCESS, subdoc_len, fd; xmlChar * subdoc; const xmlChar *name; char * tmpname; while (xmlTextReaderRead(reader) == 1) { name = xmlTextReaderConstLocalName(reader); if (name == NULL) { cli_dbgmsg("cli_scanxar: xmlTextReaderConstLocalName() no name.\n"); rc = CL_EFORMAT; break; } if (xmlStrEqual(name, (const xmlChar *)"toc") && xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) return CL_SUCCESS; if (xmlStrEqual(name, (const xmlChar *)"subdoc") && xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) { subdoc = xmlTextReaderReadInnerXml(reader); if (subdoc == NULL) { cli_dbgmsg("cli_scanxar: no content in subdoc element.\n"); xmlTextReaderNext(reader); continue; } subdoc_len = xmlStrlen(subdoc); cli_dbgmsg("cli_scanxar: in-memory scan of xml subdocument, len %i.\n", subdoc_len); rc = cli_mem_scandesc(subdoc, subdoc_len, ctx); if (rc == CL_VIRUS && SCAN_ALL) rc = CL_SUCCESS; /* make a file to leave if --leave-temps in effect */ if(ctx->engine->keeptmp) { if ((rc = cli_gentempfd(ctx->engine->tmpdir, &tmpname, &fd)) != CL_SUCCESS) { cli_dbgmsg("cli_scanxar: Can't create temporary file for subdocument.\n"); } else { cli_dbgmsg("cli_scanxar: Writing subdoc to temp file %s.\n", tmpname); if (cli_writen(fd, subdoc, subdoc_len) < 0) { cli_dbgmsg("cli_scanxar: cli_writen error writing subdoc temporary file.\n"); rc = CL_EWRITE; } rc = xar_cleanup_temp_file(ctx, fd, tmpname); } } xmlFree(subdoc); if (rc != CL_SUCCESS) return rc; xmlTextReaderNext(reader); } } return rc; }
void PTXReader::step() { int retval = xmlTextReaderRead(reader); if(retval != 1) { parseError(L"unexpected EOF"); } name = XMLParseUtil::towstring(xmlTextReaderConstName(reader)); type = xmlTextReaderNodeType(reader); //cerr<<"In PTXReader::step: name='"<<name<<"', type="<<type<<"\n"; }
ExtractionWay XMLParser::_ReadXMLWay() { ExtractionWay way; if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) { const int depth = xmlTextReaderDepth( inputReader ); while ( xmlTextReaderRead( inputReader ) == 1 ) { const int childType = xmlTextReaderNodeType( inputReader ); if ( childType != 1 && childType != 15 ) { continue; } const int childDepth = xmlTextReaderDepth( inputReader ); xmlChar* childName = xmlTextReaderName( inputReader ); if ( childName == NULL ) { continue; } if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) { xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" ); way.id = stringToUint((char*)id); xmlFree(id); xmlFree( childName ); break; } if ( childType != 1 ) { xmlFree( childName ); continue; } if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) { xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" ); xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" ); // cout << "->k=" << k << ", v=" << value << endl; if ( k != NULL && value != NULL ) { way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value)); } if ( k != NULL ) { xmlFree( k ); } if ( value != NULL ) { xmlFree( value ); } } else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) { xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" ); if ( ref != NULL ) { way.path.push_back( stringToUint(( const char* ) ref ) ); xmlFree( ref ); } } xmlFree( childName ); } } return way; }
/* * Parse the configuration file and initialize ows struct */ static void ows_parse_config_xml(ows * o, const char *filename) { xmlTextReaderPtr r; const xmlChar *name; int ret; assert(o); assert(filename); r = xmlReaderForFile(filename, "UTF-8", 0); if (!r) { ows_error(o, OWS_ERROR_CONFIG_FILE, "Unable to open config file !", "parse_config_file"); return; } if (!o->layers) o->layers = ows_layer_list_init(); while ((ret = xmlTextReaderRead(r)) == 1) { if (xmlTextReaderNodeType(r) == XML_READER_TYPE_ELEMENT) { name = xmlTextReaderConstLocalName(r); if (!strcmp((char *) name, "tinyows")) ows_parse_config_tinyows(o, r); if (!strcmp((char *) name, "metadata")) ows_parse_config_metadata(o, r); if (!strcmp((char *) name, "abstract")) ows_parse_config_abstract(o, r); if (!strcmp((char *) name, "contact")) ows_parse_config_contact(o, r); if (!strcmp((char *) name, "pg")) ows_parse_config_pg(o, r); if (!strcmp((char *) name, "limits")) ows_parse_config_limits(o, r); if (!strcmp((char *) name, "layer")) ows_parse_config_layer(o, r); } } if (ret != 0) { xmlFreeTextReader(r); ows_error(o, OWS_ERROR_CONFIG_FILE, "Unable to open config file !", "parse_config_file"); return; } xmlFreeTextReader(r); }
/* * This is the workhorse behind for ksFromXML() and ksFromXMLfile(). * It will process the entire XML document in reader and convert and * save it in ks KeySet. Each node is processed by the processNode() function. * * This function is completely dependent on libxml. */ static int ksFromXMLReader(KeySet *ks,xmlTextReaderPtr reader) { int ret = 0; xmlChar *nodeName=0; ret = xmlTextReaderRead(reader); /* go to first node */ while (ret == 1) { /* walk node per node until the end of the stream */ nodeName=xmlTextReaderName(reader); if (!strcmp((char *)nodeName,"key")) consumeKeyNode(ks, 0, reader); else if (!strcmp((char *)nodeName,"keyset")) consumeKeySetNode(ks, 0, reader); ret = xmlTextReaderRead(reader); xmlFree (nodeName); } return ret; }
bool c_XMLReader::t_read() { if (m_ptr) { int ret = xmlTextReaderRead(m_ptr); if (ret == -1) { raise_warning("An Error Occured while reading"); return false; } else { return ret; } } raise_warning("Load Data before trying to read"); return false; }
/* reader:read() */ static int xmlreader_read(lua_State *L) { xmlreader xr = check_xmlreader(L, 1); int ret = xmlTextReaderRead(xr); if (ret != -1) { lua_pushboolean(L, ret); return 1; } else { lua_pushnil(L); xmlreader_pusherror(L); return 2; } }