/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) NGINX, Inc.
 */

#include <nxt_main.h>


/*
 * nxt_int_parse() returns size_t value >= 0 on success,
 * -1 on failure, and -2 on overflow.
 */

nxt_int_t
nxt_int_parse(const u_char *p, size_t length)
{
    u_char      c;
    nxt_uint_t  val;

    static const nxt_uint_t cutoff = NXT_INT_T_MAX / 10;
    static const nxt_uint_t cutlim = NXT_INT_T_MAX % 10;

    if (nxt_fast_path(length != 0)) {

        val = 0;

        do {
            c = *p++;

            /* Values below '0' become >= 208. */
            c = c - '0';

            if (nxt_slow_path(c > 9)) {
                return -1;
            }

            if (nxt_slow_path(val >= cutoff && (val > cutoff || c > cutlim))) {
                /* An overflow. */
                return -2;
            }

            val = val * 10 + c;

            length--;

        } while (length != 0);

        return val;
    }

    return -1;
}


/*
 * nxt_size_t_parse() returns size_t value >= 0 on success,
 * -1 on failure, and -2 on overflow.
 */

ssize_t
nxt_size_t_parse(const u_char *p, size_t length)
{
    u_char  c;
    size_t  val;

    static const size_t cutoff = NXT_SIZE_T_MAX / 10;
    static const size_t cutlim = NXT_SIZE_T_MAX % 10;

    if (nxt_fast_path(length != 0)) {

        val = 0;

        do {
            c = *p++;

            /* Values below '0' become >= 208. */
            c = c - '0';

            if (nxt_slow_path(c > 9)) {
                return -1;
            }

            if (nxt_slow_path(val >= cutoff && (val > cutoff || c > cutlim))) {
                /* An overflow. */
                return -2;
            }

            val = val * 10 + c;

            length--;

        } while (length != 0);

        return val;
    }

    return -1;
}


/*
 * nxt_size_parse() parses size string with optional K or M units and
 * returns size_t value >= 0 on success, -1 on failure, and -2 on overflow.
 */

ssize_t
nxt_size_parse(const u_char *p, size_t length)
{
    u_char      unit;
    ssize_t     val, max;
    nxt_uint_t  shift;

    if (nxt_fast_path(length != 0)) {

        length--;

        /* Upper case. */
        unit = p[length] & ~0x20;

        switch (unit) {

        case 'G':
            max = NXT_SIZE_T_MAX >> 30;
            shift = 30;
            break;

        case 'M':
            max = NXT_SIZE_T_MAX >> 20;
            shift = 20;
            break;

        case 'K':
            max = NXT_SIZE_T_MAX >> 10;
            shift = 10;
            break;

        default:
            return nxt_size_t_parse(p, length + 1);
        }

        val = nxt_size_t_parse(p, length);

        if (nxt_fast_path(val >= 0)) {

            if (nxt_slow_path(val > max)) {
                /* An overflow. */
                return -2;
            }

            val <<= shift;
        }

        return val;
    }

    return -1;
}


/*
 * nxt_off_t_parse() returns nxt_off_t value >= 0 on success,
 * -1 on failure, and -2 on overflow.
 */

nxt_off_t
nxt_off_t_parse(const u_char *p, size_t length)
{
    u_char      c;
    nxt_uoff_t  val;

    static const nxt_uoff_t cutoff = NXT_OFF_T_MAX / 10;
    static const nxt_uoff_t cutlim = NXT_OFF_T_MAX % 10;

    if (nxt_fast_path(length != 0)) {

        val = 0;

        do {
            c = *p++;

            /* Values below '0' become >= 208. */
            c = c - '0';

            if (nxt_slow_path(c > 9)) {
                return -1;
            }

            if (nxt_slow_path(val >= cutoff && (val > cutoff || c > cutlim))) {
                /* An overflow. */
                return -2;
            }

            val = val * 10 + c;

            length--;

        } while (length != 0);

        return val;
    }

    return -1;
}


/*
 * nxt_str_int_parse() returns nxt_int_t value >= 0 on success,
 * -1 on failure, and -2 on overflow and also updates the 's' argument.
 */

nxt_int_t
nxt_str_int_parse(nxt_str_t *s)
{
    u_char      c, *p;
    size_t      length;
    nxt_uint_t  val;

    static const nxt_uint_t cutoff = NXT_INT_T_MAX / 10;
    static const nxt_uint_t cutlim = NXT_INT_T_MAX % 10;

    length = s->length;

    if (nxt_slow_path(length == 0)) {
        return -1;
    }

    p = s->start;
    val = 0;

    do {
        c = *p;

        /* Values below '0' become >= 208. */
        c = c - '0';

        if (c > 9) {
            break;
        }

        if (nxt_slow_path(val >= cutoff && (val > cutoff || c > cutlim))) {
            /* An overflow. */
            return -2;
        }

        val = val * 10 + c;

        p++;
        length--;

    } while (length != 0);

    s->length = length;
    s->start = p;

    return val;
}


/*
 * nxt_number_parse() returns a double value >= 0 and updates the start
 * argument on success, or returns -1 on failure or -2 on overflow.
 */

double
nxt_number_parse(const u_char **start, const u_char *end)
{
    u_char        c;
    nxt_bool_t    overflow;
    nxt_uint_t    integral, frac, power;
    const u_char  *p;

    static const nxt_uint_t cutoff = NXT_INT_T_MAX / 10;
    static const nxt_uint_t cutlim = NXT_INT_T_MAX % 10;

    p = *start;
    integral = 0;

    while (p < end) {
        c = *p;

        if (c == '.') {
            goto dot;
        }

        /* Values below '0' become >= 208. */
        c = c - '0';

        if (c > 9) {
            break;
        }

        overflow = nxt_expect(0, (integral >= cutoff
                                  && (integral > cutoff || c > cutlim)));

        if (overflow) {
            return -2;
        }

        integral = integral * 10 + c;

        p++;
    }

    if (nxt_fast_path(p != *start)) {
        *start = p;
        return integral;
    }

    /* No value. */
    return -1;

dot:

    if (nxt_slow_path(p == *start)) {
        /* No leading digit before dot. */
        return -1;
    }

    frac = 0;
    power = 1;

    for (p++; p < end; p++) {
        c = *p;

        /* Values below '0' become >= 208. */
        c = c - '0';

        if (c > 9) {
            break;
        }

        overflow = nxt_expect(0, (frac >= cutoff && (frac > cutoff
                                                     || c > cutlim))
                                 || power > cutoff);

        if (overflow) {
            return -2;
        }

        frac = frac * 10 + c;
        power *= 10;
    }

    *start = p;

    return integral + (double) frac / power;
}