// Read an INI file into easy-to-access name/value pairs.

// inih and INIReader are released under the New BSD license (see LICENSE.txt).

// Go to the project home page for more info:

//

// https://github.com/benhoyt/inih

#include "config.h"

#include "ini.hpp"

#include <algorithm>

#include <cctype>

#include <cstdlib>

using std::string;

using namespace Exiv2;

/* inih -- simple .INI file parser

inih is released under the New BSD license (see LICENSE.txt). Go to the project

home page for more info:

https://github.com/benhoyt/inih

*/

#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)

#define _CRT_SECURE_NO_WARNINGS

#endif

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#if !INI_USE_STACK

#include <cstdlib>

#endif

#define MAX_SECTION 50

#define MAX_NAME 50

/* Strip whitespace chars off end of given string, in place. Return s. */

static char* rstrip(char* s)

{

    char* p = s + strlen(s);

    while (p > s && isspace((unsigned char)(*--p)))

        *p = '\0';

    return s;

}

/* Return pointer to first non-whitespace char in given string. */

static char* lskip(const char* s)

{

    while (*s && isspace((unsigned char)(*s)))

        s++;

    return (char*)s;

}

/* Return pointer to first char (of chars) or inline comment in given string,

   or pointer to null at end of string if neither found. Inline comment must

   be prefixed by a whitespace character to register as a comment. */

static char* find_chars_or_comment(const char* s, const char* chars)

{

#if INI_ALLOW_INLINE_COMMENTS

    int was_space = 0;

    while (*s && (!chars || !strchr(chars, *s)) &&

           !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {

        was_space = isspace((unsigned char)(*s));

        s++;

    }

#else

    while (*s && (!chars || !strchr(chars, *s))) {

        s++;

    }

#endif

    return (char*)s;

}

/* Version of strncpy that ensures dest (size bytes) is null-terminated. */

static char* strncpy0(char* dest, const char* src, size_t size)

{

    strncpy(dest, src, size);

    dest[size - 1] = '\0';

    return dest;

}

/* See documentation in header file. */

int Exiv2::ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,

                     void* user)

{

    /* Uses a fair bit of stack (use heap instead if you need to) */

#if INI_USE_STACK

    char line[INI_MAX_LINE];

#else

    char* line;

#endif

    char section[MAX_SECTION] = "";

    char prev_name[MAX_NAME] = "";

    char* start;

    char* end;

    char* name;

    char* value;

    int lineno = 0;

    int error = 0;

#if !INI_USE_STACK

    line = (char*)malloc(INI_MAX_LINE);

    if (!line) {

        return -2;

    }

#endif

    /* Scan through stream line by line */

    while (reader(line, INI_MAX_LINE, stream) != NULL) {

        lineno++;

        start = line;

#if INI_ALLOW_BOM

        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&

                           (unsigned char)start[1] == 0xBB &&

                           (unsigned char)start[2] == 0xBF) {

            start += 3;

        }

#endif

        start = lskip(rstrip(start));

        if (*start == ';' || *start == '#') {

            /* Per Python configparser, allow both ; and # comments at the

               start of a line */

        }

#if INI_ALLOW_MULTILINE

        else if (*prev_name && *start && start > line) {

            /* Non-blank line with leading whitespace, treat as continuation

               of previous name's value (as per Python configparser). */

            if (!handler(user, section, prev_name, start) && !error)

                error = lineno;

        }

#endif

        else if (*start == '[') {

            /* A "[section]" line */

            end = find_chars_or_comment(start + 1, "]");

            if (*end == ']') {

                *end = '\0';

                strncpy0(section, start + 1, sizeof(section));

                *prev_name = '\0';

            }

            else if (!error) {

                /* No ']' found on section line */

                error = lineno;

            }

        }

        else if (*start) {

            /* Not a comment, must be a name[=:]value pair */

            end = find_chars_or_comment(start, "=:");

            if (*end == '=' || *end == ':') {

                *end = '\0';

                name = rstrip(start);

                value = lskip(end + 1);

#if INI_ALLOW_INLINE_COMMENTS

                end = find_chars_or_comment(value, NULL);

                if (*end)

                    *end = '\0';

#endif

                rstrip(value);

                /* Valid name[=:]value pair found, call handler */

                strncpy0(prev_name, name, sizeof(prev_name));

                if (!handler(user, section, name, value) && !error)

                    error = lineno;

            }

            else if (!error) {

                /* No '=' or ':' found on name[=:]value line */

                error = lineno;

            }

        }

#if INI_STOP_ON_FIRST_ERROR

        if (error)

            break;

#endif

    }

#if !INI_USE_STACK

    free(line);

#endif

    return error;

}

/* See documentation in header file. */

int Exiv2::ini_parse_file(FILE* file, ini_handler handler, void* user)

{

    return Exiv2::ini_parse_stream((ini_reader)fgets, file, handler, user);

}

/* See documentation in header file. */

int Exiv2::ini_parse(const char* filename, ini_handler handler, void* user)

{

    FILE* file;

    int error;

    file = fopen(filename, "r");

    if (!file)

        return -1;

    error = Exiv2::ini_parse_file(file, handler, user);

    fclose(file);

    return error;

}

INIReader::INIReader(const std::string &filename)

{

    _error = ini_parse(filename.c_str(), ValueHandler, this);

}

int INIReader::ParseError()

{

    return _error;

}

string INIReader::Get(string section, string name, string default_value)

{

    string key = MakeKey(section, name);

    return _values.count(key) ? _values[key] : default_value;

}

long INIReader::GetInteger(string section, string name, long default_value)

{

    string valstr = Get(section, name, "");

    const char* value = valstr.c_str();

    char* end;

    // This parses "1234" (decimal) and also "0x4D2" (hex)

    long n = strtol(value, &end, 0);

    return end > value ? n : default_value;

}

double INIReader::GetReal(string section, string name, double default_value)

{

    string valstr = Get(section, name, "");

    const char* value = valstr.c_str();

    char* end;

    double n = strtod(value, &end;;

    return end > value ? n : default_value;

}

bool INIReader::GetBoolean(string section, string name, bool default_value)

{

    string valstr = Get(section, name, "");

    // Convert to lower case to make string comparisons case-insensitive

    std::transform(valstr.begin(), valstr.end(), valstr.begin(), ::tolower);

    if (valstr == "true" || valstr == "yes" || valstr == "on" || valstr == "1")

        return true;

    else if (valstr == "false" || valstr == "no" || valstr == "off" || valstr == "0")

        return false;

    else

        return default_value;

}

string INIReader::MakeKey(string section, string name)

{

    string key = section + "=" + name;

    // Convert to lower case to make section/name lookups case-insensitive

    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    return key;

}

int INIReader::ValueHandler(void* user, const char* section, const char* name,

                            const char* value)

{

    INIReader* reader = (INIReader*)user;

    string key = MakeKey(section, name);

    if (reader->_values[key].size() > 0)

        reader->_values[key] += "\n";

    reader->_values[key] += value;

    return 1;

}