formatting.h File Reference

#include "fmgr.h"

Include dependency graph for formatting.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
char *	str_tolower (const char *buff, size_t nbytes, Oid collid)
char *	str_toupper (const char *buff, size_t nbytes, Oid collid)
char *	str_initcap (const char *buff, size_t nbytes, Oid collid)
char *	asc_tolower (const char *buff, size_t nbytes)
char *	asc_toupper (const char *buff, size_t nbytes)
char *	asc_initcap (const char *buff, size_t nbytes)

Function Documentation

char* asc_initcap	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 1962 of file formatting.c.

References NULL, pg_ascii_tolower(), pg_ascii_toupper(), pnstrdup(), and result.

Referenced by str_initcap().

{
    char       *result;
    char       *p;
    int         wasalnum = false;

    if (!buff)
        return NULL;

    result = pnstrdup(buff, nbytes);

    for (p = result; *p; p++)
    {
        char        c;

        if (wasalnum)
            *p = c = pg_ascii_tolower((unsigned char) *p);
        else
            *p = c = pg_ascii_toupper((unsigned char) *p);
        /* we don't trust isalnum() here */
        wasalnum = ((c >= 'A' && c <= 'Z') ||
                    (c >= 'a' && c <= 'z') ||
                    (c >= '0' && c <= '9'));
    }

    return result;
}

char* asc_tolower	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 1916 of file formatting.c.

References NULL, pg_ascii_tolower(), pnstrdup(), and result.

Referenced by asc_tolower_z(), and str_tolower().

{
    char       *result;
    char       *p;

    if (!buff)
        return NULL;

    result = pnstrdup(buff, nbytes);

    for (p = result; *p; p++)
        *p = pg_ascii_tolower((unsigned char) *p);

    return result;
}

char* asc_toupper	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 1939 of file formatting.c.

References NULL, pg_ascii_toupper(), pnstrdup(), and result.

Referenced by asc_toupper_z(), and str_toupper().

{
    char       *result;
    char       *p;

    if (!buff)
        return NULL;

    result = pnstrdup(buff, nbytes);

    for (p = result; *p; p++)
        *p = pg_ascii_toupper((unsigned char) *p);

    return result;
}

char* str_initcap	(	const char *	buff,
		size_t	nbytes,
		Oid	collid
	)

Definition at line 1767 of file formatting.c.

References asc_initcap(), COLLPROVIDER_ICU, DEFAULT_COLLATION_OID, ereport, errcode(), errhint(), errmsg(), ERROR, pg_locale_struct::info, isalnum_l, iswalnum_l, lc_ctype_is_c(), NULL, OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_tolower(), pg_toupper(), pnstrdup(), pg_locale_struct::provider, result, tolower_l, toupper_l, towlower_l, and towupper_l.

Referenced by initcap(), and str_initcap_z().

{
    char       *result;
    int         wasalnum = false;

    if (!buff)
        return NULL;

    /* C/POSIX collations use this path regardless of database encoding */
    if (lc_ctype_is_c(collid))
    {
        result = asc_initcap(buff, nbytes);
    }
#ifdef USE_WIDE_UPPER_LOWER
    else
    {
        pg_locale_t mylocale = 0;

        if (collid != DEFAULT_COLLATION_OID)
        {
            if (!OidIsValid(collid))
            {
                /*
                 * This typically means that the parser could not resolve a
                 * conflict of implicit collations, so report it that way.
                 */
                ereport(ERROR,
                        (errcode(ERRCODE_INDETERMINATE_COLLATION),
                         errmsg("could not determine which collation to use for initcap() function"),
                         errhint("Use the COLLATE clause to set the collation explicitly.")));
            }
            mylocale = pg_newlocale_from_collation(collid);
        }

#ifdef USE_ICU
        if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
        {
            int32_t     len_uchar,
                        len_conv;
            UChar      *buff_uchar;
            UChar      *buff_conv;

            len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
            len_conv = icu_convert_case(u_strToTitle_default_BI, mylocale,
                                        &buff_conv, buff_uchar, len_uchar);
            icu_from_uchar(&result, buff_conv, len_conv);
            pfree(buff_uchar);
        }
        else
#endif
        {
            if (pg_database_encoding_max_length() > 1)
            {
                wchar_t    *workspace;
                size_t      curr_char;
                size_t      result_size;

                /* Overflow paranoia */
                if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of memory")));

                /* Output workspace cannot have more codes than input bytes */
                workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));

                char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);

                for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                    {
                        if (wasalnum)
                            workspace[curr_char] = towlower_l(workspace[curr_char], mylocale->info.lt);
                        else
                            workspace[curr_char] = towupper_l(workspace[curr_char], mylocale->info.lt);
                        wasalnum = iswalnum_l(workspace[curr_char], mylocale->info.lt);
                    }
                    else
#endif
                    {
                        if (wasalnum)
                            workspace[curr_char] = towlower(workspace[curr_char]);
                        else
                            workspace[curr_char] = towupper(workspace[curr_char]);
                        wasalnum = iswalnum(workspace[curr_char]);
                    }
                }

                /*
                 * Make result large enough; case change might change number
                 * of bytes
                 */
                result_size = curr_char * pg_database_encoding_max_length() + 1;
                result = palloc(result_size);

                wchar2char(result, workspace, result_size, mylocale);
                pfree(workspace);
            }
