static int append_command(void)
{
if (pile_write(&command_pile, &new_command, sizeof(new_command)))
return FALSE;
current_testcase.commands = (struct messtest_command *) pile_getptr(&command_pile);
command_count++;
return TRUE;
}
void messtest_get_data(xml_data_node *node, mess_pile *pile)
{
void *ptr;
int i = 0;
size_t j, size;
int found;
char c;
char quote_char;
blobparse_state_t blobstate = BLOBSTATE_INITIAL;
const char *s;
size_t len;
int multiple = 0;
s = node->value ? node->value : "";
len = strlen(s);
while(i < len)
{
/* read next character */
c = s[i++];
switch(blobstate)
{
case BLOBSTATE_INITIAL:
if ((c == '\0') || isspace(c))
{
/* ignore EOF and whitespace */
}
else if (c == '0')
{
blobstate = BLOBSTATE_AFTER_0;
}
else if (c == '*')
{
blobstate = BLOBSTATE_AFTER_STAR;
multiple = (size_t) -1;
}
else if (c == '\'')
{
blobstate = BLOBSTATE_SINGLEQUOTES;
}
else if (c == '\"')
{
blobstate = BLOBSTATE_DOUBLEQUOTES;
}
else
goto parseerror;
break;
case BLOBSTATE_AFTER_0:
if (tolower(c) == 'x')
{
blobstate = BLOBSTATE_HEX;
}
else
goto parseerror;
break;
case BLOBSTATE_AFTER_STAR:
if (isdigit(c))
{
/* add this digit to the multiple */
if (multiple == (size_t) -1)
multiple = 0;
else
multiple *= 10;
multiple += c - '0';
}
else if ((c != '\0') && isspace(c) && (multiple == (size_t) -1))
{
/* ignore whitespace */
}
else
{
/* do the multiplication */
size = pile_size(pile);
ptr = pile_detach(pile);
for (j = 0; j < multiple; j++)
pile_write(pile, ptr, size);
free(ptr);
blobstate = BLOBSTATE_INITIAL;
}
break;
case BLOBSTATE_HEX:
if ((c == '\0') || isspace(c))
{
blobstate = BLOBSTATE_INITIAL;
}
else
{
found = FALSE;
i--;
while(((i + 2) <= len) && isxdigit(s[i]) && isxdigit(s[i+1]))
{
c = (hexdigit(s[i]) << 4) | hexdigit(s[i+1]);
pile_putc(pile, c);
i += 2;
found = TRUE;
}
if (!found)
goto parseerror;
}
break;
case BLOBSTATE_SINGLEQUOTES:
case BLOBSTATE_DOUBLEQUOTES:
quote_char = blobstate == BLOBSTATE_SINGLEQUOTES ? '\'' : '\"';
if (c == quote_char)
{
blobstate = BLOBSTATE_INITIAL;
}
else if (c != '\0')
{
pile_putc(pile, c);
}
else
goto parseerror;
break;
}
}
return;
parseerror:
error_report("Parse Error");
return;
}
int messtest(const struct messtest_options *opts, int *test_count, int *failure_count)
{
char saved_directory[1024];
FILE *file;
int result = -1;
char *script_directory;
xml_parse_options parse_options;
xml_parse_error parse_error;
xml_data_node *root_node;
xml_data_node *tests_node;
mess_pile pile;
const char *xml;
size_t sz;
char buf[256];
*test_count = 0;
*failure_count = 0;
pile_init(&pile);
/* open the script file */
file = fopen(opts->script_filename, "r");
if (!file)
{
fprintf(stderr, "%s: Cannot open file\n", opts->script_filename);
goto done;
}
/* read the file */
while(!feof(file))
{
sz = fread(buf, 1, sizeof(buf), file);
pile_write(&pile, buf, sz);
}
pile_writebyte(&pile, '\0', 1);
xml = (const char *) pile_getptr(&pile);
/* save the current working directory, and change to the test directory */
saved_directory[0] = '\0';
if (!opts->preserve_directory)
{
script_directory = osd_dirname(opts->script_filename);
if (script_directory)
{
osd_getcurdir(saved_directory, sizeof(saved_directory) / sizeof(saved_directory[0]));
osd_setcurdir(script_directory);
free(script_directory);
}
}
/* set up parse options */
memset(&parse_options, 0, sizeof(parse_options));
parse_options.init_parser = parse_init;
parse_options.flags = XML_PARSE_FLAG_WHITESPACE_SIGNIFICANT;
parse_options.error = &parse_error;
/* do the parse */
root_node = xml_string_read(xml, &parse_options);
if (!root_node)
{
fprintf(stderr, "%s:%d:%d: %s\n",
opts->script_filename,
parse_error.error_line,
parse_error.error_column,
parse_error.error_message);
goto done;
}
/* find the tests node */
tests_node = xml_get_sibling(root_node->child, "tests");
if (!tests_node)
goto done;
node_tests(tests_node, test_count, failure_count);
result = 0;
done:
/* restore the directory */
if (saved_directory[0])
osd_setcurdir(saved_directory);
pile_delete(&pile);
return result;
}
