regc_locale.c File Reference

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

Go to the source code of this file.

Data Structures
struct	cname

Functions
static chr	element (struct vars *v, const chr *startp, const chr *endp)
static struct cvec *	range (struct vars *v, chr a, chr b, int cases)
static int	before (chr x, chr y)
static struct cvec *	eclass (struct vars *v, chr c, int cases)
static enum char_classes	lookupcclass (struct vars *v, const chr *startp, const chr *endp)
static struct cvec *	cclasscvec (struct vars *v, enum char_classes cclasscode, int cases)
static int	cclass_column_index (struct colormap *cm, chr c)
static struct cvec *	allcases (struct vars *v, chr c)
static int	cmp (const chr *x, const chr *y, size_t len)
static int	casecmp (const chr *x, const chr *y, size_t len)

Variables
static const struct cname	cnames []
static const char *const	classNames [NUM_CCLASSES+1]

Function Documentation

allcases()

static struct cvec* allcases ( struct vars *  v, chr  c  )

static

Definition at line 717 of file regc_locale.c.

{
    struct cvec *cv;
    chr         lc,
                uc;
 
    lc = pg_wc_tolower(c);
    uc = pg_wc_toupper(c);
 
    cv = getcvec(v, 2, 0);
    addchr(cv, lc);
    if (lc != uc)
        addchr(cv, uc);
    return cv;
}

References addchr(), getcvec(), pg_wc_tolower(), and pg_wc_toupper().

Referenced by eclass().

before()

static int before ( chr  x, chr  y  )

static

Definition at line 488 of file regc_locale.c.

{
    if (x < y)
        return 1;
    return 0;
}

References x, and y.

Referenced by avlRotate(), dclist_insert_before(), DescribeQuery(), dlist_insert_before(), do_edit(), ExecQueryAndProcessResults(), ExecQueryUsingCursor(), and range().

casecmp()

static int casecmp ( const chr *  x, const chr *  y, size_t  len  )

static

Definition at line 758 of file regc_locale.c.

{
    for (; len > 0; len--, x++, y++)
    {
        if ((*x != *y) && (pg_wc_tolower(*x) != pg_wc_tolower(*y)))
            return 1;
    }
    return 0;
}

References len, pg_wc_tolower(), x, and y.

cclass_column_index()

static int cclass_column_index ( struct colormap *  cm, chr  c  )

static

Definition at line 671 of file regc_locale.c.

{
    int         colnum = 0;
 
    /* Shouldn't go through all these pushups for simple chrs */
    assert(c > MAX_SIMPLE_CHR);
 
    /*
     * Note: we should not see requests to consider cclasses that are not
     * treated as locale-specific by cclasscvec(), above.
     */
    if (cm->classbits[CC_PRINT] && pg_wc_isprint(c))
        colnum |= cm->classbits[CC_PRINT];
    if (cm->classbits[CC_ALNUM] && pg_wc_isalnum(c))
        colnum |= cm->classbits[CC_ALNUM];
    if (cm->classbits[CC_ALPHA] && pg_wc_isalpha(c))
        colnum |= cm->classbits[CC_ALPHA];
    if (cm->classbits[CC_WORD] && pg_wc_isword(c))
        colnum |= cm->classbits[CC_WORD];
    assert(cm->classbits[CC_ASCII] == 0);
    assert(cm->classbits[CC_BLANK] == 0);
    assert(cm->classbits[CC_CNTRL] == 0);
    if (cm->classbits[CC_DIGIT] && pg_wc_isdigit(c))
        colnum |= cm->classbits[CC_DIGIT];
    if (cm->classbits[CC_PUNCT] && pg_wc_ispunct(c))
        colnum |= cm->classbits[CC_PUNCT];
    assert(cm->classbits[CC_XDIGIT] == 0);
    if (cm->classbits[CC_SPACE] && pg_wc_isspace(c))
        colnum |= cm->classbits[CC_SPACE];
    if (cm->classbits[CC_LOWER] && pg_wc_islower(c))
        colnum |= cm->classbits[CC_LOWER];
    if (cm->classbits[CC_UPPER] && pg_wc_isupper(c))
        colnum |= cm->classbits[CC_UPPER];
    if (cm->classbits[CC_GRAPH] && pg_wc_isgraph(c))
        colnum |= cm->classbits[CC_GRAPH];
 
    return colnum;
}

