unicode_case.c File Reference

#include "postgres.h"
#include "common/unicode_case.h"
#include "common/unicode_case_table.h"
#include "common/unicode_category.h"
#include "mb/pg_wchar.h"

Include dependency graph for unicode_case.c:

Go to the source code of this file.

Enumerations
enum	CaseMapResult { CASEMAP_SELF , CASEMAP_SIMPLE , CASEMAP_SPECIAL }

Functions
static char32_t	find_case_map (char32_t ucs, const char32_t *map)
static size_t	convert_case (char *dst, size_t dstsize, const char *src, ssize_t srclen, CaseKind str_casekind, bool full, WordBoundaryNext wbnext, void *wbstate)
static enum CaseMapResult	casemap (char32_t u1, CaseKind casekind, bool full, const char *src, size_t srclen, size_t srcoff, char32_t *simple, const char32_t **special)
char32_t	unicode_lowercase_simple (char32_t code)
char32_t	unicode_titlecase_simple (char32_t code)
char32_t	unicode_uppercase_simple (char32_t code)
char32_t	unicode_casefold_simple (char32_t code)
size_t	unicode_strlower (char *dst, size_t dstsize, const char *src, ssize_t srclen, bool full)
size_t	unicode_strtitle (char *dst, size_t dstsize, const char *src, ssize_t srclen, bool full, WordBoundaryNext wbnext, void *wbstate)
size_t	unicode_strupper (char *dst, size_t dstsize, const char *src, ssize_t srclen, bool full)
size_t	unicode_strfold (char *dst, size_t dstsize, const char *src, ssize_t srclen, bool full)
static bool	check_final_sigma (const unsigned char *str, size_t len, size_t offset)
static bool	check_special_conditions (int conditions, const char *str, size_t len, size_t offset)

Variables
static const char32_t *const	casekind_map [NCaseKind]

Enumeration Type Documentation

CaseMapResult

enum CaseMapResult

Enumerator
CASEMAP_SELF
CASEMAP_SIMPLE
CASEMAP_SPECIAL

Definition at line 23 of file unicode_case.c.

{
    CASEMAP_SELF,
    CASEMAP_SIMPLE,
    CASEMAP_SPECIAL,
};

Function Documentation

casemap()

static enum CaseMapResult casemap ( char32_t  u1, CaseKind  casekind, bool  full, const char *  src, size_t  srclen, size_t  srcoff, char32_t *  simple, const char32_t **  special  )

static

Definition at line 397 of file unicode_case.c.

{
    uint16      idx;
 
    /* Fast path for codepoints < 0x80 */
    if (u1 < 0x80)
    {
        /*
         * The first elements in all tables are reserved as 0 (as NULL). The
         * data starts at index 1, not 0.
         */
        *simple = casekind_map[casekind][u1 + 1];
 
        return CASEMAP_SIMPLE;
    }
 
    idx = case_index(u1);
 
    if (idx == 0)
        return CASEMAP_SELF;
 
    if (full && case_map_special[idx] &&
        check_special_conditions(special_case[case_map_special[idx]].conditions,
                                 src, srclen, srcoff))
    {
        *special = special_case[case_map_special[idx]].map[casekind];
        return CASEMAP_SPECIAL;
    }
 
    *simple = casekind_map[casekind][idx];
 
    return CASEMAP_SIMPLE;
}

References case_index(), case_map_special, casekind_map, CASEMAP_SELF, CASEMAP_SIMPLE, CASEMAP_SPECIAL, check_special_conditions(), idx(), pg_special_case::map, and special_case.

Referenced by convert_case(), and main().

check_final_sigma()

static bool check_final_sigma ( const unsigned char *  str, size_t  len, size_t  offset  )

static

Definition at line 312 of file unicode_case.c.

