numutils.c File Reference

#include "postgres.h"
#include <math.h>
#include <limits.h>
#include <ctype.h>
#include "common/int.h"
#include "utils/builtins.h"
#include "port/pg_bitutils.h"

Include dependency graph for numutils.c:

Go to the source code of this file.

Functions
static int	decimalLength32 (const uint32 v)
static int	decimalLength64 (const uint64 v)
int16	pg_strtoint16 (const char *s)
int16	pg_strtoint16_safe (const char *s, Node *escontext)
int32	pg_strtoint32 (const char *s)
int32	pg_strtoint32_safe (const char *s, Node *escontext)
int64	pg_strtoint64 (const char *s)
int64	pg_strtoint64_safe (const char *s, Node *escontext)
uint32	uint32in_subr (const char *s, char **endloc, const char *typname, Node *escontext)
uint64	uint64in_subr (const char *s, char **endloc, const char *typname, Node *escontext)
int	pg_itoa (int16 i, char *a)
int	pg_ultoa_n (uint32 value, char *a)
int	pg_ltoa (int32 value, char *a)
int	pg_ulltoa_n (uint64 value, char *a)
int	pg_lltoa (int64 value, char *a)
char *	pg_ultostr_zeropad (char *str, uint32 value, int32 minwidth)
char *	pg_ultostr (char *str, uint32 value)

Variables
static const char	DIGIT_TABLE [200]
static const int8	hexlookup [128]

Function Documentation

decimalLength32()

static int decimalLength32 ( const uint32  v )

inlinestatic

Definition at line 45 of file numutils.c.

{
    int         t;
    static const uint32 PowersOfTen[] = {
        1, 10, 100,
        1000, 10000, 100000,
        1000000, 10000000, 100000000,
        1000000000
    };
 
    /*
     * Compute base-10 logarithm by dividing the base-2 logarithm by a
     * good-enough approximation of the base-2 logarithm of 10
     */
    t = (pg_leftmost_one_pos32(v) + 1) * 1233 / 4096;
    return t + (v >= PowersOfTen[t]);
}

References pg_leftmost_one_pos32().

Referenced by pg_ultoa_n().

decimalLength64()

static int decimalLength64 ( const uint64  v )

inlinestatic

Definition at line 64 of file numutils.c.

{
    int         t;
    static const uint64 PowersOfTen[] = {
        UINT64CONST(1), UINT64CONST(10),
        UINT64CONST(100), UINT64CONST(1000),
        UINT64CONST(10000), UINT64CONST(100000),
        UINT64CONST(1000000), UINT64CONST(10000000),
        UINT64CONST(100000000), UINT64CONST(1000000000),
        UINT64CONST(10000000000), UINT64CONST(100000000000),
        UINT64CONST(1000000000000), UINT64CONST(10000000000000),
        UINT64CONST(100000000000000), UINT64CONST(1000000000000000),
        UINT64CONST(10000000000000000), UINT64CONST(100000000000000000),
        UINT64CONST(1000000000000000000), UINT64CONST(10000000000000000000)
    };
 
    /*
     * Compute base-10 logarithm by dividing the base-2 logarithm by a
     * good-enough approximation of the base-2 logarithm of 10
     */
    t = (pg_leftmost_one_pos64(v) + 1) * 1233 / 4096;
    return t + (v >= PowersOfTen[t]);
}

References pg_leftmost_one_pos64().

Referenced by pg_ulltoa_n().

pg_itoa()

int pg_itoa	(	int16	i,
		char *	a
	)

Definition at line 793 of file numutils.c.

{
    return pg_ltoa((int32) i, a);
}

References a, i, and pg_ltoa().

Referenced by int2out(), int2vectorout(), LogicalTapeImport(), and LogicalTapeSetCreate().

pg_lltoa()

int pg_lltoa	(	int64	value,
		char *	a
	)

Definition at line 978 of file numutils.c.

{
    uint64      uvalue = value;
    int         len = 0;
 
    if (value < 0)
    {
        uvalue = (uint64) 0 - uvalue;
        a[len++] = '-';
    }
 
    len += pg_ulltoa_n(uvalue, a + len);
    a[len] = '\0';
    return len;
}

References a, len, pg_ulltoa_n(), and value.

Referenced by int8out(), and printsimple().

pg_ltoa()