References assert, CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH, CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_WORD, CC_XDIGIT, colormap::classbits, MAX_SIMPLE_CHR, pg_wc_isalnum(), pg_wc_isalpha(), pg_wc_isdigit(), pg_wc_isgraph(), pg_wc_islower(), pg_wc_isprint(), pg_wc_ispunct(), pg_wc_isspace(), pg_wc_isupper(), and pg_wc_isword().

Referenced by pg_reg_getcolor().

cclasscvec()

static struct cvec* cclasscvec ( struct vars *  v, enum char_classes  cclasscode, int  cases  )

static

Definition at line 569 of file regc_locale.c.

{
    struct cvec *cv = NULL;
 
    /*
     * Remap lower and upper to alpha if the match is case insensitive.
     */
 
    if (cases &&
        (cclasscode == CC_LOWER ||
         cclasscode == CC_UPPER))
        cclasscode = CC_ALPHA;
 
    /*
     * Now compute the character class contents.  For classes that are based
     * on the behavior of a <wctype.h> or <ctype.h> function, we use
     * pg_ctype_get_cache so that we can cache the results.  Other classes
     * have definitions that are hard-wired here, and for those we just
     * construct a transient cvec on the fly.
     *
     * NB: keep this code in sync with cclass_column_index(), below.
     */
 
    switch (cclasscode)
    {
        case CC_PRINT:
            cv = pg_ctype_get_cache(pg_wc_isprint, cclasscode);
            break;
        case CC_ALNUM:
            cv = pg_ctype_get_cache(pg_wc_isalnum, cclasscode);
            break;
        case CC_ALPHA:
            cv = pg_ctype_get_cache(pg_wc_isalpha, cclasscode);
            break;
        case CC_WORD:
            cv = pg_ctype_get_cache(pg_wc_isword, cclasscode);
            break;
        case CC_ASCII:
            /* hard-wired meaning */
            cv = getcvec(v, 0, 1);
            if (cv)
                addrange(cv, 0, 0x7f);
            break;
        case CC_BLANK:
            /* hard-wired meaning */
            cv = getcvec(v, 2, 0);
            addchr(cv, '\t');
            addchr(cv, ' ');
            break;
        case CC_CNTRL:
            /* hard-wired meaning */
            cv = getcvec(v, 0, 2);
            addrange(cv, 0x0, 0x1f);
            addrange(cv, 0x7f, 0x9f);
            break;
        case CC_DIGIT:
            cv = pg_ctype_get_cache(pg_wc_isdigit, cclasscode);
            break;
        case CC_PUNCT:
            cv = pg_ctype_get_cache(pg_wc_ispunct, cclasscode);
            break;
        case CC_XDIGIT:
 
            /*
             * It's not clear how to define this in non-western locales, and
             * even less clear that there's any particular use in trying. So
             * just hard-wire the meaning.
             */
            cv = getcvec(v, 0, 3);
            if (cv)
            {
                addrange(cv, '0', '9');
                addrange(cv, 'a', 'f');
                addrange(cv, 'A', 'F');
            }
            break;
        case CC_SPACE:
            cv = pg_ctype_get_cache(pg_wc_isspace, cclasscode);
            break;
        case CC_LOWER:
            cv = pg_ctype_get_cache(pg_wc_islower, cclasscode);
            break;
        case CC_UPPER:
            cv = pg_ctype_get_cache(pg_wc_isupper, cclasscode);
            break;
        case CC_GRAPH:
            cv = pg_ctype_get_cache(pg_wc_isgraph, cclasscode);
            break;
    }
 
    /* If cv is NULL now, the reason must be "out of memory" */
    if (cv == NULL)
        ERR(REG_ESPACE);
    return cv;
}

References addchr(), addrange(), CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH, CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_WORD, CC_XDIGIT, cvec::cclasscode, ERR, getcvec(), pg_ctype_get_cache(), pg_wc_isalnum(), pg_wc_isalpha(), pg_wc_isdigit(), pg_wc_isgraph(), pg_wc_islower(), pg_wc_isprint(), pg_wc_ispunct(), pg_wc_isspace(), pg_wc_isupper(), pg_wc_isword(), and REG_ESPACE.

cmp()

static int cmp ( const chr *  x, const chr *  y, size_t  len  )

static

Definition at line 743 of file regc_locale.c.

{
    return memcmp(VS(x), VS(y), len * sizeof(chr));
}

References len, VS, x, and y.