{
    /* the start of the string is not preceded by a Cased character */
    if (offset == 0)
        return false;
 
    /* iterate backwards, looking for Cased character */
    for (int i = offset - 1; i >= 0; i--)
    {
        if ((str[i] & 0x80) == 0 || (str[i] & 0xC0) == 0xC0)
        {
            char32_t    curr = utf8_to_unicode(str + i);
 
            if (pg_u_prop_case_ignorable(curr))
                continue;
            else if (pg_u_prop_cased(curr))
                break;
            else
                return false;
        }
        else if ((str[i] & 0xC0) == 0x80)
            continue;
 
        Assert(false);          /* invalid UTF-8 */
    }
 
    /* end of string is not followed by a Cased character */
    if (offset == len)
        return true;
 
    /* iterate forwards, looking for Cased character */
    for (int i = offset + 1; i < len && str[i] != '\0'; i++)
    {
        if ((str[i] & 0x80) == 0 || (str[i] & 0xC0) == 0xC0)
        {
            char32_t    curr = utf8_to_unicode(str + i);
 
            if (pg_u_prop_case_ignorable(curr))
                continue;
            else if (pg_u_prop_cased(curr))
                return false;
            else
                break;
        }
        else if ((str[i] & 0xC0) == 0x80)
            continue;
 
        Assert(false);          /* invalid UTF-8 */
    }
 
    return true;
}

References Assert(), i, len, pg_u_prop_case_ignorable(), pg_u_prop_cased(), str, and utf8_to_unicode().

Referenced by check_special_conditions().

check_special_conditions()

static bool check_special_conditions ( int  conditions, const char *  str, size_t  len, size_t  offset  )

static

Definition at line 370 of file unicode_case.c.

{
    if (conditions == 0)
        return true;
    else if (conditions == PG_U_FINAL_SIGMA)
        return check_final_sigma((unsigned char *) str, len, offset);
 
    /* no other conditions supported */
    Assert(false);
    return false;
}

References Assert(), check_final_sigma(), len, PG_U_FINAL_SIGMA, and str.

Referenced by casemap().

convert_case()

static size_t convert_case ( char *  dst, size_t  dstsize, const char *  src, ssize_t  srclen, CaseKind  str_casekind, bool  full, WordBoundaryNext  wbnext, void *  wbstate  )

static

Definition at line 213 of file unicode_case.c.

{
    /* character CaseKind varies while titlecasing */
    CaseKind    chr_casekind = str_casekind;
    size_t      srcoff = 0;
    size_t      result_len = 0;
    size_t      boundary = 0;
 
    Assert((str_casekind == CaseTitle && wbnext && wbstate) ||
           (str_casekind != CaseTitle && !wbnext && !wbstate));
 
    if (str_casekind == CaseTitle)
    {
        boundary = wbnext(wbstate);
        Assert(boundary == 0);  /* start of text is always a boundary */
    }
 
    while ((srclen < 0 || srcoff < srclen) && src[srcoff] != '\0')
    {
        char32_t    u1 = utf8_to_unicode((unsigned char *) src + srcoff);
        int         u1len = unicode_utf8len(u1);
        char32_t    simple = 0;
        const char32_t *special = NULL;
        enum CaseMapResult casemap_result;
 
        if (str_casekind == CaseTitle)
        {
            if (srcoff == boundary)
            {
                chr_casekind = full ? CaseTitle : CaseUpper;
                boundary = wbnext(wbstate);
            }
            else
                chr_casekind = CaseLower;
        }
 
        casemap_result = casemap(u1, chr_casekind, full, src, srclen, srcoff,
                                 &simple, &special);
 
        switch (casemap_result)
        {
            case CASEMAP_SELF:
                /* no mapping; copy bytes from src */
                Assert(simple == 0);
                Assert(special == NULL);
                if (result_len + u1len <= dstsize)
                    memcpy(dst + result_len, src + srcoff, u1len);
 
                result_len += u1len;
                break;
            case CASEMAP_SIMPLE:
                {
                    /* replace with single character */
                    char32_t    u2 = simple;
                    char32_t    u2len = unicode_utf8len(u2);
 
                    Assert(special == NULL);
                    if (result_len + u2len <= dstsize)
                        unicode_to_utf8(u2, (unsigned char *) dst + result_len);
 
                    result_len += u2len;
                }
                break;
            case CASEMAP_SPECIAL:
                /* replace with up to MAX_CASE_EXPANSION characters */
                Assert(simple == 0);
                for (int i = 0; i < MAX_CASE_EXPANSION && special[i]; i++)
                {
                    char32_t    u2 = special[i];
                    size_t      u2len = unicode_utf8len(u2);
 
                    if (result_len + u2len <= dstsize)
                        unicode_to_utf8(u2, (unsigned char *) dst + result_len);
 
                    result_len += u2len;
                }
                break;
        }
 
        srcoff += u1len;
    }
 
    if (result_len < dstsize)
        dst[result_len] = '\0';
 
    return result_len;
}