int pg_ltoa	(	int32	value,
		char *	a
	)

Definition at line 871 of file numutils.c.

{
    uint32      uvalue = (uint32) value;
    int         len = 0;
 
    if (value < 0)
    {
        uvalue = (uint32) 0 - uvalue;
        a[len++] = '-';
    }
    len += pg_ultoa_n(uvalue, a + len);
    a[len] = '\0';
    return len;
}

References a, len, pg_ultoa_n(), and value.

Referenced by int4out(), pg_itoa(), and printsimple().

pg_strtoint16()

int16 pg_strtoint16

(

const char *

s

)

Definition at line 113 of file numutils.c.

{
    return pg_strtoint16_safe(s, NULL);
}

References pg_strtoint16_safe().

pg_strtoint16_safe()

int16 pg_strtoint16_safe	(	const char *	s,
		Node *	escontext
	)

Definition at line 119 of file numutils.c.

{
    const char *ptr = s;
    const char *firstdigit;
    uint16      tmp = 0;
    bool        neg = false;
 
    /* skip leading spaces */
    while (likely(*ptr) && isspace((unsigned char) *ptr))
        ptr++;
 
    /* handle sign */
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
    else if (*ptr == '+')
        ptr++;
 
    /* process digits */
    if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (isxdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 16)))
                    goto out_of_range;
 
                tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (*ptr >= '0' && *ptr <= '7')
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 8)))
                    goto out_of_range;
 
                tmp = tmp * 8 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (*ptr >= '0' && *ptr <= '1')
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 2)))
                    goto out_of_range;
 
                tmp = tmp * 2 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else
    {
        firstdigit = ptr;
 
        while (*ptr)
        {
            if (isdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 10)))
                    goto out_of_range;
 
                tmp = tmp * 10 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore may not be first */
                if (unlikely(ptr == firstdigit))
                    goto invalid_syntax;
                /* and it must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
 
    /* require at least one digit */
    if (unlikely(ptr == firstdigit))
        goto invalid_syntax;
 
    /* allow trailing whitespace, but not other trailing chars */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    if (unlikely(*ptr != '\0'))
        goto invalid_syntax;
 
    if (neg)
    {
        /* check the negative equivalent will fit without overflowing */
        if (tmp > (uint16) (-(PG_INT16_MIN + 1)) + 1)
            goto out_of_range;
        return -((int16) tmp);
    }
 
    if (tmp > PG_INT16_MAX)
        goto out_of_range;
 
    return (int16) tmp;
 
out_of_range:
    ereturn(escontext, 0,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value \"%s\" is out of range for type %s",
                    s, "smallint")));
 
invalid_syntax:
    ereturn(escontext, 0,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "smallint", s)));
}

References ereturn, errcode(), errmsg(), hexlookup, likely, PG_INT16_MAX, PG_INT16_MIN, and unlikely.

Referenced by int2in(), and pg_strtoint16().

pg_strtoint32()

int32 pg_strtoint32

(

const char *

s

)

Definition at line 291 of file numutils.c.

{
    return pg_strtoint32_safe(s, NULL);
}

References pg_strtoint32_safe().

Referenced by ArrayGetIntegerTypmods(), check_foreign_key(), libpqrcv_endstreaming(), libpqrcv_identify_system(), pq_parse_errornotice(), prsd_headline(), and text_format().

pg_strtoint32_safe()

int32 pg_strtoint32_safe	(	const char *	s,
		Node *	escontext
	)

Definition at line 297 of file numutils.c.

{
    const char *ptr = s;
    const char *firstdigit;
    uint32      tmp = 0;
    bool        neg = false;
 
    /* skip leading spaces */
    while (likely(*ptr) && isspace((unsigned char) *ptr))
        ptr++;
 
    /* handle sign */
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
    else if (*ptr == '+')
        ptr++;
 
    /* process digits */
    if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (isxdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 16)))
                    goto out_of_range;
 
                tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (*ptr >= '0' && *ptr <= '7')
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 8)))
                    goto out_of_range;
 
                tmp = tmp * 8 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (*ptr >= '0' && *ptr <= '1')
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 2)))
                    goto out_of_range;
 
                tmp = tmp * 2 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else
    {
        firstdigit = ptr;
 
        while (*ptr)
        {
            if (isdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 10)))
                    goto out_of_range;
 
                tmp = tmp * 10 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore may not be first */
                if (unlikely(ptr == firstdigit))
                    goto invalid_syntax;
                /* and it must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
 
    /* require at least one digit */
    if (unlikely(ptr == firstdigit))
        goto invalid_syntax;
 
    /* allow trailing whitespace, but not other trailing chars */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    if (unlikely(*ptr != '\0'))
        goto invalid_syntax;
 
    if (neg)
    {
        /* check the negative equivalent will fit without overflowing */
        if (tmp > (uint32) (-(PG_INT32_MIN + 1)) + 1)
            goto out_of_range;
        return -((int32) tmp);
    }
 
    if (tmp > PG_INT32_MAX)
        goto out_of_range;
 
    return (int32) tmp;
 