Referenced by addToArray(), adjacent_cmp_bounds(), adjacent_inner_consistent(), append_startup_cost_compare(), append_total_cost_compare(), avlInsertNode(), binaryCompareStrings(), binaryheap_remove_node(), bit_cmp(), bitposition(), bounds_adjacent(), bpchar_larger(), bpchar_smaller(), bpcharcmp(), bpcharge(), bpchargt(), bpcharle(), bpcharlt(), bsearch_arg(), build_expanded_ranges(), byteacmp(), byteage(), byteagt(), byteale(), bytealt(), calc_word_similarity(), collectMatchBitmap(), comp_ptrgm(), compareItems(), compareStrings(), executeComparison(), findeq(), gcd_var(), GetVariable(), gin_btree_compare_prefix(), gin_cmp_prefix(), gin_cmp_tslexeme(), ginMergeItemPointers(), IndexNextWithReorder(), invariant_g_offset(), invariant_l_nontarget_offset(), invariant_l_offset(), invariant_leq_offset(), library_name_compare(), list_sort(), ln_var(), make_row_comparison_op(), make_row_distinct_op(), matchPartialInPendingList(), mcelem_array_contain_overlap_selec(), mcelem_array_contained_selec(), merge_overlapping_ranges(), multirange_cmp(), multirange_elem_bsearch_comparison(), multirange_ge(), multirange_gt(), multirange_le(), multirange_lt(), oidvectoreq(), oidvectorge(), oidvectorgt(), oidvectorle(), oidvectorlt(), oidvectorne(), pairingheap_GISTSearchItem_cmp(), range_cmp(), range_compare(), range_contains_elem_internal(), range_ge(), range_gt(), range_le(), range_lt(), range_serialize(), rbound_bsearch(), rbt_find(), rbt_find_great(), rbt_find_less(), rbt_insert(), read_letter(), reduce_expanded_ranges(), seg_different(), seg_ge(), seg_gt(), seg_le(), seg_lt(), seg_same(), set_cheapest(), SetVariable(), SetVariableHooks(), sift_up(), sort_expanded_ranges(), spg_range_quad_inner_consistent(), transformAExprIn(), tsCompareString(), tsvector_bsearch(), tsvector_concat(), and VariableHasHook().

eclass()

static struct cvec* eclass ( struct vars *  v, chr  c, int  cases  )

static

Definition at line 500 of file regc_locale.c.

{
    struct cvec *cv;
 
    /* crude fake equivalence class for testing */
    if ((v->cflags & REG_FAKE) && c == 'x')
    {
        cv = getcvec(v, 4, 0);
        addchr(cv, CHR('x'));
        addchr(cv, CHR('y'));
        if (cases)
        {
            addchr(cv, CHR('X'));
            addchr(cv, CHR('Y'));
        }
        return cv;
    }
 
    /* otherwise, none */
    if (cases)
        return allcases(v, c);
    cv = getcvec(v, 1, 0);
    assert(cv != NULL);
    addchr(cv, c);
    return cv;
}

References addchr(), allcases(), assert, vars::cflags, CHR, getcvec(), and REG_FAKE.

Referenced by eclass_useful_for_merging(), make_canonical_pathkey(), make_pathkey_from_sortinfo(), and print_pathkeys().

element()

static chr element ( struct vars *  v, const chr *  startp, const chr *  endp  )

static

Definition at line 376 of file regc_locale.c.

{
    const struct cname *cn;
    size_t      len;
 
    /* generic:  one-chr names stand for themselves */
    assert(startp < endp);
    len = endp - startp;
    if (len == 1)
        return *startp;
 
    NOTE(REG_ULOCALE);
 
    /* search table */
    for (cn = cnames; cn->name != NULL; cn++)
    {
        if (strlen(cn->name) == len &&
            pg_char_and_wchar_strncmp(cn->name, startp, len) == 0)
        {
            break;              /* NOTE BREAK OUT */
        }
    }
    if (cn->name != NULL)
        return CHR(cn->code);
 
    /* couldn't find it */
    ERR(REG_ECOLLATE);
    return 0;
}

References assert, CHR, cnames, cname::code, ERR, len, cname::name, NOTE, pg_char_and_wchar_strncmp(), REG_ECOLLATE, and REG_ULOCALE.

Referenced by chrnamed(), ecpg_store_input(), ExecEvalHashedScalarArrayOp(), json_array_element(), json_array_element_text(), jsonb_array_element(), jsonb_array_element_text(), nfalsepos_for_missing_strings(), populate_array_element(), populate_with_dummy_strings(), transformArrayExpr(), transformCreateSchemaStmtElements(), and transformCreateStmt().

