361 lines
8.5 KiB
C
361 lines
8.5 KiB
C
/*
|
|
* Copyright (C) 2012 Grigori Goronzy <greg@kinoho.net>
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include "ucdn.h"
|
|
|
|
typedef struct {
|
|
unsigned char category;
|
|
unsigned char combining;
|
|
unsigned char bidi_class;
|
|
unsigned char east_asian_width;
|
|
unsigned char script;
|
|
unsigned char linebreak_class;
|
|
} UCDRecord;
|
|
|
|
typedef struct {
|
|
unsigned short from, to;
|
|
} MirrorPair;
|
|
|
|
typedef struct {
|
|
unsigned short from, to;
|
|
unsigned char type;
|
|
} BracketPair;
|
|
|
|
typedef struct {
|
|
unsigned int start;
|
|
short count, index;
|
|
} Reindex;
|
|
|
|
#include "ucdn_db.h"
|
|
|
|
/* constants required for Hangul (de)composition */
|
|
#define SBASE 0xAC00
|
|
#define LBASE 0x1100
|
|
#define VBASE 0x1161
|
|
#define TBASE 0x11A7
|
|
#define SCOUNT 11172
|
|
#define LCOUNT 19
|
|
#define VCOUNT 21
|
|
#define TCOUNT 28
|
|
#define NCOUNT (VCOUNT * TCOUNT)
|
|
|
|
static const UCDRecord *get_ucd_record(uint32_t code)
|
|
{
|
|
int index, offset;
|
|
|
|
if (code >= 0x110000)
|
|
index = 0;
|
|
else {
|
|
index = index0[code >> (SHIFT1+SHIFT2)] << SHIFT1;
|
|
offset = (code >> SHIFT2) & ((1<<SHIFT1) - 1);
|
|
index = index1[index + offset] << SHIFT2;
|
|
offset = code & ((1<<SHIFT2) - 1);
|
|
index = index2[index + offset];
|
|
}
|
|
|
|
return &ucd_records[index];
|
|
}
|
|
|
|
static const unsigned short *get_decomp_record(uint32_t code)
|
|
{
|
|
int index, offset;
|
|
|
|
if (code >= 0x110000)
|
|
index = 0;
|
|
else {
|
|
index = decomp_index0[code >> (DECOMP_SHIFT1+DECOMP_SHIFT2)]
|
|
<< DECOMP_SHIFT1;
|
|
offset = (code >> DECOMP_SHIFT2) & ((1<<DECOMP_SHIFT1) - 1);
|
|
index = decomp_index1[index + offset] << DECOMP_SHIFT2;
|
|
offset = code & ((1<<DECOMP_SHIFT2) - 1);
|
|
index = decomp_index2[index + offset];
|
|
}
|
|
|
|
return &decomp_data[index];
|
|
}
|
|
|
|
static int compare_reindex(const void *a, const void *b)
|
|
{
|
|
Reindex *ra = (Reindex *)a;
|
|
Reindex *rb = (Reindex *)b;
|
|
|
|
if (ra->start < rb->start)
|
|
return -1;
|
|
else if (ra->start > (rb->start + rb->count))
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static int get_comp_index(uint32_t code, const Reindex *idx, size_t len)
|
|
{
|
|
Reindex *res;
|
|
Reindex r = {0, 0, 0};
|
|
r.start = code;
|
|
res = (Reindex *) bsearch(&r, idx, len, sizeof(Reindex), compare_reindex);
|
|
|
|
if (res != NULL)
|
|
return res->index + (code - res->start);
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
static int compare_mp(const void *a, const void *b)
|
|
{
|
|
MirrorPair *mpa = (MirrorPair *)a;
|
|
MirrorPair *mpb = (MirrorPair *)b;
|
|
return mpa->from - mpb->from;
|
|
}
|
|
|
|
static int compare_bp(const void *a, const void *b)
|
|
{
|
|
BracketPair *bpa = (BracketPair *)a;
|
|
BracketPair *bpb = (BracketPair *)b;
|
|
return bpa->from - bpb->from;
|
|
}
|
|
|
|
static BracketPair *search_bp(uint32_t code)
|
|
{
|
|
BracketPair bp = {0,0,2};
|
|
BracketPair *res;
|
|
|
|
bp.from = code;
|
|
res = (BracketPair *) bsearch(&bp, bracket_pairs, BIDI_BRACKET_LEN,
|
|
sizeof(BracketPair), compare_bp);
|
|
return res;
|
|
}
|
|
|
|
static int hangul_pair_decompose(uint32_t code, uint32_t *a, uint32_t *b)
|
|
{
|
|
int si = code - SBASE;
|
|
|
|
if (si < 0 || si >= SCOUNT)
|
|
return 0;
|
|
|
|
if (si % TCOUNT) {
|
|
/* LV,T */
|
|
*a = SBASE + (si / TCOUNT) * TCOUNT;
|
|
*b = TBASE + (si % TCOUNT);
|
|
return 3;
|
|
} else {
|
|
/* L,V */
|
|
*a = LBASE + (si / NCOUNT);
|
|
*b = VBASE + (si % NCOUNT) / TCOUNT;
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
static int hangul_pair_compose(uint32_t *code, uint32_t a, uint32_t b)
|
|
{
|
|
if (a >= SBASE && a < (SBASE + SCOUNT) && b >= TBASE && b < (TBASE + TCOUNT)) {
|
|
/* LV,T */
|
|
*code = a + (b - TBASE);
|
|
return 3;
|
|
} else if (a >= LBASE && a < (LBASE + LCOUNT) && b >= VBASE && b < (VBASE + VCOUNT)) {
|
|
/* L,V */
|
|
int li = a - LBASE;
|
|
int vi = b - VBASE;
|
|
*code = SBASE + li * NCOUNT + vi * TCOUNT;
|
|
return 2;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static uint32_t decode_utf16(const unsigned short **code_ptr)
|
|
{
|
|
const unsigned short *code = *code_ptr;
|
|
|
|
if (code[0] < 0xd800 || code[0] > 0xdc00) {
|
|
*code_ptr += 1;
|
|
return (uint32_t)code[0];
|
|
} else {
|
|
*code_ptr += 2;
|
|
return 0x10000 + ((uint32_t)code[1] - 0xdc00) +
|
|
(((uint32_t)code[0] - 0xd800) << 10);
|
|
}
|
|
}
|
|
|
|
const char *ucdn_get_unicode_version(void)
|
|
{
|
|
return UNIDATA_VERSION;
|
|
}
|
|
|
|
int ucdn_get_combining_class(uint32_t code)
|
|
{
|
|
return get_ucd_record(code)->combining;
|
|
}
|
|
|
|
int ucdn_get_east_asian_width(uint32_t code)
|
|
{
|
|
return get_ucd_record(code)->east_asian_width;
|
|
}
|
|
|
|
int ucdn_get_general_category(uint32_t code)
|
|
{
|
|
return get_ucd_record(code)->category;
|
|
}
|
|
|
|
int ucdn_get_bidi_class(uint32_t code)
|
|
{
|
|
return get_ucd_record(code)->bidi_class;
|
|
}
|
|
|
|
int ucdn_get_mirrored(uint32_t code)
|
|
{
|
|
return ucdn_mirror(code) != code;
|
|
}
|
|
|
|
int ucdn_get_script(uint32_t code)
|
|
{
|
|
return get_ucd_record(code)->script;
|
|
}
|
|
|
|
int ucdn_get_linebreak_class(uint32_t code)
|
|
{
|
|
return get_ucd_record(code)->linebreak_class;
|
|
}
|
|
|
|
int ucdn_get_resolved_linebreak_class(uint32_t code)
|
|
{
|
|
const UCDRecord *record = get_ucd_record(code);
|
|
|
|
switch (record->linebreak_class)
|
|
{
|
|
case UCDN_LINEBREAK_CLASS_AI:
|
|
case UCDN_LINEBREAK_CLASS_SG:
|
|
case UCDN_LINEBREAK_CLASS_XX:
|
|
return UCDN_LINEBREAK_CLASS_AL;
|
|
|
|
case UCDN_LINEBREAK_CLASS_SA:
|
|
if (record->category == UCDN_GENERAL_CATEGORY_MC ||
|
|
record->category == UCDN_GENERAL_CATEGORY_MN)
|
|
return UCDN_LINEBREAK_CLASS_CM;
|
|
return UCDN_LINEBREAK_CLASS_AL;
|
|
|
|
case UCDN_LINEBREAK_CLASS_CJ:
|
|
return UCDN_LINEBREAK_CLASS_NS;
|
|
|
|
case UCDN_LINEBREAK_CLASS_CB:
|
|
return UCDN_LINEBREAK_CLASS_B2;
|
|
|
|
case UCDN_LINEBREAK_CLASS_NL:
|
|
return UCDN_LINEBREAK_CLASS_BK;
|
|
|
|
default:
|
|
return record->linebreak_class;
|
|
}
|
|
}
|
|
|
|
uint32_t ucdn_mirror(uint32_t code)
|
|
{
|
|
MirrorPair mp = {0};
|
|
MirrorPair *res;
|
|
|
|
mp.from = code;
|
|
res = (MirrorPair *) bsearch(&mp, mirror_pairs, BIDI_MIRROR_LEN,
|
|
sizeof(MirrorPair), compare_mp);
|
|
|
|
if (res == NULL)
|
|
return code;
|
|
else
|
|
return res->to;
|
|
}
|
|
|
|
uint32_t ucdn_paired_bracket(uint32_t code)
|
|
{
|
|
BracketPair *res = search_bp(code);
|
|
if (res == NULL)
|
|
return code;
|
|
else
|
|
return res->to;
|
|
}
|
|
|
|
int ucdn_paired_bracket_type(uint32_t code)
|
|
{
|
|
BracketPair *res = search_bp(code);
|
|
if (res == NULL)
|
|
return UCDN_BIDI_PAIRED_BRACKET_TYPE_NONE;
|
|
else
|
|
return res->type;
|
|
}
|
|
|
|
int ucdn_decompose(uint32_t code, uint32_t *a, uint32_t *b)
|
|
{
|
|
const unsigned short *rec;
|
|
int len;
|
|
|
|
if (hangul_pair_decompose(code, a, b))
|
|
return 1;
|
|
|
|
rec = get_decomp_record(code);
|
|
len = rec[0] >> 8;
|
|
|
|
if ((rec[0] & 0xff) != 0 || len == 0)
|
|
return 0;
|
|
|
|
rec++;
|
|
*a = decode_utf16(&rec);
|
|
if (len > 1)
|
|
*b = decode_utf16(&rec);
|
|
else
|
|
*b = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
int ucdn_compose(uint32_t *code, uint32_t a, uint32_t b)
|
|
{
|
|
int l, r, index, indexi, offset;
|
|
|
|
if (hangul_pair_compose(code, a, b))
|
|
return 1;
|
|
|
|
l = get_comp_index(a, nfc_first, sizeof(nfc_first) / sizeof(Reindex));
|
|
r = get_comp_index(b, nfc_last, sizeof(nfc_last) / sizeof(Reindex));
|
|
|
|
if (l < 0 || r < 0)
|
|
return 0;
|
|
|
|
indexi = l * TOTAL_LAST + r;
|
|
index = comp_index0[indexi >> (COMP_SHIFT1+COMP_SHIFT2)] << COMP_SHIFT1;
|
|
offset = (indexi >> COMP_SHIFT2) & ((1<<COMP_SHIFT1) - 1);
|
|
index = comp_index1[index + offset] << COMP_SHIFT2;
|
|
offset = indexi & ((1<<COMP_SHIFT2) - 1);
|
|
*code = comp_data[index + offset];
|
|
|
|
return *code != 0;
|
|
}
|
|
|
|
int ucdn_compat_decompose(uint32_t code, uint32_t *decomposed)
|
|
{
|
|
int i, len;
|
|
const unsigned short *rec = get_decomp_record(code);
|
|
len = rec[0] >> 8;
|
|
|
|
if (len == 0)
|
|
return 0;
|
|
|
|
rec++;
|
|
for (i = 0; i < len; i++)
|
|
decomposed[i] = decode_utf16(&rec);
|
|
|
|
return len;
|
|
}
|