#endif                          /* USE_WIDE_UPPER_LOWER */
            else
            {
                char       *p;

                result = pnstrdup(buff, nbytes);

                /*
                 * Note: we assume that toupper_l()/tolower_l() will not be so
                 * broken as to need guard tests.  When using the default
                 * collation, we apply the traditional Postgres behavior that
                 * forces ASCII-style treatment of I/i, but in non-default
                 * collations you get exactly what the collation says.
                 */
                for (p = result; *p; p++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                    {
                        if (wasalnum)
                            *p = tolower_l((unsigned char) *p, mylocale->info.lt);
                        else
                            *p = toupper_l((unsigned char) *p, mylocale->info.lt);
                        wasalnum = isalnum_l((unsigned char) *p, mylocale->info.lt);
                    }
                    else
#endif
                    {
                        if (wasalnum)
                            *p = pg_tolower((unsigned char) *p);
                        else
                            *p = pg_toupper((unsigned char) *p);
                        wasalnum = isalnum((unsigned char) *p);
                    }
                }
            }
        }

char* str_tolower	(	const char *	buff,
		size_t	nbytes,
		Oid	collid
	)

Definition at line 1519 of file formatting.c.

References asc_tolower(), COLLPROVIDER_ICU, DEFAULT_COLLATION_OID, ereport, errcode(), errhint(), errmsg(), ERROR, pg_locale_struct::info, lc_ctype_is_c(), NULL, OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_tolower(), pnstrdup(), pg_locale_struct::provider, result, tolower_l, and towlower_l.

Referenced by citext_eq(), citext_hash(), citext_ne(), citextcmp(), lower(), ltree_strncasecmp(), and str_tolower_z().

{
    char       *result;

    if (!buff)
        return NULL;

    /* C/POSIX collations use this path regardless of database encoding */
    if (lc_ctype_is_c(collid))
    {
        result = asc_tolower(buff, nbytes);
    }
#ifdef USE_WIDE_UPPER_LOWER
    else
    {
        pg_locale_t mylocale = 0;

        if (collid != DEFAULT_COLLATION_OID)
        {
            if (!OidIsValid(collid))
            {
                /*
                 * This typically means that the parser could not resolve a
                 * conflict of implicit collations, so report it that way.
                 */
                ereport(ERROR,
                        (errcode(ERRCODE_INDETERMINATE_COLLATION),
                         errmsg("could not determine which collation to use for lower() function"),
                         errhint("Use the COLLATE clause to set the collation explicitly.")));
            }
            mylocale = pg_newlocale_from_collation(collid);
        }

#ifdef USE_ICU
        if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
        {
            int32_t     len_uchar;
            int32_t     len_conv;
            UChar      *buff_uchar;
            UChar      *buff_conv;

            len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
            len_conv = icu_convert_case(u_strToLower, mylocale,
                                        &buff_conv, buff_uchar, len_uchar);
            icu_from_uchar(&result, buff_conv, len_conv);
            pfree(buff_uchar);
        }
        else
#endif
        {
            if (pg_database_encoding_max_length() > 1)
            {
                wchar_t    *workspace;
                size_t      curr_char;
                size_t      result_size;

                /* Overflow paranoia */
                if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of memory")));

                /* Output workspace cannot have more codes than input bytes */
                workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));

                char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);

                for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        workspace[curr_char] = towlower_l(workspace[curr_char], mylocale->info.lt);
                    else
#endif
                        workspace[curr_char] = towlower(workspace[curr_char]);
                }

                /*
                 * Make result large enough; case change might change number
                 * of bytes
                 */
                result_size = curr_char * pg_database_encoding_max_length() + 1;
                result = palloc(result_size);

                wchar2char(result, workspace, result_size, mylocale);
                pfree(workspace);
            }
