#include "parse_utils.h"

#include "igraph_foreign.h"

#include "igraph_memory.h"

#include "config.h" /* HAVE_XLOCALE */

#include <ctype.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#if defined(HAVE_XLOCALE)

/* On some systems, xlocale.h exists, but uselocale() is still in locale.h.

 * Thus we include both. */

#include <xlocale.h>

#include <locale.h>

#else

#include <locale.h>

#endif

/* Trims whitespace from the beginning and the end of a string with a specified length.

 * A pointer to the first character of the result substring, as well as its length, are returned.

 *

 * If you have a null-terminated string, call this function as

 *

 *     igraph_i_trim_whitespace(str, strlen(str), &res, &len);

 *

 * This does not carry a performance penalty, as the end of the string would need to be

 * determined anyway.

 */

void igraph_i_trim_whitespace(const char *str, size_t str_len, const char **res, size_t *res_len) {

    const char *beg = str, *end = str + str_len;

    while (beg < end && isspace(beg[0]) ) beg++;

    while (end > beg && isspace(end[-1])) end--;

    *res = beg;

    *res_len = end - beg;

}

/* TODO: Support for reporting line number where parse error occurred. */

/* Converts a string to an integer. Throws an error if the result is not representable.

 *

 * The input is a not-necessarily-null-terminated string that must contain only the number.

 * Any additional characters at the end of the string, such as whitespace, will trigger

 * a parsing error.

 *

 * An error is returned if the input is an empty string.

 */

igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_integer_t *value) {

    char buffer[128];

    char *tmp, *end;

    char last_char;

    igraph_bool_t out_of_range, dynamic_alloc;

    long long val;

    if (length == 0) {

        IGRAPH_ERROR("Cannot parse integer from empty string.", IGRAPH_PARSEERROR);

    }

    dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);

    if (dynamic_alloc) {

        tmp = IGRAPH_CALLOC(length+1, char);

        IGRAPH_CHECK_OOM(tmp, "Failed to parse integer.");

    } else {

        tmp = buffer;

    }

    strncpy(tmp, str, length);

    tmp[length]='\0';

    /* To avoid having to choose the appropriate strto?() function based on

     * the definition of igraph_integer_t, we first use a long long variable

     * which should be at least as large as igraph_integer_t on any platform. */

    errno = 0;

    val = strtoll(tmp, &end, 10);

    out_of_range = errno == ERANGE;

    *value = (igraph_integer_t) val;

    last_char = *end;

    if (*value != val) {

        out_of_range = true;

    }

    /* Free memory before raising any errors. */

    if (dynamic_alloc) {

        IGRAPH_FREE(tmp);

    }

    if (out_of_range) {

        IGRAPH_ERROR("Failed to parse integer.", val > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW);

    }

    /* Did we parse to the end of the string? */

    if (last_char) {

        IGRAPH_ERRORF("Unexpected character '%c' while parsing integer.", IGRAPH_PARSEERROR, last_char);

    }

    return IGRAPH_SUCCESS;

}

/* Converts a string to a real number. Throws an error if the result is not representable.

 *

 * The input is a not-necessarily-null-terminated string that must contain only the number.

 * Any additional characters at the end of the string, such as whitespace, will trigger

 * a parsing error.

 *

 * NaN and Inf are supported. An error is returned if the input is an empty string.

 */

igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) {

    char buffer[128];

    char *tmp, *end;

    char last_char;

    igraph_bool_t out_of_range, dynamic_alloc;

    if (length == 0) {

        IGRAPH_ERROR("Cannot parse real number from empty string.", IGRAPH_PARSEERROR);

    }

    dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]);

    if (dynamic_alloc) {

        tmp = IGRAPH_CALLOC(length+1, char);

        IGRAPH_CHECK_OOM(tmp, "Failed to parse real number.");

    } else {

        tmp = buffer;

    }

    strncpy(tmp, str, length);

    tmp[length]='\0';

    errno = 0;

    *value = strtod(tmp, &end);

    out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */

    last_char = *end;

    /* Free memory before raising any errors. */

    if (dynamic_alloc) {

        IGRAPH_FREE(tmp);

    }

    if (out_of_range) {

        IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW);

    }

    /* Did we parse to the end of the string? */

    if (last_char) {

        IGRAPH_ERRORF("Unexpected character '%c' while parsing real number.", IGRAPH_PARSEERROR, last_char);

    }

    return IGRAPH_SUCCESS;

}

