1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ******************************************************************************* 5 * 6 * Copyright (C) 1999-2016, International Business Machines 7 * Corporation and others. All Rights Reserved. 8 * 9 ******************************************************************************* 10 * file name: scrptrun.cpp 11 * 12 * created on: 10/17/2001 13 * created by: Eric R. Mader 14 */ 15 16 #include "unicode/utypes.h" 17 #include "unicode/uscript.h" 18 19 #include "cmemory.h" 20 #include "scrptrun.h" 21 22 const char ScriptRun::fgClassID=0; 23 24 UChar32 ScriptRun::pairedChars[] = { 25 0x0028, 0x0029, // ascii paired punctuation 26 0x003c, 0x003e, 27 0x005b, 0x005d, 28 0x007b, 0x007d, 29 0x00ab, 0x00bb, // guillemets 30 0x2018, 0x2019, // general punctuation 31 0x201c, 0x201d, 32 0x2039, 0x203a, 33 0x3008, 0x3009, // chinese paired punctuation 34 0x300a, 0x300b, 35 0x300c, 0x300d, 36 0x300e, 0x300f, 37 0x3010, 0x3011, 38 0x3014, 0x3015, 39 0x3016, 0x3017, 40 0x3018, 0x3019, 41 0x301a, 0x301b 42 }; 43 44 const int32_t ScriptRun::pairedCharCount = UPRV_LENGTHOF(pairedChars); 45 const int32_t ScriptRun::pairedCharPower = 1 << highBit(pairedCharCount); 46 const int32_t ScriptRun::pairedCharExtra = pairedCharCount - pairedCharPower; 47 48 int8_t ScriptRun::highBit(int32_t value) 49 { 50 if (value <= 0) { 51 return -32; 52 } 53 54 int8_t bit = 0; 55 56 if (value >= 1 << 16) { 57 value >>= 16; 58 bit += 16; 59 } 60 61 if (value >= 1 << 8) { 62 value >>= 8; 63 bit += 8; 64 } 65 66 if (value >= 1 << 4) { 67 value >>= 4; 68 bit += 4; 69 } 70 71 if (value >= 1 << 2) { 72 value >>= 2; 73 bit += 2; 74 } 75 76 if (value >= 1 << 1) { 77 value >>= 1; 78 bit += 1; 79 } 80 81 return bit; 82 } 83 84 int32_t ScriptRun::getPairIndex(UChar32 ch) 85 { 86 int32_t probe = pairedCharPower; 87 int32_t index = 0; 88 89 if (ch >= pairedChars[pairedCharExtra]) { 90 index = pairedCharExtra; 91 } 92 93 while (probe > (1 << 0)) { 94 probe >>= 1; 95 96 if (ch >= pairedChars[index + probe]) { 97 index += probe; 98 } 99 } 100 101 if (pairedChars[index] != ch) { 102 index = -1; 103 } 104 105 return index; 106 } 107 108 UBool ScriptRun::sameScript(int32_t scriptOne, int32_t scriptTwo) 109 { 110 return scriptOne <= USCRIPT_INHERITED || scriptTwo <= USCRIPT_INHERITED || scriptOne == scriptTwo; 111 } 112 113 UBool ScriptRun::next() 114 { 115 int32_t startSP = parenSP; // used to find the first new open character 116 UErrorCode error = U_ZERO_ERROR; 117 118 // if we've fallen off the end of the text, we're done 119 if (scriptEnd >= charLimit) { 120 return false; 121 } 122 123 scriptCode = USCRIPT_COMMON; 124 125 for (scriptStart = scriptEnd; scriptEnd < charLimit; scriptEnd += 1) { 126 UChar high = charArray[scriptEnd]; 127 UChar32 ch = high; 128 129 // if the character is a high surrogate and it's not the last one 130 // in the text, see if it's followed by a low surrogate 131 if (high >= 0xD800 && high <= 0xDBFF && scriptEnd < charLimit - 1) 132 { 133 UChar low = charArray[scriptEnd + 1]; 134 135 // if it is followed by a low surrogate, 136 // consume it and form the full character 137 if (low >= 0xDC00 && low <= 0xDFFF) { 138 ch = (high - 0xD800) * 0x0400 + low - 0xDC00 + 0x10000; 139 scriptEnd += 1; 140 } 141 } 142 143 UScriptCode sc = uscript_getScript(ch, &error); 144 int32_t pairIndex = getPairIndex(ch); 145 146 // Paired character handling: 147 // 148 // if it's an open character, push it onto the stack. 149 // if it's a close character, find the matching open on the 150 // stack, and use that script code. Any non-matching open 151 // characters above it on the stack will be poped. 152 if (pairIndex >= 0) { 153 if ((pairIndex & 1) == 0) { 154 parenStack[++parenSP].pairIndex = pairIndex; 155 parenStack[parenSP].scriptCode = scriptCode; 156 } else if (parenSP >= 0) { 157 int32_t pi = pairIndex & ~1; 158 159 while (parenSP >= 0 && parenStack[parenSP].pairIndex != pi) { 160 parenSP -= 1; 161 } 162 163 if (parenSP < startSP) { 164 startSP = parenSP; 165 } 166 167 if (parenSP >= 0) { 168 sc = parenStack[parenSP].scriptCode; 169 } 170 } 171 } 172 173 if (sameScript(scriptCode, sc)) { 174 if (scriptCode <= USCRIPT_INHERITED && sc > USCRIPT_INHERITED) { 175 scriptCode = sc; 176 177 // now that we have a final script code, fix any open 178 // characters we pushed before we knew the script code. 179 while (startSP < parenSP) { 180 parenStack[++startSP].scriptCode = scriptCode; 181 } 182 } 183 184 // if this character is a close paired character, 185 // pop it from the stack 186 if (pairIndex >= 0 && (pairIndex & 1) != 0 && parenSP >= 0) { 187 parenSP -= 1; 188 startSP -= 1; 189 } 190 } else { 191 // if the run broke on a surrogate pair, 192 // end it before the high surrogate 193 if (ch >= 0x10000) { 194 scriptEnd -= 1; 195 } 196 197 break; 198 } 199 } 200 201 return true; 202 } 203 204
