/* See COPYING.txt for the full license governing this code. */

/**

 * \file parsehelper.c

 *

 * Source file with some helper functions for parsing strings.

 */

#include <SDL_test.h>

#include "SDL_visualtest_harness_argparser.h"

/* this function uses a DFA to count the number of tokens in an agruments string.

   state 0 is taken to be the start and end state. State 1 handles a double quoted

   argument and state 2 handles unquoted arguments. */

static int

CountTokens(char* args)

{

    int index, num_tokens;

    int state; /* current state of the DFA */

    if(!args)

    	return -1;

    index = 0;

    state = 0;

    num_tokens = 0;

    while(args[index])

    {

        char ch = args[index];

        switch(state)

        {

            case 0:

            if(ch == '\"')

            {

                state = 1;

                num_tokens++;

            }

            else if(!SDL_isspace(ch))

            {

                state = 2;

                num_tokens++;

            }

            break;

            case 1:

            if(ch == '\"')

            {

                state = 0;

            }

            break;

            case 2:

            if(SDL_isspace(ch))

            {

                state = 0;

            }

            break;

        }

        index++;

    }

    return num_tokens;

}

/* - size of tokens is num_tokens + 1

- uses the same DFA used in CountTokens() to split args into an array of strings */

static int

TokenizeHelper(char* str, char** tokens, int num_tokens, int max_token_len)

{

    int index, state, done, st_index, token_index;

    if(!str)

    {

        SDLTest_LogError("str argument cannot be NULL");

        return 0;

    }

    if(!tokens)

    {

        SDLTest_LogError("tokens argument cannot be NULL");

        return 0;

    }

    if(num_tokens <= 0)

    {

        SDLTest_LogError("num_tokens argument must be positive");

        return 0;

    }

    if(max_token_len <= 0)

    {

        SDLTest_LogError("max_token_len argument must be positive");

        return 0;

    }

    /* allocate memory for the tokens */

    tokens[num_tokens] = NULL;

    for(index = 0; index < num_tokens; index++)

    {

        tokens[index] = (char*)SDL_malloc(max_token_len);

        if(!tokens[index])

        {

            int i;

            SDLTest_LogError("malloc() failed.");

            for(i = 0; i < index; i++)

                SDL_free(tokens[i]);

            return 0;

        }

        tokens[index][0] = '\0';

    }

    /* copy the tokens into the array */

    st_index = 0;

    index = 0;

    token_index = 0;

    state = 0;

    done = 0;

    while(!done)

    {

        char ch = str[index];

        switch(state)

        {

            case 0:

            if(ch == '\"')

            {

                state = 1;

                st_index = index + 1;

            }

            else if(!ch)

                done = 1;

            else if(ch && !SDL_isspace(ch))

            {

                state = 2;

                st_index = index;

            }

            break;

            case 1:

            if(ch == '\"')

            {

                int i;

                state = 0;

                for(i = st_index; i < index; i++)

                {

                    tokens[token_index][i - st_index] = str[i];

                }

                tokens[token_index][i - st_index] = '\0';

                token_index++;

            }

            else if(!ch)

            {

                SDLTest_LogError("Parsing Error!");

                done = 1;

            }

            break;

            case 2:

            if(!ch)

                done = 1;

            if(SDL_isspace(ch) || !ch)

            {

                int i;

                state = 0;

                for(i = st_index; i < index; i++)

                {

                    tokens[token_index][i - st_index] = str[i];

                }

                tokens[token_index][i - st_index] = '\0';

                token_index++;

            }

            break;

        }

        index++;

    }

    return 1;

}

char**

SDLVisualTest_Tokenize(char* str, int max_token_len)

{

    int num_tokens;

    char** tokens;

    if(!str)

    {

        SDLTest_LogError("str argument cannot be NULL");

        return NULL;

    }

    if(max_token_len <= 0)

    {

        SDLTest_LogError("max_token_len argument must be positive");

        return NULL;

    }

    num_tokens = CountTokens(str);

    if(num_tokens == 0)

        return NULL;

    tokens = (char**)SDL_malloc(sizeof(char*) * (num_tokens + 1));

    if(!TokenizeHelper(str, tokens, num_tokens, max_token_len))

    {

        SDLTest_LogError("TokenizeHelper() failed");

        SDL_free(tokens);

        return NULL;

    }

    return tokens;

}

char**

SDLVisualTest_ParseArgsToArgv(char* args)

{

    char** argv;

    int num_tokens;

    num_tokens = CountTokens(args);

    if(num_tokens == 0)

        return NULL;

    /* allocate space for arguments */

    argv = (char**)SDL_malloc((num_tokens + 2) * sizeof(char*));

    if(!argv)

    {

        SDLTest_LogError("malloc() failed.");

        return NULL;

    }

    /* tokenize */

    if(!TokenizeHelper(args, argv + 1, num_tokens, MAX_SUT_ARGS_LEN))

    {

        SDLTest_LogError("TokenizeHelper() failed");

        SDL_free(argv);

        return NULL;

    }

    argv[0] = NULL;

    return argv;

}