/* Skips all whitespace in a file. */

igraph_error_t igraph_i_fskip_whitespace(FILE *file) {

    int ch;

    do {

        ch = fgetc(file);

    } while (isspace(ch));

    if (ferror(file)) {

        IGRAPH_ERROR("Error reading file.", IGRAPH_EFILE);

    }

    ungetc(ch, file);

    return IGRAPH_SUCCESS;

}

/* Reads an integer from a file. Throws an error if the result is not representable.

 *

 * Any initial whitespace is skipped. If no number is found, an error is raised.

 *

 * This function assumes that the number is followed by whitespace or the end of the file.

 * If this is not the case, an error will be raised.

 */

igraph_error_t igraph_i_fget_integer(FILE *file, igraph_integer_t *value) {

    /* The value requiring the most characters on 64-bit is -2^63, i.e. "-9223372036854775808".

     * This is 20 characters long, plus one for the null terminator, requiring a buffer of

     * at least 21 characters. We use a slightly larger buffer to allow for leading zeros and

     * clearer error messages.

     *

     * Note: The string held in this buffer is not null-terminated.

     */

    char buf[32];

    int ch;

    IGRAPH_CHECK(igraph_i_fskip_whitespace(file));

    int i = 0; /* must be 'int' due to use in printf format specifier */

    while (1) {

        ch = fgetc(file);

        if (ch == EOF) break;

        if (isspace(ch)) {

            ungetc(ch, file);

            break;

        }

        if (i == sizeof(buf)) {

            /* Reached the end of the buffer. */

            IGRAPH_ERRORF("'%.*s' is not a valid integer value.", IGRAPH_PARSEERROR, i, buf);

        }

        buf[i++] = ch;

    }

    if (ferror(file)) {

        IGRAPH_ERROR("Error while reading integer.", IGRAPH_EFILE);

    }

    if (i == 0) {

        IGRAPH_ERROR("Integer expected, reached end of file instead.", IGRAPH_PARSEERROR);

    }

    IGRAPH_CHECK(igraph_i_parse_integer(buf, i, value));

    return IGRAPH_SUCCESS;

}

/* Reads a real number from a file. Throws an error if the result is not representable.

 *

 * Any initial whitespace is skipped. If no number is found, an error is raised.

 *

 * This function assumes that the number is followed by whitespace or the end of the file.

 * If this is not the case, an error will be raised.

 */

igraph_error_t igraph_i_fget_real(FILE *file, igraph_real_t *value) {

    /* The value requiring the most characters with an IEEE-754 double is the smallest

     * representable number, with signs added, "-2.2250738585072014e-308"

     *

     * This is 24 characters long, plus one for the null terminator, requiring a buffer of

     * at least 25 characters. This is 17 mantissa digits for lossless representation,

     * 3 exponent digits, "e", and up to two minus signs. We use a larger buffer as some

     * files may have more digits specified than necessary for exact representation.

     *

     * Note: The string held in this buffer is not null-terminated.

     */

    char buf[64];

    int ch;

    IGRAPH_CHECK(igraph_i_fskip_whitespace(file));

    int i = 0; /* must be 'int' due to use in printf format specifier */

    while (1) {

        ch = fgetc(file);

        if (ch == EOF) break;

        if (isspace(ch)) {

            ungetc(ch, file);

            break;

        }

        if (i == sizeof(buf)) {

            /* Reached the end of the buffer. */

            IGRAPH_ERRORF("'%.*s' is not a valid real value.", IGRAPH_PARSEERROR, i, buf);

        }

        buf[i++] = ch;

    }

    if (ferror(file)) {

        IGRAPH_ERROR("Error while reading real number.", IGRAPH_EFILE);

    }

    if (i == 0) {

        IGRAPH_ERROR("Real number expected, reached end of file instead.", IGRAPH_PARSEERROR);

    }

    IGRAPH_CHECK(igraph_i_parse_real(buf, i, value));

    return IGRAPH_SUCCESS;

}