out_of_range:
    ereturn(escontext, 0,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value \"%s\" is out of range for type %s",
                    s, "integer")));
 
invalid_syntax:
    ereturn(escontext, 0,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "integer", s)));
}

References ereturn, errcode(), errmsg(), hexlookup, likely, PG_INT32_MAX, PG_INT32_MIN, and unlikely.

Referenced by int4in(), and pg_strtoint32().

pg_strtoint64()

int64 pg_strtoint64

(

const char *

s

)

Definition at line 469 of file numutils.c.

{
    return pg_strtoint64_safe(s, NULL);
}

References pg_strtoint64_safe().

pg_strtoint64_safe()

int64 pg_strtoint64_safe	(	const char *	s,
		Node *	escontext
	)

Definition at line 475 of file numutils.c.

{
    const char *ptr = s;
    const char *firstdigit;
    uint64      tmp = 0;
    bool        neg = false;
 
    /* skip leading spaces */
    while (*ptr && isspace((unsigned char) *ptr))
        ptr++;
 
    /* handle sign */
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
    else if (*ptr == '+')
        ptr++;
 
    /* process digits */
    if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (isxdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 16)))
                    goto out_of_range;
 
                tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (*ptr >= '0' && *ptr <= '7')
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 8)))
                    goto out_of_range;
 
                tmp = tmp * 8 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
    {
        firstdigit = ptr += 2;
 
        while (*ptr)
        {
            if (*ptr >= '0' && *ptr <= '1')
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 2)))
                    goto out_of_range;
 
                tmp = tmp * 2 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else
    {
        firstdigit = ptr;
 
        while (*ptr)
        {
            if (isdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 10)))
                    goto out_of_range;
 
                tmp = tmp * 10 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore may not be first */
                if (unlikely(ptr == firstdigit))
                    goto invalid_syntax;
                /* and it must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
 
    /* require at least one digit */
    if (unlikely(ptr == firstdigit))
        goto invalid_syntax;
 
    /* allow trailing whitespace, but not other trailing chars */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    if (unlikely(*ptr != '\0'))
        goto invalid_syntax;
 
    if (neg)
    {
        /* check the negative equivalent will fit without overflowing */
        if (tmp > (uint64) (-(PG_INT64_MIN + 1)) + 1)
            goto out_of_range;
        return -((int64) tmp);
    }
 
    if (tmp > PG_INT64_MAX)
        goto out_of_range;
 
    return (int64) tmp;
 
out_of_range:
    ereturn(escontext, 0,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value \"%s\" is out of range for type %s",
                    s, "bigint")));
 
invalid_syntax:
    ereturn(escontext, 0,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "bigint", s)));
}

References ereturn, errcode(), errmsg(), hexlookup, PG_INT64_MAX, PG_INT64_MIN, and unlikely.

Referenced by int8in(), make_const(), and pg_strtoint64().

pg_ulltoa_n()

int pg_ulltoa_n	(	uint64	value,
		char *	a
	)

Definition at line 891 of file numutils.c.