#endif                          /* USE_WIDE_UPPER_LOWER */
            else
            {
                char       *p;

                result = pnstrdup(buff, nbytes);

                /*
                 * Note: we assume that tolower_l() will not be so broken as
                 * to need an isupper_l() guard test.  When using the default
                 * collation, we apply the traditional Postgres behavior that
                 * forces ASCII-style treatment of I/i, but in non-default
                 * collations you get exactly what the collation says.
                 */
                for (p = result; *p; p++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        *p = tolower_l((unsigned char) *p, mylocale->info.lt);
                    else
#endif
                        *p = pg_tolower((unsigned char) *p);
                }
            }
        }

char* str_toupper	(	const char *	buff,
		size_t	nbytes,
		Oid	collid
	)

Definition at line 1643 of file formatting.c.

References asc_toupper(), COLLPROVIDER_ICU, DEFAULT_COLLATION_OID, ereport, errcode(), errhint(), errmsg(), ERROR, pg_locale_struct::info, lc_ctype_is_c(), NULL, OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_toupper(), pnstrdup(), pg_locale_struct::provider, result, toupper_l, and towupper_l.

Referenced by str_toupper_z(), and upper().

{
    char       *result;

    if (!buff)
        return NULL;

    /* C/POSIX collations use this path regardless of database encoding */
    if (lc_ctype_is_c(collid))
    {
        result = asc_toupper(buff, nbytes);
    }
#ifdef USE_WIDE_UPPER_LOWER
    else
    {
        pg_locale_t mylocale = 0;

        if (collid != DEFAULT_COLLATION_OID)
        {
            if (!OidIsValid(collid))
            {
                /*
                 * This typically means that the parser could not resolve a
                 * conflict of implicit collations, so report it that way.
                 */
                ereport(ERROR,
                        (errcode(ERRCODE_INDETERMINATE_COLLATION),
                         errmsg("could not determine which collation to use for upper() function"),
                         errhint("Use the COLLATE clause to set the collation explicitly.")));
            }
            mylocale = pg_newlocale_from_collation(collid);
        }

#ifdef USE_ICU
        if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
        {
            int32_t     len_uchar,
                        len_conv;
            UChar      *buff_uchar;
            UChar      *buff_conv;

            len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
            len_conv = icu_convert_case(u_strToUpper, mylocale,
                                        &buff_conv, buff_uchar, len_uchar);
            icu_from_uchar(&result, buff_conv, len_conv);
            pfree(buff_uchar);
        }
        else
#endif
        {
            if (pg_database_encoding_max_length() > 1)
            {
                wchar_t    *workspace;
                size_t      curr_char;
                size_t      result_size;

                /* Overflow paranoia */
                if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of memory")));

                /* Output workspace cannot have more codes than input bytes */
                workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));

                char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);

                for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        workspace[curr_char] = towupper_l(workspace[curr_char], mylocale->info.lt);
                    else
#endif
                        workspace[curr_char] = towupper(workspace[curr_char]);
                }

                /*
                 * Make result large enough; case change might change number
                 * of bytes
                 */
                result_size = curr_char * pg_database_encoding_max_length() + 1;
                result = palloc(result_size);

                wchar2char(result, workspace, result_size, mylocale);
                pfree(workspace);
            }
#endif                          /* USE_WIDE_UPPER_LOWER */
            else
            {
                char       *p;

                result = pnstrdup(buff, nbytes);

                /*
                 * Note: we assume that toupper_l() will not be so broken as
                 * to need an islower_l() guard test.  When using the default
                 * collation, we apply the traditional Postgres behavior that
                 * forces ASCII-style treatment of I/i, but in non-default
                 * collations you get exactly what the collation says.
                 */
                for (p = result; *p; p++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        *p = toupper_l((unsigned char) *p, mylocale->info.lt);
                    else
#endif
                        *p = pg_toupper((unsigned char) *p);
                }
            }
        }