bool XMLReader::processNode() { if (m_reader == NULL) { std::cout << "error" << std::endl ; } if (xmlTextReaderRead(m_reader) != 1) { return false ; } m_attributes.clear() ; if (xmlTextReaderHasAttributes(m_reader) == 1) { int count = xmlTextReaderAttributeCount(m_reader) ; for (int i = 0 ; i < count ; i++) { xmlTextReaderMoveToAttributeNo(m_reader, i) ; m_attributes.insert( std::pair<std::string, std::string>( (char*) xmlTextReaderConstLocalName( m_reader), (char*) xmlTextReaderConstValue( m_reader))) ; } xmlTextReaderMoveToElement(m_reader) ; } // std::cout << print() << std::endl ; return true ; }
/** * Callback for XML-Node processing **/ void processNode(xmlTextReaderPtr reader, char *objPath, ruleExecInfo_t* rei) { xmlChar *name, *value; rodsLog( LOG_NOTICE, "Calling processNode()\n"); name = xmlTextReaderName(reader); value = xmlTextReaderValue(reader); if (xmlStrEqual(name, BAD_CAST "spectrumList")) { end = 1; } else if (xmlStrEqual(name, BAD_CAST "cvParam")) { if(xmlTextReaderHasAttributes(reader) > 0) { rodsLog(LOG_NOTICE, "Extracting cvParam information...\n"); xmlChar *cvLabel = xmlTextReaderGetAttribute(reader, (xmlChar *) "cvLabel"); xmlChar *cvAccession = xmlTextReaderGetAttribute(reader, (xmlChar *) "accession"); xmlChar *cvName = xmlTextReaderGetAttribute(reader, (xmlChar *) "name"); xmlChar *cvValue = xmlTextReaderGetAttribute(reader, (xmlChar *) "name"); printf("cvParam: [%s] [%s] [%s] [%s]\n", cvLabel, cvAccession, cvName, cvValue); createMetadataOnObject(objPath, (char*) "cvParam", (char *) cvLabel, (char*) "", rei); createMetadataOnObject(objPath, (char *) cvLabel, (char *) cvValue, (char *) cvAccession, rei); createMetadataOnObject(objPath, (char *) cvLabel, (char *) cvName, (char*) "", rei); } } }
void XmlParser::_readMember() { std::string type; std::string ref; std::string role; // Read attributes if (xmlTextReaderHasAttributes(_reader) == XmlStatus::TRUE) { while (xmlTextReaderMoveToNextAttribute(_reader)) { std::string k = (char*) xmlTextReaderConstName(_reader); std::string v = (char*) xmlTextReaderConstValue(_reader); if (k == "type") { type = v; } else if (k == "ref") { ref = v; } else if (k == "role") { role = v; } } } if (_prevMemberParentElementId == _parentElementId) { _dbBuilder.addMember(_parentElementId, ref, type, role, false); } else { _dbBuilder.addMember(_parentElementId, ref, type, role, true); _prevMemberParentElementId = _parentElementId; } }
//----------------------------------------- void LegacyParser::processGraphNode(xmlTextReaderPtr reader) { //----------------------------------------- _gexf->setGraphType(GRAPH_UNDIRECTED); /* default */ int hasAttr = xmlTextReaderHasAttributes(reader); if(hasAttr == 1) { string mode = "static"; try { mode = this->getStringAttribute(reader, "mode"); } catch(exception &e) { cerr << "INFO " << "Unknown mode, static used." << endl; } /*if( mode.compare("dynamic") == 0 ) { // dynamic mode will never be implemented for GEXF 1.0 } else { // static used by default // nothing to do }*/ try { string defaultedgetype = this->getStringAttribute(reader, "defaultedgetype"); if( defaultedgetype.compare("dir") == 0 ) { _gexf->setGraphType(GRAPH_DIRECTED); } else { cerr << "INFO " << "Unknown default edge type, undirected used." << endl; } } catch (exception &e) { cerr << "INFO " << "Unknown default edge type, undirected used." << endl; } } else if(hasAttr == -1) { throw FileReaderException("An error occured in xmlTextReaderHasAttributes() for Graph node."); } }
bool BEXMLTextReader::has_attributes() { int has_attributes = xmlTextReaderHasAttributes ( reader ) == 1; if ( has_attributes == kBE_XMLReaderError ) { throw BEXMLReaderInterface_Exception ( last_error() ); } return has_attributes == 1; }
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; }
//----------------------------------------- void LegacyParser::processMetaNode(xmlTextReaderPtr reader) { //----------------------------------------- int hasAttr = xmlTextReaderHasAttributes(reader); if(hasAttr == 1) { string lastmodifieddate= this->getStringAttribute(reader, "lastmodifieddate"); _gexf->getMetaData().setLastModifiedDate( lastmodifieddate ); } else if(hasAttr == -1) { throw FileReaderException("An error occured in xmlTextReaderHasAttributes() for Meta node."); } }
//----------------------------------------- void LegacyParser::processNodeNode(xmlTextReaderPtr reader) { //----------------------------------------- int hasAttr = xmlTextReaderHasAttributes(reader); if(hasAttr == 1) { t_id node_id = this->getIdAttribute(reader, "id"); string label= this->getStringAttribute(reader, "label"); _gexf->getUndirectedGraph().addNode( node_id ); _gexf->getData().setNodeLabel( node_id, label ); _last_node_type = NODE; _last_id = node_id; } else if(hasAttr == -1) { throw FileReaderException("An error occured in xmlTextReaderHasAttributes() for Graph node."); } }
void XmlParser::_readOsm() { std::string versionStr; std::string generatorStr; // Read attributes if (xmlTextReaderHasAttributes(_reader) == XmlStatus::TRUE) { while (xmlTextReaderMoveToNextAttribute(_reader)) { std::string k = (char*) xmlTextReaderConstName(_reader); std::string v = (char*) xmlTextReaderConstValue(_reader); if (k == "version") { versionStr = v; } else if (k == "generator") { generatorStr = v; } } } _dbBuilder.addOSM(versionStr, generatorStr); }
void XmlParser::_readNode() { std::string idStr; std::string latStr; std::string lonStr; std::string versionStr; std::string timestampStr; std::string changesetStr; std::string uidStr; std::string userStr; std::string actionStr; std::string visibleStr; // Read attributes if (xmlTextReaderHasAttributes(_reader) == XmlStatus::TRUE) { while (xmlTextReaderMoveToNextAttribute(_reader)) { std::string k = (char*) xmlTextReaderConstName(_reader); std::string v = (char*) xmlTextReaderConstValue(_reader); if (k == "id") { idStr = v; } else if (k == "lat") { latStr = v; } else if (k == "lon") { lonStr = v; } else if (k == "version") { versionStr = v; } else if (k == "timestamp") { timestampStr = v; } else if (k == "changeset") { changesetStr = v; } else if (k == "uid") { uidStr = v; } else if (k == "user") { userStr = v; } else if (k == "action") { actionStr = v; } else if (k == "visible") { visibleStr = v; } } } _parentElementType = ElementType::NODE; _parentElementId = idStr; _dbBuilder.addNode(idStr, latStr, lonStr, versionStr, timestampStr, changesetStr, uidStr, userStr, actionStr, visibleStr); }
//----------------------------------------- void LegacyParser::processGEXFNode(xmlTextReaderPtr reader) { //----------------------------------------- int hasAttr = xmlTextReaderHasAttributes(reader); if(hasAttr == 1) { string version = "1.0"; try { version = this->getStringAttribute(reader, "version"); //_gexf->getMetaData().setVersion( version ); } catch (exception &e) { cerr << "WARN " << e.what() << endl; } if( version.compare("1.0") != 0 ) throw FileReaderException("Wrong GEXF version."); } else if(hasAttr == -1) { throw FileReaderException("An error occured in xmlTextReaderHasAttributes() for GEXF node."); } }
//----------------------------------------- void LegacyParser::processAttributesNode(xmlTextReaderPtr reader) { //----------------------------------------- int hasAttr = xmlTextReaderHasAttributes(reader); if(hasAttr == 1) { string attribute_class = this->getStringAttribute(reader, "class"); if( attribute_class.compare("node") == 0 ) { _last_node_type = ATTR_NODE; } else if( attribute_class.compare("edge") == 0 ) { _last_node_type = ATTR_EDGE; } else { throw FileReaderException("Attributes node: unknown class"); } } else if(hasAttr == -1) { throw FileReaderException("An error occured in xmlTextReaderHasAttributes() for Attributes node."); } }
void XmlParser::_readNd() { if (_prevParentElementId == _parentElementId) { ++_ndPosCount; } else { _prevParentElementId = _parentElementId; _ndPosCount = 0; } std::string ref; // Read attributes if (xmlTextReaderHasAttributes(_reader) == XmlStatus::TRUE) { while (xmlTextReaderMoveToNextAttribute(_reader)) { std::string k = (char*) xmlTextReaderConstName(_reader); std::string v = (char*) xmlTextReaderConstValue(_reader); if (k == "ref") { ref = v; } } } _dbBuilder.addNd(_parentElementId, ref, _ndPosCount); }
//----------------------------------------- void LegacyParser::processEdgeNode(xmlTextReaderPtr reader) { //----------------------------------------- int hasAttr = xmlTextReaderHasAttributes(reader); if(hasAttr == 1) { t_id edge_id = this->getIdAttribute(reader, "id"); t_id source = this->getIdAttribute(reader, "source"); t_id target = this->getIdAttribute(reader, "target"); float cardinal = 1.0; string tmp_type = ""; try { cardinal = this->getFloatAttribute(reader, "cardinal"); } catch(exception &e) { // nothing to do } try { tmp_type = this->getStringAttribute(reader, "type"); } catch(exception &e) { // nothing to do } t_edge_type type = EDGE_UNDIRECTED; if( tmp_type.compare("dou") == 0 ) { type = EDGE_MUTUAL; } else if( _gexf->getGraphType() == GRAPH_DIRECTED || tmp_type.compare("dir") == 0 ) { type = EDGE_DIRECTED; } if(_gexf->getGraphType() == GRAPH_DIRECTED) { _gexf->getDirectedGraph().addEdge( edge_id, source, target, cardinal, type); } else { /*undirected or mixed, use undirected*/ _gexf->getUndirectedGraph().addEdge( edge_id, source, target, cardinal, type); } _last_node_type = EDGE; _last_id = edge_id; } else if(hasAttr == -1) { throw FileReaderException("An error occured in xmlTextReaderHasAttributes() for Graph node."); } }
//----------------------------------------- void LegacyParser::processAttributeNode(xmlTextReaderPtr reader) { //----------------------------------------- int hasAttr = xmlTextReaderHasAttributes(reader); if(hasAttr == 1) { t_id attribute_id = this->getIdAttribute(reader, "id"); string title = this->getStringAttribute(reader, "title"); string type_str = this->getStringAttribute(reader, "type"); const t_attr_type type = Conv::strToAttrType(type_str); if( _last_node_type == ATTR_NODE ) { _gexf->getData().addNodeAttributeColumn(attribute_id, title, Conv::attrTypeToStr(type)); } else if( _last_node_type == ATTR_EDGE ) { _gexf->getData().addEdgeAttributeColumn(attribute_id, title, Conv::attrTypeToStr(type)); } _last_id = attribute_id; } else if(hasAttr == -1) { throw FileReaderException("An error occured in xmlTextReaderHasAttributes() for Graph node."); } }
void XmlParser::_readTag() { std::string k; std::string v; // Read attributes if (xmlTextReaderHasAttributes(_reader) == XmlStatus::TRUE) { while (xmlTextReaderMoveToNextAttribute(_reader)) { std::string key = (char*) xmlTextReaderConstName(_reader); std::string val = (char*) xmlTextReaderConstValue(_reader); if (key == "k") { k = val; } else if (key == "v") { v = val; } } } // Only blast the previous tags for the element once when updating. if (_prevTagParentElementId == _parentElementId) { _dbBuilder.addTag(_parentElementType, _parentElementId, k, v, false); } else { _dbBuilder.addTag(_parentElementType, _parentElementId, k, v, true); _prevTagParentElementId = _parentElementId; } }
/* * call-seq: * reader.has_attributes? -> bool * * Get whether the node has attributes. */ static VALUE rxml_reader_has_attributes(VALUE self) { xmlTextReaderPtr xreader = rxml_text_reader_get(self); return xmlTextReaderHasAttributes(xreader) ? Qtrue : Qfalse; }
/* reader:has_attributes() */ static int xmlreader_has_attributes(lua_State *L) { xmlreader xr = check_xmlreader(L, 1); int ret = xmlTextReaderHasAttributes(xr); BOOL_OR_ERROR(L, ret); }
bool IWORKParser::parse() { const shared_ptr<xmlTextReader> sharedReader(xmlReaderForIO(readFromStream, closeStream, m_input.get(), "", nullptr, 0), xmlFreeTextReader); if (!sharedReader) return false; xmlTextReaderPtr reader = sharedReader.get(); assert(reader); const IWORKTokenizer &tokenizer = getTokenizer(); stack<IWORKXMLContextPtr_t> contextStack; int ret = xmlTextReaderRead(reader); contextStack.push(createDocumentContext()); bool keynoteDocTypeChecked=false; char const *defaultNS=nullptr; while ((1 == ret)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { if (!keynoteDocTypeChecked) { // check for keynote 1 file with doctype node and not a namespace in first node keynoteDocTypeChecked=true; if (xmlTextReaderNodeType(reader)==XML_READER_TYPE_ELEMENT && xmlTextReaderConstNamespaceUri(reader)==nullptr) defaultNS="http://developer.apple.com/schemas/APXL"; } const int id = tokenizer.getQualifiedId(char_cast(xmlTextReaderConstLocalName(reader)), defaultNS ? defaultNS : char_cast(xmlTextReaderConstNamespaceUri(reader))); IWORKXMLContextPtr_t newContext = contextStack.top()->element(id); if (!newContext) newContext = createDiscardContext(); const bool isEmpty = xmlTextReaderIsEmptyElement(reader); newContext->startOfElement(); if (xmlTextReaderHasAttributes(reader)) { ret = xmlTextReaderMoveToFirstAttribute(reader); while (1 == ret) { processAttribute(reader, newContext, tokenizer); ret = xmlTextReaderMoveToNextAttribute(reader); } } if (isEmpty) newContext->endOfElement(); else contextStack.push(newContext); break; } case XML_READER_TYPE_END_ELEMENT: { contextStack.top()->endOfElement(); contextStack.pop(); break; } case XML_READER_TYPE_CDATA : { const xmlChar *text = xmlTextReaderConstValue(reader); if (text) contextStack.top()->CDATA(char_cast(text)); break; } case XML_READER_TYPE_TEXT : { xmlChar *const text = xmlTextReaderReadString(reader); contextStack.top()->text(char_cast(text)); xmlFree(text); break; } default: break; } ret = xmlTextReaderRead(reader); } while (!contextStack.empty()) // finish parsing in case of broken XML { contextStack.top()->endOfElement(); contextStack.pop(); } xmlTextReaderClose(reader); return true; }
/** * read file and print element paths */ int parse_xml_file(const char *filename) { int ret, prev_depth = 0; xmlTextReaderPtr reader; for (reader = xmlReaderForFile(filename, NULL, 0);;) { int depth; const xmlChar *name; xmlReaderTypes type; if (!reader) { fprintf(stderr, "couldn't read file '%s'\n", filename); exit(EXIT_BAD_FILE); } ret = xmlTextReaderRead(reader); if (ret <= 0) break; type = xmlTextReaderNodeType(reader); depth = xmlTextReaderDepth(reader); name = xmlTextReaderConstName(reader); if (type != XML_READER_TYPE_ELEMENT) continue; while (curXPath && depth <= prev_depth) { xmlChar *slash = BAD_CAST strrchr((char*) curXPath, '/'); if (slash) *slash = '\0'; prev_depth--; } prev_depth = depth; if (depth > 0) curXPath = xmlStrcat(curXPath, BAD_CAST "/"); curXPath = xmlStrcat(curXPath, name); if (elOps.show_attr) { int have_attr; fprintf(stdout, "%s\n", curXPath); for (have_attr = xmlTextReaderMoveToFirstAttribute(reader); have_attr; have_attr = xmlTextReaderMoveToNextAttribute(reader)) { const xmlChar *aname = xmlTextReaderConstName(reader); fprintf(stdout, "%s/@%s\n", curXPath, aname); } } else if (elOps.show_attr_and_val) { fprintf(stdout, "%s", curXPath); if (xmlTextReaderHasAttributes(reader)) { int have_attr, first = 1; fprintf(stdout, "["); for (have_attr = xmlTextReaderMoveToFirstAttribute(reader); have_attr; have_attr = xmlTextReaderMoveToNextAttribute(reader)) { const xmlChar *aname = xmlTextReaderConstName(reader), *avalue = xmlTextReaderConstValue(reader); char quote; if (!first) fprintf(stdout, " and "); first = 0; quote = xmlStrchr(avalue, '\'')? '"' : '\''; fprintf(stdout, "@%s=%c%s%c", aname, quote, avalue, quote); } fprintf(stdout, "]"); } fprintf(stdout, "\n"); } else if (elOps.sort_uniq) { if ((elOps.check_depth == 0) || (elOps.check_depth != 0 && depth < elOps.check_depth)) { xmlHashAddEntry(uniq, curXPath, (void*) 1); } } else fprintf(stdout, "%s\n", curXPath); } return ret == -1? EXIT_LIB_ERROR : ret; }
static Eina_Bool _lng_read(Language_XML *xml, xmlTextReaderPtr reader) { Eina_Bool empty; xmlChar *name, *value; if (!reader) return EINA_FALSE; language_xml_clear(xml); while (xmlTextReaderRead(reader) == 1) { name = xmlTextReaderName(reader); value = xmlTextReaderValue(reader); empty = xmlTextReaderIsEmptyElement(reader); switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { _lng_start(xml); _lng_set(xml, (char *) name, NULL, "tag"); if (xmlTextReaderHasAttributes(reader)) { xmlTextReaderMoveToFirstAttribute(reader); do { xmlChar *attr_name, *attr_value; attr_name = xmlTextReaderName(reader); attr_value = xmlTextReaderValue(reader); _lng_set(xml, (char *) attr_name, (char *) attr_value, "atr"); xmlFree(attr_name); xmlFree(attr_value); } while (xmlTextReaderMoveToNextAttribute(reader) == 1); } if (!empty) break; } case XML_READER_TYPE_END_ELEMENT: { if (!xml) return EINA_FALSE; if (!xml->current) xml->current = xml->top; else xml->current = xml->current->parent; break; } case XML_READER_TYPE_WHITESPACE: break; case XML_READER_TYPE_TEXT: { _lng_set(xml, (char *) value, NULL, "val"); break; } } xmlFree(name); xmlFree(value); } xmlTextReaderClose(reader); xmlFreeTextReader(reader); xml->current = xml->top; return EINA_TRUE; }
bool IWORKParser::parse() { const shared_ptr<xmlTextReader> sharedReader(xmlReaderForIO(readFromStream, closeStream, m_input.get(), "", 0, 0), xmlFreeTextReader); if (!sharedReader) return false; xmlTextReaderPtr reader = sharedReader.get(); assert(reader); const IWORKTokenizer &tokenizer = getTokenizer(); stack<IWORKXMLContextPtr_t> contextStack; int ret = xmlTextReaderRead(reader); contextStack.push(createDocumentContext()); while ((1 == ret)) { switch (xmlTextReaderNodeType(reader)) { case XML_READER_TYPE_ELEMENT: { const int id = tokenizer.getQualifiedId(char_cast(xmlTextReaderConstLocalName(reader)), char_cast(xmlTextReaderConstNamespaceUri(reader))); IWORKXMLContextPtr_t newContext = contextStack.top()->element(id); if (!newContext) newContext = createDiscardContext(); const bool isEmpty = xmlTextReaderIsEmptyElement(reader); newContext->startOfElement(); if (xmlTextReaderHasAttributes(reader)) { ret = xmlTextReaderMoveToFirstAttribute(reader); while (1 == ret) { processAttribute(reader, newContext, tokenizer); ret = xmlTextReaderMoveToNextAttribute(reader); } } if (isEmpty) newContext->endOfElement(); else contextStack.push(newContext); break; } case XML_READER_TYPE_END_ELEMENT: { contextStack.top()->endOfElement(); contextStack.pop(); break; } case XML_READER_TYPE_TEXT : { xmlChar *const text = xmlTextReaderReadString(reader); contextStack.top()->text(char_cast(text)); xmlFree(text); break; } default: break; } ret = xmlTextReaderRead(reader); } while (!contextStack.empty()) // finish parsing in case of broken XML { contextStack.top()->endOfElement(); contextStack.pop(); } xmlTextReaderClose(reader); return true; }
bool XmlReader::HasAttributes() { return (xmlTextReaderHasAttributes(libxml_stuff->reader) == 1); }
void getSetInfo(xmlTextReaderPtr reader) { if (reader == NULL) { fprintf(stderr, "Unable to access the file.\n"); exit(EXIT_FAILURE); } int ret; ret = xmlTextReaderRead(reader); // Si no se recupera un siguiente nodo, se termina la ejecución if (ret != 1) { fprintf(stderr, "ERROR: Unable to parse XML file.\n"); exit(EXIT_FAILURE); } xmlChar *name; name = xmlTextReaderLocalName(reader); // Si el nodo recuperado no corresponde al tag Set, se aborta if (xmlStrcasecmp(name, (const xmlChar*)"Set") != 0) { xmlFree(name); fprintf(stderr, "ERROR: No `Set` tag. Invalid XML file.\n"); exit(EXIT_FAILURE); } xmlFree(name); // Comprueba que el nodo contenga atributos if (xmlTextReaderHasAttributes(reader) != 1) { fprintf(stderr, "ERROR: `Set` tag has no attributes.\n"); exit(EXIT_FAILURE); } printf("=== File info ===\n"); xmlChar *value; // Número de grupos de tareas en el archivo value = xmlTextReaderGetAttribute(reader, (const xmlChar*)"size"); expRtsNr = atoi((char*) value); printf("Expected number of RTS: %d\n", expRtsNr); xmlFree(value); // Número de STR a verificar si no se paso opción --limit if (cont == 0) { cont = expRtsNr; } limit = cont; // Reservamos memoria para almacenar los FU fuArray = (double *) malloc(cont * sizeof(double)); // Cantidad de tareas por cada sistema value = xmlTextReaderGetAttribute(reader, (const xmlChar*)"n"); taskNr = atoi((char*) value); printf("Number of tasks per RTS: %d\n", taskNr); xmlFree(value); // FU para todos los RTS if (gexpFu == 0) { value = xmlTextReaderGetAttribute(reader, (const xmlChar*)"u"); if (value == NULL) { xmlFree(value); fprintf(stderr, "ERROR: `Set` tag has no FU value. Specify one with --fu option.\n"); exit(EXIT_FAILURE); } gexpFu = atof((char*) value); xmlFree(value); } printf("Expected FU for all RTS: %.5f (%.3f)\n", gexpFu / 100.0, gexpFu); printf("RTS to analize: %d\n", cont); printf("Delta: %.3f\n", delta); }
/* * call-seq: * reader.has_attributes? -> bool * * Get whether the node has attributes. */ static VALUE rxml_reader_has_attributes(VALUE self) { return xmlTextReaderHasAttributes(rxml_text_reader_get(self)) ? Qtrue : Qfalse; }
/* @method Boolean XmlReader.hasAttributes() */ METHOD XmlReader_hasAttributes(Ctx *ctx, knh_sfp_t *sfp) { xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]); int ret = xmlTextReaderHasAttributes(reader); KNH_RETURN_Boolean(ctx,sfp,ret); }
static int ooxml_content_cb(int fd, cli_ctx *ctx) { int ret = CL_SUCCESS, tmp, toval = 0, state; int core=0, extn=0, cust=0, dsig=0; int mcore=0, mextn=0, mcust=0; const xmlChar *name, *value, *CT, *PN; xmlTextReaderPtr reader = NULL; uint32_t loff; unsigned long sav_scansize = ctx->scansize; unsigned int sav_scannedfiles = ctx->scannedfiles; cli_dbgmsg("in ooxml_content_cb\n"); /* perform engine limit checks in temporary tracking session */ ret = ooxml_updatelimits(fd, ctx); if (ret != CL_CLEAN) return ret; /* apply a reader to the document */ reader = xmlReaderForFd(fd, "[Content_Types].xml", NULL, CLAMAV_MIN_XMLREADER_FLAGS); if (reader == NULL) { cli_dbgmsg("ooxml_content_cb: xmlReaderForFd error for ""[Content_Types].xml""\n"); cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_XML_READER_FD"); ctx->scansize = sav_scansize; ctx->scannedfiles = sav_scannedfiles; return CL_SUCCESS; // libxml2 failed! } /* locate core-properties, extended-properties, and custom-properties (optional) */ while ((state = xmlTextReaderRead(reader)) == 1) { if (cli_json_timeout_cycle_check(ctx, &toval) != CL_SUCCESS) { ret = CL_ETIMEOUT; goto ooxml_content_exit; } name = xmlTextReaderConstLocalName(reader); if (name == NULL) continue; if (strcmp((const char *)name, "Override")) continue; if (xmlTextReaderHasAttributes(reader) != 1) continue; CT = PN = NULL; while (xmlTextReaderMoveToNextAttribute(reader) == 1) { name = xmlTextReaderConstLocalName(reader); value = xmlTextReaderConstValue(reader); if (name == NULL || value == NULL) continue; if (!xmlStrcmp(name, (const xmlChar *)"ContentType")) { CT = value; } else if (!xmlStrcmp(name, (const xmlChar *)"PartName")) { PN = value; } cli_dbgmsg("%s: %s\n", name, value); } if (!CT && !PN) continue; if (!xmlStrcmp(CT, (const xmlChar *)"application/vnd.openxmlformats-package.core-properties+xml")) { /* default: /docProps/core.xml*/ tmp = unzip_search_single(ctx, (const char *)(PN+1), xmlStrlen(PN)-1, &loff); if (tmp == CL_ETIMEOUT) { ret = tmp; } else if (tmp != CL_VIRUS) { cli_dbgmsg("cli_process_ooxml: failed to find core properties file \"%s\"!\n", PN); mcore++; } else { cli_dbgmsg("ooxml_content_cb: found core properties file \"%s\" @ %x\n", PN, loff); if (!core) { tmp = unzip_single_internal(ctx, loff, ooxml_core_cb); if (tmp == CL_ETIMEOUT || tmp == CL_EMEM) { ret = tmp; } } core++; } } else if (!xmlStrcmp(CT, (const xmlChar *)"application/vnd.openxmlformats-officedocument.extended-properties+xml")) { /* default: /docProps/app.xml */ tmp = unzip_search_single(ctx, (const char *)(PN+1), xmlStrlen(PN)-1, &loff); if (tmp == CL_ETIMEOUT) { ret = tmp; } else if (tmp != CL_VIRUS) { cli_dbgmsg("cli_process_ooxml: failed to find extended properties file \"%s\"!\n", PN); mextn++; } else { cli_dbgmsg("ooxml_content_cb: found extended properties file \"%s\" @ %x\n", PN, loff); if (!extn) { tmp = unzip_single_internal(ctx, loff, ooxml_extn_cb); if (tmp == CL_ETIMEOUT || tmp == CL_EMEM) { ret = tmp; } } extn++; } } else if (!xmlStrcmp(CT, (const xmlChar *)"application/vnd.openxmlformats-officedocument.custom-properties+xml")) { /* default: /docProps/custom.xml */ tmp = unzip_search_single(ctx, (const char *)(PN+1), xmlStrlen(PN)-1, &loff); if (tmp == CL_ETIMEOUT) { ret = tmp; } else if (tmp != CL_VIRUS) { cli_dbgmsg("cli_process_ooxml: failed to find custom properties file \"%s\"!\n", PN); mcust++; } else { cli_dbgmsg("ooxml_content_cb: found custom properties file \"%s\" @ %x\n", PN, loff); /* custom properties are not parsed */ cust++; } } else if (!xmlStrcmp(CT, (const xmlChar *)"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml")) { dsig++; } if (ret != CL_SUCCESS) goto ooxml_content_exit; } ooxml_content_exit: if (core) { cli_jsonint(ctx->wrkproperty, "CorePropertiesFileCount", core); if (core > 1) cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_MULTIPLE_CORE_PROPFILES"); } else if (!mcore) cli_dbgmsg("cli_process_ooxml: file does not contain core properties file\n"); if (mcore) { cli_jsonint(ctx->wrkproperty, "CorePropertiesMissingFileCount", mcore); cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_MISSING_CORE_PROPFILES"); } if (extn) { cli_jsonint(ctx->wrkproperty, "ExtendedPropertiesFileCount", extn); if (extn > 1) cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_MULTIPLE_EXTN_PROPFILES"); } else if (!mextn) cli_dbgmsg("cli_process_ooxml: file does not contain extended properties file\n"); if (mextn) { cli_jsonint(ctx->wrkproperty, "ExtendedPropertiesMissingFileCount", mextn); cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_MISSING_EXTN_PROPFILES"); } if (cust) { cli_jsonint(ctx->wrkproperty, "CustomPropertiesFileCount", cust); if (cust > 1) cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_MULTIPLE_CUSTOM_PROPFILES"); } else if (!mcust) cli_dbgmsg("cli_process_ooxml: file does not contain custom properties file\n"); if (mcust) { cli_jsonint(ctx->wrkproperty, "CustomPropertiesMissingFileCount", mcust); cli_json_parse_error(ctx->wrkproperty, "OOXML_ERROR_MISSING_CUST_PROPFILES"); } if (dsig) { cli_jsonint(ctx->wrkproperty, "DigitalSignaturesCount", dsig); } /* restore the engine tracking limits; resets session limit tracking */ ctx->scansize = sav_scansize; ctx->scannedfiles = sav_scannedfiles; xmlTextReaderClose(reader); xmlFreeTextReader(reader); return ret; }
void processNode(xmlTextReaderPtr reader) { xmlChar *name; xmlChar *wcet; xmlChar *period; xmlChar *expFuChar; name = xmlTextReaderLocalName(reader); if (xmlStrcasecmp(name, (const xmlChar*)"S") == 0) { // Tag de inicio if (xmlTextReaderNodeType(reader) == 1) { rtsNr = rtsNr + 1; // Comprueba que el nodo contenga atributos if (xmlTextReaderHasAttributes(reader) != 1) { fprintf(stderr, "ERROR: `S` tag has no attributes.\n"); exit(EXIT_FAILURE); } expFuChar = xmlTextReaderGetAttribute(reader, (const xmlChar*)"U"); expFu = atof((char*) expFuChar) / 100.0; xmlFree(expFuChar); } // Tag de cierre -- XmlNodeType.EndElement vale 15 if (xmlTextReaderNodeType(reader) == 15) { int flag; double diff, diff2; flag = 0; diff = fabs(fu - expFu); diff2 = fabs(fu - gexpFu / 100.0); if (diff > delta) { if (verbose) { fprintf(stderr, "ERROR -- RTS %d, wrong FU: %.5f, expected %.5f (S)\n", rtsNr, fu, expFu); } invalidFuCnt = invalidFuCnt + 1; flag = 1; } else if (diff2 > delta) { if (verbose) { fprintf(stderr, "ERROR -- RTS %d, wrong FU: %.5f, expected %.5f (Set)\n", rtsNr, fu, gexpFu / 100.0); } // No incrementa el contador si ya se detecto como erroneo if (flag == 0) { invalidFuCnt = invalidFuCnt + 1; } } else { // FU correcto validFuCnt = validFuCnt + 1; } fuArray[rtsNr - 1] = fu; fu = 0.0; flag = 0; cont = cont - 1; } } // Tarea if (xmlStrcasecmp(name, (const xmlChar*)"i") == 0) { wcet = xmlTextReaderGetAttribute(reader, (const xmlChar*)"C"); period = xmlTextReaderGetAttribute(reader, (const xmlChar*)"T"); fu = fu + atof((char*) wcet) / atof((char*) period); xmlFree(wcet); xmlFree(period); } xmlFree(name); }
void daeLIBXMLPlugin::readAttributes( daeElement *element, xmlTextReaderPtr reader ) { // See if the element has attributes if(xmlTextReaderHasAttributes(reader)) { // Read in and set all the attributes while(xmlTextReaderMoveToNextAttribute(reader)) { daeMetaAttribute *ma = element->getMeta()->getMetaAttribute((const daeString)xmlTextReaderConstName(reader)); if( ( ma != NULL && ma->getType() != NULL && ma->getType()->getUsesStrings() ) || strcmp(element->getMeta()->getName(), "any") == 0 ) { // String is used as one piece if(!element->setAttribute( (const daeString)xmlTextReaderConstName(reader), (const daeString)xmlTextReaderConstValue(reader) ) ) { const xmlChar * attName = xmlTextReaderConstName(reader); const xmlChar * attValue = xmlTextReaderConstValue(reader); char err[256]; memset( err, 0, 256 ); #if LIBXML_VERSION >= 20620 sprintf(err,"The DOM was unable to create an attribute %s = %s at line %d\nProbably a schema violation.\n", attName, attValue ,xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"The DOM was unable to create an attribute %s = %s \nProbably a schema violation.\n", attName, attValue); #endif daeErrorHandler::get()->handleWarning( err ); } } else { // String needs to be broken up into whitespace seperated items. The "set" methods for numbers are smart enough to // grab just the first number in a string, but the ones for string lists require a null terminator between each // string. If this could be fixed we could avoid a copy and memory allocation by using xmlTextReaderConstValue(reader) if ( ma == NULL ) { const xmlChar * attName = xmlTextReaderConstName(reader); const xmlChar * attValue = xmlTextReaderConstValue(reader); char err[256]; memset( err, 0, 256 ); #if LIBXML_VERSION >= 20620 sprintf(err,"The DOM was unable to create an attribute %s = %s at line %d\nProbably a schema violation.\n", attName, attValue ,xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"The DOM was unable to create an attribute %s = %s \nProbably a schema violation.\n", attName, attValue); #endif daeErrorHandler::get()->handleWarning( err ); continue; } xmlChar* value = xmlTextReaderValue(reader); daeChar* current = (daeChar *)value; while(*current != 0) { // !!!GAC NEEDS TO BE CHANGED to use XML standard whitespace parsing // Skip leading whitespace while(*current == ' ' || *current == '\r' || *current == '\n' || *current == '\t') current++; if(*current != 0) { daeChar* start=current; // Find end of string and insert a zero terminator while(*current != ' ' && *current != '\r' && *current != '\n' && *current != '\t' && *current != 0) current++; if(*current != 0) { *current = 0; current++; } if(!element->setAttribute( (const daeString)xmlTextReaderConstName(reader), start) ) { const xmlChar * attName = xmlTextReaderConstName(reader); const xmlChar * attValue = xmlTextReaderConstValue(reader); char err[256]; memset( err, 0, 256 ); #if LIBXML_VERSION >= 20620 sprintf(err,"The DOM was unable to create an attribute %s = %s at line %d\nProbably a schema violation.\n", attName, attValue ,xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"The DOM was unable to create an attribute %s = %s \nProbably a schema violation.\n", attName, attValue); #endif daeErrorHandler::get()->handleWarning( err ); } } } xmlFree(value); } } } }
EPUB3Error EPUB3ProcessXMLReaderNodeForMetadataInOPF(EPUB3Ref epub, xmlTextReaderPtr reader, EPUB3XMLParseContextPtr *context) { assert(epub != NULL); assert(reader != NULL); EPUB3Error error = kEPUB3Success; const xmlChar *name = xmlTextReaderConstLocalName(reader); xmlReaderTypes nodeType = xmlTextReaderNodeType(reader); switch(nodeType) { case XML_READER_TYPE_ELEMENT: { if(!xmlTextReaderIsEmptyElement(reader)) { (void)EPUB3SaveParseContext(context, kEPUB3OPFStateMetadata, name, 0, NULL, kEPUB3_YES, NULL); // Only parse text node for the identifier marked as unique-identifier in the package tag // see: http://idpf.org/epub/30/spec/epub30-publications.html#sec-opf-dcidentifier if(xmlStrcmp(name, BAD_CAST "identifier") == 0) { if(xmlTextReaderHasAttributes(reader)) { xmlChar * itemId = xmlTextReaderGetAttribute(reader, BAD_CAST "id"); if(itemId == NULL) { (*context)->shouldParseTextNode = kEPUB3_NO; } else if(itemId != NULL && xmlStrcmp(itemId, BAD_CAST epub->metadata->_uniqueIdentifierID) != 0) { (*context)->shouldParseTextNode = kEPUB3_NO; } EPUB3_XML_FREE_AND_NULL(itemId); } break; } } if(epub->metadata->version == kEPUB3Version_2) { // There is no standard for cover images in EPUB 2. This is the accepted ad hoc method for defining one // http://blog.threepress.org/2009/11/20/best-practices-in-epub-cover-images/ // http://www.mobipocket.com/dev/article.asp?BaseFolder=prcgen&File=cover.htm#IDPF2 if(xmlStrcmp(name, BAD_CAST "meta") == 0) { if(xmlTextReaderHasAttributes(reader)) { xmlChar * metaName = xmlTextReaderGetAttribute(reader, BAD_CAST "name"); if(metaName != NULL && xmlStrcmp(metaName, BAD_CAST "cover") == 0) { xmlChar * coverId = xmlTextReaderGetAttribute(reader, BAD_CAST "content"); EPUB3MetadataSetCoverImageId(epub->metadata, (const char *)coverId); EPUB3_XML_FREE_AND_NULL(coverId); } EPUB3_XML_FREE_AND_NULL(metaName); } } } break; } case XML_READER_TYPE_TEXT: { const xmlChar *value = xmlTextReaderValue(reader); if(value != NULL && (*context)->shouldParseTextNode) { if(xmlStrcmp((*context)->tagName, BAD_CAST "title") == 0) { (void)EPUB3MetadataSetTitle(epub->metadata, (const char *)value); } else if(xmlStrcmp((*context)->tagName, BAD_CAST "identifier") == 0) { (void)EPUB3MetadataSetIdentifier(epub->metadata, (const char *)value); } else if(xmlStrcmp((*context)->tagName, BAD_CAST "language") == 0) { (void)EPUB3MetadataSetLanguage(epub->metadata, (const char *)value); } } break; } case XML_READER_TYPE_END_ELEMENT: { (void)EPUB3PopAndFreeParseContext(context); break; } default: break; } return error; }