lookupcclass()

static enum char_classes lookupcclass ( struct vars *  v, const chr *  startp, const chr *  endp  )

static

Definition at line 500 of file regc_locale.c.

{
    size_t      len;
    const char *const *namePtr;
    int         i;
 
    /*
     * Map the name to the corresponding enumerated value.
     */
    len = endp - startp;
    for (namePtr = classNames, i = 0; *namePtr != NULL; namePtr++, i++)
    {
        if (strlen(*namePtr) == len &&
            pg_char_and_wchar_strncmp(*namePtr, startp, len) == 0)
            return (enum char_classes) i;
    }
 
    ERR(REG_ECTYPE);
    return (enum char_classes) 0;
}

range()

static struct cvec* range ( struct vars *  v, chr  a, chr  b, int  cases  )

static

Definition at line 412 of file regc_locale.c.

{
    int         nchrs;
    struct cvec *cv;
    chr         c,
                cc;
 
    if (a != b && !before(a, b))
    {
        ERR(REG_ERANGE);
        return NULL;
    }
 
    if (!cases)
    {                           /* easy version */
        cv = getcvec(v, 0, 1);
        NOERRN();
        addrange(cv, a, b);
        return cv;
    }
 
    /*
     * When case-independent, it's hard to decide when cvec ranges are usable,
     * so for now at least, we won't try.  We use a range for the originally
     * specified chrs and then add on any case-equivalents that are outside
     * that range as individual chrs.
     *
     * To ensure sane behavior if someone specifies a very large range, limit
     * the allocation size to 100000 chrs (arbitrary) and check for overrun
     * inside the loop below.
     */
    nchrs = b - a + 1;
    if (nchrs <= 0 || nchrs > 100000)
        nchrs = 100000;
 
    cv = getcvec(v, nchrs, 1);
    NOERRN();
    addrange(cv, a, b);
 
    for (c = a; c <= b; c++)
    {
        cc = pg_wc_tolower(c);
        if (cc != c &&
            (before(cc, a) || before(b, cc)))
        {
            if (cv->nchrs >= cv->chrspace)
            {
                ERR(REG_ETOOBIG);
                return NULL;
            }
            addchr(cv, cc);
        }
        cc = pg_wc_toupper(c);
        if (cc != c &&
            (before(cc, a) || before(b, cc)))
        {
            if (cv->nchrs >= cv->chrspace)
            {
                ERR(REG_ETOOBIG);
                return NULL;
            }
            addchr(cv, cc);
        }
        INTERRUPT(v->re);
    }
 
    return cv;
}

References a, addchr(), addrange(), b, before(), cvec::chrspace, ERR, getcvec(), INTERRUPT, cvec::nchrs, NOERRN, pg_wc_tolower(), pg_wc_toupper(), vars::re, REG_ERANGE, and REG_ETOOBIG.

Referenced by AdjustIntervalForTypmod(), brin_range_deserialize(), brin_range_serialize(), chrnamed(), codepoint_range_cmp(), compute_range_stats(), DecodeInterval(), DecodeTime(), DecodeTimeCommon(), DecodeTimeForInterval(), ensure_free_space_in_buffer(), executeItemOptUnwrapTarget(), g_box_consider_split(), get_gist_range_class(), interval_in(), make_range(), mda_get_prod(), multirange_constructor1(), multirange_get_range(), multirange_in(), multirange_out(), multirange_send(), multirange_unnest(), pg_prng_uint64_range(), pg_to_ascii(), printJsonPathItem(), range_constructor2(), range_constructor3(), range_deduplicate_values(), range_deserialize(), range_get_flags(), range_gist_class_split(), range_gist_double_sorting_split(), range_gist_fallback_split(), range_gist_picksplit(), range_gist_single_sorting_split(), range_in(), range_out(), range_recv(), range_send(), range_serialize(), range_set_contain_empty(), record_manifest_details_for_wal_range(), spg_range_quad_inner_consistent(), spg_range_quad_picksplit(), and transformJsonArrayQueryConstructor().

Variable Documentation

classNames

const char* const classNames[NUM_CCLASSES+1]

static

Initial value:

= {
    "alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph",
    "lower", "print", "punct", "space", "upper", "xdigit", "word",
    NULL
}

Definition at line 356 of file regc_locale.c.

cnames

const struct cname cnames[]

static

Referenced by element().