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.

Functions
static const pg_case_map *	find_case_map (pg_wchar ucs)
static size_t	convert_case (char *dst, size_t dstsize, const char *src, ssize_t srclen, CaseKind str_casekind, WordBoundaryNext wbnext, void *wbstate)
pg_wchar	unicode_lowercase_simple (pg_wchar code)
pg_wchar	unicode_titlecase_simple (pg_wchar code)
pg_wchar	unicode_uppercase_simple (pg_wchar code)
size_t	unicode_strlower (char *dst, size_t dstsize, const char *src, ssize_t srclen)
size_t	unicode_strtitle (char *dst, size_t dstsize, const char *src, ssize_t srclen, WordBoundaryNext wbnext, void *wbstate)
size_t	unicode_strupper (char *dst, size_t dstsize, const char *src, ssize_t srclen)

Function Documentation

convert_case()

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

static

Definition at line 137 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')
    {
        pg_wchar    u1 = utf8_to_unicode((unsigned char *) src + srcoff);
        int         u1len = unicode_utf8len(u1);
        const       pg_case_map *casemap = find_case_map(u1);
 
        if (str_casekind == CaseTitle)
        {
            if (srcoff == boundary)
            {
                chr_casekind = CaseUpper;
                boundary = wbnext(wbstate);
            }
            else
                chr_casekind = CaseLower;
        }
 
        /* perform mapping, update result_len, and write to dst */
        if (casemap)
        {
            pg_wchar    u2 = casemap->simplemap[chr_casekind];
            pg_wchar    u2len = unicode_utf8len(u2);
 
            if (result_len + u2len <= dstsize)
                unicode_to_utf8(u2, (unsigned char *) dst + result_len);
 
            result_len += u2len;
        }
        else
        {
            /* no mapping; copy bytes from src */
            if (result_len + u1len <= dstsize)
                memcpy(dst + result_len, src + srcoff, u1len);
 
            result_len += u1len;
        }
 
        srcoff += u1len;
    }
 
    if (result_len < dstsize)
        dst[result_len] = '\0';
 
    return result_len;
}

References Assert, CaseLower, CaseTitle, CaseUpper, find_case_map(), pg_case_map::simplemap, unicode_to_utf8(), unicode_utf8len(), and utf8_to_unicode().

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

find_case_map()

static const pg_case_map * find_case_map ( pg_wchar  ucs )

static

Definition at line 203 of file unicode_case.c.

{
    int         min;
    int         mid;
    int         max;
 
    /* all chars <= 0x80 are stored in array for fast lookup */
    Assert(lengthof(case_map) >= 0x80);
    if (ucs < 0x80)
    {
        const       pg_case_map *map = &case_map[ucs];
 
        Assert(map->codepoint == ucs);
        return map;
    }
 
    /* otherwise, binary search */
    min = 0x80;
    max = lengthof(case_map) - 1;
    while (max >= min)
    {
        mid = (min + max) / 2;
        if (ucs > case_map[mid].codepoint)
            min = mid + 1;
        else if (ucs < case_map[mid].codepoint)
            max = mid - 1;
        else
            return &case_map[mid];
    }
 
    return NULL;
}

References Assert, case_map, pg_case_map::codepoint, and lengthof.

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

unicode_lowercase_simple()

pg_wchar unicode_lowercase_simple

(

pg_wchar

code

)

Definition at line 29 of file unicode_case.c.

{
    const       pg_case_map *map = find_case_map(code);
 
    return map ? map->simplemap[CaseLower] : code;
}

References CaseLower, find_case_map(), and pg_case_map::simplemap.

Referenced by pg_wc_tolower().

unicode_strlower()

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

Definition at line 69 of file unicode_case.c.

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

References CaseLower, and convert_case().

Referenced by str_tolower(), and test_strlower().

unicode_strtitle()

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

Definition at line 100 of file unicode_case.c.

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

References CaseTitle, and convert_case().

Referenced by str_initcap().

unicode_strupper()

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

Definition at line 124 of file unicode_case.c.

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

References CaseUpper, and convert_case().

Referenced by str_toupper().

unicode_titlecase_simple()

pg_wchar unicode_titlecase_simple

(

pg_wchar

code

)

Definition at line 37 of file unicode_case.c.

{
    const       pg_case_map *map = find_case_map(code);
 
    return map ? map->simplemap[CaseTitle] : code;
}

References CaseTitle, find_case_map(), and pg_case_map::simplemap.

unicode_uppercase_simple()

pg_wchar unicode_uppercase_simple

(

pg_wchar

code

)

Definition at line 45 of file unicode_case.c.

{
    const       pg_case_map *map = find_case_map(code);
 
    return map ? map->simplemap[CaseUpper] : code;
}

References CaseUpper, find_case_map(), and pg_case_map::simplemap.

Referenced by pg_wc_toupper().