intl/icu/source/extra/scrptrun/scrptrun.cpp@129ffea94266
intl/icu/source/extra/scrptrun/scrptrun.cpp
Sat, 03 Jan 2015 20:18:00 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Sat, 03 Jan 2015 20:18:00 +0100
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
- permissions
- -rw-r--r--
Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.
1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 1999-2001, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: scrptrun.cpp
9 *
10 * created on: 10/17/2001
11 * created by: Eric R. Mader
12 */
14 #include "unicode/utypes.h"
15 #include "unicode/uscript.h"
17 #include "scrptrun.h"
19 #define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
21 const char ScriptRun::fgClassID=0;
23 UChar32 ScriptRun::pairedChars[] = {
24 0x0028, 0x0029, // ascii paired punctuation
25 0x003c, 0x003e,
26 0x005b, 0x005d,
27 0x007b, 0x007d,
28 0x00ab, 0x00bb, // guillemets
29 0x2018, 0x2019, // general punctuation
30 0x201c, 0x201d,
31 0x2039, 0x203a,
32 0x3008, 0x3009, // chinese paired punctuation
33 0x300a, 0x300b,
34 0x300c, 0x300d,
35 0x300e, 0x300f,
36 0x3010, 0x3011,
37 0x3014, 0x3015,
38 0x3016, 0x3017,
39 0x3018, 0x3019,
40 0x301a, 0x301b
41 };
43 const int32_t ScriptRun::pairedCharCount = ARRAY_SIZE(pairedChars);
44 const int32_t ScriptRun::pairedCharPower = 1 << highBit(pairedCharCount);
45 const int32_t ScriptRun::pairedCharExtra = pairedCharCount - pairedCharPower;
47 int8_t ScriptRun::highBit(int32_t value)
48 {
49 if (value <= 0) {
50 return -32;
51 }
53 int8_t bit = 0;
55 if (value >= 1 << 16) {
56 value >>= 16;
57 bit += 16;
58 }
60 if (value >= 1 << 8) {
61 value >>= 8;
62 bit += 8;
63 }
65 if (value >= 1 << 4) {
66 value >>= 4;
67 bit += 4;
68 }
70 if (value >= 1 << 2) {
71 value >>= 2;
72 bit += 2;
73 }
75 if (value >= 1 << 1) {
76 value >>= 1;
77 bit += 1;
78 }
80 return bit;
81 }
83 int32_t ScriptRun::getPairIndex(UChar32 ch)
84 {
85 int32_t probe = pairedCharPower;
86 int32_t index = 0;
88 if (ch >= pairedChars[pairedCharExtra]) {
89 index = pairedCharExtra;
90 }
92 while (probe > (1 << 0)) {
93 probe >>= 1;
95 if (ch >= pairedChars[index + probe]) {
96 index += probe;
97 }
98 }
100 if (pairedChars[index] != ch) {
101 index = -1;
102 }
104 return index;
105 }
107 UBool ScriptRun::sameScript(int32_t scriptOne, int32_t scriptTwo)
108 {
109 return scriptOne <= USCRIPT_INHERITED || scriptTwo <= USCRIPT_INHERITED || scriptOne == scriptTwo;
110 }
112 UBool ScriptRun::next()
113 {
114 int32_t startSP = parenSP; // used to find the first new open character
115 UErrorCode error = U_ZERO_ERROR;
117 // if we've fallen off the end of the text, we're done
118 if (scriptEnd >= charLimit) {
119 return false;
120 }
122 scriptCode = USCRIPT_COMMON;
124 for (scriptStart = scriptEnd; scriptEnd < charLimit; scriptEnd += 1) {
125 UChar high = charArray[scriptEnd];
126 UChar32 ch = high;
128 // if the character is a high surrogate and it's not the last one
129 // in the text, see if it's followed by a low surrogate
130 if (high >= 0xD800 && high <= 0xDBFF && scriptEnd < charLimit - 1)
131 {
132 UChar low = charArray[scriptEnd + 1];
134 // if it is followed by a low surrogate,
135 // consume it and form the full character
136 if (low >= 0xDC00 && low <= 0xDFFF) {
137 ch = (high - 0xD800) * 0x0400 + low - 0xDC00 + 0x10000;
138 scriptEnd += 1;
139 }
140 }
142 UScriptCode sc = uscript_getScript(ch, &error);
143 int32_t pairIndex = getPairIndex(ch);
145 // Paired character handling:
146 //
147 // if it's an open character, push it onto the stack.
148 // if it's a close character, find the matching open on the
149 // stack, and use that script code. Any non-matching open
150 // characters above it on the stack will be poped.
151 if (pairIndex >= 0) {
152 if ((pairIndex & 1) == 0) {
153 parenStack[++parenSP].pairIndex = pairIndex;
154 parenStack[parenSP].scriptCode = scriptCode;
155 } else if (parenSP >= 0) {
156 int32_t pi = pairIndex & ~1;
158 while (parenSP >= 0 && parenStack[parenSP].pairIndex != pi) {
159 parenSP -= 1;
160 }
162 if (parenSP < startSP) {
163 startSP = parenSP;
164 }
166 if (parenSP >= 0) {
167 sc = parenStack[parenSP].scriptCode;
168 }
169 }
170 }
172 if (sameScript(scriptCode, sc)) {
173 if (scriptCode <= USCRIPT_INHERITED && sc > USCRIPT_INHERITED) {
174 scriptCode = sc;
176 // now that we have a final script code, fix any open
177 // characters we pushed before we knew the script code.
178 while (startSP < parenSP) {
179 parenStack[++startSP].scriptCode = scriptCode;
180 }
181 }
183 // if this character is a close paired character,
184 // pop it from the stack
185 if (pairIndex >= 0 && (pairIndex & 1) != 0 && parenSP >= 0) {
186 parenSP -= 1;
187 startSP -= 1;
188 }
189 } else {
190 // if the run broke on a surrogate pair,
191 // end it before the high surrogate
192 if (ch >= 0x10000) {
193 scriptEnd -= 1;
194 }
196 break;
197 }
198 }
200 return true;
201 }
