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;
}
static int next_iter(lua_State *L)
{
mxml_node_t **parent;
mxml_node_t **child;
mxml_node_t **sib;
child = (mxml_node_t **)lua_touserdata(L, lua_upvalueindex(2));
/* First time through child == NULL */
if (child == NULL) {
parent = l_checkMXMLP(L, lua_upvalueindex(1));
child = _l_new_node(L);
*child = mxmlGetFirstChild(*parent);
if (mxmlGetType(*child) == MXML_ELEMENT) {
lua_pushvalue(L, -1);
lua_replace(L, lua_upvalueindex(2));
return 1;
}
}
do {
*child = mxmlGetNextSibling(*child);
} while ((*child) && (mxmlGetType(*child) != MXML_ELEMENT));
if (!*child) {
lua_pop(L, 1);
return 0;
}
lua_pushvalue(L, -1);
lua_replace(L, lua_upvalueindex(2));
return 1;
}
static int l_get_type(lua_State *L)
{
mxml_node_t *node = l_checkMXML(L, 1);
mxml_type_t type;
lua_pushnumber(L, mxmlGetType(node));
/*
type = mxmlGetType(node);
switch (type) {
case MXML_CUSTOM:
lua_pushstring(L, "MXML_CUSTOM");
break;
case MXML_ELEMENT:
lua_pushstring(L, "MXML_ELEMENT");
break;
case MXML_IGNORE:
lua_pushstring(L, "MXML_IGNORE");
break;
case MXML_INTEGER:
lua_pushstring(L, "MXML_INTEGER");
break;
case MXML_OPAQUE:
lua_pushstring(L, "MXML_OPAQUE");
break;
case MXML_REAL:
lua_pushstring(L, "MXML_REAL");
break;
case MXML_TEXT:
lua_pushstring(L, "MXML_TEXT");
break;
}
*/
return 1;
}
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);
}
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;
}