{
    int         olength,
                i = 0;
    uint32      value2;
 
    /* Degenerate case */
    if (value == 0)
    {
        *a = '0';
        return 1;
    }
 
    olength = decimalLength64(value);
 
    /* Compute the result string. */
    while (value >= 100000000)
    {
        const uint64 q = value / 100000000;
        uint32      value3 = (uint32) (value - 100000000 * q);
 
        const uint32 c = value3 % 10000;
        const uint32 d = value3 / 10000;
        const uint32 c0 = (c % 100) << 1;
        const uint32 c1 = (c / 100) << 1;
        const uint32 d0 = (d % 100) << 1;
        const uint32 d1 = (d / 100) << 1;
 
        char       *pos = a + olength - i;
 
        value = q;
 
        memcpy(pos - 2, DIGIT_TABLE + c0, 2);
        memcpy(pos - 4, DIGIT_TABLE + c1, 2);
        memcpy(pos - 6, DIGIT_TABLE + d0, 2);
        memcpy(pos - 8, DIGIT_TABLE + d1, 2);
        i += 8;
    }
 
    /* Switch to 32-bit for speed */
    value2 = (uint32) value;
 
    if (value2 >= 10000)
    {
        const uint32 c = value2 - 10000 * (value2 / 10000);
        const uint32 c0 = (c % 100) << 1;
        const uint32 c1 = (c / 100) << 1;
 
        char       *pos = a + olength - i;
 
        value2 /= 10000;
 
        memcpy(pos - 2, DIGIT_TABLE + c0, 2);
        memcpy(pos - 4, DIGIT_TABLE + c1, 2);
        i += 4;
    }
    if (value2 >= 100)
    {
        const uint32 c = (value2 % 100) << 1;
        char       *pos = a + olength - i;
 
        value2 /= 100;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
        i += 2;
    }
    if (value2 >= 10)
    {
        const uint32 c = value2 << 1;
        char       *pos = a + olength - i;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
    }
    else
        *a = (char) ('0' + value2);
 
    return olength;
}

References a, decimalLength64(), DIGIT_TABLE, i, and value.

Referenced by BuildQueryCompletionString(), and pg_lltoa().

pg_ultoa_n()

int pg_ultoa_n	(	uint32	value,
		char *	a
	)

Definition at line 806 of file numutils.c.

{
    int         olength,
                i = 0;
 
    /* Degenerate case */
    if (value == 0)
    {
        *a = '0';
        return 1;
    }
 
    olength = decimalLength32(value);
 
    /* Compute the result string. */
    while (value >= 10000)
    {
        const uint32 c = value - 10000 * (value / 10000);
        const uint32 c0 = (c % 100) << 1;
        const uint32 c1 = (c / 100) << 1;
 
        char       *pos = a + olength - i;
 
        value /= 10000;
 
        memcpy(pos - 2, DIGIT_TABLE + c0, 2);
        memcpy(pos - 4, DIGIT_TABLE + c1, 2);
        i += 4;
    }
    if (value >= 100)
    {
        const uint32 c = (value % 100) << 1;
 
        char       *pos = a + olength - i;
 
        value /= 100;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
        i += 2;
    }
    if (value >= 10)
    {
        const uint32 c = value << 1;
 
        char       *pos = a + olength - i;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
    }
    else
    {
        *a = (char) ('0' + value);
    }
 
    return olength;
}

References a, decimalLength32(), DIGIT_TABLE, i, and value.

Referenced by pg_ltoa(), pg_ultostr(), pg_ultostr_zeropad(), and printsimple().

pg_ultostr()

char* pg_ultostr	(	char *	str,
		uint32	value
	)

Definition at line 1058 of file numutils.c.

{
    int         len = pg_ultoa_n(value, str);
 
    return str + len;
}

References len, pg_ultoa_n(), generate_unaccent_rules::str, and value.

Referenced by AppendSeconds().

pg_ultostr_zeropad()

char* pg_ultostr_zeropad	(	char *	str,
		uint32	value,
		int32	minwidth
	)

Definition at line 1018 of file numutils.c.

{
    int         len;
 
    Assert(minwidth > 0);
 
    if (value < 100 && minwidth == 2)   /* Short cut for common case */
    {
        memcpy(str, DIGIT_TABLE + value * 2, 2);
        return str + 2;
    }
 
    len = pg_ultoa_n(value, str);
    if (len >= minwidth)
        return str + len;
 
    memmove(str + minwidth - len, str, len);
    memset(str, '0', minwidth - len);
    return str + minwidth;
}

References Assert(), DIGIT_TABLE, len, pg_ultoa_n(), generate_unaccent_rules::str, and value.

Referenced by AppendSeconds(), EncodeDateOnly(), EncodeDateTime(), EncodeTimeOnly(), and EncodeTimezone().

uint32in_subr()

uint32 uint32in_subr	(	const char *	s,
		char **	endloc,
		const char *	typname,
		Node *	escontext
	)

