int ConfigurationXML::parse(const char* configurationXML) {
mxml_node_t *tree, *node;
int ret;
tree = mxmlLoadString(NULL, configurationXML, MXML_NO_CALLBACK);
node = mxmlGetFirstChild(tree);
while (node && mxmlGetType(node) != MXML_ELEMENT)
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
ret = configurationsTag(node);
node = mxmlGetFirstChild(node);
while (node) {
if (mxmlGetType(node) != MXML_ELEMENT) {
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
continue;
}
configurationTag(node);
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
}
mxmlDelete(tree);
return ret;
}
int ConfigurationXML::parse(const char* configurationXML) {
mxml_node_t *tree, *node;
int ret;
// clear counter overflow
gSessionData->mCounterOverflow = 0;
mIndex = 0;
// disable all counters prior to parsing the configuration xml
for (int i = 0; i < MAX_PERFORMANCE_COUNTERS; i++) {
gSessionData->mCounters[i].setEnabled(false);
}
tree = mxmlLoadString(NULL, configurationXML, MXML_NO_CALLBACK);
node = mxmlGetFirstChild(tree);
while (node && mxmlGetType(node) != MXML_ELEMENT)
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
ret = configurationsTag(node);
node = mxmlGetFirstChild(node);
while (node) {
if (mxmlGetType(node) != MXML_ELEMENT) {
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
continue;
}
configurationTag(node);
node = mxmlWalkNext(node, tree, MXML_NO_DESCEND);
}
mxmlDelete(tree);
return ret;
}
int
PLCvalidation_precompileST(mxml_node_t *pou, mxml_node_t *ST) {
ST = mxmlWalkNext (ST, NULL, MXML_DESCEND);
if (ST->type != MXML_ELEMENT) {
RTL_TRDBG (TRACE_ST, "precompile ST code : not an MXML_ELEMENT (%d)\n", ST->type);
return 0;
}
char *STcode = ST->value.element.name;
if (!memcmp(STcode, "![CDATA[", 8))
STcode += 8;
while (STcode[strlen(STcode)-1] == ']')
STcode[strlen(STcode)-1] = 0;
RTL_TRDBG (TRACE_ST, "precompile ST code : (%s)\n", STcode);
if (compileST (STcode) != 0) {
char *name = (char *)mxmlElementGetAttr(pou, "name");
sprintf (_lastError, "pou '%s' compilation failed '%20.20s'", name, STcode);
return -1;
}
mxmlElementSetAttrf (ST, "tree", "%ld", programBlock);
RTL_TRDBG (TRACE_ST, "ST code precompiled at %p\n", programBlock);
return 0;
}
/**
* @brief Retrieve the text contained in a xml token, eg <tok>content</tok>
* @param node The xml node
* @return The contained text
*/
char *getContainedText(mxml_node_t *node) {
char *content = NULL;
if (node && node->type == MXML_OPAQUE) {
content = (char *)mxmlGetOpaque (node);
if (content && !strcmp(content, "\n")) {
node = mxmlWalkNext (node, NULL, MXML_DESCEND);
content = (char *)mxmlGetCDATA(node);
}
}
return content;
}
skin* conf_read(char* filepath, int* skin_nb)
{
FILE *fp;
mxml_node_t *tree;
*skin_nb = 0;
fp = fopen(filepath, "r");
tree = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
if(tree == NULL){
printf("Error while reading the conf file\n");
exit(EXIT_FAILURE);
}
mxml_node_t *node_root = mxmlWalkNext(tree, tree, MXML_DESCEND); //tetris (hanchor node)
mxml_node_t *node_skins = mxmlFindElement(node_root, tree, "skins", NULL, NULL, MXML_DESCEND);
mxml_node_t *node_skin; //hanchor node
for (node_skin = mxmlFindElement(node_skins, node_skins, "skin", NULL, NULL, MXML_DESCEND);
node_skin != NULL;
node_skin = mxmlFindElement(node_skin, node_skins,"skin",NULL, NULL, MXML_DESCEND))
{
(*skin_nb)++;
}
skin* p_skin = malloc(*skin_nb * sizeof(skin));
mxml_node_t *node_res; //parse each skin child nodes
int i=0;
for (node_skin = mxmlFindElement(node_skins, node_skins, "skin", NULL, NULL, MXML_DESCEND);
node_skin != NULL;
node_skin = mxmlFindElement(node_skin, node_skins,"skin",NULL, NULL, MXML_NO_DESCEND))
{
p_skin[i].name = strdup(mxmlElementGetAttr(node_skin, "name"));
for(int j = 0; p_skin[i].name[j];j++)p_skin[i].name[j]= toupper(p_skin[i].name[j]);
node_res = mxmlFindElement(node_skin, node_skins,"gfx",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].gfx = strdup(node_res->value.opaque);
node_res = mxmlFindElement(node_skin, node_skins,"bg",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].bg = strdup(node_res->value.opaque);
node_res = mxmlFindElement(node_skin, node_skins,"menu",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].menu = strdup(node_res->value.opaque);
node_res = mxmlFindElement(node_skin, node_skins,"music",NULL, NULL, MXML_DESCEND);
node_res = mxmlWalkNext(node_res, tree, MXML_DESCEND); //text
p_skin[i].music = strdup(node_res->value.opaque);
i++;
}
fclose(fp);
return p_skin;
}
mxml_node_t * /* O - Element node or NULL */
mxmlFindElement(mxml_node_t *node, /* I - Current node */
mxml_node_t *top, /* I - Top node */
const char *name, /* I - Element name or NULL for any */
const char *attr, /* I - Attribute name, or NULL for none */
const char *value, /* I - Attribute value, or NULL for any */
int descend) /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
{
const char *temp; /* Current attribute value */
/*
* Range check input...
*/
if (!node || !top || (!attr && value))
return (NULL);
/*
* Start with the next node...
*/
node = mxmlWalkNext(node, top, descend);
/*
* Loop until we find a matching element...
*/
while (node != NULL)
{
/*
* See if this node matches...
*/
if (node->type == MXML_ELEMENT &&
node->value.element.name &&
(!name || !strcmp(node->value.element.name, name)))
{
/*
* See if we need to check for an attribute...
*/
if (!attr)
return (node); /* No attribute search, return it... */
/*
* Check for the attribute...
*/
if ((temp = mxmlElementGetAttr(node, attr)) != NULL)
{
/*
* OK, we have the attribute, does it match?
*/
if (!value || !strcmp(value, temp))
return (node); /* Yes, return it... */
}
}
/*
* No match, move on to the next node...
*/
if (descend == MXML_DESCEND)
node = mxmlWalkNext(node, top, MXML_DESCEND);
else
node = node->next;
}
return (NULL);
}
void main(void)
{
FILE *fp;
char str[128];
const char *xml_path = "0:\\Zbin\\Utilities\\mxmltest\\test.xml";
fp = fopen(xml_path, "r");
if (fp == NULL)
{
sprintf(str, "Can't open file: %s", xml_path);
ShowMSG(1, (int)str);
return;
}
mxml_node_t *tree = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK);
fclose(fp);
if (tree == NULL)
{
ShowMSG(1, (int)"mxmlLoadFile = NULL");
return;
}
const char *log_path = "0:\\Zbin\\Log\\mxmltest.log";
fp = fopen(log_path, "a");
if (fp == NULL)
{
sprintf(str, "Can't open file: %s", log_path);
ShowMSG(1, (int)str);
mxmlDelete(tree);
return;
}
mxml_node_t *node = tree;
mxml_node_t *next = NULL;
while (node != NULL)
{
switch (mxmlGetType(node))
{
case MXML_ELEMENT:
sprintf(str, "MXML_ELEMENT = %s\n", mxmlGetElement(node));
fwrite(str, sizeof(char), strlen(str), fp);
break;
case MXML_TEXT:
sprintf(str, "MXML_TEXT = %s\n", mxmlGetText(node, 0));
fwrite(str, sizeof(char), strlen(str), fp);
break;
}
next = mxmlGetFirstChild(node);
if (next != NULL)
{
node = next;
}
else
{
next = mxmlGetNextSibling(node);
if (next == NULL)
{
next = mxmlWalkNext(node, NULL, MXML_DESCEND);
}
node = next;
}
}
fclose(fp);
mxmlDelete(tree);
}
int main (int argc, char *argv[])
{
Log log;
FILE *inFp = 0;
FILE *outFp = 0;
mxml_node_t *outTree = 0; // hold the xml input to ICAT
mxml_node_t *inTree = 0; // Hold the parameter list
try
{
// Check if my assumption of type size are correct.
// ************************************************
if(sizeof(short) != 2 || sizeof(int) != 4 )
log.set("Compiler Test", "The integer sizes are not as expected", "(short 2 bytes; int 4 bytes)").printLevel(NXING_LOG_WARNING);
if(sizeof(float) != 4 ||sizeof(double) != 8)
log.set("Compiler Test", "The float sizes are not as expected", "(float 4 bytes; double 8 bytes)").printLevel(NXING_LOG_WARNING);
char mappingFl[NXING_BIG_SIZE] = "";
char nexusFl[NXING_BIG_SIZE] = "";
char outputFl[NXING_BIG_SIZE] = "";
if(argc < 3)
{
throw log.set("main", "Not enough input parameters!", "Needs 2 input files, mapping file and the NeXus file.", "And one output file.", NXING_ERR_WRONG_INPUT);
}
else
{
if(argv[1] != 0) strcpy(mappingFl, argv[1]);
if(argv[2] != 0) strcpy(nexusFl, argv[2]);
if(argv[3] != 0) strcpy(outputFl, argv[3]);
else strcpy(outputFl, "output.xml");
}
log.set("main", "input - mapping", mappingFl).printLevel(NXING_LOG_NORMAL);
log.set("main", "input - nexus ", nexusFl).printLevel(NXING_LOG_NORMAL);
log.set("main", "input - output ", outputFl).printLevel(NXING_LOG_NORMAL);
// Read input XML Parameters.
// **************************'
#ifndef MXML_WRAP
mxmlSetWrapMargin(0);
#endif
inFp = fopen(mappingFl, "r");
if( inFp == 0 ) throw log.set("main", "Can't open the parameter file!", mappingFl, "", NXING_ERR_CANT_OPEN_PARAM);
mxml_node_t *inNode; // hold the node to read from.
inTree = mxmlLoadFile(NULL, inFp, MXML_TEXT_CALLBACK);
fclose(inFp);
inFp = 0;
if(inTree != 0) log.set("main", "The mapping file has been read!", mappingFl).printLevel(NXING_LOG_ALL);
// Create XML output to ICAT.
// **************************
outFp = fopen(outputFl, "w");
if( outFp == 0 ) throw log.set("main", "Can't open the output file!", outputFl, "", NXING_ERR_CANT_OPEN_OUTPUT);
if(inTree->type == MXML_ELEMENT && (strncmp(inTree->value.element.name, "?xml", 4) == 0)){
outTree = mxmlNewElement(MXML_NO_PARENT, inTree->value.element.name);
}
log.set("main", "Output Created, first tag added!", inTree->value.element.name).printLevel(NXING_LOG_DEBUG);
//
// Open the neXus file.
// ********************
NxClass nx(nexusFl);
//if(nx.isNotOK) throw log.set("Can't open the neXus file!", nexusFl, nx.status);
log.set("main", "NeXµs file read!", nexusFl, "", nx.status).printLevel(NXING_LOG_DEBUG);
/*
* Parse the parameter file, read the neXus file and populate the XML output.
*/
log.set("main", "Parsing the mapping file!").printLevel(NXING_LOG_DEBUG);
inNode = mxmlWalkNext(inTree, inTree, MXML_DESCEND);
parseXml(inNode, &outTree, nx);
/*
* Save the output file
*/
mxmlSaveFile(outTree, outFp, whitespace_cb);
log.set("main", "Output file Saved!", outputFl).printLevel(NXING_LOG_DEBUG);
/*
* Close the files
*/
fclose(outFp);
/*
* Delete the xml Trees
*/
mxmlDelete(inTree);
mxmlDelete(outTree);
exit(0);
}
catch(Log log)
{
log.printLevel(NXING_LOG_ERROR);
if(inFp != 0) fclose(inFp);
if(outFp != 0) fclose(outFp);
if(inTree != 0) mxmlDelete(inTree);
if(outTree != 0) mxmlDelete(outTree);
exit(0);
}
}
/***
* TODO: LOOK AT THIS SECTION 2/21/12
* Parses through an XML file and sets the watt color of individual components?
* Called on Button Action Event....
*/
void GreenLight::setPowerColors(bool displayPower)
{
std::map< std::string, std::map< std::string, int > > componentWattsMap;
/***
* If the switch is off, revert all components colors back to their default color(?)
*/
if (!displayPower)
{
std::set< Component *>::iterator sit;
for (sit = _components.begin(); sit != _components.end(); sit++)
(*sit)->defaultColor();
return;
}
// Display power per component
FILE *fp = fopen(cvr::ConfigManager::getEntry("local",
"Plugin.GreenLight.Power", "").c_str(), "r");
if (!fp)
{ //If there is no valid entry? file?
std::cerr << "Error (setComponentColors): Cannot open \""
<< cvr::ConfigManager::getEntry("local", "Plugin.GreenLight.Power", "")
<< "\"." << std::endl;
_displayPowerCheckbox->setValue(false);
return;
}
mxml_node_t * xmlTree = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK);
mxml_node_t * measurements =
mxmlFindElement(xmlTree,xmlTree,"measurements",NULL,NULL,MXML_DESCEND_FIRST);
if (measurements == NULL)
{
std::cerr << "Warning: No <measurements> tag in xml power file. Aborting." << std::endl;
return;
}
mxml_node_t * sensor = mxmlFindElement(measurements,measurements,"sensor",
NULL,NULL,MXML_DESCEND_FIRST);
if (sensor)
{ // interpret xml
do
{
mxml_node_t * nameNode = mxmlFindElement(sensor,sensor,"name",
NULL,NULL,MXML_DESCEND_FIRST);
mxml_node_t * timeNode = mxmlFindElement(sensor,sensor,"time",
NULL,NULL,MXML_DESCEND_FIRST);
mxml_node_t * valueNode = mxmlFindElement(sensor,sensor,"value",
NULL,NULL,MXML_DESCEND_FIRST);
if (nameNode == NULL || nameNode->child->value.text.whitespace == 1)
{
std::cerr << "Error parsing power xml file (bad name on sensor)." << std::endl;
continue;
}
std::string name = nameNode->child->value.text.string;
if (timeNode == NULL || timeNode->child == NULL || timeNode->child->next == NULL)
{
std::cerr << "Error parsing power xml file for \"" << name <<"\" time." << std::endl;
continue;
}
std::string time = timeNode->child->value.text.string;
time += " ";
time += timeNode->child->next->value.text.string;
if (valueNode == NULL || valueNode->child->value.text.whitespace == 1)
{
std::cerr << "Error parsing power xml file for \"" << name <<"\" value." << std::endl;
continue;
}
std::string value = valueNode->child->value.text.string;
int wattage = utl::intFromString(value);
std::map< std::string, std::map< std::string, int > >::iterator mit;
if ((mit = componentWattsMap.find(name)) == componentWattsMap.end())
{
std::map<std::string, int> newMap;
newMap[time] = wattage;
componentWattsMap[name] = newMap;
}
else
{
std::map< std::string, int >::iterator tit;
if ((tit = mit->second.find(time)) == mit->second.end())
mit->second[time] = wattage;
else
tit->second += wattage;
}
} while ((sensor = mxmlWalkNext(sensor,measurements,MXML_NO_DESCEND)) != NULL);
}
std::set< Component * >::iterator sit;
for (sit = _components.begin(); sit != _components.end(); sit++)
{
std::list< osg::Vec3 > colors;
std::list< osg::Vec4 > colors4;
std::map< std::string, std::map< std::string, int > >::iterator cit;
if ((cit = componentWattsMap.find((*sit)->name)) != componentWattsMap.end())
{
std::list< int > watts;
int minWatt = 0, maxWatt = 0;
std::map< std::string, int >::iterator mit;
for (mit = cit->second.begin(); mit!= cit->second.end(); mit++)
{
watts.push_back( mit->second );
if (mit->second != 0 && (mit->second < minWatt || minWatt == 0))
minWatt = mit->second;
if (mit->second > maxWatt)
maxWatt = mit->second;
}
std::list< int >::iterator lit;
for (lit = watts.begin(); lit != watts.end(); lit++)
{
// if the magnifyRange checkbox is set to true.. use minWatt/maxWatt as the color,
// otherwise, use the current iteration's (sit) Component's color value..
if (_magnifyRangeCheckbox != NULL && _magnifyRangeCheckbox->getValue())
{
colors.push_back( wattColor(*lit, minWatt, maxWatt) );
colors4.push_back( wattColor2(*lit, minWatt, maxWatt) );
}
else
{
colors.push_back( wattColor(*lit, (*sit)->minWattage, (*sit)->maxWattage) );
colors4.push_back( wattColor2(*lit, (*sit)->minWattage, (*sit)->maxWattage) );
}
currentAnimationRef = 0;
}
}
else
{
colors.push_back( wattColor(0, (*sit)->minWattage, (*sit)->maxWattage) );
colors4.push_back( wattColor2(0, (*sit)->minWattage, (*sit)->maxWattage) );
}
// Set color of components to the vector list of colors.
// ORIGINAL CALL:: //(*sit)->setColor( colors );
(*sit)->setColor( colors4 );
}
}
static void parseXml(mxml_node_t* rootNode, TrackData* trackData)
{
struct track_key k;
int g, i, foldedGroupCount = 0, is_key, track_index = 0;
mxml_node_t* node = rootNode;
free(trackData->bookmarks);
trackData->bookmarks = NULL;
trackData->bookmarkCount = 0;
trackData->highlightRowStep = 8;
// Traverse the tracks node data
while (1)
{
node = mxmlWalkNext(node, rootNode, MXML_DESCEND);
if (!node)
break;
switch (mxmlGetType(node))
{
case MXML_ELEMENT:
{
const char* element_name = mxmlGetElement(node);
if (!strcmp("bookmark", element_name))
{
const char* row = mxmlElementGetAttr(node, "row");
if (row)
TrackData_toggleBookmark(trackData, atoi(row));
}
if (!strcmp("group", element_name))
{
s_foldedGroupNames[foldedGroupCount++] = strdup(mxmlElementGetAttr(node, "name"));
}
if (!strcmp("tracks", element_name))
{
const char* start_row = mxmlElementGetAttr(node, "startRow");
const char* end_row = mxmlElementGetAttr(node, "endRow");
const char* hlrow_step = mxmlElementGetAttr(node, "highlightRowStep");
if (start_row)
trackData->startRow = atoi(start_row);
if (end_row)
trackData->endRow = atoi(end_row);
if (hlrow_step)
trackData->highlightRowStep = atoi(hlrow_step);
}
if (!strcmp("track", element_name))
{
int i;
struct sync_track* track;
Track* t;
// TODO: Create the new track/channel here
const char* track_name = mxmlElementGetAttr(node, "name");
const char* color_text = mxmlElementGetAttr(node, "color");
const char* folded_text = mxmlElementGetAttr(node, "folded");
track_index = TrackData_createGetTrack(trackData, track_name);
t = &trackData->tracks[track_index];
track = trackData->syncData.tracks[track_index];
if (!color_text && t->color == 0)
{
t->color = TrackData_getNextColor(trackData);
}
else
{
if (color_text)
t->color = strtoul(color_text, 0, 16);
}
if (folded_text)
{
if (folded_text[0] == '1')
t->folded = true;
}
// If we already have this track loaded we delete all the existing keys
for (i = 0; i < track->num_keys; ++i)
{
int row = track->keys[i].row;
RemoteConnection_sendDeleteKeyCommand(track->name, row);
}
free(track->keys);
track->keys = 0;
track->num_keys = 0;
}
else if (!strcmp("key", element_name))
{
struct sync_track* track = trackData->syncData.tracks[track_index];
const char* row = mxmlElementGetAttr(node, "row");
const char* value = mxmlElementGetAttr(node, "value");
const char* interpolation = mxmlElementGetAttr(node, "interpolation");
k.row = atoi(row);
k.value = (float)(atof(value));
k.type = (atoi(interpolation));
is_key = is_key_frame(track, k.row);
assert(!is_key);
sync_set_key(track, &k);
RemoteConnection_sendSetKeyCommand(track->name, &k);
}
}
default: break;
}
}
TrackData_linkGroups(trackData);
// Apply fold status on the groups
for (i = 0; i < foldedGroupCount; ++i)
{
for (g = 0; g < trackData->groupCount; ++g)
{
Group* group = &trackData->groups[g];
const char* groupName = group->name;
const char* foldedName = s_foldedGroupNames[i];
// groups with 1 track is handled as non-grouped
if (group->trackCount == 1)
continue;
if (!strcmp(foldedName, groupName))
{
trackData->groups[g].folded = true;
break;
}
}
free(s_foldedGroupNames[i]);
}
trackData->tracks[0].selected = true;
}
game* game_load(char* file)
{
game* p_game = malloc(sizeof(game));
FILE *fp = NULL;
mxml_node_t *mxml_xml = NULL;
mxml_node_t *node = NULL; //parse throught the xml
mxml_node_t *node_i = NULL;
fp = fopen(file, "r");
mxml_xml = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
mxml_node_t *node_root = mxmlWalkNext(mxml_xml, mxml_xml, MXML_DESCEND); //state (hanchor node)
//UNIT
mxml_node_t* node_unit = mxmlFindElement(node_root, mxml_xml, "unit", NULL, NULL, MXML_DESCEND);
p_game->p_unit = unit_load_xml(mxmlElementGetAttr(node_unit, "src"));
unit_init(p_game->p_unit);
mxml_node_t* node_location = mxmlFindElement(node_unit, mxml_xml, "location", NULL, NULL, MXML_DESCEND);
p_game->p_unit->p_sprite->x = atoi(mxmlElementGetAttr(node_location, "x"));
p_game->p_unit->p_sprite->y = atoi(mxmlElementGetAttr(node_location, "y"));
node = mxmlFindElement(node_unit, mxml_xml, "HP", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->HP = atoi(node->value.opaque);
node = mxmlFindElement(node_unit, mxml_xml, "MP", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->MP = atoi(node->value.opaque);
node = mxmlFindElement(node_unit, mxml_xml, "XP", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->XP = atoi(node->value.opaque);
node = mxmlFindElement(node_unit, mxml_xml, "gold", NULL, NULL, MXML_DESCEND);
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
if(node)p_game->p_unit->gold = atoi(node->value.opaque);
p_game->name = (char*)strdup("Legend of bozo");
if(mxmlElementGetAttr(node_location, "file")){
char* name = strdup(strrchr (mxmlElementGetAttr(node_location, "file"), '/') + 1);
p_game->context = calloc(strlen(name) + 1, sizeof(char));
strcpy(p_game->context, name);
free(name);name=NULL;
p_game->nb_maps = map_load_xml_all(mxmlElementGetAttr(node_location, "file"), &p_game->p_map);
p_game->cur_map = map_get_index(mxmlElementGetAttr(node_location, "name"), p_game->p_map, p_game->nb_maps);
}else{
printf("The node location do not have a file attribut, in the xml file %s\n", file);
exit(EXIT_FAILURE);
}
//load ennemies
char* ennemie_path = calloc(strlen("./res/entities/ennemies/") + strlen(p_game->context) + 1, sizeof(char));
strcpy(ennemie_path, "./res/entities/ennemies/");
strcat(ennemie_path, p_game->context);
p_game->ennemie_nb = ennemie_load_xml_name(ennemie_path, mxmlElementGetAttr(node_location, "name"), &p_game->p_ennemie);
free(ennemie_path);ennemie_path=NULL;
//load NPCs
char* NPC_path = calloc(strlen("./res/entities/NPCs/") + strlen(p_game->context) + 1, sizeof(char));
strcpy(NPC_path, "./res/entities/NPCs/");
strcat(NPC_path, p_game->context);
p_game->NPC_nb = NPC_load_xml_name(NPC_path, mxmlElementGetAttr(node_location, "name"), &p_game->p_NPC);
free(NPC_path);NPC_path=NULL;
p_game->sound_on = 1;
//VARS
p_game->vars=NULL;
mxml_node_t* node_vars = mxmlFindElement(node_root, mxml_xml, "vars", NULL, NULL, MXML_DESCEND);
for (node_i = mxmlFindElement(node_vars, mxml_xml, "var", NULL, NULL, MXML_DESCEND);
node_i != NULL;
node_i = mxmlFindElement(node_i, mxml_xml, "var", NULL, NULL, MXML_DESCEND))
{
var* p_var = malloc(sizeof(var));
p_var->name = (char*)strdup(mxmlElementGetAttr(node_i, "name"));
p_var->value = (char*)strdup(mxmlElementGetAttr(node_i, "value"));
p_game->vars = linked_list_push_front(p_game->vars , p_var);
}
mxmlDelete(node_i);
mxmlDelete(node);
mxmlDelete(mxml_xml);
fclose(fp);
return p_game;
}
event* event_load_xml(mxml_node_t *event_node, mxml_node_t* mxml_xml)
{
event *p_event = NULL;
char* sz_event_type=NULL;
bool is_auto=true;
mxml_node_t *node= NULL; //parse throught the xml
node = mxmlFindElement(event_node, mxml_xml, "event", NULL, NULL, MXML_DESCEND);
sz_event_type = (char*)strdup(mxmlElementGetAttr(node, "type")); //event attribut
//(strcmp(mxmlElementGetAttr(node, "auto"), "true") == 0) ? is_auto = true : false; //check attribut, if string "true" then set boolean to true
if(!sz_event_type){
printf( "Load event error : Can't get event type \n");
}
else if(!strcmp(sz_event_type, "text")){
p_event = malloc(sizeof(event));
p_event->type = EVENT_MESSAGE;
p_event->is_auto = is_auto;
p_event->p_next = NULL;
event_text* p_event_message = malloc(sizeof(event_text));
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //label
p_event_message->text = (char*)strdup(node->value.opaque);
p_event->data = p_event_message;
}
else if(!strcmp(sz_event_type, "teleport")){
p_event = malloc(sizeof(event));
p_event->type = EVENT_TELEPORT;
p_event->is_auto = is_auto;
p_event->p_next = NULL;
event_teleport *p_event_teleport = malloc(sizeof(event_teleport));
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //destination
if(mxmlElementGetAttr(node, "file") && strcmp(mxmlElementGetAttr(node, "file"), "")){
p_event_teleport->file = (char*)strdup(mxmlElementGetAttr(node, "file")); //attribut
}
else p_event_teleport->file = NULL;
if(mxmlElementGetAttr(node, "name") && mxmlElementGetAttr(node, "name")){
p_event_teleport->name = (char*)strdup(mxmlElementGetAttr(node, "name")); //attribut
}
else p_event_teleport->name = NULL;
char* x = (char*)strdup(mxmlElementGetAttr(node, "x"));
if(x && atoi(x) >= 0){
p_event_teleport->x = atoi(x);
free(x);x=NULL;
}
else p_event_teleport->x=-1;
char* y = (char*)strdup(mxmlElementGetAttr(node, "y"));
if(y && atoi(y) >= 0){
p_event_teleport->y = atoi(y);
free(y);y=NULL;
}
else p_event_teleport->y=-1;
p_event->data = p_event_teleport;
}
else if(!strcmp(sz_event_type, "tile_change")){
//get source tile and change the value to dest
}
else if(!strcmp(sz_event_type, "script")){
p_event = malloc(sizeof(event));
p_event->type = EVENT_SCRIPT;
p_event->is_auto = is_auto;
p_event->p_next = NULL;
event_script* p_event_script = malloc(sizeof(event_script));
p_event_script->language = (char*)strdup(mxmlElementGetAttr(node, "language")); //event attribut
node = mxmlWalkNext(node, mxml_xml, MXML_DESCEND); //text
p_event_script->script = (char*)strdup(node->value.opaque);
p_event->data = p_event_script;
p_event_script->version = (char*)strdup("5.1");
}
else{
printf( "Load event error : Unknown event type (%s)\n", sz_event_type);
}
free(sz_event_type);
return p_event;
}
//NILS
struct gameXMLinfo LoadGameInfo(char* gameid)
/* gameid: full game id */
/* langtxt: "English","French","German" */
{
// load game info using forced language, or game individual setting, or main language setting
char langcode[100] = "";
char *langtxt = GetLangSettingFromGame(gameid);
strlcpy(langcode,ConvertLangTextToCode(langtxt),sizeof(langcode));
/* reset all game info */
gameinfo = gameinfo_reset;
/* index all IDs */
nodeindex = mxmlIndexNew(nodedata,"id", NULL);
nodeid = mxmlIndexReset(nodeindex);
*element_text = 0;
/* search for game matching gameid */
while (1) {
nodeid = mxmlIndexFind(nodeindex,"id", NULL);
if (nodeid != NULL) {
get_nodetext(nodeid, element_text, sizeof(element_text));
if (!strcmp(element_text,gameid)) {
break;
}
} else {
break;
}
}
if (!strcmp(element_text,gameid)) {
/* text from elements */
strlcpy(gameinfo.id,element_text,sizeof(gameinfo.id));
GetTextFromNode(nodeid, nodedata, "region", NULL, NULL, MXML_NO_DESCEND, gameinfo.region,sizeof(gameinfo.region));
GetTextFromNode(nodeid, nodedata, "version", NULL, NULL, MXML_NO_DESCEND, gameinfo.version,sizeof(gameinfo.version));
GetTextFromNode(nodeid, nodedata, "genre", NULL, NULL, MXML_NO_DESCEND, gameinfo.genre,sizeof(gameinfo.genre));
GetTextFromNode(nodeid, nodedata, "developer", NULL, NULL, MXML_NO_DESCEND, gameinfo.developer,sizeof(gameinfo.developer));
GetTextFromNode(nodeid, nodedata, "publisher", NULL, NULL, MXML_NO_DESCEND, gameinfo.publisher,sizeof(gameinfo.publisher));
GetPublisherFromGameid(gameid,gameinfo.publisherfromid,sizeof(gameinfo.publisherfromid));
GetTextFromNode(nodeid, nodedata, "input", "players", NULL, MXML_NO_DESCEND, gameinfo.max_players,sizeof(gameinfo.max_players));
/* text from attributes */
GetTextFromNode(nodeid, nodedata, "date", "year", NULL, MXML_NO_DESCEND, gameinfo.year,sizeof(gameinfo.year));
GetTextFromNode(nodeid, nodedata, "date", "month", NULL,MXML_NO_DESCEND, gameinfo.month,sizeof(gameinfo.month));
GetTextFromNode(nodeid, nodedata, "date", "day", NULL, MXML_NO_DESCEND, gameinfo.day,sizeof(gameinfo.day));
GetTextFromNode(nodeid, nodedata, "rating", "type", NULL, MXML_NO_DESCEND, gameinfo.ratingtype,sizeof(gameinfo.ratingtype));
GetTextFromNode(nodeid, nodedata, "rating", "value", NULL, MXML_NO_DESCEND, gameinfo.ratingvalue,sizeof(gameinfo.ratingvalue));
GetTextFromNode(nodeid, nodedata, "rom", "crc", NULL, MXML_NO_DESCEND, gameinfo.iso_crc,sizeof(gameinfo.iso_crc));
GetTextFromNode(nodeid, nodedata, "rom", "md5", NULL, MXML_NO_DESCEND, gameinfo.iso_md5,sizeof(gameinfo.iso_md5));
GetTextFromNode(nodeid, nodedata, "rom", "sha1", NULL, MXML_NO_DESCEND, gameinfo.iso_sha1,sizeof(gameinfo.iso_sha1));
/* text from child elements */
nodefound = mxmlFindElement(nodeid, nodedata, "locale", "lang", "EN", MXML_NO_DESCEND);
if (nodefound != NULL) {
GetTextFromNode(nodefound, nodedata, "title", NULL, NULL, MXML_DESCEND, gameinfo.title_EN,sizeof(gameinfo.title_EN));
GetTextFromNode(nodefound, nodedata, "synopsis", NULL, NULL, MXML_DESCEND, gameinfo.synopsis_EN,sizeof(gameinfo.synopsis_EN));
}
nodefound = mxmlFindElement(nodeid, nodedata, "locale", "lang", langcode, MXML_NO_DESCEND);
if (nodefound != NULL) {
GetTextFromNode(nodefound, nodedata, "title", NULL, NULL, MXML_DESCEND, gameinfo.title,sizeof(gameinfo.title));
GetTextFromNode(nodefound, nodedata, "synopsis", NULL, NULL, MXML_DESCEND, gameinfo.synopsis,sizeof(gameinfo.synopsis));
}
// fall back to English title and synopsis if prefered language was not found
if (!strcmp(gameinfo.title,"")) {
strlcpy(gameinfo.title,gameinfo.title_EN,sizeof(gameinfo.title));
}
if (!strcmp(gameinfo.synopsis,"")) {
strlcpy(gameinfo.synopsis,gameinfo.synopsis_EN,sizeof(gameinfo.synopsis));
}
/* list locale lang attributes */
nodefound = mxmlFindElement(nodeid, nodedata, "locale", "lang", NULL, MXML_NO_DESCEND);
if (nodefound != NULL) {
int incr = 0;
while (nodefound != NULL) {
++incr;
strlcpy(gameinfo.locales[incr],mxmlElementGetAttr(nodefound, "lang"),sizeof(gameinfo.locales[incr]));
nodefound = mxmlWalkNext(nodefound, nodedata, MXML_NO_DESCEND);
if (nodefound != NULL) {
nodefound = mxmlFindElement(nodefound, nodedata, "locale", "lang", NULL, MXML_NO_DESCEND);
}
}
}
/* unbounded child elements */
GetTextFromNode(nodeid, nodedata, "wi-fi", "players", NULL, MXML_NO_DESCEND, gameinfo.wifiplayers,sizeof(gameinfo.wifiplayers));
nodefound = mxmlFindElement(nodeid, nodedata, "wi-fi", NULL, NULL, MXML_NO_DESCEND);
if (nodefound != NULL) {
gameinfo.wifiCnt = 0;
nodeindextmp = mxmlIndexNew(nodefound,"feature", NULL);
nodeidtmp = mxmlIndexReset(nodeindextmp);
while (nodeidtmp != NULL) {
nodeidtmp = mxmlIndexFind(nodeindextmp,"feature", NULL);
if (nodeidtmp != NULL) {
++gameinfo.wifiCnt;
GetTextFromNode(nodeidtmp, nodedata, "feature", NULL, NULL, MXML_DESCEND, gameinfo.wififeatures[gameinfo.wifiCnt],
sizeof(gameinfo.wififeatures[gameinfo.wifiCnt]));
gameinfo.wififeatures[gameinfo.wifiCnt][0] = toupper((int)gameinfo.wififeatures[gameinfo.wifiCnt][0]);
if (gameinfo.wifiCnt == XML_ELEMMAX)
break;
}
}
mxmlIndexDelete(nodeindextmp); // placed after each mxmlIndexNew to prevent memory leak
}
nodefound = mxmlFindElement(nodeid, nodedata, "rating", NULL, NULL, MXML_NO_DESCEND);
if (nodefound != NULL) {
gameinfo.descriptorCnt=0;
nodeindextmp = mxmlIndexNew(nodefound,"descriptor", NULL);
nodeidtmp = mxmlIndexReset(nodeindextmp);
while (nodeidtmp != NULL) {
nodeidtmp = mxmlIndexFind(nodeindextmp,"descriptor", NULL);
if (nodeidtmp != NULL) {
++gameinfo.descriptorCnt;
GetTextFromNode(nodeidtmp, nodedata, "descriptor", NULL, NULL, MXML_DESCEND,
gameinfo.ratingdescriptors[gameinfo.descriptorCnt], sizeof(gameinfo.ratingdescriptors[gameinfo.descriptorCnt]));
if (gameinfo.descriptorCnt == XML_ELEMMAX)
break;
}
}
mxmlIndexDelete(nodeindextmp);
}
GetTextFromNode(nodeid, nodedata, "input", "players", NULL, MXML_NO_DESCEND, gameinfo.players,sizeof(gameinfo.players));
nodefound = mxmlFindElement(nodeid, nodedata, "input", NULL, NULL, MXML_NO_DESCEND);
if (nodefound != NULL) {
gameinfo.accessoryCnt=0;
gameinfo.accessoryReqCnt=0;
nodeindextmp = mxmlIndexNew(nodefound,"control", NULL);
nodeidtmp = mxmlIndexReset(nodeindextmp);
while (nodeidtmp != NULL) {
nodeidtmp = mxmlIndexFind(nodeindextmp,"control", NULL);
if (nodeidtmp != NULL) {
if (!strcmp(mxmlElementGetAttr(nodeidtmp, "required"),"true") && gameinfo.accessoryReqCnt < XML_ELEMMAX) {
++gameinfo.accessoryReqCnt;
strlcpy(gameinfo.accessoriesReq[gameinfo.accessoryReqCnt],mxmlElementGetAttr(nodeidtmp, "type"),
sizeof(gameinfo.accessoriesReq[gameinfo.accessoryReqCnt]));
} else if (gameinfo.accessoryCnt < XML_ELEMMAX) {
++gameinfo.accessoryCnt;
strlcpy(gameinfo.accessories[gameinfo.accessoryCnt],mxmlElementGetAttr(nodeidtmp, "type"),
sizeof(gameinfo.accessories[gameinfo.accessoryCnt]));
}
}
}
mxmlIndexDelete(nodeindextmp);
}
/* convert rating value */
ConvertRating(gameinfo.ratingvalue, gameinfo.ratingtype, "CERO",gameinfo.ratingvalueCERO,sizeof(gameinfo.ratingvalueCERO));
ConvertRating(gameinfo.ratingvalue, gameinfo.ratingtype, "ESRB",gameinfo.ratingvalueESRB,sizeof(gameinfo.ratingvalueESRB));
ConvertRating(gameinfo.ratingvalue, gameinfo.ratingtype, "PEGI",gameinfo.ratingvaluePEGI,sizeof(gameinfo.ratingvaluePEGI));
/* provide genre as an array: gameinfo.genresplit */
if (strcmp(gameinfo.genre,"") != 0) {
gameinfo.genreCnt=0;
const char *delimgenre = ",;";
char genretxt[200];
strlcpy(genretxt,gameinfo.genre,sizeof(genretxt));
char *splitresult;
splitresult = strtok(genretxt, delimgenre);
if (splitresult != NULL) {
++gameinfo.genreCnt;
trimcopy(splitresult,splitresult,strlen(splitresult)+1);
strlcpy(gameinfo.genresplit[gameinfo.genreCnt],splitresult,sizeof(gameinfo.genresplit[gameinfo.genreCnt]));
gameinfo.genresplit[gameinfo.genreCnt][0] = toupper((int)gameinfo.genresplit[gameinfo.genreCnt][0]);
while (splitresult != NULL) {
splitresult = strtok(NULL, delimgenre);
if (splitresult != NULL && strcmp(splitresult,"")!=0) {
++gameinfo.genreCnt;
trimcopy(splitresult,splitresult,strlen(splitresult)+1);
strlcpy(gameinfo.genresplit[gameinfo.genreCnt],splitresult,sizeof(gameinfo.genresplit[gameinfo.genreCnt]));
gameinfo.genresplit[gameinfo.genreCnt][0] = toupper((int)gameinfo.genresplit[gameinfo.genreCnt][0]);
if (gameinfo.genreCnt == XML_ELEMMAX)
break;
}
}
}
}
}
// if game was not found or info is missing
// guess publisher from game id in case it is missing
if (!strcmp(gameinfo.publisher,"")) {
GetPublisherFromGameid(gameid,gameinfo.publisherfromid,sizeof(gameinfo.publisherfromid));
strlcpy(gameinfo.publisher,gameinfo.publisherfromid,sizeof(gameinfo.publisher));
}
// if missing, get region from game ID
if (!strcmp(gameinfo.region,"")) {
if (gameid[3] == 'E') strlcpy(gameinfo.region,"NTSC-U",sizeof(gameinfo.region));
if (gameid[3] == 'J') strlcpy(gameinfo.region,"NTSC-J",sizeof(gameinfo.region));
if (gameid[3] == 'W') strlcpy(gameinfo.region,"NTSC-J",sizeof(gameinfo.region));
if (gameid[3] == 'K') strlcpy(gameinfo.region,"NTSC-K",sizeof(gameinfo.region));
if (gameid[3] == 'P') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'D') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'F') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'I') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'S') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'H') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'U') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'X') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'Y') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
if (gameid[3] == 'Z') strlcpy(gameinfo.region,"PAL",sizeof(gameinfo.region));
}
// free memory
mxmlIndexDelete(nodeindex);
return gameinfo;
}
