int load_game(char * path, settings * game_settings){
FILE * fp;
mxml_node_t *xml_tree;
mxml_node_t *xml_node;
char row_node[17] = "game/board/row_x";
char row[9] = { 0 };
cord c;
fp = fopen(path, "r");
if (fp == NULL)
return FALSE;
xml_tree = mxmlLoadFile(NULL, fp, MXML_OPAQUE_CALLBACK);
fclose(fp);
xml_node = mxmlFindPath(xml_tree, "game/next_turn");
game_settings->next = (xml_node == NULL) ? WHITE : string_to_color(mxmlGetOpaque(xml_node));
xml_node = mxmlFindPath(xml_tree, "game/game_mode");
game_settings->mode = (xml_node == NULL) ? PLAYER_VS_COMP : atoi(mxmlGetOpaque(xml_node));
if (game_settings->mode == PLAYER_VS_COMP){
xml_node = mxmlFindPath(xml_tree, "game/difficulty");
game_settings->minimax_depth = (xml_node == NULL) ? 1 : atoi(mxmlGetOpaque(xml_node));
xml_node = mxmlFindPath(xml_tree, "game/user_color");
game_settings->color = (xml_node == NULL) ? WHITE : string_to_color(mxmlGetOpaque(xml_node));
}
for (int y = 8; y > 0; y--) {
row_node[15] = '0' + y;
xml_node = mxmlFindPath(xml_tree, row_node);
strcpy(row, mxmlGetOpaque(xml_node));
for (int x = 0; x < 8; x++) {
c.x = x;
c.y = y - 1;
board_piece(game_settings->board, c) = (row[x] == '_') ? EMPTY : row[x];
}
}
//mxmlDelete(xml_tree);
return TRUE;
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char* argv[]) { /* I - Command-line args */
int i; /* Looping var */
FILE* fp; /* File to read */
int fd; /* File descriptor */
mxml_node_t* tree, /* XML tree */
*node; /* Node which should be in test.xml */
mxml_index_t* ind; /* XML index */
char buffer[16384]; /* Save string */
static const char* types[] = /* Strings for node types */
{
"MXML_ELEMENT",
"MXML_INTEGER",
"MXML_OPAQUE",
"MXML_REAL",
"MXML_TEXT"
};
/*
* Check arguments...
*/
if (argc != 2) {
fputs("Usage: testmxml filename.xml\n", stderr);
return (1);
}
/*
* Test the basic functionality...
*/
tree = mxmlNewElement(MXML_NO_PARENT, "element");
if (!tree) {
fputs("ERROR: No parent node in basic test!\n", stderr);
return (1);
}
if (tree->type != MXML_ELEMENT) {
fprintf(stderr, "ERROR: Parent has type %s (%d), expected MXML_ELEMENT!\n",
tree->type < MXML_ELEMENT || tree->type > MXML_TEXT ?
"UNKNOWN" : types[tree->type], tree->type);
mxmlDelete(tree);
return (1);
}
if (strcmp(tree->value.element.name, "element")) {
fprintf(stderr, "ERROR: Parent value is \"%s\", expected \"element\"!\n",
tree->value.element.name);
mxmlDelete(tree);
return (1);
}
mxmlNewInteger(tree, 123);
mxmlNewOpaque(tree, "opaque");
mxmlNewReal(tree, 123.4f);
mxmlNewText(tree, 1, "text");
mxmlLoadString(tree, "<group type='string'>string string string</group>",
MXML_NO_CALLBACK);
mxmlLoadString(tree, "<group type='integer'>1 2 3</group>",
MXML_INTEGER_CALLBACK);
mxmlLoadString(tree, "<group type='real'>1.0 2.0 3.0</group>",
MXML_REAL_CALLBACK);
mxmlLoadString(tree, "<group>opaque opaque opaque</group>",
MXML_OPAQUE_CALLBACK);
mxmlLoadString(tree, "<foo><bar><one><two>value<two>value2</two></two></one>"
"</bar></foo>", MXML_OPAQUE_CALLBACK);
node = tree->child;
if (!node) {
fputs("ERROR: No first child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_INTEGER) {
fprintf(stderr, "ERROR: First child has type %s (%d), expected MXML_INTEGER!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (node->value.integer != 123) {
fprintf(stderr, "ERROR: First child value is %d, expected 123!\n",
node->value.integer);
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node) {
fputs("ERROR: No second child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_OPAQUE) {
fprintf(stderr, "ERROR: Second child has type %s (%d), expected MXML_OPAQUE!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (!node->value.opaque || strcmp(node->value.opaque, "opaque")) {
fprintf(stderr, "ERROR: Second child value is \"%s\", expected \"opaque\"!\n",
node->value.opaque ? node->value.opaque : "(null)");
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node) {
fputs("ERROR: No third child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_REAL) {
fprintf(stderr, "ERROR: Third child has type %s (%d), expected MXML_REAL!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (node->value.real != 123.4f) {
fprintf(stderr, "ERROR: Third child value is %f, expected 123.4!\n",
node->value.real);
mxmlDelete(tree);
return (1);
}
node = node->next;
if (!node) {
fputs("ERROR: No fourth child node in basic test!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_TEXT) {
fprintf(stderr, "ERROR: Fourth child has type %s (%d), expected MXML_TEXT!\n",
node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
if (!node->value.text.whitespace ||
!node->value.text.string || strcmp(node->value.text.string, "text")) {
fprintf(stderr, "ERROR: Fourth child value is %d,\"%s\", expected 1,\"text\"!\n",
node->value.text.whitespace,
node->value.text.string ? node->value.text.string : "(null)");
mxmlDelete(tree);
return (1);
}
for (i = 0; i < 4; i ++) {
node = node->next;
if (!node) {
fprintf(stderr, "ERROR: No group #%d child node in basic test!\n", i + 1);
mxmlDelete(tree);
return (1);
}
if (node->type != MXML_ELEMENT) {
fprintf(stderr, "ERROR: Group child #%d has type %s (%d), expected MXML_ELEMENT!\n",
i + 1, node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
"UNKNOWN" : types[node->type], node->type);
mxmlDelete(tree);
return (1);
}
}
/*
* Test mxmlFindPath...
*/
node = mxmlFindPath(tree, "*/two");
if (!node) {
fputs("ERROR: Unable to find value for \"*/two\".\n", stderr);
mxmlDelete(tree);
return (1);
} else if (node->type != MXML_OPAQUE || strcmp(node->value.opaque, "value")) {
fputs("ERROR: Bad value for \"*/two\".\n", stderr);
mxmlDelete(tree);
return (1);
}
node = mxmlFindPath(tree, "foo/*/two");
if (!node) {
fputs("ERROR: Unable to find value for \"foo/*/two\".\n", stderr);
mxmlDelete(tree);
return (1);
} else if (node->type != MXML_OPAQUE || strcmp(node->value.opaque, "value")) {
fputs("ERROR: Bad value for \"foo/*/two\".\n", stderr);
mxmlDelete(tree);
return (1);
}
node = mxmlFindPath(tree, "foo/bar/one/two");
if (!node) {
fputs("ERROR: Unable to find value for \"foo/bar/one/two\".\n", stderr);
mxmlDelete(tree);
return (1);
} else if (node->type != MXML_OPAQUE || strcmp(node->value.opaque, "value")) {
fputs("ERROR: Bad value for \"foo/bar/one/two\".\n", stderr);
mxmlDelete(tree);
return (1);
}
/*
* Test indices...
*/
ind = mxmlIndexNew(tree, NULL, NULL);
if (!ind) {
fputs("ERROR: Unable to create index of all nodes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 10) {
fprintf(stderr, "ERROR: Index of all nodes contains %d "
"nodes; expected 10!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, "group", NULL)) {
fputs("ERROR: mxmlIndexFind for \"group\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, "group", NULL);
if (!ind) {
fputs("ERROR: Unable to create index of groups!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 4) {
fprintf(stderr, "ERROR: Index of groups contains %d "
"nodes; expected 4!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexEnum(ind)) {
fputs("ERROR: mxmlIndexEnum failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, NULL, "type");
if (!ind) {
fputs("ERROR: Unable to create index of type attributes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 3) {
fprintf(stderr, "ERROR: Index of type attributes contains %d "
"nodes; expected 3!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, NULL, "string")) {
fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
ind = mxmlIndexNew(tree, "group", "type");
if (!ind) {
fputs("ERROR: Unable to create index of elements and attributes!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (ind->num_nodes != 3) {
fprintf(stderr, "ERROR: Index of elements and attributes contains %d "
"nodes; expected 3!\n", ind->num_nodes);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexReset(ind);
if (!mxmlIndexFind(ind, "group", "string")) {
fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
mxmlIndexDelete(ind);
mxmlDelete(tree);
return (1);
}
mxmlIndexDelete(ind);
/*
* Check the mxmlDelete() works properly...
*/
for (i = 0; i < 9; i ++) {
if (tree->child) {
mxmlDelete(tree->child);
} else {
fprintf(stderr, "ERROR: Child pointer prematurely NULL on child #%d\n",
i + 1);
mxmlDelete(tree);
return (1);
}
}
if (tree->child) {
fputs("ERROR: Child pointer not NULL after deleting all children!\n", stderr);
return (1);
}
if (tree->last_child) {
fputs("ERROR: Last child pointer not NULL after deleting all children!\n", stderr);
return (1);
}
mxmlDelete(tree);
/*
* Open the file...
*/
if (argv[1][0] == '<') {
tree = mxmlLoadString(NULL, argv[1], type_cb);
} else if ((fp = fopen(argv[1], "rb")) == NULL) {
perror(argv[1]);
return (1);
} else {
/*
* Read the file...
*/
tree = mxmlLoadFile(NULL, fp, type_cb);
fclose(fp);
}
if (!tree) {
fputs("Unable to read XML file!\n", stderr);
return (1);
}
if (!strcmp(argv[1], "test.xml")) {
/*
* Verify that mxmlFindElement() and indirectly mxmlWalkNext() work
* properly...
*/
if ((node = mxmlFindElement(tree, tree, "choice", NULL, NULL,
MXML_DESCEND)) == NULL) {
fputs("Unable to find first <choice> element in XML tree!\n", stderr);
mxmlDelete(tree);
return (1);
}
if (!mxmlFindElement(node, tree, "choice", NULL, NULL, MXML_NO_DESCEND)) {
fputs("Unable to find second <choice> element in XML tree!\n", stderr);
mxmlDelete(tree);
return (1);
}
}
/*
* Print the XML tree...
*/
mxmlSaveFile(tree, stdout, whitespace_cb);
/*
* Save the XML tree to a string and print it...
*/
if (mxmlSaveString(tree, buffer, sizeof(buffer), whitespace_cb) > 0) {
fputs(buffer, stderr);
}
/*
* Delete the tree...
*/
mxmlDelete(tree);
/*
* Read from/write to file descriptors...
*/
if (argv[1][0] != '<') {
/*
* Open the file again...
*/
if ((fd = open(argv[1], O_RDONLY | O_BINARY)) < 0) {
perror(argv[1]);
return (1);
}
/*
* Read the file...
*/
tree = mxmlLoadFd(NULL, fd, type_cb);
close(fd);
/*
* Create filename.xmlfd...
*/
snprintf(buffer, sizeof(buffer), "%sfd", argv[1]);
if ((fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666)) < 0) {
perror(buffer);
mxmlDelete(tree);
return (1);
}
/*
* Write the file...
*/
mxmlSaveFd(tree, fd, whitespace_cb);
close(fd);
/*
* Delete the tree...
*/
mxmlDelete(tree);
}
/*
* Test SAX methods...
*/
memset(event_counts, 0, sizeof(event_counts));
if (argv[1][0] == '<') {
mxmlSAXLoadString(NULL, argv[1], type_cb, sax_cb, NULL);
} else if ((fp = fopen(argv[1], "rb")) == NULL) {
perror(argv[1]);
return (1);
} else {
/*
* Read the file...
*/
mxmlSAXLoadFile(NULL, fp, type_cb, sax_cb, NULL);
fclose(fp);
}
if (!strcmp(argv[1], "test.xml")) {
if (event_counts[MXML_SAX_CDATA] != 1) {
fprintf(stderr, "MXML_SAX_CDATA seen %d times, expected 1 times!\n",
event_counts[MXML_SAX_CDATA]);
return (1);
}
if (event_counts[MXML_SAX_COMMENT] != 1) {
fprintf(stderr, "MXML_SAX_COMMENT seen %d times, expected 1 times!\n",
event_counts[MXML_SAX_COMMENT]);
return (1);
}
if (event_counts[MXML_SAX_DATA] != 60) {
fprintf(stderr, "MXML_SAX_DATA seen %d times, expected 60 times!\n",
event_counts[MXML_SAX_DATA]);
return (1);
}
if (event_counts[MXML_SAX_DIRECTIVE] != 1) {
fprintf(stderr, "MXML_SAX_DIRECTIVE seen %d times, expected 1 times!\n",
event_counts[MXML_SAX_DIRECTIVE]);
return (1);
}
if (event_counts[MXML_SAX_ELEMENT_CLOSE] != 20) {
fprintf(stderr, "MXML_SAX_ELEMENT_CLOSE seen %d times, expected 20 times!\n",
event_counts[MXML_SAX_ELEMENT_CLOSE]);
return (1);
}
if (event_counts[MXML_SAX_ELEMENT_OPEN] != 20) {
fprintf(stderr, "MXML_SAX_ELEMENT_OPEN seen %d times, expected 20 times!\n",
event_counts[MXML_SAX_ELEMENT_OPEN]);
return (1);
}
}
/*
* Return...
*/
return (0);
}