Definition at line 649 of file numutils.c.

{
    uint32      result;
    unsigned long cvt;
    char       *endptr;
 
    errno = 0;
    cvt = strtoul(s, &endptr, 0);
 
    /*
     * strtoul() normally only sets ERANGE.  On some systems it may also set
     * EINVAL, which simply means it couldn't parse the input string.  Be sure
     * to report that the same way as the standard error indication (that
     * endptr == s).
     */
    if ((errno && errno != ERANGE) || endptr == s)
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        typname, s)));
 
    if (errno == ERANGE)
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value \"%s\" is out of range for type %s",
                        s, typname)));
 
    if (endloc)
    {
        /* caller wants to deal with rest of string */
        *endloc = endptr;
    }
    else
    {
        /* allow only whitespace after number */
        while (*endptr && isspace((unsigned char) *endptr))
            endptr++;
        if (*endptr)
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            typname, s)));
    }
 
    result = (uint32) cvt;
 
    /*
     * Cope with possibility that unsigned long is wider than uint32, in which
     * case strtoul will not raise an error for some values that are out of
     * the range of uint32.
     *
     * For backwards compatibility, we want to accept inputs that are given
     * with a minus sign, so allow the input value if it matches after either
     * signed or unsigned extension to long.
     *
     * To ensure consistent results on 32-bit and 64-bit platforms, make sure
     * the error message is the same as if strtoul() had returned ERANGE.
     */
#if PG_UINT32_MAX != ULONG_MAX
    if (cvt != (unsigned long) result &&
        cvt != (unsigned long) ((int) result))
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value \"%s\" is out of range for type %s",
                        s, typname)));
#endif
 
    return result;
}

References ereturn, errcode(), errmsg(), and typname.

Referenced by cidin(), oidin(), oidparse(), oidvectorin(), and xidin().

uint64in_subr()

uint64 uint64in_subr	(	const char *	s,
		char **	endloc,
		const char *	typname,
		Node *	escontext
	)

Definition at line 736 of file numutils.c.

{
    uint64      result;
    char       *endptr;
 
    errno = 0;
    result = strtou64(s, &endptr, 0);
 
    /*
     * strtoul[l] normally only sets ERANGE.  On some systems it may also set
     * EINVAL, which simply means it couldn't parse the input string.  Be sure
     * to report that the same way as the standard error indication (that
     * endptr == s).
     */
    if ((errno && errno != ERANGE) || endptr == s)
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        typname, s)));
 
    if (errno == ERANGE)
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value \"%s\" is out of range for type %s",
                        s, typname)));
 
    if (endloc)
    {
        /* caller wants to deal with rest of string */
        *endloc = endptr;
    }
    else
    {
        /* allow only whitespace after number */
        while (*endptr && isspace((unsigned char) *endptr))
            endptr++;
        if (*endptr)
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            typname, s)));
    }
 
    return result;
}

References ereturn, errcode(), errmsg(), strtou64, and typname.

Referenced by xid8in().

Variable Documentation

DIGIT_TABLE

const char DIGIT_TABLE[200]

static

Initial value:

=
"00" "01" "02" "03" "04" "05" "06" "07" "08" "09"
"10" "11" "12" "13" "14" "15" "16" "17" "18" "19"
"20" "21" "22" "23" "24" "25" "26" "27" "28" "29"
"30" "31" "32" "33" "34" "35" "36" "37" "38" "39"
"40" "41" "42" "43" "44" "45" "46" "47" "48" "49"
"50" "51" "52" "53" "54" "55" "56" "57" "58" "59"
"60" "61" "62" "63" "64" "65" "66" "67" "68" "69"
"70" "71" "72" "73" "74" "75" "76" "77" "78" "79"
"80" "81" "82" "83" "84" "85" "86" "87" "88" "89"
"90" "91" "92" "93" "94" "95" "96" "97" "98" "99"

Definition at line 29 of file numutils.c.

Referenced by pg_ulltoa_n(), pg_ultoa_n(), pg_ultostr_zeropad(), to_chars(), to_chars_df(), and to_chars_f().

hexlookup

const int8 hexlookup[128]

static

Initial value:

= {
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
}

Definition at line 88 of file numutils.c.

Referenced by pg_strtoint16_safe(), pg_strtoint32_safe(), and pg_strtoint64_safe().