References Assert(), CaseLower, casemap(), CASEMAP_SELF, CASEMAP_SIMPLE, CASEMAP_SPECIAL, CaseTitle, CaseUpper, i, MAX_CASE_EXPANSION, unicode_to_utf8(), unicode_utf8len(), and utf8_to_unicode().

Referenced by unicode_strfold(), unicode_strlower(), unicode_strtitle(), and unicode_strupper().

find_case_map()

static char32_t find_case_map ( char32_t  ucs, const char32_t *  map  )

static

Definition at line 438 of file unicode_case.c.

{
    /* Fast path for codepoints < 0x80 */
    if (ucs < 0x80)
        /* The first elements in all tables are reserved as 0 (as NULL). */
        return map[ucs + 1];
    return map[case_index(ucs)];
}

References case_index().

Referenced by unicode_casefold_simple(), unicode_lowercase_simple(), unicode_titlecase_simple(), and unicode_uppercase_simple().

unicode_casefold_simple()

char32_t unicode_casefold_simple

(

char32_t

code

)

Definition at line 74 of file unicode_case.c.

{
    char32_t    cp = find_case_map(code, case_map_fold);
 
    return cp != 0 ? cp : code;
}

References case_map_fold, and find_case_map().

unicode_lowercase_simple()

char32_t unicode_lowercase_simple

(

char32_t

code

)

Definition at line 50 of file unicode_case.c.

{
    char32_t    cp = find_case_map(code, case_map_lower);
 
    return cp != 0 ? cp : code;
}

References case_map_lower, and find_case_map().

Referenced by wc_tolower_builtin().

unicode_strfold()

size_t unicode_strfold	(	char *	dst,
		size_t	dstsize,
		const char *	src,
		ssize_t	srclen,
		bool	full
	)

Definition at line 189 of file unicode_case.c.

{
    return convert_case(dst, dstsize, src, srclen, CaseFold, full, NULL,
                        NULL);
}

References CaseFold, and convert_case().

Referenced by strfold_builtin(), and tfunc_fold().

unicode_strlower()

size_t unicode_strlower	(	char *	dst,
		size_t	dstsize,
		const char *	src,
		ssize_t	srclen,
		bool	full
	)

Definition at line 101 of file unicode_case.c.

{
    return convert_case(dst, dstsize, src, srclen, CaseLower, full, NULL,
                        NULL);
}

References CaseLower, and convert_case().

Referenced by strlower_builtin(), and tfunc_lower().

unicode_strtitle()

size_t unicode_strtitle	(	char *	dst,
		size_t	dstsize,
		const char *	src,
		ssize_t	srclen,
		bool	full,
		WordBoundaryNext	wbnext,
		void *	wbstate
	)

Definition at line 138 of file unicode_case.c.

{
    return convert_case(dst, dstsize, src, srclen, CaseTitle, full, wbnext,
                        wbstate);
}

References CaseTitle, and convert_case().

Referenced by strtitle_builtin(), and tfunc_title().

unicode_strupper()

size_t unicode_strupper	(	char *	dst,
		size_t	dstsize,
		const char *	src,
		ssize_t	srclen,
		bool	full
	)

Definition at line 165 of file unicode_case.c.

{
    return convert_case(dst, dstsize, src, srclen, CaseUpper, full, NULL,
                        NULL);
}

References CaseUpper, and convert_case().

Referenced by strupper_builtin(), and tfunc_upper().

unicode_titlecase_simple()

char32_t unicode_titlecase_simple

(

char32_t

code

)

Definition at line 58 of file unicode_case.c.

{
    char32_t    cp = find_case_map(code, case_map_title);
 
    return cp != 0 ? cp : code;
}

References case_map_title, and find_case_map().

unicode_uppercase_simple()

char32_t unicode_uppercase_simple

(

char32_t

code

)

Definition at line 66 of file unicode_case.c.

{
    char32_t    cp = find_case_map(code, case_map_upper);
 
    return cp != 0 ? cp : code;
}

References case_map_upper, and find_case_map().

Referenced by wc_toupper_builtin().

Variable Documentation

casekind_map

const char32_t* const casekind_map[NCaseKind]

static

Initial value:

=
{
    [CaseLower] = case_map_lower,
    [CaseTitle] = case_map_title,
    [CaseUpper] = case_map_upper,
    [CaseFold] = case_map_fold,
}

Definition at line 33 of file unicode_case.c.

Referenced by casemap().