SDL/visualtest/src/sut_configparser.c

/* See COPYING.txt for the full license governing this code. */
/**
 * \file sut_configparser.c
 *
 * Source file for the parser for SUT config files.
 */

#include <limits.h>
#include <string.h>
#include <SDL_test.h>
#include <SDL_rwops.h>
#include "SDL_visualtest_sut_configparser.h"
#include "SDL_visualtest_parsehelper.h"
#include "SDL_visualtest_rwhelper.h"

int
SDLVisualTest_ParseSUTConfig(char* file, SDLVisualTest_SUTConfig* config)
{
    char line[MAX_SUTOPTION_LINE_LENGTH];
    SDLVisualTest_RWHelperBuffer buffer;
    char* token_ptr;
    char* token_end;
    int num_lines, i, token_len;
    SDL_RWops* rw;

    if(!file)
    {
        SDLTest_LogError("file argument cannot be NULL");
        return 0;
    }
    if(!config)
    {
        SDLTest_LogError("config argument cannot be NULL");
        return 0;
    }

    /* count the number of lines */
    rw = SDL_RWFromFile(file, "r");
    if(!rw)
    {
        SDLTest_LogError("SDL_RWFromFile() failed");
        return 0;
    }
    SDLVisualTest_RWHelperResetBuffer(&buffer);
    num_lines = SDLVisualTest_RWHelperCountNonEmptyLines(rw, &buffer, '#');
    if(num_lines == -1)
        return 0;
    else if(num_lines == 0)
    {
        config->options = NULL;
        config->num_options = 0;
        SDL_RWclose(rw);
        return 1;
    }

    /* allocate memory */
    SDL_RWseek(rw, 0, RW_SEEK_SET);
    SDLVisualTest_RWHelperResetBuffer(&buffer);
    config->num_options = num_lines;
    config->options = (SDLVisualTest_SUTOption*)SDL_malloc(num_lines * 
                      sizeof(SDLVisualTest_SUTOption));
    if(!config->options)
    {
        SDLTest_LogError("malloc() failed");
        SDL_RWclose(rw);
        return 0;
    }

    /* actually parse the options */
    for(i = 0; i < num_lines; i++)
    {
        if(!SDLVisualTest_RWHelperReadLine(rw, line, MAX_SUTOPTION_LINE_LENGTH,
                                           &buffer, '#'))
        {
            SDLTest_LogError("SDLVisualTest_RWHelperReadLine() failed");
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }

        /* parse name */
        token_ptr = strtok(line, ", ");
        if(!token_ptr)
        {
            SDLTest_LogError("Could not parse line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }
        token_len = SDL_strlen(token_ptr) + 1;
        SDL_strlcpy(config->options[i].name, token_ptr, token_len);

        /* parse type */
        token_ptr = strtok(NULL, ", ");
        if(!token_ptr)
        {
            SDLTest_LogError("Could not parse line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }
        if(SDL_strcmp(token_ptr, "string") == 0)
            config->options[i].type = SDL_SUT_OPTIONTYPE_STRING;
        else if(SDL_strcmp(token_ptr, "integer") == 0)
            config->options[i].type = SDL_SUT_OPTIONTYPE_INT;
        else if(SDL_strcmp(token_ptr, "enum") == 0)
            config->options[i].type = SDL_SUT_OPTIONTYPE_ENUM;
        else if(SDL_strcmp(token_ptr, "boolean") == 0)
            config->options[i].type = SDL_SUT_OPTIONTYPE_BOOL;
        else
        {
            SDLTest_LogError("Could not parse type token at line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }

        /* parse values */
        token_ptr = strtok(NULL, "]");
        if(!token_ptr)
        {
            SDLTest_LogError("Could not parse line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }
        token_ptr = SDL_strchr(token_ptr, '[');
        if(!token_ptr)
        {
            SDLTest_LogError("Could not parse enum token at line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }
        token_ptr++;
        if(config->options[i].type == SDL_SUT_OPTIONTYPE_INT)
        {
            if(SDL_sscanf(token_ptr, "%d %d", &config->options[i].data.range.min,
                          &config->options[i].data.range.max) != 2)
            {
                config->options[i].data.range.min = INT_MIN;
                config->options[i].data.range.max = INT_MAX;
            }
        }
        else if(config->options[i].type == SDL_SUT_OPTIONTYPE_ENUM)
        {
            config->options[i].data.enum_values = SDLVisualTest_Tokenize(token_ptr,
                                                  MAX_SUTOPTION_ENUMVAL_LEN);
            if(!config->options[i].data.enum_values)
            {
                SDLTest_LogError("Could not parse enum token at line %d", i + 1);
                SDL_free(config->options);
                SDL_RWclose(rw);
                return 0;
            }
        }

        /* parse required */
        token_ptr = strtok(NULL, ", ");
        if(!token_ptr)
        {
            SDLTest_LogError("Could not parse line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }

        if(SDL_strcmp(token_ptr, "true") == 0)
            config->options[i].required = SDL_TRUE;
        else if(SDL_strcmp(token_ptr, "false") == 0)
            config->options[i].required = SDL_FALSE;
        else
        {
            SDLTest_LogError("Could not parse required token at line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }

        /* parse categories */
        token_ptr = strtok(NULL, ",");
        if(!token_ptr)
        {
            SDLTest_LogError("Could not parse line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }
        token_ptr = SDL_strchr(token_ptr, '[');
        if(!token_ptr)
        {
            SDLTest_LogError("Could not parse enum token at line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }
        token_ptr++;
        token_end = SDL_strchr(token_ptr, ']');
        *token_end = '\0';
        if(!token_end)
        {
            SDLTest_LogError("Could not parse enum token at line %d", i + 1);
            SDL_free(config->options);
            SDL_RWclose(rw);
            return 0;
        }
        config->options[i].categories = SDLVisualTest_Tokenize(token_ptr,
                                        MAX_SUTOPTION_CATEGORY_LEN);
    }
    SDL_RWclose(rw);
    return 1;
}

void
SDLVisualTest_FreeSUTConfig(SDLVisualTest_SUTConfig* config)
{
    if(config && config->options)
    {
        SDLVisualTest_SUTOption* option;
        for(option = config->options;
            option != config->options + config->num_options; option++)
        {
            if(option->categories)
                SDL_free(option->categories);
            if(option->type == SDL_SUT_OPTIONTYPE_ENUM && option->data.enum_values)
                SDL_free(option->data.enum_values);
        }
        SDL_free(config->options);
        config->options = NULL;
        config->num_options = 0;
    }
}