static int expect_element_end ( xmlTextReaderPtr reader, char *exp_name) { xmlChar *name; /* maybe we are already on the end element ... lets see */ if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT){ xmlChar *temp; xmlChar *temp2; temp = xmlTextReaderName(reader); temp2 = (xmlChar*)sprintf_alloc("/%s", temp); name = xmlStrdup(temp2); xmlFree(temp); free(temp2); } else { name = get_xml_element(reader); } if (name == NULL) return -1; if (xmlStrcasecmp(name+1,(xmlChar *)exp_name) != 0 || name[0] != '/'){ rrd_set_error("line %d: expected </%s> end element but found <%s>", xmlTextReaderGetParserLineNumber(reader),exp_name,name); xmlFree(name); return -1; } xmlFree(name); return 0; } /* expect_element_end */
static int get_xml_time_t( xmlTextReaderPtr reader, time_t *value) { xmlChar *text; time_t temp; if ((text = get_xml_text(reader)) != NULL){ errno = 0; #if SIZEOF_TIME_T == 4 temp = strtol((char *)text,NULL, 0); #elif SIZEOF_TIME_T == 8 temp = strtoll((char *)text,NULL, 0); #else #error "Don't know how to deal with TIME_T other than 4 or 8 bytes" #endif if (errno>0){ rrd_set_error("ling %d: get_xml_time_t from '%s' %s", xmlTextReaderGetParserLineNumber(reader), text,rrd_strerror(errno)); xmlFree(text); return -1; } xmlFree(text); *value = temp; return 0; } return -1; } /* get_xml_time_t */
char* readRequiredAttribute( xmlTextReaderPtr xmlRead, const char* name ) { char* s = (char*) xmlTextReaderGetAttribute( xmlRead, name ); if( s == NULL || strlen( s ) == 0 ) { printf( "Error on line %d: expected required attribute\n", xmlTextReaderGetParserLineNumber( xmlRead ) ); return NULL; } return s; }
char* readString( xmlTextReaderPtr xmlRead ) { char* s = (char*) xmlTextReaderReadInnerXML( xmlRead ); if( s == NULL || strlen( s ) == 0 ) { printf( "Error on line %d: expected string\n", xmlTextReaderGetParserLineNumber( xmlRead ) ); return NULL; } return s; }
gint xml_reader_get_line_number (XmlReader *reader) { g_return_val_if_fail(XML_IS_READER(reader), -1); if (reader->xml) return xmlTextReaderGetParserLineNumber(reader->xml); return -1; }
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 */
void reportError(void *ptr, xmlErrorPtr error) { ErrorInfo *errorInfo = (ErrorInfo*) ptr; assert(errorInfo); if (errorInfo->verbose) { int msglen; int domain = error->domain; const char *filename = error->file? error->file : errorInfo? errorInfo->filename : NULL; xmlTextReaderPtr reader = errorInfo->xmlReader; int line = (!filename)? 0 : (reader)? xmlTextReaderGetParserLineNumber(reader) : error->line; int column = (!filename)? 0 : (reader)? xmlTextReaderGetParserColumnNumber(reader) : error->int2; if (line) { fprintf(stderr, "%s:%d.%d: ", filename, line, column); } msglen = strlen(error->message); if (error->message[msglen-1] == '\n') error->message[msglen-1] = '\0'; fprintf(stderr, "%s", error->message); /* only print extra info if it's not in message */ if (error->str1 && strstr(error->message, error->str1) == NULL) { fprintf(stderr, ": %s", error->str1); if (error->str2 && strstr(error->message, error->str2) == NULL) { fprintf(stderr, ", %s", error->str2); } if (error->str3 && strstr(error->message, error->str3) == NULL) { fprintf(stderr, ", %s", error->str3); } } fprintf(stderr, "\n"); if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) || (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) || (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) { xmlParserCtxtPtr ctxt = error->ctxt; if (ctxt) xmlParserPrintFileContext(ctxt->input); } } if (errorInfo->stop == STOP) { exit(EXIT_FAILURE); } }
/* reader:line_number() */ static int xmlreader_line_number(lua_State *L) { xmlreader xr = check_xmlreader(L, 1); int ret = xmlTextReaderGetParserLineNumber(xr); if (ret != 0) { lua_pushinteger(L, ret); } else { lua_pushnil(L); /* Should we just return 0? */ } return 1; }
int XMIResource::processText(xmlTextReaderPtr reader) { int ret; switch (parent) { case e_nzcross: // nzcross is a Block property ret = loadIntArray(reader, NZCROSS, processed.back()); break; case e_nmode: // nmode is a Block property ret = loadIntArray(reader, NMODE, processed.back()); break; case e_rpar: // rpar is a Block property ret = loadDoubleArray(reader, RPAR, processed.back()); break; case e_ipar: // ipar is a Block property ret = loadIntArray(reader, IPAR, processed.back()); break; case e_state: // state is a Block property ret = loadDoubleArray(reader, RPAR, processed.back()); break; case e_dstate: // dstate is a Block property ret = loadDoubleArray(reader, RPAR, processed.back()); break; case e_expression: // expression is a Block property ret = loadStringArray(reader, EXPRS, processed.back()); break; case e_context: // context is a Layer property ret = loadStringArray(reader, DIAGRAM_CONTEXT, processed.back()); break; case e_datatype: // datatype is a port property ret = loadIntArray(reader, DATATYPE, processed.back()); break; default: sciprint("Unable to decode text value at line %d\n", xmlTextReaderGetParserLineNumber(reader) - 1); ret = -1; break; } return ret; }
static int expect_element ( xmlTextReaderPtr reader, char *exp_name) { xmlChar *name; name = get_xml_element(reader); if (!name) return -1; if (xmlStrcasecmp(name,(xmlChar *)exp_name) != 0){ rrd_set_error("line %d: expected <%s> element but found <%s>", xmlTextReaderGetParserLineNumber(reader),name,exp_name); xmlFree(name); return -1; } xmlFree(name); return 0; } /* expect_element */
static int get_xml_ulong( xmlTextReaderPtr reader, unsigned long *value) { xmlChar *text; unsigned long temp; if ((text = get_xml_text(reader)) != NULL){ errno = 0; temp = strtoul((char *)text,NULL, 0); if (errno>0){ rrd_set_error("ling %d: get_xml_ulong from '%s' %s", xmlTextReaderGetParserLineNumber(reader), text,rrd_strerror(errno)); xmlFree(text); return -1; } xmlFree(text); *value = temp; return 0; } return -1; } /* get_xml_ulong */
static int get_xml_double( xmlTextReaderPtr reader, double *value) { xmlChar *text; double temp; if ((text = get_xml_text(reader))!= NULL){ if (xmlStrcasestr(text,(xmlChar *)"nan")){ *value = DNAN; xmlFree(text); return 0; } else if (xmlStrcasestr(text,(xmlChar *)"-inf")){ *value = -DINF; xmlFree(text); return 0; } else if (xmlStrcasestr(text,(xmlChar *)"+inf") || xmlStrcasestr(text,(xmlChar *)"inf")){ *value = DINF; xmlFree(text); return 0; } if ( rrd_strtodbl((char *)text,NULL, &temp, NULL) != 2 ){ rrd_set_error("ling %d: get_xml_double from '%s' %s", xmlTextReaderGetParserLineNumber(reader), text,rrd_strerror(errno)); xmlFree(text); return -1; } xmlFree(text); *value = temp; return 0; } return -1; } /* get_xml_double */
/* * call-seq: * reader.line_number -> number * * Provide the line number of the current parsing point. */ static VALUE rxml_reader_line_number(VALUE self) { xmlTextReaderPtr xreader = rxml_text_reader_get(self); return INT2NUM(xmlTextReaderGetParserLineNumber(xreader)); }
static int parse_tag_rra_database( xmlTextReaderPtr reader, rrd_t *rrd ) { rra_def_t *cur_rra_def; unsigned int total_row_cnt; int status; int i; xmlChar *element; total_row_cnt = 0; for (i = 0; i < (((int) rrd->stat_head->rra_cnt) - 1); i++) total_row_cnt += rrd->rra_def[i].row_cnt; cur_rra_def = rrd->rra_def + i; status = 0; while ((element = get_xml_element(reader)) != NULL){ if (xmlStrcasecmp(element,(const xmlChar *)"row") == 0){ rrd_value_t *temp; rrd_value_t *cur_rrd_value; unsigned int total_values_count = rrd->stat_head->ds_cnt * (total_row_cnt + 1); /* Allocate space for the new values.. */ temp = (rrd_value_t *) realloc(rrd->rrd_value, sizeof(rrd_value_t) * total_values_count); if (temp == NULL) { rrd_set_error("parse_tag_rra_database: realloc failed."); status = -1; break; } rrd->rrd_value = temp; cur_rrd_value = rrd->rrd_value + (rrd->stat_head->ds_cnt * total_row_cnt); memset(cur_rrd_value, '\0', sizeof(rrd_value_t) * rrd->stat_head->ds_cnt); total_row_cnt++; cur_rra_def->row_cnt++; status = parse_tag_rra_database_row(reader, rrd, cur_rrd_value); if (status == 0) status = expect_element(reader,"/row"); } /* if (xmlStrcasecmp(element,"row")) */ else { if ( xmlStrcasecmp(element,(const xmlChar *)"/database") == 0){ xmlFree(element); break; } else { rrd_set_error("line %d: found unexpected tag: %s", xmlTextReaderGetParserLineNumber(reader),element); status = -1; } } xmlFree(element); if (status != 0) break; } return (status); } /* int parse_tag_rra_database */
void readConfig( const char* filename ) { /* States: * 0 : reading new entities ( to: 1, 3, 4, 5 ) * 1 : reading machine * 2 : reading role * 3 : reading core * 4 : reading file * 5 : reading test ( to: 2 ) */ int state = 0; struct machine m; struct role r; struct file f; struct core c; struct test t; xmlTextReaderPtr xmlRead = xmlReaderForFile( filename, NULL, XML_PARSE_NONET | XML_PARSE_NOENT | XML_PARSE_NOCDATA | XML_PARSE_NOXINCNODE | XML_PARSE_COMPACT ); if( !xmlRead ) quit( "Could not open %s for reading as XML config\n", filename ); xmlTextReaderSetErrorHandler( xmlRead, xmlErrorHandler, 0 ); int nodeType, ret; xmlChar* nodeName; while( 1 ) { if( ( ret = xmlTextReaderRead( xmlRead ) ) != 1 ) { if( ret < 0 ) quit( "Error occurred\n" ); if( state ) quit( "No more nodes to read, but state is not 0. Incomplete elements.\n" ); xmlTextReaderClose( xmlRead ); return; } nodeType = xmlTextReaderNodeType( xmlRead ); nodeName = NULL; switch( nodeType ) { case XmlNodeType.Element : nodeName = xmlTextReaderLocalName( xmlRead ); switch( state ) { case 0 : if( !strcmp( nodeName, "machine" ) ) { state = 1; bzero( m, sizeof( struct machine ) ); readValidRequiredAttribute( m.name, "machine", "name" ); readValidRequiredAttribute( m.address, "machine", "address" ); if( !strcmp( m.address, "DAS4" ) ) { readValidRequiredAttribute( m.count, "machine", "DAS4 node count" ); char* end = NULL; m.icount = strtol( m.count, &end, 10 ); if( end == m.count || *end || m.icount < 1 ) quit( "Invalid DAS4 node count for machine %s\n", m.name ); } break; } if( !strcmp( nodeName, "core" ) ) { state = 3; bzero( c, sizeof( struct core ) ); readValidRequiredAttribute( c.name, "core", "name" ); break; } if( !strcmp( nodeName, "file" ) ) { state = 4; bzero( f, sizeof( struct file ) ); readValidRequiredAttribute( f.name, "file", "name" ); readValidRequiredAttribute( f.size, "file", "size" ); char* end = NULL; f.isize = strtol( f.size, &end, 10 ); if( end == f.size || f.isize < 1 ) quit( "Invalid size specifier for file %s\n", f.name ); if( *end && *(end+1) ) quit( "Invalid size specifier for file %s\n", f.name ); if( *end ) { switch( *end ) { case 'b' : case 'B' : break; case 'k' : case 'K' : f.isize *= 1024; break; case 'm' : case 'M' : f.isize *= 1024 * 1024; break; case 'g' : case 'G' : f.isize *= 1024 * 1024 * 1024; break; case 't' : case 'T' : f.isize *= 1024 * 1024 * 1024 * 1024; break; default : quit( "Invalid size specifier for file %s\n", f.name ); } } if( f.isize > 512 * 1024 * 1024 ) { int p = 512*1024*1024; while( p < f.isize ) p <<= 1; if( p != f.isize ) quit( "Invalid size specifier for file %s: sizes above 512M should be powers of 2\n", f.name ); } if( f.isize & 0x3 ) quit( "Invalid size specifier for file %s: sizes should be a multiple of 4\n", f.name ); break; } if( !strcmp( nodeName, "test" ) ) { state = 5; bzero( t, sizeof( struct test ) ); readValidRequiredAttribute( t.name, "test", "name" ); break; } break; case 1 : if( !strcmp( nodeName, "tmpDir" ) ) { onlyOne( m.tmpdir, "machine", "tmpDir" ); readValidString( m.tmpdir, "temporary directory location" ); skipToEndElement( "tmpDir" ); break; } if( !strcmp( nodeName, "params" ) ) { onlyOne( m.params, "machine", "params" ); readValidString( m.params, "params" ); skipToEndElement( "params" ); break; } printf( "Unexpected element %s in machine %s\n", nodeName, m.name ); break; case 2 : if( !strcmp( nodeName, "machine" ) ) { if( r.machineCount > 255 ) quit( "Maximum of 256 machines per role passed on line %d\n", xmlTextReaderGetParserLineNumber( xmlRead ) ); readValid( r.machine[r.machineCount], "machine name" ); r.machineCount++; skipToEndElement( "machine" ); break; } if( !strcmp( nodeName, "user" ) ) { onlyOne( r.user, "role", "user" ); readValidString( r.user, "user" ); skipToEndElement( "user" ); break; } if( !strcmp( nodeName, "core" ) ) { onlyOne( r.core, "role", "core" ); readValidString( r.core, "core name" ); skipToEndElement( "core" ); break; } if( !strcmp( nodeName, "file" ) ) { onlyOne( r.file, "role", "file" ); readValidString( r.file, "file name" ); skipToEndElement( "file" ); break; } if( !strcmp( nodeName, "params" ) ) { onlyOne( r.params, "role", "params" ); readValidString( r.params, "params" ); skipToEndElement( "params" ); break; } printf( "Unexpected element %s in role on line %d\n", nodeName, xmlTextReaderGetParserLineNumber( xmlRead ) ); break; case 3 : if( !strcmp( nodeName, "params" ) ) { onlyOne( c.params, "core", "params" ); readValidString( c.params, "params" ); skipToEndElement( "params" ); break; } if( !strcmp( nodeName, "localDir" ) ) { onlyOne( c.localdir, "core", "localDir" ); readValidString( c.localdir, "local core directory" ); skipToEndElement( "localDir" ); break; } if( !strcmp( nodeName, "compilationDir" ) ) { onlyOne( c.compdir, "core", "compilationDir" ); readValidString( c.compdir, "relative compilation directory" ); skipToEndElement( "compilationDir" ); break; } if( !strcmp( nodeName, "program" ) ) { onlyOne( c.program, "core", "program" ); readValidString( c.program, "program name" ); skipToEndElement( "program" ); break; } printf( "Unexpected element %s in core %s\n", nodeName, c.name ); skipToEndElement( nodeName ); break; case 4 : if( !strcmp( nodeName, "offset" ) ) { onlyOne( c.offset, "file", "offset" ); readValidString( c.offset, "offset" ); char* end = NULL; f.ioffset = strtol( f.offset, &end, 10 ); if( end == f.offset || *end || f.ioffset < 0 || f >= f.isize ) quit( "Invalid file offset for file %s\n", f.name ); skipToEndElement( "offset" ); break; } printf( "Unexpected element %s in file %s\n", nodeName, f.name ); skipToEndElement( nodeName ); break; case 5 : if( !strcmp( nodeName, "role" ) ) { state = 2; bzero( r, sizeof( struct role ) ); readValidRequiredAttribute( r.type, "role", "type" ); if( strcmp( r.type, "seed" ) && strcmp( r.type, "leech" ) ) quit( "Invalid value for attribute 'type' for role on line %d, expected 'seed' or 'leech'\n", xmlTextReaderGetParserLineNumber( xmlRead ) ); break; } quit( "Unexpected element %s in test on line %d\n", nodeName, xmlTextReaderGetParserLineNumber( xmlRead ) ); default : quit( "State sanity\n", nodeName ); } break; case XmlNodeType.EndElement : nodeName = xmlTextReaderLocalName( xmlRead ); switch( state ) { case 0 : quit( "End element %s found while not in entity\n", nodeName ); case 1 : if( !strcmp( nodeName, "machine" ) ) { memcpy( machines + machineCount, &m, sizeof( struct machine ) ); machineCount++; state = 0; } break; case 2 : if( !strcmp( nodeName, "role" ) ) { mempcy( t.roles + r.roleCount, &r, sizeof( struct role ) ); t.roleCount++; state = 5; } break; case 3 : if( !strcmp( nodeName, "core" ) ) { memcpy( cores + coreCount, &c, sizeof( struct core ) ); coreCount++; state = 0; } break; case 4 : if( !strcmp( nodeName, "file" ) ) { memcpy( files + fileCount, &f, sizeof( struct file ) ); fileCount++; state = 0; } break; case 5 : if( !strcmp( nodeName, "test" ) ) { memcpy( tests + testCount, &t, sizeof( struct test ) ); testCount++; state = 0; } break; default : quit( "State sanity\n" ); } default : } if( nodeName ) free( nodeName ); } } void validateConfigAndGenerateScripts( ) { int i, j, k, l; bool found; // == Validate test-role references to machines, cores and files // == Also register which machine uses which cores and which files for( i = 0; i < testCount; i++ ) { for( j = 0; j < tests[i].roleCount; j++ ) { // Check for validity of each role's core found = false; for( k = 0; k < coreCount; k++ ) { if( !strcmp( cores[k].name, tests[i].roles[j].core ) ) { found = true; break; } } if( !found ) quit( "Test %s role %i refers to core %s which does not exist\n", tests[i].name, j, tests[i].roles[j].core ); // Check for validity of each role's file found = false; for( k = 0; k < fileCount; k++ ) { if( !strcmp( files[k].name, tests[i].roles[j].file ) ) { found = true; break; } } if( !found ) quit( "Test %s role %i refers to file %s which does not exist\n", tests[i].name, j, tests[i].roles[j].file ); // Check for validity of each role's machines for( l = 0; l < tests[i].roles[j].machineCount; l++ ) { found = false; for( k = 0; k < machineCount; k++ ) { if( !strcmp( machines[k].name, tests[i].roles[j].machines[l] ) ) { // Machine found: register used core with the machine if needed for( m = 0; m < machines[k].coreCount; m++ ) { if( !strcmp( machines[k].cores[m], tests[i].roles[j].core ) ) { found = true; break; } } if( !found ) machines[k].cores[machines[k].coreCount++] = tests[i].roles[j].core; // Machine found: register used file with the machine if needed, only if seeding if( !strcmp( tests[i].roles[j].type, "seed" ) ) { found = false; for( m = 0; m < machines[k].fileCount; m++ ) { if( !strcmp( machines[k].files[m], tests[i].roles[j].file ) ) { found = true; break; } } if( !found ) machines[k].files[machines[k].fileCount++] = tests[i].roles[j].file; } // Machine found found = true; break; } } if( !found ) quit( "Test %s role %i refers to machine %s which does not exist\n", tests[i].name, j, tests[i].roles[j].machines[l] ); } } } // Create temporary script FILE* script = tmpfile(); if( !script ) quit( "Can't create temporary script\n" ); fprintf( script, "#!/bin/bash\n" ); // == Check validity of machines and users: can each machine be accessed? for( i = 0; i < machineCount; i++ ) { // Creates a function in the script for sending command to the machine using ssh // Call using // ssh_machine_%i "commands" || cleanup -1 // where %i is the index of the machine in machines. Also be sure to return non-zero from your commands on error. fprintf( script, "function ssh_machine_%i {\n", i ); if( strcmp( machines[i].address, "DAS4" ) ) fprintf( script, " ssh -T -n -o BatchMode=yes -h \"%s\"", machines[i].address ); else fprintf( script, " ssh -T -n -o BatchMode=yes -h fs3.das4.tudelft.nl" ); if( machines[i].user ) fprintf( script, " -l \"%s\"", machines[i].user ); if( machines[i].params ) fprintf( script, " %s", machines[i].params ); fprintf( script, " $1 || return -1;\n" ); fprintf( script, "}\n" ); // Creates a function in the script for sending files to the machine using scp // Call using // scp_to_machine_%i localfile remotefile fprintf( script, "function scp_to_machine_%i {\n", i ); fprintf( script, "scp -o BatchMode=yes " ); if( machines[i].params ) fprintf( script, "%s ", machines[i].params ); fprintf( script, "$1 ", l ); if( machines[i].user ) fprintf( script, "\"%s\"@", machines[i].user ); if( strcmp( machines[i].address, "DAS4" ) ) fprintf( script, "\"%s\"", machines[i].address ); else fprintf( script, "fs3.das4.tudelft.nl" ); fprintf( script, ":$2 || cleanup -1\n", i, l ) fprintf( script, "}\n" ); // Creates a function in the script for retrieving files from the machine using scp // Call using // scp_from_machine_%i remotefile localfile fprintf( script, "function scp_from_machine_%i {\n", i ); fprintf( script, "scp -o BatchMode=yes " ); if( machines[i].params ) fprintf( script, "%s ", machines[i].params ); if( machines[i].user ) fprintf( script, "\"%s\"@", machines[i].user ); if( strcmp( machines[i].address, "DAS4" ) ) fprintf( script, "\"%s\"", machines[i].address ); else fprintf( script, "fs3.das4.tudelft.nl" ); fprintf( script, ":$1 $2 || cleanup -1\n", i, l ) fprintf( script, "}\n" ); // Checks reachability of machine fprintf( script, "ssh_machine_%i || exit -1\n", i ); } // == Check validity of each core: can each core be packaged? Can it be compiled locally and does the program then exist? // Create a cleanup file. This file should have code appended to cleanup things when errors occur or testing has finished. See existing code for examples of concatenating to it. // The cleanup function is available after this as well. Call it with an exit argument to end the script cleanly. fprintf( script, "CLEANUPFILE=`mktemp`\n" ); fprintf( script, "chmod +x CLEANUPFILE\n" ); fprintf( script, "[ -x CLEANUPFILE ] || exit -1\n" ); fprintf( script, "function cleanup {\n" ); fprintf( script, " (\ncat <<EOL\nrm $CLEANUPFILE\nEOL\n) >> $CLEANUPFILE\n" ); fprintf( script, " . $CLEANUPFILE\n" ); fprintf( script " exit $1\n" ); fprintf( script, "}\n" ); // Create a local temporary directory for storage fprintf( script, "TARDIR=`mktemp -d`\n[ \"X${TARDIR}X\" == \"XX\" ] && exit -1\n" ); fprintf( script, "(\ncat <<EOL\n#!/bin/bash\nrm -rf $TARDIR\nEOL\n) >> $CLEANUPFILE\n" ); fprintf( script, "CURDIR=`pwd`\n" ); // Create a tarball for the testenvironment in the temporary local storage fprintf( script, "make clean || cleanup -1\n" ); fprintf( script, "tar cf ${TARDIR}/testenvironment.tar . || cleanup -1\n" ); fprintf( script, "bzip2 ${TARDIR}/testenvironment.tar || cleanup -1\n" ); // Check whether the needed tools of the testenvironment compile locally fprintf( script, "make genfakedata || cleanup -1\n" ); for( i = 0; i < coreCount; i++ ) { if( !cores[i].localdir ) cores[i].localdir = strdup( "../" ); // Create a tarball for the core in the temporary local storage fprintf( script, "cd %s || cleanup -1\n", cores[i].localdir ); fprintf( script, "make clean\n" ); // Not checked: SHOULD be available, but... fprintf( script, "tar cf ${TARDIR}/core_%i.tar . || cleanup -1\n", i ); fprintf( script, "bzip2 ${TARDIR}/core_%i.tar || cleanup -1\n", i ); if( !cores[i].compdir ) cores[i].compdir = strdup( "testenvironment/" ); // Check whether the core compiles locally and the program exists after fprintf( script, "cd %s || cleanup -1\n", cores[i].compdir ); fprintf( script, "make || cleanup -1\n" ); if( !cores[i].program ) cores[i].program = strdup( "swift" ); fprintf( script, "[ -x %s ] || cleanup -1\n", cores[i].program ); fprintf( script, "cd ${CURDIR}\n" ); } // For each file, precalculate the hash for( i = 0; i < fileCount; i++ ) { // Create some temporary file to write fake data to. These fake data files will be regenerated at each machine since generating is faster than copying. size_t size = files[i].isize; FILE* data = tmpfile(); if( !data ) quit( "can't create temporary data file\n" ); int datan = fileno( data ); int filesize; if( size > 512*1024*1024 ) filesize = 512*1024*1024; else filesize = size; if( generateFakeData( datan, filesize ) ) quit( "could not write fake data\n" ); MemoryHashStorage mhs; FileOffsetDataStorage fods( datan, files[i].ioffset ); if( !fods.valid() ) quit( "can't read back from temporary data file\n" ); HashTree ht( fods, Sha1Hash::ZERO, mhs ); Sha1Hash hash = ht.root_hash(); if( size > filesize ) { MemoryHashStorage mhs2; int max = size/filesize; for( j = 0; j < max; j++ ) mhs2.setHash( bin64(0,j), hash ); int lvl = 0; do { max >>= 1; lvl++; for( j = 0; j < max; j++ ) mhs2.hashLeftRight( bin64_t(lvl, j) ); } while( max > 1 ); files[i].hash = mhs.getHash( bin64_t(lvl, 0) ); } else
int XmlTextReader::LineNumber() const { return xmlTextReaderGetParserLineNumber(ToReader(m_p)); }
void PTXReader::parseError(wstring const &message) { cerr << "Error: (" << xmlTextReaderGetParserLineNumber(reader); wcerr << L"): " << message << L"." << endl; exit(EXIT_FAILURE); }
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; }
/*DEF*/void *XoReadXmlReader(/*xmlTextReaderPtr*/ void *preader,char *roottype,int flags,int *err) { xmlTextReaderPtr reader = (xmlTextReaderPtr)preader; int next; t_ctxt ctxt; int ret; *err = 0; memset (&ctxt,0,sizeof(ctxt)); ctxt.roottype = roottype; ctxt.flags = flags; ctxt.ns.flags = flags; _XoAllocCtxt(&ctxt); if ( C_PARSE_TARGET(&ctxt) ) { void *r; char *tag = "<dont_save_this_tag>"; r = _XoRootPush(NULL,&ctxt,NULL,tag,err); if (!r) { _XoFreeCtxt(&ctxt); return NULL; } _XoSetElementName(r,tag); *err = 0; } if ( !C_PARSE_TRACE(&ctxt) ) xmlTextReaderSetErrorHandler(reader,IgnoreTrace,NULL); ret = 1; next = xmlTextReaderRead(reader); while (next == 1 && ret > 0) { ctxt.depth = xmlTextReaderDepth(reader); ctxt.nodetype = xmlTextReaderNodeType(reader); ctxt.qname = (char *)xmlTextReaderName(reader); ctxt.value = (char *)xmlTextReaderValue(reader); switch (ctxt.nodetype) { case XML_READER_TYPE_ELEMENT : ctxt.isempty = xmlTextReaderIsEmptyElement(reader); ctxt.atcount = xmlTextReaderAttributeCount(reader); FetchAttributes(reader,&ctxt); break; case XML_READER_TYPE_TEXT : break; } ret = _XoProcessNode(reader,&ctxt); if (ctxt.atcount) _XoFreeAttributesWith(&ctxt,xmlFree); if (ctxt.qname) xmlFree(ctxt.qname); if (ctxt.value) xmlFree(ctxt.value); if (ret < 0) { ctxt.line = xmlTextReaderGetParserLineNumber(reader); goto errload; } next = xmlTextReaderRead(reader); if ( C_PARSE_INTERACTIF(&ctxt) ) { int c; switch(ctxt.prevnode) { case XML_READER_TYPE_ELEMENT : case XML_READER_TYPE_TEXT : case XML_READER_TYPE_END_ELEMENT : _XoDumpStack(&ctxt); fflush(stdin); c = getchar(); if (c == 'p') { void *o; o = ctxt.obj[ctxt.level-1]; XoSaveAscii(o,stdout); } break; } } } if (next != 0) // parsing error, get line number { *err = xmlTextReaderGetParserLineNumber(reader); } if (next != 0) { if ( C_PARSE_TRACE(&ctxt) ) XOML_TRACE("XoReadXmlReader() : failed to parse next=%d ret=%d line=%d\n", next,ret,*err); if (ctxt.obj[0]) XoFree(ctxt.obj[0],1); _XoFreeCtxt(&ctxt); return NULL; } errload : if (ret < 0) { *err = ret; if ( C_PARSE_TRACE(&ctxt) ) XOML_TRACE("XoReadXmlReader() : failed to load next=%d ret=%d line=%d\n", next,ret,ctxt.line); if (ctxt.obj[0]) XoFree(ctxt.obj[0],1); _XoFreeCtxt(&ctxt); return NULL; } _XoFreeCtxt(&ctxt); return ctxt.obj[0]; }
void daeLIBXMLPlugin::readValue( daeElement *element, xmlTextReaderPtr reader ) { if ( element->getMeta()->getValueAttribute() == NULL ) { char err[256]; memset( err, 0, 256 ); #if LIBXML_VERSION >= 20620 sprintf(err,"The DOM was unable to set a value for element of type %s at line %d\nProbably a schema violation.\n", element->getTypeName() ,xmlTextReaderGetParserLineNumber(reader)); #else sprintf(err,"The DOM was unable to set a value for element of type %s at line %d\nProbably a schema violation.\n", element->getTypeName() ); #endif daeErrorHandler::get()->handleWarning( err ); } else if(element->getMeta()->getUsesStringContents()) { // String is used as one piece element->getMeta()->getValueAttribute()->set(element,(const daeString)xmlTextReaderConstValue(reader)); } 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) 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++; } element->getMeta()->getValueAttribute()->set(element,start); // eat the characters we just read (would be nice if set returned characters used. } } xmlFree(value); } int ret = xmlTextReaderRead(reader); assert(ret==1); }
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); } } } }
int XMIResource::processElement(xmlTextReaderPtr reader) { const xmlChar *name = xmlTextReaderConstLocalName(reader); parent = NB_XCOS_NAMES; // lookup for known node names // thanks to the string intern-ing, the pointer comparison could be used auto found = std::find(constXcosNames.begin(), constXcosNames.end(), name); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_Diagram: { // the root diagram should be decoded model::BaseObject o(root, DIAGRAM); processed.push_back(o); return loadDiagram(reader, o); } case e_child: { // this is a child of a diagram, resolve the type and call the loaders // iterate on attributes to lookup for EMF type // iterate on attributes for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader)) { const xmlChar* nsURI = xmlTextReaderConstNamespaceUri(reader); if (nsURI != xsiNamespaceUri) { continue; } auto foundName = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstLocalName(reader)); enum xcosNames currentName = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), foundName)); if (currentName != e_type) { continue; } const xmlChar* value = xmlTextReaderConstValue(reader); const xmlChar* valueWithoutPrefix = BAD_CAST(std::strchr((const char*) value, ':')); if (valueWithoutPrefix == nullptr) { valueWithoutPrefix = value; } else { // remove the leading ':' valueWithoutPrefix = valueWithoutPrefix + 1; } const xmlChar* interned = xmlTextReaderConstString(reader, valueWithoutPrefix); auto found = std::find(constXcosNames.begin(), constXcosNames.end(), interned); enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found)); switch (current) { case e_Block: { ScicosID o = controller.createObject(BLOCK); // assign the child model::BaseObject parent = processed.back(); std::vector<ScicosID> children; controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children); children.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children); model::BaseObject child(o, BLOCK); processed.push_back(child); return loadBlock(reader, child); } case e_Link: { ScicosID o = controller.createObject(LINK); // assign the child model::BaseObject parent = processed.back(); std::vector<ScicosID> children; controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children); children.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children); model::BaseObject child(o, LINK); processed.push_back(child); return loadLink(reader, child); } case e_Annotation: { ScicosID o = controller.createObject(ANNOTATION); // assign the child model::BaseObject parent = processed.back(); std::vector<ScicosID> children; controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children); children.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children); model::BaseObject child(o, ANNOTATION); return loadAnnotation(reader, child); } default: sciprint("Not handled child type=%s at line %d\n", *found, xmlTextReaderGetParserLineNumber(reader) - 1); return -1; } } break; } case e_in: // no break on purpose case e_out: // no break on purpose case e_ein: // no break on purpose case e_eout: { ScicosID o = controller.createObject(PORT); enum object_properties_t p; switch (current) { case e_in: p = INPUTS; break; case e_out: p = OUTPUTS; break; case e_ein: p = EVENT_INPUTS; break; case e_eout: p = EVENT_OUTPUTS; break; default: return -1; } model::BaseObject parent = processed.back(); // add the port them to the parent std::vector<ScicosID> ports; controller.getObjectProperty(parent.id(), parent.kind(), p, ports); ports.push_back(o); controller.setObjectProperty(parent.id(), parent.kind(), p, ports); // decode content model::BaseObject child(o, PORT); return loadPort(reader, child); } case e_geometry: // geometry is used for rectangle coordinates of its parent return loadGeometry(reader, processed.back()); case e_nzcross: // nzcross is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_nmode: // nmode is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_rpar: // rpar is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_ipar: // ipar is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_opar: // ipar is a Block property return loadBase64(reader, OPAR, processed.back()); case e_state: // state is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_dstate: // dstate is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_odstate: // odstate is a Block property return loadBase64(reader, ODSTATE, processed.back()); case e_equations: // equation is a Block property return loadBase64(reader, EQUATIONS, processed.back()); case e_expression: // expression is a Block property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_exprs: // exprs is a Block property return loadBase64(reader, EXPRS, processed.back()); case e_controlPoint: // controlPoint is a link property return loadPoint(reader, processed.back()); case e_context: // context is a Layer property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; case e_properties: // properties is a Diagram property return loadSimulationConfig(reader, processed.back()); case e_datatype: // datatype is a Port property if (!xmlTextReaderIsEmptyElement(reader)) { parent = current; } return 1; default: sciprint("Unknown \"%s\" element name at line %d\n", name, xmlTextReaderGetParserLineNumber(reader) - 1); return -1; } return 1; }
/* * Parse the <params> block within an RRA definition */ static int parse_tag_rra_params( xmlTextReaderPtr reader, rra_def_t *rra_def) { xmlChar *element; int status; status = -1; while ((element = get_xml_element(reader)) != NULL){ /* * Parameters for CF_HWPREDICT */ if (xmlStrcasecmp(element, (const xmlChar *) "hw_alpha") == 0) status = get_xml_double(reader, &rra_def->par[RRA_hw_alpha].u_val); else if (xmlStrcasecmp(element, (const xmlChar *) "hw_beta") == 0) status = get_xml_double(reader, &rra_def->par[RRA_hw_beta].u_val); else if (xmlStrcasecmp(element, (const xmlChar *) "dependent_rra_idx") == 0) status = get_xml_ulong(reader, &rra_def-> par[RRA_dependent_rra_idx].u_cnt); /* * Parameters for CF_SEASONAL and CF_DEVSEASONAL */ else if (xmlStrcasecmp(element, (const xmlChar *) "seasonal_gamma") == 0) status = get_xml_double(reader, &rra_def->par[RRA_seasonal_gamma].u_val); else if (xmlStrcasecmp (element, (const xmlChar *) "seasonal_smooth_idx") == 0) status = get_xml_ulong(reader, &rra_def-> par[RRA_seasonal_smooth_idx].u_cnt); else if (xmlStrcasecmp(element, (const xmlChar *) "smoothing_window") == 0) status = get_xml_double(reader, &rra_def-> par[RRA_seasonal_smoothing_window]. u_val); /* else if (dependent_rra_idx) ...; */ /* * Parameters for CF_FAILURES */ else if (xmlStrcasecmp(element, (const xmlChar *) "delta_pos") == 0) status = get_xml_double(reader, &rra_def->par[RRA_delta_pos].u_val); else if (xmlStrcasecmp(element, (const xmlChar *) "delta_neg") == 0) status = get_xml_double(reader, &rra_def->par[RRA_delta_neg].u_val); else if (xmlStrcasecmp(element, (const xmlChar *) "window_len") == 0) status = get_xml_ulong(reader, &rra_def->par[RRA_window_len]. u_cnt); else if (xmlStrcasecmp(element, (const xmlChar *) "failure_threshold") == 0) status = get_xml_ulong(reader, &rra_def-> par[RRA_failure_threshold].u_cnt); /* * Parameters for CF_AVERAGE, CF_MAXIMUM, CF_MINIMUM, and CF_LAST */ else if (xmlStrcasecmp(element, (const xmlChar *) "xff") == 0) status = get_xml_double(reader, &rra_def->par[RRA_cdp_xff_val]. u_val); /* * Compatibility code for 1.0.49 */ else if (xmlStrcasecmp(element, (const xmlChar *) "value") == 0) { /* {{{ */ unsigned int i = 0; for (i=0;i<ARRAY_LENGTH(rra_def->par);i++){ if ((i == RRA_dependent_rra_idx) || (i == RRA_seasonal_smooth_idx) || (i == RRA_failure_threshold)) status = get_xml_ulong(reader, &rra_def->par[i]. u_cnt); else status = get_xml_double(reader, &rra_def->par[i].u_val); if (status != 0) break; if ( i-1 < ARRAY_LENGTH(rra_def->par)){ status = expect_element(reader,"/value"); if (status == 0){ status = expect_element(reader,"value"); } } if (status != 0){ break; } } } /* }}} */ else if (xmlStrcasecmp(element,(const xmlChar *) "/params") == 0){ xmlFree(element); return status; } /* }}} */ else { rrd_set_error("line %d: parse_tag_rra_params: Unknown tag: %s", xmlTextReaderGetParserLineNumber(reader),element); status = -1; } status = expect_element_end(reader,(char *)element); xmlFree(element); if (status != 0) break; } return (status); } /* int parse_tag_rra_params */
static int parse_tag_rra_database( xmlTextReaderPtr reader, rrd_t *rrd ) { rra_def_t *cur_rra_def; rra_ptr_t *cur_rra_ptr; unsigned int total_row_cnt; int status; int i; xmlChar *element; unsigned int start_row_cnt; int ds_cnt; ds_cnt = rrd->stat_head->ds_cnt; total_row_cnt = 0; for (i = 0; i < (((int) rrd->stat_head->rra_cnt) - 1); i++) total_row_cnt += rrd->rra_def[i].row_cnt; cur_rra_def = rrd->rra_def + i; cur_rra_ptr = rrd->rra_ptr + i; start_row_cnt = total_row_cnt; status = 0; while ((element = get_xml_element(reader)) != NULL){ if (xmlStrcasecmp(element,(const xmlChar *)"row") == 0){ rrd_value_t *temp; rrd_value_t *cur_rrd_value; unsigned int total_values_count = rrd->stat_head->ds_cnt * (total_row_cnt + 1); /* Allocate space for the new values.. */ temp = (rrd_value_t *) realloc(rrd->rrd_value, sizeof(rrd_value_t) * total_values_count); if (temp == NULL) { rrd_set_error("parse_tag_rra_database: realloc failed."); status = -1; break; } rrd->rrd_value = temp; cur_rrd_value = rrd->rrd_value + (rrd->stat_head->ds_cnt * total_row_cnt); memset(cur_rrd_value, '\0', sizeof(rrd_value_t) * rrd->stat_head->ds_cnt); total_row_cnt++; cur_rra_def->row_cnt++; status = parse_tag_rra_database_row(reader, rrd, cur_rrd_value); if (status == 0) status = expect_element(reader,"/row"); } /* if (xmlStrcasecmp(element,"row")) */ else { if ( xmlStrcasecmp(element,(const xmlChar *)"/database") == 0){ xmlFree(element); break; } else { rrd_set_error("line %d: found unexpected tag: %s", xmlTextReaderGetParserLineNumber(reader),element); status = -1; } } xmlFree(element); if (status != 0) break; } /* Set the RRA pointer to a random location */ cur_rra_ptr->cur_row = rrd_random() % cur_rra_def->row_cnt; /* * rotate rows to match cur_row... * * this will require some extra temp. memory. We can do this rather * brainlessly, because we have done all kinds of realloc before, * so we messed around with memory a lot already. */ /* What we want: +-start_row_cnt | +-cur_rra_def->row_cnt | | |a---------n012-------------------------| (cur_rra_def->row_cnt slots of ds_cnt width) What we have | |012-------------------------a---------n| Do this by: copy away 0..(a-1) to a temp buffer move a..n to start of buffer copy temp buffer to position after where we moved n to */ int a = cur_rra_def->row_cnt - cur_rra_ptr->cur_row - 1; rrd_value_t *temp = malloc(ds_cnt * sizeof(rrd_value_t) * a); if (temp == NULL) { rrd_set_error("parse_tag_rra: malloc failed."); return -1; } rrd_value_t *start = rrd->rrd_value + start_row_cnt * ds_cnt; /* */ memcpy(temp, start, a * ds_cnt * sizeof(rrd_value_t)); memmove(start, start + a * ds_cnt, (cur_rra_ptr->cur_row + 1) * ds_cnt * sizeof(rrd_value_t)); memcpy(start + (cur_rra_ptr->cur_row + 1) * ds_cnt, temp, a * ds_cnt * sizeof(rrd_value_t)); free(temp); return (status); } /* int parse_tag_rra_database */
/* dept -1 causes depth to be ignored */ static xmlChar* get_xml_element ( xmlTextReaderPtr reader ) { int rc; while((rc = xmlTextReaderRead(reader)) == 1){ int type; xmlChar *name; type = xmlTextReaderNodeType(reader); if (type == XML_READER_TYPE_TEXT){ xmlChar *value; value = xmlTextReaderValue(reader); rrd_set_error("line %d: expected element but found text '%s'", xmlTextReaderGetParserLineNumber(reader),value); xmlFree(value); return NULL; } /* skip all other non-elements */ if (type != XML_READER_TYPE_ELEMENT && type != XML_READER_TYPE_END_ELEMENT) continue; name = xmlTextReaderName(reader); if (type == XML_READER_TYPE_END_ELEMENT){ xmlChar *temp; xmlChar *temp2; temp = (xmlChar*)sprintf_alloc("/%s",name); temp2 = xmlStrdup(temp); free(temp); xmlFree(name); return temp2; } /* all seems well, return the happy news */ return name; } if (rc == 0) { rrd_set_error("the xml ended while we were looking for an element"); } else { xmlErrorPtr err = xmlGetLastError(); /* argh: err->message often contains \n at the end. This is not what we want: Bite the bullet by copying the message, replacing any \n, constructing the rrd error message and freeing the temp. buffer. */ char *msgcpy = NULL, *c; if (err != NULL && err->message != NULL) { msgcpy = strdup(err->message); if (msgcpy != NULL) { for (c = msgcpy ; *c ; c++) { if (*c == '\n') *c = ' '; } /* strip whitespace from end of message */ for (c-- ; c != msgcpy ; c--) { if (!isprint(*c)) { *c = 0; } } } else { /* out of memory during error handling, hmmmm */ } } rrd_set_error("error reading/parsing XML: %s", msgcpy != NULL ? msgcpy : "?"); if (msgcpy) free(msgcpy); } return NULL; } /* get_xml_element */
/* * call-seq: * reader.line_number -> number * * Provide the line number of the current parsing point. */ static VALUE rxml_reader_line_number(VALUE self) { return INT2NUM(xmlTextReaderGetParserLineNumber(rxml_text_reader_get(self))); }
static int parse_tag_rra( xmlTextReaderPtr reader, rrd_t *rrd) { int status; xmlChar *element; rra_def_t *cur_rra_def; cdp_prep_t *cur_cdp_prep; rra_ptr_t *cur_rra_ptr; /* Allocate more rra_def space for this RRA */ { /* {{{ */ rra_def_t *temp; temp = (rra_def_t *) realloc(rrd->rra_def, sizeof(rra_def_t) * (rrd->stat_head->rra_cnt + 1)); if (temp == NULL) { rrd_set_error("parse_tag_rra: realloc failed."); return (-1); } rrd->rra_def = temp; cur_rra_def = rrd->rra_def + rrd->stat_head->rra_cnt; memset(cur_rra_def, '\0', sizeof(rra_def_t)); } /* }}} */ /* allocate cdp_prep_t */ { /* {{{ */ cdp_prep_t *temp; temp = (cdp_prep_t *) realloc(rrd->cdp_prep, sizeof(cdp_prep_t) * rrd->stat_head->ds_cnt * (rrd->stat_head->rra_cnt + 1)); if (temp == NULL) { rrd_set_error("parse_tag_rra: realloc failed."); return (-1); } rrd->cdp_prep = temp; cur_cdp_prep = rrd->cdp_prep + (rrd->stat_head->ds_cnt * rrd->stat_head->rra_cnt); memset(cur_cdp_prep, '\0', sizeof(cdp_prep_t) * rrd->stat_head->ds_cnt); } /* }}} */ /* allocate rra_ptr_t */ { /* {{{ */ rra_ptr_t *temp; temp = (rra_ptr_t *) realloc(rrd->rra_ptr, sizeof(rra_ptr_t) * (rrd->stat_head->rra_cnt + 1)); if (temp == NULL) { rrd_set_error("parse_tag_rra: realloc failed."); return (-1); } rrd->rra_ptr = temp; cur_rra_ptr = rrd->rra_ptr + rrd->stat_head->rra_cnt; memset(cur_rra_ptr, '\0', sizeof(rra_ptr_t)); } /* }}} */ /* All space successfully allocated, increment number of RRAs. */ rrd->stat_head->rra_cnt++; status = 0; while ((element = get_xml_element(reader)) != NULL){ if (xmlStrcasecmp(element, (const xmlChar *) "cf") == 0) status = parse_tag_rra_cf(reader, cur_rra_def); else if (xmlStrcasecmp(element, (const xmlChar *) "pdp_per_row") == 0) status = get_xml_ulong(reader, &cur_rra_def->pdp_cnt); else if (atoi(rrd->stat_head->version) == 1 && xmlStrcasecmp(element, (const xmlChar *) "xff") == 0) status = get_xml_double(reader, (double *) &cur_rra_def-> par[RRA_cdp_xff_val].u_val); else if (atoi(rrd->stat_head->version) >= 2 && xmlStrcasecmp(element, (const xmlChar *) "params") == 0){ xmlFree(element); status = parse_tag_rra_params(reader, cur_rra_def); if (status == 0) continue; else return status; } else if (xmlStrcasecmp(element, (const xmlChar *) "cdp_prep") == 0){ xmlFree(element); status = parse_tag_rra_cdp_prep(reader, rrd, cur_cdp_prep); if (status == 0) continue; else return status; } else if (xmlStrcasecmp(element, (const xmlChar *) "database") == 0){ xmlFree(element); status = parse_tag_rra_database(reader, rrd); if (status == 0) continue; else return status; } else if (xmlStrcasecmp(element,(const xmlChar *) "/rra") == 0){ xmlFree(element); return status; } /* }}} */ else { rrd_set_error("line %d: parse_tag_rra: Unknown tag: %s", xmlTextReaderGetParserLineNumber(reader), element); status = -1; } if (status != 0) { xmlFree(element); return status; } status = expect_element_end(reader,(char *)element); xmlFree(element); if (status != 0) { return status; } } return (status); } /* int parse_tag_rra */
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; }