/* igraph_i_safelocale() and igraph_i_unsafelocale() will set the numeric locale to "C"

 * and re-set it to its original value. This is to ensure that parsing and writing

 * numbers uses a decimal point instead of a comma.

 *

 * These functions attempt to set the locale only for the current thread on a best-effort

 * basis. On some platforms this is not possible, so the global locale will be changed.

 * This is not safe to do in multi-threaded programs (not even if igraph runs only in

 * a single thread).

 */

struct igraph_safelocale_s {

#ifdef HAVE_USELOCALE

    locale_t original_locale;

    locale_t c_locale;

#else

    char    *original_locale;

# ifdef HAVE__CONFIGTHREADLOCALE

    int      per_thread_locale;

# endif

#endif

};

/**

 * \function igraph_enter_safelocale

 * \brief Temporarily set the C locale.

 *

 * igraph's foreign format readers and writers require a locale that uses a

 * decimal point instead of a decimal comma. This is a convenience function

 * that temporarily sets the C locale so that readers and writers would work

 * correctly. It \em must be paired with a call to \ref igraph_exit_safelocale(),

 * otherwise a memory leak will occur.

 *

 * </para><para>

 * This function tries to set the locale for the current thread only on a

 * best-effort basis. Restricting the locale change to a single thread is not

 * supported on all platforms. In these cases, this function falls back to using

 * the standard <code>setlocale()</code> function, which affects the entire process

 * and is not safe to use from concurrent threads.

 *

 * </para><para>

 * It is generally recommended to run igraph within a thread that has been

 * permanently set to the C locale using system-specific means. This is a convenience

 * function for situations when this is not easily possible because the programmer

 * is not in control of the process, such as when developing plugins/extensions.

 * Note that processes start up in the C locale by default, thus nothing needs to

 * be done unless the locale has been changed away from the default.

 *

 * \param loc Pointer to a variable of type \c igraph_safelocale_t. The current

 *     locale will be stored here, so that it can be restored using

 *     \ref igraph_exit_safelocale().

 * \return Error code.

 *

 * \example examples/simple/safelocale.c

 */

igraph_error_t igraph_enter_safelocale(igraph_safelocale_t *loc) {

    *loc = IGRAPH_CALLOC(1, struct igraph_safelocale_s);

    IGRAPH_CHECK_OOM(loc, "Could not set C locale.");

    igraph_safelocale_t l = *loc;

#ifdef HAVE_USELOCALE

    l->c_locale = newlocale(LC_NUMERIC_MASK, "C", NULL);

    if (! l->c_locale) {

        IGRAPH_ERROR("Could not set C locale.", IGRAPH_FAILURE);

    }

    l->original_locale = uselocale(l->c_locale);

#else

    l->original_locale = strdup(setlocale(LC_NUMERIC, NULL));

    IGRAPH_CHECK_OOM(l->original_locale, "Not enough memory.");

# ifdef HAVE__CONFIGTHREADLOCALE

    /* On Windows, we can enable per-thread locale */

    l->per_thread_locale = _configthreadlocale(0);

    _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);

# endif

    setlocale(LC_NUMERIC, "C");

#endif

    return IGRAPH_SUCCESS;

}

/**

 * \function igraph_exit_safelocale

 * \brief Temporarily set the C locale.

 *

 * Restores a locale saved by \ref igraph_enter_safelocale() and deallocates

 * all associated data. This function \em must be paired with a call to

 * \ref igraph_enter_safelocale().

 *

 * \param loc A variable of type \c igraph_safelocale_t, originally set

 *     by \ref igraph_enter_safelocale().

 */

void igraph_exit_safelocale(igraph_safelocale_t *loc) {

    igraph_safelocale_t l = *loc;

#ifdef HAVE_USELOCALE

    uselocale(l->original_locale);

    freelocale(l->c_locale);

#else

    setlocale(LC_NUMERIC, l->original_locale);

    IGRAPH_FREE(l->original_locale);

# ifdef HAVE__CONFIGTHREADLOCALE

    /* Restore per-thread locale setting on Windows */

    _configthreadlocale(l->per_thread_locale);

# endif

#endif

    IGRAPH_FREE(*loc);

}