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