362 lines
9.2 KiB
C
362 lines
9.2 KiB
C
/*
|
|
**********************************************************************
|
|
* Copyright (C) 1999-2009, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
**********************************************************************
|
|
*
|
|
* File USC_IMPL.C
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 07/08/2002 Eric Mader Creation.
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "unicode/uscript.h"
|
|
#include "usc_impl.h"
|
|
#include "cmemory.h"
|
|
|
|
#define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
|
|
|
|
#define PAREN_STACK_DEPTH 32
|
|
|
|
#define MOD(sp) ((sp) % PAREN_STACK_DEPTH)
|
|
#define LIMIT_INC(sp) (((sp) < PAREN_STACK_DEPTH)? (sp) + 1 : PAREN_STACK_DEPTH)
|
|
#define INC(sp,count) (MOD((sp) + (count)))
|
|
#define INC1(sp) (INC(sp, 1))
|
|
#define DEC(sp,count) (MOD((sp) + PAREN_STACK_DEPTH - (count)))
|
|
#define DEC1(sp) (DEC(sp, 1))
|
|
#define STACK_IS_EMPTY(scriptRun) ((scriptRun)->pushCount <= 0)
|
|
#define STACK_IS_NOT_EMPTY(scriptRun) (! STACK_IS_EMPTY(scriptRun))
|
|
#define TOP(scriptRun) ((scriptRun)->parenStack[(scriptRun)->parenSP])
|
|
#define SYNC_FIXUP(scriptRun) ((scriptRun)->fixupCount = 0)
|
|
|
|
struct ParenStackEntry
|
|
{
|
|
int32_t pairIndex;
|
|
UScriptCode scriptCode;
|
|
};
|
|
|
|
struct UScriptRun
|
|
{
|
|
int32_t textLength;
|
|
const UChar *textArray;
|
|
|
|
int32_t scriptStart;
|
|
int32_t scriptLimit;
|
|
UScriptCode scriptCode;
|
|
|
|
struct ParenStackEntry parenStack[PAREN_STACK_DEPTH];
|
|
int32_t parenSP;
|
|
int32_t pushCount;
|
|
int32_t fixupCount;
|
|
};
|
|
|
|
static int8_t highBit(int32_t value);
|
|
|
|
static const UChar32 pairedChars[] = {
|
|
0x0028, 0x0029, /* ascii paired punctuation */
|
|
0x003c, 0x003e,
|
|
0x005b, 0x005d,
|
|
0x007b, 0x007d,
|
|
0x00ab, 0x00bb, /* guillemets */
|
|
0x2018, 0x2019, /* general punctuation */
|
|
0x201c, 0x201d,
|
|
0x2039, 0x203a,
|
|
0x3008, 0x3009, /* chinese paired punctuation */
|
|
0x300a, 0x300b,
|
|
0x300c, 0x300d,
|
|
0x300e, 0x300f,
|
|
0x3010, 0x3011,
|
|
0x3014, 0x3015,
|
|
0x3016, 0x3017,
|
|
0x3018, 0x3019,
|
|
0x301a, 0x301b
|
|
};
|
|
|
|
static void push(UScriptRun *scriptRun, int32_t pairIndex, UScriptCode scriptCode)
|
|
{
|
|
scriptRun->pushCount = LIMIT_INC(scriptRun->pushCount);
|
|
scriptRun->fixupCount = LIMIT_INC(scriptRun->fixupCount);
|
|
|
|
scriptRun->parenSP = INC1(scriptRun->parenSP);
|
|
scriptRun->parenStack[scriptRun->parenSP].pairIndex = pairIndex;
|
|
scriptRun->parenStack[scriptRun->parenSP].scriptCode = scriptCode;
|
|
}
|
|
|
|
static void pop(UScriptRun *scriptRun)
|
|
{
|
|
if (STACK_IS_EMPTY(scriptRun)) {
|
|
return;
|
|
}
|
|
|
|
if (scriptRun->fixupCount > 0) {
|
|
scriptRun->fixupCount -= 1;
|
|
}
|
|
|
|
scriptRun->pushCount -= 1;
|
|
scriptRun->parenSP = DEC1(scriptRun->parenSP);
|
|
|
|
/* If the stack is now empty, reset the stack
|
|
pointers to their initial values.
|
|
*/
|
|
if (STACK_IS_EMPTY(scriptRun)) {
|
|
scriptRun->parenSP = -1;
|
|
}
|
|
}
|
|
|
|
static void fixup(UScriptRun *scriptRun, UScriptCode scriptCode)
|
|
{
|
|
int32_t fixupSP = DEC(scriptRun->parenSP, scriptRun->fixupCount);
|
|
|
|
while (scriptRun->fixupCount-- > 0) {
|
|
fixupSP = INC1(fixupSP);
|
|
scriptRun->parenStack[fixupSP].scriptCode = scriptCode;
|
|
}
|
|
}
|
|
|
|
static int8_t
|
|
highBit(int32_t value)
|
|
{
|
|
int8_t bit = 0;
|
|
|
|
if (value <= 0) {
|
|
return -32;
|
|
}
|
|
|
|
if (value >= 1 << 16) {
|
|
value >>= 16;
|
|
bit += 16;
|
|
}
|
|
|
|
if (value >= 1 << 8) {
|
|
value >>= 8;
|
|
bit += 8;
|
|
}
|
|
|
|
if (value >= 1 << 4) {
|
|
value >>= 4;
|
|
bit += 4;
|
|
}
|
|
|
|
if (value >= 1 << 2) {
|
|
value >>= 2;
|
|
bit += 2;
|
|
}
|
|
|
|
if (value >= 1 << 1) {
|
|
value >>= 1;
|
|
bit += 1;
|
|
}
|
|
|
|
return bit;
|
|
}
|
|
|
|
static int32_t
|
|
getPairIndex(UChar32 ch)
|
|
{
|
|
int32_t pairedCharCount = ARRAY_SIZE(pairedChars);
|
|
int32_t pairedCharPower = 1 << highBit(pairedCharCount);
|
|
int32_t pairedCharExtra = pairedCharCount - pairedCharPower;
|
|
|
|
int32_t probe = pairedCharPower;
|
|
int32_t pairIndex = 0;
|
|
|
|
if (ch >= pairedChars[pairedCharExtra]) {
|
|
pairIndex = pairedCharExtra;
|
|
}
|
|
|
|
while (probe > (1 << 0)) {
|
|
probe >>= 1;
|
|
|
|
if (ch >= pairedChars[pairIndex + probe]) {
|
|
pairIndex += probe;
|
|
}
|
|
}
|
|
|
|
if (pairedChars[pairIndex] != ch) {
|
|
pairIndex = -1;
|
|
}
|
|
|
|
return pairIndex;
|
|
}
|
|
|
|
static UBool
|
|
sameScript(UScriptCode scriptOne, UScriptCode scriptTwo)
|
|
{
|
|
return scriptOne <= USCRIPT_INHERITED || scriptTwo <= USCRIPT_INHERITED || scriptOne == scriptTwo;
|
|
}
|
|
|
|
U_CAPI UScriptRun * U_EXPORT2
|
|
uscript_openRun(const UChar *src, int32_t length, UErrorCode *pErrorCode)
|
|
{
|
|
UScriptRun *result = NULL;
|
|
|
|
if (pErrorCode == NULL || U_FAILURE(*pErrorCode)) {
|
|
return NULL;
|
|
}
|
|
|
|
result = uprv_malloc(sizeof (UScriptRun));
|
|
|
|
if (result == NULL) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
uscript_setRunText(result, src, length, pErrorCode);
|
|
|
|
/* Release the UScriptRun if uscript_setRunText() returns an error */
|
|
if (U_FAILURE(*pErrorCode)) {
|
|
uprv_free(result);
|
|
result = NULL;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
uscript_closeRun(UScriptRun *scriptRun)
|
|
{
|
|
if (scriptRun != NULL) {
|
|
uprv_free(scriptRun);
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
uscript_resetRun(UScriptRun *scriptRun)
|
|
{
|
|
if (scriptRun != NULL) {
|
|
scriptRun->scriptStart = 0;
|
|
scriptRun->scriptLimit = 0;
|
|
scriptRun->scriptCode = USCRIPT_INVALID_CODE;
|
|
scriptRun->parenSP = -1;
|
|
scriptRun->pushCount = 0;
|
|
scriptRun->fixupCount = 0;
|
|
}
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
uscript_setRunText(UScriptRun *scriptRun, const UChar *src, int32_t length, UErrorCode *pErrorCode)
|
|
{
|
|
if (pErrorCode == NULL || U_FAILURE(*pErrorCode)) {
|
|
return;
|
|
}
|
|
|
|
if (scriptRun == NULL || length < 0 || ((src == NULL) != (length == 0))) {
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
|
|
scriptRun->textArray = src;
|
|
scriptRun->textLength = length;
|
|
|
|
uscript_resetRun(scriptRun);
|
|
}
|
|
|
|
U_CAPI UBool U_EXPORT2
|
|
uscript_nextRun(UScriptRun *scriptRun, int32_t *pRunStart, int32_t *pRunLimit, UScriptCode *pRunScript)
|
|
{
|
|
UErrorCode error = U_ZERO_ERROR;
|
|
|
|
/* if we've fallen off the end of the text, we're done */
|
|
if (scriptRun == NULL || scriptRun->scriptLimit >= scriptRun->textLength) {
|
|
return FALSE;
|
|
}
|
|
|
|
SYNC_FIXUP(scriptRun);
|
|
scriptRun->scriptCode = USCRIPT_COMMON;
|
|
|
|
for (scriptRun->scriptStart = scriptRun->scriptLimit; scriptRun->scriptLimit < scriptRun->textLength; scriptRun->scriptLimit += 1) {
|
|
UChar high = scriptRun->textArray[scriptRun->scriptLimit];
|
|
UChar32 ch = high;
|
|
UScriptCode sc;
|
|
int32_t pairIndex;
|
|
|
|
/*
|
|
* if the character is a high surrogate and it's not the last one
|
|
* in the text, see if it's followed by a low surrogate
|
|
*/
|
|
if (high >= 0xD800 && high <= 0xDBFF && scriptRun->scriptLimit < scriptRun->textLength - 1) {
|
|
UChar low = scriptRun->textArray[scriptRun->scriptLimit + 1];
|
|
|
|
/*
|
|
* if it is followed by a low surrogate,
|
|
* consume it and form the full character
|
|
*/
|
|
if (low >= 0xDC00 && low <= 0xDFFF) {
|
|
ch = (high - 0xD800) * 0x0400 + low - 0xDC00 + 0x10000;
|
|
scriptRun->scriptLimit += 1;
|
|
}
|
|
}
|
|
|
|
sc = uscript_getScript(ch, &error);
|
|
pairIndex = getPairIndex(ch);
|
|
|
|
/*
|
|
* Paired character handling:
|
|
*
|
|
* if it's an open character, push it onto the stack.
|
|
* if it's a close character, find the matching open on the
|
|
* stack, and use that script code. Any non-matching open
|
|
* characters above it on the stack will be poped.
|
|
*/
|
|
if (pairIndex >= 0) {
|
|
if ((pairIndex & 1) == 0) {
|
|
push(scriptRun, pairIndex, scriptRun->scriptCode);
|
|
} else {
|
|
int32_t pi = pairIndex & ~1;
|
|
|
|
while (STACK_IS_NOT_EMPTY(scriptRun) && TOP(scriptRun).pairIndex != pi) {
|
|
pop(scriptRun);
|
|
}
|
|
|
|
if (STACK_IS_NOT_EMPTY(scriptRun)) {
|
|
sc = TOP(scriptRun).scriptCode;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sameScript(scriptRun->scriptCode, sc)) {
|
|
if (scriptRun->scriptCode <= USCRIPT_INHERITED && sc > USCRIPT_INHERITED) {
|
|
scriptRun->scriptCode = sc;
|
|
|
|
fixup(scriptRun, scriptRun->scriptCode);
|
|
}
|
|
|
|
/*
|
|
* if this character is a close paired character,
|
|
* pop the matching open character from the stack
|
|
*/
|
|
if (pairIndex >= 0 && (pairIndex & 1) != 0) {
|
|
pop(scriptRun);
|
|
}
|
|
} else {
|
|
/*
|
|
* if the run broke on a surrogate pair,
|
|
* end it before the high surrogate
|
|
*/
|
|
if (ch >= 0x10000) {
|
|
scriptRun->scriptLimit -= 1;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if (pRunStart != NULL) {
|
|
*pRunStart = scriptRun->scriptStart;
|
|
}
|
|
|
|
if (pRunLimit != NULL) {
|
|
*pRunLimit = scriptRun->scriptLimit;
|
|
}
|
|
|
|
if (pRunScript != NULL) {
|
|
*pRunScript = scriptRun->scriptCode;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|