#include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

 #include <glib.h>

 #include <bl/bl.h>

 #include "testcaseparser.h"

 #include "testcaseinput.h"

 #include "testcaseio.h"

 #include "warningsparser.h"

 /*

  * Read a testcase in from a file.

  * On error, print a suitable message using g_printerr and return NULL.

  * The returned testcase should be freed with testcase_free().

  */

 Testcase *testcase_parse_file(const char *filename)

 {

     Testcase *testcase;

     TestcaseParser *parser;

     TestcaseInput *input=NULL;

     GMarkupParseContext *context;

     GError *err=NULL;

     char *s,*arg;

     const char *tag,*text;

     gboolean found_tag=FALSE;

     parser=testcase_parser_new_from_file(filename);

     if (!parser)

 	return NULL;

     if (!*testcase_parser_get_flag(parser))

     {

 	g_printerr("%s: Not a valid testcase (flag)\n",filename);

 	testcase_parser_free(parser);

 	return NULL;

     }

     testcase=g_new0(Testcase,1);

     testcase->basename=g_path_get_basename(filename);

     s=strrchr(testcase->basename,'.');

     if (s)

 	*s='\0';

     while(testcase_parser_get_next_tag(parser,&tag,&text))

     {

 	if (!input && !strcmp(tag,"INPUT"))

 	    input=testcase_input_new("TEST-XXXXXX",text);

 	else if (g_str_has_prefix(tag,"INPUT(") && tag[strlen(tag)-1]==')')

 	{

 	    arg=g_strndup(tag+6,strlen(tag)-7);

 	    s=g_path_get_dirname(arg);

 	    if (strcmp(s,"."))

 	    {

 		/*

 		 * Otherwise it would be possible to overwrite an arbitary

 		 * file on somebody's computer by getting them to run a

 		 * testcase!

 		 */

 		g_printerr(

 		  "%s: Input files may not have a directory component\n",arg);

 		g_free(s);

 		g_free(arg);

 		testcase_free(testcase);

 		testcase_parser_free(parser);

 		return NULL;

 	    }

 	    g_free(s);

 	    testcase->inputs=g_slist_prepend(testcase->inputs,

 	      testcase_input_new(arg,text));

 	    if (!strstr(arg,"XXXXXX"))

 		testcase->flags|=TESTCASE_TMP_DIR;

 	    g_free(arg);

 	}

 	else if (!testcase->expected && !testcase->warnings &&

 	  !strcmp(tag,"EXPECTED"))

 	    testcase->expected=g_strdup(text);

 	else if (!testcase->expected && !testcase->warnings &&

 	  !strcmp(tag,"WARNINGS"))

 	{

 	    context=warnings_parse_context_new(testcase);

 	    if (!g_markup_parse_context_parse(context,text,-1,&err) ||

 	      !g_markup_parse_context_end_parse(context,&err))

 	    {

 		g_markup_parse_context_free(context);

 		g_printerr("%s\n",err->message);

 		g_clear_error(&err);

 		testcase_free(testcase);

 		testcase_parser_free(parser);

 		return NULL;

 	    }

 	    g_markup_parse_context_free(context);

 	}

 	else if (!testcase->encoding && !strcmp(tag,"ENCODING"))

 	    testcase->encoding=g_strchomp(g_strdup(text));

 	else if (!testcase->encoding && !strcmp(tag,"OPTIONS"))

 	{

 	    testcase->options=g_strsplit(text,"\n",0);

 	    g_free(testcase->options[g_strv_length(testcase->options)-1]);

 	    testcase->options[g_strv_length(testcase->options)-1]=NULL;

 	}

 	else

 	{

 	    g_printerr("%s: Not a valid testcase (%s)\n",filename,tag);

 	    testcase_free(testcase);

 	    testcase_parser_free(parser);

 	    return NULL;

 	}

 	found_tag=TRUE;

     }

     if (!testcase_parser_at_eof(parser))

     {

 	if (found_tag)

 	    g_printerr("%s: Not a valid testcase (garbage at end)\n",

 	      filename);

 	else

 	    g_printerr("%s: Not a valid testcase (no valid tags)\n",

 	      filename);

 	testcase_free(testcase);

 	testcase_parser_free(parser);

 	return NULL;

     }

     if (!input)

 	input=testcase_input_new("TEST-XXXXXX",NULL);

     testcase->inputs=g_slist_prepend(testcase->inputs,input);

     testcase_parser_free(parser);

     return testcase;

 }