| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 1999-2016, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: scrptrun.cpp |
| * |
| * created on: 10/17/2001 |
| * created by: Eric R. Mader |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "unicode/uscript.h" |
| |
| #include "cmemory.h" |
| #include "scrptrun.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| const char ScriptRun::fgClassID=0; |
| |
| UChar32 ScriptRun::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 |
| }; |
| |
| const int32_t ScriptRun::pairedCharCount = UPRV_LENGTHOF(pairedChars); |
| const int32_t ScriptRun::pairedCharPower = 1 << highBit(pairedCharCount); |
| const int32_t ScriptRun::pairedCharExtra = pairedCharCount - pairedCharPower; |
| |
| int8_t ScriptRun::highBit(int32_t value) |
| { |
| if (value <= 0) { |
| return -32; |
| } |
| |
| int8_t bit = 0; |
| |
| 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; |
| } |
| |
| int32_t ScriptRun::getPairIndex(UChar32 ch) |
| { |
| int32_t probe = pairedCharPower; |
| int32_t index = 0; |
| |
| if (ch >= pairedChars[pairedCharExtra]) { |
| index = pairedCharExtra; |
| } |
| |
| while (probe > (1 << 0)) { |
| probe >>= 1; |
| |
| if (ch >= pairedChars[index + probe]) { |
| index += probe; |
| } |
| } |
| |
| if (pairedChars[index] != ch) { |
| index = -1; |
| } |
| |
| return index; |
| } |
| |
| UBool ScriptRun::sameScript(int32_t scriptOne, int32_t scriptTwo) |
| { |
| return scriptOne <= USCRIPT_INHERITED || scriptTwo <= USCRIPT_INHERITED || scriptOne == scriptTwo; |
| } |
| |
| UBool ScriptRun::next() |
| { |
| int32_t startSP = parenSP; // used to find the first new open character |
| UErrorCode error = U_ZERO_ERROR; |
| |
| // if we've fallen off the end of the text, we're done |
| if (scriptEnd >= charLimit) { |
| return false; |
| } |
| |
| scriptCode = USCRIPT_COMMON; |
| |
| for (scriptStart = scriptEnd; scriptEnd < charLimit; scriptEnd += 1) { |
| UChar high = charArray[scriptEnd]; |
| UChar32 ch = high; |
| |
| // 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 && scriptEnd < charLimit - 1) |
| { |
| UChar low = charArray[scriptEnd + 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; |
| scriptEnd += 1; |
| } |
| } |
| |
| UScriptCode sc = uscript_getScript(ch, &error); |
| int32_t 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) { |
| parenStack[++parenSP].pairIndex = pairIndex; |
| parenStack[parenSP].scriptCode = scriptCode; |
| } else if (parenSP >= 0) { |
| int32_t pi = pairIndex & ~1; |
| |
| while (parenSP >= 0 && parenStack[parenSP].pairIndex != pi) { |
| parenSP -= 1; |
| } |
| |
| if (parenSP < startSP) { |
| startSP = parenSP; |
| } |
| |
| if (parenSP >= 0) { |
| sc = parenStack[parenSP].scriptCode; |
| } |
| } |
| } |
| |
| if (sameScript(scriptCode, sc)) { |
| if (scriptCode <= USCRIPT_INHERITED && sc > USCRIPT_INHERITED) { |
| scriptCode = sc; |
| |
| // now that we have a final script code, fix any open |
| // characters we pushed before we knew the script code. |
| while (startSP < parenSP) { |
| parenStack[++startSP].scriptCode = scriptCode; |
| } |
| } |
| |
| // if this character is a close paired character, |
| // pop it from the stack |
| if (pairIndex >= 0 && (pairIndex & 1) != 0 && parenSP >= 0) { |
| parenSP -= 1; |
| startSP -= 1; |
| } |
| } else { |
| // if the run broke on a surrogate pair, |
| // end it before the high surrogate |
| if (ch >= 0x10000) { |
| scriptEnd -= 1; |
| } |
| |
| break; |
| } |
| } |
| |
| return true; |
| } |
| |
| U_NAMESPACE_END |