TileMapParseStatus TileMapLayer_parse_data(xmlTextReaderPtr reader,
TileMap *map, TileMapLayer *layer) {
TileMapParseStatus status = TILEMAP_PARSE_OK;
while (xmlTextReaderMoveToNextAttribute(reader)) {
xmlChar *attrName = xmlTextReaderName(reader);
xmlChar *attrVal = xmlTextReaderValue(reader);
if (streq(attrName, "encoding")) {
check(streq(attrVal, "base64"), "Incorrect layer data encoding");
} else if (streq(attrName, "compression")) {
check(streq(attrVal, "gzip"), "Incorrect layer data compression");
}
}
while (xmlTextReaderRead(reader)) {
xmlChar *childName = xmlTextReaderName(reader);
if (xmlTextReaderNodeType(reader) == XML_ELEMENT_DECL &&
streq(childName, "data")) {
break;
} else if (xmlTextReaderNodeType(reader) == XML_TEXT_NODE) {
int tile_count = 0;
extract_gids_from_encoded_data(xmlTextReaderValue(reader),
&(layer->tile_gids), &tile_count);
check(tile_count == map->rows * map->cols, "Inconsistent layer size");
layer->gid_count = tile_count;
}
}
return status;
error:
return TILEMAP_PARSE_INVALID_FORMAT;
}
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;
}
int main (void)
{
xmlTextReaderPtr xml = xmlReaderForFd (STDIN_FILENO, "", NULL, 0);
while (xmlTextReaderRead (xml)) {
char *name = (char *) BAD_CAST xmlTextReaderName (xml);
if (xmlTextReaderNodeType (xml) == XML_READER_TYPE_ELEMENT &&
strcasecmp (name, "text") == 0) {
while (xmlTextReaderRead (xml) && // memory leak :
xmlStrcmp (xmlTextReaderName (xml), BAD_CAST "#text") != 0) {}
printf ("%s\n", xmlTextReaderValue (xml));
}
}
}
void Table::RTTraiteTuple(int & etat, SetOfInt & tmpSetOfInt)
{
// on recupere le reader
xmlTextReaderPtr reader = getXmlReader();
if ((xmlTextReaderNodeType(reader) == baliseOuvrante) && (xmlStrcmp(xmlTextReaderName(reader), xmlCharStrdup("Item")) == 0))
etat = RTItem;
if ((xmlTextReaderNodeType(reader) == baliseFermante) && (xmlStrcmp(xmlTextReaderName(reader), xmlCharStrdup("Tuple")) == 0))
etat = RTFin;
// on réinitialise le reader
setXmlReader(reader);
}
TileMapParseStatus TileMap_parse_map(xmlTextReaderPtr reader, Engine *engine,
TileMap *map) {
TileMapParseStatus status = TILEMAP_PARSE_OK;
xmlChar *name = xmlTextReaderName(reader);
if (!(streq(name, "map") &&
xmlTextReaderNodeType(reader) == XML_ELEMENT_NODE)) {
return TILEMAP_PARSE_INVALID_FORMAT;
}
while (xmlTextReaderMoveToNextAttribute(reader)) {
xmlChar *attrName = xmlTextReaderName(reader);
xmlChar *attrVal = xmlTextReaderValue(reader);
if (streq(attrName, "orientation")) {
if (!streq(attrVal, "orthogonal")) {
return TILEMAP_PARSE_INVALID_ORIENTATION;
}
} else if (streq(attrName, "width")) {
map->cols = atoi((const char *)attrVal);
} else if (streq(attrName, "height")) {
map->rows = atoi((const char *)attrVal);
} else if (streq(attrName, "tilewidth")) {
map->tile_size.w = atoi((const char *)attrVal);
} else if (streq(attrName, "tileheight")) {
map->tile_size.h = atoi((const char *)attrVal);
}
}
while (xmlTextReaderRead(reader)) {
xmlChar *childName = xmlTextReaderName(reader);
if (xmlTextReaderNodeType(reader) == XML_ELEMENT_DECL &&
streq(childName, "map")) {
break;
} else if (streq(childName, "tileset")) {
Tileset *tileset = NULL;
status = TileMap_parse_tileset(reader, engine, map, &tileset);
if (status != TILEMAP_PARSE_OK) return status;
DArray_push(map->tilesets, tileset);
} else if (streq(childName, "layer")) {
TileMapLayer *layer = NULL;
status = TileMap_parse_layer(reader, map, &layer);
if (status != TILEMAP_PARSE_OK) return status;
DArray_push(map->layers, layer);
}
}
return status;
}
void Table::ICTraiteListItems(int & etat, int & cpt)
{
// on recupere le reader
xmlTextReaderPtr reader = getXmlReader();
// balise = <Item>
if ((xmlTextReaderNodeType(reader) == baliseOuvrante) && (xmlStrcmp(xmlTextReaderName(reader), xmlCharStrdup("Item")) == 0))
etat = ICItem;
if ((xmlTextReaderNodeType(reader) == baliseFermante) && (xmlStrcmp(xmlTextReaderName(reader), xmlCharStrdup("ListItems")) == 0))
etat = ICFin;
// on réinitialise le reader
setXmlReader(reader);
}
/*
* Parse the configuration file's pg element about connection information
*/
static void ows_parse_config_pg(ows * o, xmlTextReaderPtr r)
{
xmlChar *a, *v;
assert(o);
assert(r);
if (xmlTextReaderMoveToFirstAttribute(r) != 1) return;
do {
a = xmlTextReaderName(r);
if ( !strcmp((char *) a, "host")
|| !strcmp((char *) a, "user")
|| !strcmp((char *) a, "password")
|| !strcmp((char *) a, "dbname")
|| !strcmp((char *) a, "port")) {
v = xmlTextReaderValue(r);
buffer_add_str(o->pg_dsn, (char *) a);
buffer_add_str(o->pg_dsn, "=");
buffer_add_str(o->pg_dsn, (char *) v);
buffer_add_str(o->pg_dsn, " ");
xmlFree(v);
} else if (!strcmp((char *) a, "encoding")) {
v = xmlTextReaderValue(r);
buffer_add_str(o->db_encoding, (char *) v);
xmlFree(v);
}
xmlFree(a);
} while (xmlTextReaderMoveToNextAttribute(r) == 1);
if (!o->db_encoding->use)
buffer_add_str(o->db_encoding, OWS_DEFAULT_DB_ENCODING);
}
void processNode( xmlTextReaderPtr reader, node *nodeTable) {
int index ;
const xmlChar *name, *value;
name = xmlTextReaderConstName(reader);
if (name == NULL)
name = BAD_CAST "--";
index = 0 ;
while ( xmlTextReaderRead( reader) == 1) {
switch ( xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_ELEMENT :
if ( strcmp((char *) xmlTextReaderName( reader), "groupobject") == 0) {
strcpy( nodeTable[index].name, (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "name")) ;
strcpy( nodeTable[index].alias, (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "alias")) ;
nodeTable[index].knxGroupAddr = atoi( (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "knxGroupAddr")) ;
nodeTable[index].type = lookupDPT( (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "dpt")) ;
// printf( "Element node\n") ;
// printf( " Id............: %s \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "id")) ;
// printf( " Name..........: '%s' \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "name")) ;
// printf( " DPT...........: %s(%d) \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "dpt"), nodeTable[index].type) ;
// printf( " Group addr....: %s \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "groupAddr")) ;
// printf( " Trigger only..: %s \n", (char *) xmlTextReaderGetAttribute( reader, (xmlChar *) "trigger")) ;
index++ ;
}
break ;
}
}
}
/**
* 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);
}
}
}
string BEXMLTextReader::name()
{
const xmlChar * node_name = xmlTextReaderName ( reader );
string name = (const char *)node_name;
xmlFree ( (xmlChar *)node_name );
return name;
}
static void processNode(xmlTextReaderPtr reader, struct osmdata_t *osmdata) {
xmlChar *name;
name = xmlTextReaderName(reader);
if (name == NULL)
name = xmlStrdup(BAD_CAST "--");
switch(xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_ELEMENT:
StartElement(reader, name, osmdata);
if (xmlTextReaderIsEmptyElement(reader))
EndElement(name, osmdata); /* No end_element for self closing tags! */
break;
case XML_READER_TYPE_END_ELEMENT:
EndElement(name, osmdata);
break;
case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
/* Ignore */
break;
default:
fprintf(stderr, "Unknown node type %d\n", xmlTextReaderNodeType(reader));
break;
}
xmlFree(name);
}
std :: string getNextNode ()
{
xmlChar * name, * value;
do
{
xmlTextReaderRead (reader);
name = xmlTextReaderName (reader);
value = xmlTextReaderValue (reader);
}
while (! strcmp ((char *) name, "#text") && isSep (value));
std :: string str;
if (strcmp ((char *) name, "#text"))
str.assign ((char *) name);
else
str.assign ((char *) value);
if (name)
xmlFree (name);
if (value)
xmlFree (value);
return str;
}
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 */
char* getElementContent(MemoryStruct *xmlDoc, char *elementName)
{
xmlTextReaderPtr reader;
int ret;
xmlChar *name, *value;
reader = xmlReaderForMemory(xmlDoc->data, xmlDoc->size, "http://www.example.org/", NULL, 0);
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
while (ret == 1) {
name = xmlTextReaderName(reader);
if (strcmp(elementName, (char*) name) == 0 && xmlTextReaderNodeType(reader) == 1) {
//printf("Name: %s\tType: %d\t", name, xmlTextReaderNodeType(reader));
ret = xmlTextReaderRead(reader);
if (ret == 1) {
value = xmlTextReaderValue(reader);
//printf("Value: %s\n", value);
//xmlFree(value);
xmlFree(name);
xmlFreeTextReader(reader);
return (char*) value;
}
}
xmlFree(name);
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) printf("Failed to parse.\n");
}
else printf("Unable to read XML from memory.\n");
return;
}
//Parse AC flight plan xml (block & waypoint names
void parse_ac_fp(int DevNameIndex, char *filename) {
xmlTextReaderPtr reader;
int ret;
reader = xmlReaderForFile(filename, NULL, XML_PARSE_NOWARNING | XML_PARSE_NOERROR); /* Dont validate with the DTD */
xmlChar *name, *value;
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
int wp_queue=1;
int bl_queue=1;
while (ret == 1) {
name = xmlTextReaderName(reader);
if (name == NULL) {
name = xmlStrdup(BAD_CAST "--");
}
//read waypoint names
if (xmlStrEqual(name, (const xmlChar *)"waypoint")) {
//waypoint node read name attr.
xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"name");
value = xmlTextReaderValue(reader);
//copy it to DevNames[] structure
strcpy(DevNames[DevNameIndex].AcWp[wp_queue].Wp_Name, (char *) value);
wp_queue++;
}
if (xmlStrEqual(name, (const xmlChar *)"block")) {
//Read block names
if ( xmlTextReaderAttributeCount(reader) >= 1 ) {
xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"name");
value = xmlTextReaderValue(reader);
strcpy(DevNames[DevNameIndex].AcBl[bl_queue].Bl_Name, (char *) value);
bl_queue++;
}
}
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
if (verbose) {
printf("App Server: failed to parse %s\n", filename);
fflush(stdout);
}
}
}
else
{
if (verbose) {
printf("App Server: Unable to open %s\n", filename);
fflush(stdout);
}
}
}
void parse_ac_af(int DevNameIndex, char *filename) {
xmlTextReaderPtr reader;
int ret;
reader = xmlReaderForFile(filename, NULL, XML_PARSE_NOWARNING | XML_PARSE_NOERROR); /* Dont validate with the DTD */
xmlChar *name, *value;
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
while (ret == 1) {
name = xmlTextReaderName(reader);
if (name == NULL) {
name = xmlStrdup(BAD_CAST "--");
}
if (xmlStrEqual(name, (const xmlChar *)"firmware")) {
xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"name");
value = xmlTextReaderValue(reader);
//check if firmware name is accaptable
if (check_firmware_type(value)>0) {
strcpy(DevNames[DevNameIndex].type, (char *) value);
}
}
if (xmlStrEqual(name, (const xmlChar *)"define")) {
xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"name");
value = xmlTextReaderValue(reader);
if (xmlStrEqual(value, (const xmlChar *)"AC_ICON")) {
xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"value");
value = xmlTextReaderValue(reader);
strcpy(DevNames[DevNameIndex].type, (char *) value);
return;
}
}
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
if (verbose) {
printf("App Server: failed to parse %s\n", filename);
fflush(stdout);
}
}
} else {
if (verbose) {
printf("App Server: Unable to open %s\n", filename);
fflush(stdout);
}
}
}
//Parse dl values
void parse_ac_settings(int DevNameIndex, char *filename) {
xmlTextReaderPtr reader;
int ret;
reader = xmlReaderForFile(filename, NULL, XML_PARSE_NOWARNING | XML_PARSE_NOERROR); /* Dont validate with the DTD */
// Init some variables (-1 means no settings in xml file)
DevNames[DevNameIndex].dl_launch_ind = -1;
DevNames[DevNameIndex].kill_thr_ind = -1;
DevNames[DevNameIndex].flight_altitude_ind = -1;
xmlChar *name, *value;
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
int valind = 0;
while (ret == 1) {
name = xmlTextReaderName(reader);
if (name == NULL) {
name = xmlStrdup(BAD_CAST "--");
}
if (xmlStrEqual(name, (const xmlChar *)"dl_setting")) {
xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"var");
value = xmlTextReaderValue(reader);
if (xmlStrEqual(value, (const xmlChar *)"launch")) {
DevNames[DevNameIndex].dl_launch_ind=valind;
}
if (xmlStrEqual(value, (const xmlChar *)"kill_throttle")) {
DevNames[DevNameIndex].kill_thr_ind=valind;
}
if (xmlStrEqual(value, (const xmlChar *)"flight_altitude")) {
DevNames[DevNameIndex].flight_altitude_ind=valind;
}
xmlTextReaderNext(reader);
valind+=1;
}
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
if (verbose) {
printf("App Server: %s : failed to parse\n", filename);
fflush(stdout);
}
}
}
else {
if (verbose) {
printf("App Server: Unable to open %s\n", filename);
fflush(stdout);
}
}
}
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 */
static void
process_properties (xmlTextReaderPtr reader,
GtkSourceLanguage *language)
{
xmlNodePtr child;
xmlNodePtr node = NULL;
while (node == NULL && xmlTextReaderRead (reader) == 1)
{
xmlChar *name;
if (xmlTextReaderNodeType (reader) != 1)
continue;
name = xmlTextReaderName (reader);
if (xmlStrcmp (name, BAD_CAST "metadata") != 0)
{
xmlFree (name);
continue;
}
xmlFree (name);
node = xmlTextReaderExpand (reader);
if (node == NULL)
return;
}
if (node == NULL)
return;
for (child = node->children; child != NULL; child = child->next)
{
xmlChar *name;
xmlChar *content;
if (child->type != XML_ELEMENT_NODE ||
xmlStrcmp (child->name, BAD_CAST "property") != 0)
continue;
name = xmlGetProp (child, BAD_CAST "name");
content = xmlNodeGetContent (child);
if (name != NULL && content != NULL)
g_hash_table_insert (language->priv->properties,
g_strdup ((gchar *) name),
g_strdup ((gchar *) content));
xmlFree (name);
xmlFree (content);
}
}
bool sc_xmltv_check_current_reader_node(xmlTextReaderPtr reader, int node_type, const char *node_name, int node_depth) {
xmlChar *name = NULL;
bool result;
name = xmlTextReaderName(reader);
result = !xmlTextReaderIsEmptyElement(reader) &&
xmlTextReaderNodeType(reader) == node_type &&
(!xmlStrcmp(name, (const xmlChar *) node_name)) &&
xmlTextReaderDepth(reader) == node_depth;
xmlFree(name);
return result;
}
static int consumeKeySetNode(KeySet *ks, const char *context, xmlTextReaderPtr reader)
{
xmlChar *nodeName=0;
xmlChar *keySetNodeName=0;
xmlChar *privateContext=0;
xmlChar fullContext[800]="";
keySetNodeName=xmlTextReaderName(reader);
if (!strcmp((char *)keySetNodeName,"keyset")) {
int end=0;
privateContext=xmlTextReaderGetAttribute(reader,(const xmlChar *)"parent");
if (context && privateContext) {
xmlStrPrintf(fullContext,sizeof(fullContext),
(const xmlChar *)"%s/%s", context, privateContext);
}
/* Parse everything else */
while (!end) {
xmlTextReaderRead(reader);
nodeName=xmlTextReaderName(reader);
if (!strcmp((char *)nodeName,"key")) {
if (privateContext) consumeKeyNode(ks,(char *)(*fullContext?fullContext:privateContext),reader);
else consumeKeyNode(ks,context,reader);
} else if (!strcmp((char *)nodeName,"keyset")) {
/* A <keyset> can have nested <keyset>s */
if (xmlTextReaderNodeType(reader)==15)
/* found a </keyset> */
end=1;
else if (privateContext)
consumeKeySetNode(ks, (char *)(*fullContext?fullContext:privateContext), reader);
else consumeKeySetNode(ks, context, reader);
}
xmlFree(nodeName);
}
if (privateContext) xmlFree(privateContext),privateContext=0;
}
xmlFree (keySetNodeName);
return 0;
}
void Table::ICTraiteDebut(int & etat, int & cpt)
{
// on recupere le reader
xmlTextReaderPtr reader = getXmlReader();
// il faut que la balise soit <ListItems>
if ((xmlTextReaderNodeType(reader) == baliseOuvrante) && (xmlStrcmp(xmlTextReaderName(reader), xmlCharStrdup("ListItems")) == 0))
etat = ICListItems;
// on réinitialise le reader
setXmlReader(reader);
}
TileMapParseStatus TileMap_parse_layer(xmlTextReaderPtr reader, TileMap *map,
TileMapLayer **out_layer) {
TileMapParseStatus status = TILEMAP_PARSE_OK;
TileMapLayer *layer = TileMapLayer_create();
check(layer != NULL, "Couldn't create layer");
while (xmlTextReaderMoveToNextAttribute(reader)) {
xmlChar *attrName = xmlTextReaderName(reader);
xmlChar *attrVal = xmlTextReaderValue(reader);
if (streq(attrName, "name")) {
layer->name = calloc(1, strlen((const char *)attrVal) + 1);
strcpy(layer->name, (const char *)attrVal);
} else if (streq(attrName, "opacity")) {
layer->opacity = atof((const char *)attrVal);
} else if (streq(attrName, "visible")) {
layer->visible = atoi((const char *)attrVal);
}
}
while (xmlTextReaderRead(reader)) {
xmlChar *childName = xmlTextReaderName(reader);
if (xmlTextReaderNodeType(reader) == XML_ELEMENT_DECL &&
streq(childName, "layer")) {
break;
} else if (streq(childName, "data")) {
status = TileMapLayer_parse_data(reader, map, layer);
check(status == TILEMAP_PARSE_OK, "Failed to parse layer data");
}
}
if (status == TILEMAP_PARSE_OK) {
*out_layer = layer;
return status;
}
error:
if (layer) TileMapLayer_destroy(layer);
if (status == TILEMAP_PARSE_OK) status = TILEMAP_PARSE_UNKNOWN_ERR;
return status;
}
ExtractionWay XMLParser::_ReadXMLWay() {
ExtractionWay way;
if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
const int depth = xmlTextReaderDepth( inputReader );
while ( xmlTextReaderRead( inputReader ) == 1 ) {
const int childType = xmlTextReaderNodeType( inputReader );
if ( childType != 1 && childType != 15 ) {
continue;
}
const int childDepth = xmlTextReaderDepth( inputReader );
xmlChar* childName = xmlTextReaderName( inputReader );
if ( childName == NULL ) {
continue;
}
if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {
xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
way.id = stringToUint((char*)id);
xmlFree(id);
xmlFree( childName );
break;
}
if ( childType != 1 ) {
xmlFree( childName );
continue;
}
if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
// cout << "->k=" << k << ", v=" << value << endl;
if ( k != NULL && value != NULL ) {
way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));
}
if ( k != NULL ) {
xmlFree( k );
}
if ( value != NULL ) {
xmlFree( value );
}
} else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {
xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
if ( ref != NULL ) {
way.path.push_back( stringToUint(( const char* ) ref ) );
xmlFree( ref );
}
}
xmlFree( childName );
}
}
return way;
}
/* reader:name() */
static int xmlreader_name(lua_State *L) {
xmlreader xr = check_xmlreader(L, 1);
char *name = (char*)xmlTextReaderName(xr);
if (name) {
lua_pushstring(L, name);
xmlFree(name);
return 1;
} else {
lua_pushnil(L);
lua_pushstring(L, "not available");
return 2;
}
}
/*Read values from XML21 file 读取XML21，pm2pm物理机之间的时延带宽信息文件*/
int get_pm2pm_from_xml21(char *filename)
{
xmlTextReaderPtr reader;
xmlChar *name;
int swc=0,psc=0,ssc=0;
int ret=0;
reader = xmlNewTextReaderFilename(filename);
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
name = xmlTextReaderName(reader);/*获取reader的元素名称*/
if (name == NULL)
name = xmlStrdup(BAD_CAST "--");
/*在这个例子中，我们需要确认文档是正确的类型。“DATA”是在这个示例中使用文档的根类型。*/
if (xmlStrcmp(name, (xmlChar *) "DATA")) {
fprintf(stderr,"document of the wrong type, root node != DATA");
xmlFree(name);
xmlFreeTextReader(reader);
}
while (ret == 1) {
process_XML21_Node(reader, &swc,&psc,&ssc);
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
printf("%s : failed to parse\n", filename);
}
}
else
printf("Unable to open %s\n", filename);
_xpthis->sd->sw_total=swc; /*更新共享数据的全局变量*/
_xpthis->sd->p2s_total=psc;
_xpthis->sd->s2s_total=ssc;
ret=swc+1;
return ret;
}
/*Read values from XML2 file 读取XML2文件*/
static int get_request_from_xml1(char *filename)
{
xmlTextReaderPtr reader;
xmlChar *name;
int reqc=-1,parac=-1;
int ret=0;
reader = xmlNewTextReaderFilename(filename);
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
name = xmlTextReaderName(reader);/*获取reader的元素名称*/
if (name == NULL)
name = xmlStrdup(BAD_CAST "--");
/*在这个例子中，我们需要确认文档是正确的类型。“DATA”是在这个示例中使用文档的根类型。*/
if (xmlStrcmp(name, (const xmlChar *) "CONTROLOR")) {
fprintf(stderr,"document of the wrong type, root node != CONTROLOR");
xmlFree(name);
xmlFreeTextReader(reader);
return ret;
}
while (ret == 1) {/*处理每个节点*/
process_XML1_Node(reader, &reqc, ¶c);
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
printf("%s : failed to parse\n", filename);
}
}
else
printf("Unable to open %s\n", filename);
/*更新共享数据*/
_xpthis->sd->req_total=reqc+1;
return ret;
}
// 1つのノードを処理する
void processNode(xmlTextReaderPtr reader)
{
static parsingStatus state = STATE_NONE;
xmlElementType nodeType;
xmlChar *name, *value;
// ノード情報の取得
nodeType = xmlTextReaderNodeType(reader); // ノードタイプ
name = xmlTextReaderName(reader); // ノード名
if (!name)
name = xmlStrdup(BAD_CAST "---");
if (nodeType == XML_READER_TYPE_ELEMENT) { // 開始
if ( xmlStrcmp(name, BAD_CAST "item") == 0 ) {
state = STATE_ITEM;
} else if ( xmlStrcmp(name, BAD_CAST "price") == 0 ) {
state = STATE_PRICE;
}
} else if (nodeType == XML_READER_TYPE_END_ELEMENT) { // 終了
if ( xmlStrcmp(name, BAD_CAST "fruit") == 0 ) {
printf("-----------------------\n");
}
state = STATE_NONE;
} else if (nodeType == XML_READER_TYPE_TEXT) { // テキスト
// テキストを取得する
value = xmlTextReaderValue(reader);
if (!value)
value = xmlStrdup(BAD_CAST "---");
if ( state == STATE_ITEM ) {
printf("品名: %s\n", value);
} else if ( state == STATE_PRICE ) {
printf("価格: %s円\n", value);
}
xmlFree(value);
}
xmlFree(name);
}
/**
* glista_storage_get_all_items:
* @list: Pointer to a GList* to populate with GlistaItem objects
*
* Load all items from storage into a linked-list, which will be in turn used
* to load the data into the GtkListStore of the UI.
*/
void
glista_storage_load_all_items(GList **list)
{
xmlTextReaderPtr xml;
gchar *storage_file;
xmlChar *node_name;
GlistaItem *item;
// Build storage file path
storage_file = g_build_filename(gl_globs->configdir, GL_XML_FILENAME, NULL);
// Open XML file
if ((xml = xmlReaderForFile(storage_file, GL_XML_ENCODING, 0)) != NULL) {
// Read the XML root node
if (xmlTextReaderRead(xml) == 1) {
node_name = xmlTextReaderName(xml);
if (xmlStrEqual(node_name, BAD_CAST GL_XNODE_ROOT)) {
// Read all items
while ((item = read_next_item(xml)) != NULL) {
if (item->text != NULL) {
*list = g_list_append(*list, item);
} else {
glista_item_free(item);
}
}
} else {
g_warning("Invalid XML file: unexpected root element '%s'\n",
node_name);
}
xmlFree(node_name);
} else {
g_warning("Invalid XML file: unable to read root element\n");
}
xmlFreeTextReader(xml);
}
g_free(storage_file);
}
bool XMLParser::Parse()
{
while (xmlTextReaderRead(inputReader) == 1)
{
const int type = xmlTextReaderNodeType(inputReader);
// 1 is Element
if (type != 1)
{
continue;
}
xmlChar *currentName = xmlTextReaderName(inputReader);
if (currentName == nullptr)
{
continue;
}
if (xmlStrEqual(currentName, (const xmlChar *)"node") == 1)
{
ImportNode current_node = ReadXMLNode();
ParseNodeInLua(current_node, lua_state);
extractor_callbacks->ProcessNode(current_node);
}
if (xmlStrEqual(currentName, (const xmlChar *)"way") == 1)
{
ExtractionWay way = ReadXMLWay();
ParseWayInLua(way, lua_state);
extractor_callbacks->ProcessWay(way);
}
if (use_turn_restrictions && xmlStrEqual(currentName, (const xmlChar *)"relation") == 1)
{
InputRestrictionContainer current_restriction = ReadXMLRestriction();
if ((UINT_MAX != current_restriction.fromWay) &&
!extractor_callbacks->ProcessRestriction(current_restriction))
{
std::cerr << "[XMLParser] restriction not parsed" << std::endl;
}
}
xmlFree(currentName);
}
return true;
}
