Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : :
21 : : #include <cclass_unicode.hxx>
22 : : #include <unicode/uchar.h>
23 : : #include <rtl/math.hxx>
24 : : #include <rtl/ustring.hxx>
25 : : #include <com/sun/star/i18n/KParseTokens.hpp>
26 : : #include <com/sun/star/i18n/KParseType.hpp>
27 : : #include <com/sun/star/i18n/UnicodeType.hpp>
28 : : #include <com/sun/star/i18n/XLocaleData.hpp>
29 : : #include <com/sun/star/i18n/NativeNumberMode.hpp>
30 : :
31 : : #include <string.h> // memcpy()
32 : :
33 : : using namespace ::com::sun::star::uno;
34 : : using namespace ::com::sun::star::lang;
35 : : using namespace ::rtl;
36 : :
37 : : namespace com { namespace sun { namespace star { namespace i18n {
38 : :
39 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_ILLEGAL = 0x00000000;
40 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR = 0x00000001;
41 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_BOOL = 0x00000002;
42 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_WORD = 0x00000004;
43 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_VALUE = 0x00000008;
44 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_STRING = 0x00000010;
45 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_CHAR_DONTCARE= 0x00000020;
46 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_BOOL = 0x00000040;
47 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_WORD = 0x00000080;
48 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_WORD_SEP = 0x00000100;
49 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE = 0x00000200;
50 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_SEP = 0x00000400;
51 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_EXP = 0x00000800;
52 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_SIGN = 0x00001000;
53 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_EXP_VALUE = 0x00002000;
54 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_VALUE_DIGIT = 0x00004000;
55 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_NAME_SEP = 0x20000000;
56 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_STRING_SEP = 0x40000000;
57 : : const UPT_FLAG_TYPE cclass_Unicode::TOKEN_EXCLUDED = 0x80000000;
58 : :
59 : : #define TOKEN_DIGIT_FLAGS (TOKEN_CHAR_VALUE | TOKEN_VALUE | TOKEN_VALUE_EXP | TOKEN_VALUE_EXP_VALUE | TOKEN_VALUE_DIGIT)
60 : :
61 : : // Default identifier/name specification is [A-Za-z_][A-Za-z0-9_]*
62 : :
63 : : const sal_uInt8 cclass_Unicode::nDefCnt = 128;
64 : : const UPT_FLAG_TYPE cclass_Unicode::pDefaultParserTable[ nDefCnt ] =
65 : : {
66 : : // (...) == Calc formula compiler specific, commented out and modified
67 : :
68 : : /* \0 */ TOKEN_EXCLUDED,
69 : : TOKEN_ILLEGAL,
70 : : TOKEN_ILLEGAL,
71 : : TOKEN_ILLEGAL,
72 : : TOKEN_ILLEGAL,
73 : : TOKEN_ILLEGAL,
74 : : TOKEN_ILLEGAL,
75 : : TOKEN_ILLEGAL,
76 : : TOKEN_ILLEGAL,
77 : : /* 9 \t */ TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL)
78 : : TOKEN_ILLEGAL,
79 : : /* 11 \v */ TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL)
80 : : TOKEN_ILLEGAL,
81 : : TOKEN_ILLEGAL,
82 : : TOKEN_ILLEGAL,
83 : : TOKEN_ILLEGAL,
84 : : TOKEN_ILLEGAL,
85 : : TOKEN_ILLEGAL,
86 : : TOKEN_ILLEGAL,
87 : : TOKEN_ILLEGAL,
88 : : TOKEN_ILLEGAL,
89 : : TOKEN_ILLEGAL,
90 : : TOKEN_ILLEGAL,
91 : : TOKEN_ILLEGAL,
92 : : TOKEN_ILLEGAL,
93 : : TOKEN_ILLEGAL,
94 : : TOKEN_ILLEGAL,
95 : : TOKEN_ILLEGAL,
96 : : TOKEN_ILLEGAL,
97 : : TOKEN_ILLEGAL,
98 : : TOKEN_ILLEGAL,
99 : : TOKEN_ILLEGAL,
100 : : /* 32 */ TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
101 : : /* 33 ! */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
102 : : /* 34 " */ TOKEN_CHAR_STRING | TOKEN_STRING_SEP,
103 : : /* 35 # */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_WORD_SEP)
104 : : /* 36 $ */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_CHAR_WORD | TOKEN_WORD)
105 : : /* 37 % */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_VALUE)
106 : : /* 38 & */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
107 : : /* 39 ' */ TOKEN_NAME_SEP,
108 : : /* 40 ( */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
109 : : /* 41 ) */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
110 : : /* 42 * */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
111 : : /* 43 + */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP | TOKEN_VALUE_EXP | TOKEN_VALUE_SIGN,
112 : : /* 44 , */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_CHAR_VALUE | TOKEN_VALUE)
113 : : /* 45 - */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP | TOKEN_VALUE_EXP | TOKEN_VALUE_SIGN,
114 : : /* 46 . */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_WORD | TOKEN_CHAR_VALUE | TOKEN_VALUE)
115 : : /* 47 / */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
116 : : //for ( i = 48; i < 58; i++ )
117 : : /* 48 0 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
118 : : /* 49 1 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
119 : : /* 50 2 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
120 : : /* 51 3 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
121 : : /* 52 4 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
122 : : /* 53 5 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
123 : : /* 54 6 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
124 : : /* 55 7 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
125 : : /* 56 8 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
126 : : /* 57 9 */ TOKEN_DIGIT_FLAGS | TOKEN_WORD,
127 : : /* 58 : */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_WORD)
128 : : /* 59 ; */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
129 : : /* 60 < */ TOKEN_CHAR_BOOL | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
130 : : /* 61 = */ TOKEN_CHAR | TOKEN_BOOL | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
131 : : /* 62 > */ TOKEN_CHAR_BOOL | TOKEN_BOOL | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
132 : : /* 63 ? */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_CHAR_WORD | TOKEN_WORD)
133 : : /* 64 @ */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
134 : : //for ( i = 65; i < 91; i++ )
135 : : /* 65 A */ TOKEN_CHAR_WORD | TOKEN_WORD,
136 : : /* 66 B */ TOKEN_CHAR_WORD | TOKEN_WORD,
137 : : /* 67 C */ TOKEN_CHAR_WORD | TOKEN_WORD,
138 : : /* 68 D */ TOKEN_CHAR_WORD | TOKEN_WORD,
139 : : /* 69 E */ TOKEN_CHAR_WORD | TOKEN_WORD,
140 : : /* 70 F */ TOKEN_CHAR_WORD | TOKEN_WORD,
141 : : /* 71 G */ TOKEN_CHAR_WORD | TOKEN_WORD,
142 : : /* 72 H */ TOKEN_CHAR_WORD | TOKEN_WORD,
143 : : /* 73 I */ TOKEN_CHAR_WORD | TOKEN_WORD,
144 : : /* 74 J */ TOKEN_CHAR_WORD | TOKEN_WORD,
145 : : /* 75 K */ TOKEN_CHAR_WORD | TOKEN_WORD,
146 : : /* 76 L */ TOKEN_CHAR_WORD | TOKEN_WORD,
147 : : /* 77 M */ TOKEN_CHAR_WORD | TOKEN_WORD,
148 : : /* 78 N */ TOKEN_CHAR_WORD | TOKEN_WORD,
149 : : /* 79 O */ TOKEN_CHAR_WORD | TOKEN_WORD,
150 : : /* 80 P */ TOKEN_CHAR_WORD | TOKEN_WORD,
151 : : /* 81 Q */ TOKEN_CHAR_WORD | TOKEN_WORD,
152 : : /* 82 R */ TOKEN_CHAR_WORD | TOKEN_WORD,
153 : : /* 83 S */ TOKEN_CHAR_WORD | TOKEN_WORD,
154 : : /* 84 T */ TOKEN_CHAR_WORD | TOKEN_WORD,
155 : : /* 85 U */ TOKEN_CHAR_WORD | TOKEN_WORD,
156 : : /* 86 V */ TOKEN_CHAR_WORD | TOKEN_WORD,
157 : : /* 87 W */ TOKEN_CHAR_WORD | TOKEN_WORD,
158 : : /* 88 X */ TOKEN_CHAR_WORD | TOKEN_WORD,
159 : : /* 89 Y */ TOKEN_CHAR_WORD | TOKEN_WORD,
160 : : /* 90 Z */ TOKEN_CHAR_WORD | TOKEN_WORD,
161 : : /* 91 [ */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
162 : : /* 92 \ */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
163 : : /* 93 ] */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
164 : : /* 94 ^ */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP,
165 : : /* 95 _ */ TOKEN_CHAR_WORD | TOKEN_WORD,
166 : : /* 96 ` */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
167 : : //for ( i = 97; i < 123; i++ )
168 : : /* 97 a */ TOKEN_CHAR_WORD | TOKEN_WORD,
169 : : /* 98 b */ TOKEN_CHAR_WORD | TOKEN_WORD,
170 : : /* 99 c */ TOKEN_CHAR_WORD | TOKEN_WORD,
171 : : /* 100 d */ TOKEN_CHAR_WORD | TOKEN_WORD,
172 : : /* 101 e */ TOKEN_CHAR_WORD | TOKEN_WORD,
173 : : /* 102 f */ TOKEN_CHAR_WORD | TOKEN_WORD,
174 : : /* 103 g */ TOKEN_CHAR_WORD | TOKEN_WORD,
175 : : /* 104 h */ TOKEN_CHAR_WORD | TOKEN_WORD,
176 : : /* 105 i */ TOKEN_CHAR_WORD | TOKEN_WORD,
177 : : /* 106 j */ TOKEN_CHAR_WORD | TOKEN_WORD,
178 : : /* 107 k */ TOKEN_CHAR_WORD | TOKEN_WORD,
179 : : /* 108 l */ TOKEN_CHAR_WORD | TOKEN_WORD,
180 : : /* 109 m */ TOKEN_CHAR_WORD | TOKEN_WORD,
181 : : /* 110 n */ TOKEN_CHAR_WORD | TOKEN_WORD,
182 : : /* 111 o */ TOKEN_CHAR_WORD | TOKEN_WORD,
183 : : /* 112 p */ TOKEN_CHAR_WORD | TOKEN_WORD,
184 : : /* 113 q */ TOKEN_CHAR_WORD | TOKEN_WORD,
185 : : /* 114 r */ TOKEN_CHAR_WORD | TOKEN_WORD,
186 : : /* 115 s */ TOKEN_CHAR_WORD | TOKEN_WORD,
187 : : /* 116 t */ TOKEN_CHAR_WORD | TOKEN_WORD,
188 : : /* 117 u */ TOKEN_CHAR_WORD | TOKEN_WORD,
189 : : /* 118 v */ TOKEN_CHAR_WORD | TOKEN_WORD,
190 : : /* 119 w */ TOKEN_CHAR_WORD | TOKEN_WORD,
191 : : /* 120 x */ TOKEN_CHAR_WORD | TOKEN_WORD,
192 : : /* 121 y */ TOKEN_CHAR_WORD | TOKEN_WORD,
193 : : /* 122 z */ TOKEN_CHAR_WORD | TOKEN_WORD,
194 : : /* 123 { */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
195 : : /* 124 | */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
196 : : /* 125 } */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
197 : : /* 126 ~ */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP, // (TOKEN_ILLEGAL // UNUSED)
198 : : /* 127 */ TOKEN_CHAR | TOKEN_WORD_SEP | TOKEN_VALUE_SEP // (TOKEN_ILLEGAL // UNUSED)
199 : : };
200 : :
201 : :
202 : : const sal_Int32 cclass_Unicode::pParseTokensType[ nDefCnt ] =
203 : : {
204 : : /* \0 */ KParseTokens::ASC_OTHER,
205 : : KParseTokens::ASC_CONTROL,
206 : : KParseTokens::ASC_CONTROL,
207 : : KParseTokens::ASC_CONTROL,
208 : : KParseTokens::ASC_CONTROL,
209 : : KParseTokens::ASC_CONTROL,
210 : : KParseTokens::ASC_CONTROL,
211 : : KParseTokens::ASC_CONTROL,
212 : : KParseTokens::ASC_CONTROL,
213 : : /* 9 \t */ KParseTokens::ASC_CONTROL,
214 : : KParseTokens::ASC_CONTROL,
215 : : /* 11 \v */ KParseTokens::ASC_CONTROL,
216 : : KParseTokens::ASC_CONTROL,
217 : : KParseTokens::ASC_CONTROL,
218 : : KParseTokens::ASC_CONTROL,
219 : : KParseTokens::ASC_CONTROL,
220 : : KParseTokens::ASC_CONTROL,
221 : : KParseTokens::ASC_CONTROL,
222 : : KParseTokens::ASC_CONTROL,
223 : : KParseTokens::ASC_CONTROL,
224 : : KParseTokens::ASC_CONTROL,
225 : : KParseTokens::ASC_CONTROL,
226 : : KParseTokens::ASC_CONTROL,
227 : : KParseTokens::ASC_CONTROL,
228 : : KParseTokens::ASC_CONTROL,
229 : : KParseTokens::ASC_CONTROL,
230 : : KParseTokens::ASC_CONTROL,
231 : : KParseTokens::ASC_CONTROL,
232 : : KParseTokens::ASC_CONTROL,
233 : : KParseTokens::ASC_CONTROL,
234 : : KParseTokens::ASC_CONTROL,
235 : : KParseTokens::ASC_CONTROL,
236 : : /* 32 */ KParseTokens::ASC_OTHER,
237 : : /* 33 ! */ KParseTokens::ASC_OTHER,
238 : : /* 34 " */ KParseTokens::ASC_OTHER,
239 : : /* 35 # */ KParseTokens::ASC_OTHER,
240 : : /* 36 $ */ KParseTokens::ASC_DOLLAR,
241 : : /* 37 % */ KParseTokens::ASC_OTHER,
242 : : /* 38 & */ KParseTokens::ASC_OTHER,
243 : : /* 39 ' */ KParseTokens::ASC_OTHER,
244 : : /* 40 ( */ KParseTokens::ASC_OTHER,
245 : : /* 41 ) */ KParseTokens::ASC_OTHER,
246 : : /* 42 * */ KParseTokens::ASC_OTHER,
247 : : /* 43 + */ KParseTokens::ASC_OTHER,
248 : : /* 44 , */ KParseTokens::ASC_OTHER,
249 : : /* 45 - */ KParseTokens::ASC_OTHER,
250 : : /* 46 . */ KParseTokens::ASC_DOT,
251 : : /* 47 / */ KParseTokens::ASC_OTHER,
252 : : //for ( i = 48; i < 58; i++ )
253 : : /* 48 0 */ KParseTokens::ASC_DIGIT,
254 : : /* 49 1 */ KParseTokens::ASC_DIGIT,
255 : : /* 50 2 */ KParseTokens::ASC_DIGIT,
256 : : /* 51 3 */ KParseTokens::ASC_DIGIT,
257 : : /* 52 4 */ KParseTokens::ASC_DIGIT,
258 : : /* 53 5 */ KParseTokens::ASC_DIGIT,
259 : : /* 54 6 */ KParseTokens::ASC_DIGIT,
260 : : /* 55 7 */ KParseTokens::ASC_DIGIT,
261 : : /* 56 8 */ KParseTokens::ASC_DIGIT,
262 : : /* 57 9 */ KParseTokens::ASC_DIGIT,
263 : : /* 58 : */ KParseTokens::ASC_COLON,
264 : : /* 59 ; */ KParseTokens::ASC_OTHER,
265 : : /* 60 < */ KParseTokens::ASC_OTHER,
266 : : /* 61 = */ KParseTokens::ASC_OTHER,
267 : : /* 62 > */ KParseTokens::ASC_OTHER,
268 : : /* 63 ? */ KParseTokens::ASC_OTHER,
269 : : /* 64 @ */ KParseTokens::ASC_OTHER,
270 : : //for ( i = 65; i < 91; i++ )
271 : : /* 65 A */ KParseTokens::ASC_UPALPHA,
272 : : /* 66 B */ KParseTokens::ASC_UPALPHA,
273 : : /* 67 C */ KParseTokens::ASC_UPALPHA,
274 : : /* 68 D */ KParseTokens::ASC_UPALPHA,
275 : : /* 69 E */ KParseTokens::ASC_UPALPHA,
276 : : /* 70 F */ KParseTokens::ASC_UPALPHA,
277 : : /* 71 G */ KParseTokens::ASC_UPALPHA,
278 : : /* 72 H */ KParseTokens::ASC_UPALPHA,
279 : : /* 73 I */ KParseTokens::ASC_UPALPHA,
280 : : /* 74 J */ KParseTokens::ASC_UPALPHA,
281 : : /* 75 K */ KParseTokens::ASC_UPALPHA,
282 : : /* 76 L */ KParseTokens::ASC_UPALPHA,
283 : : /* 77 M */ KParseTokens::ASC_UPALPHA,
284 : : /* 78 N */ KParseTokens::ASC_UPALPHA,
285 : : /* 79 O */ KParseTokens::ASC_UPALPHA,
286 : : /* 80 P */ KParseTokens::ASC_UPALPHA,
287 : : /* 81 Q */ KParseTokens::ASC_UPALPHA,
288 : : /* 82 R */ KParseTokens::ASC_UPALPHA,
289 : : /* 83 S */ KParseTokens::ASC_UPALPHA,
290 : : /* 84 T */ KParseTokens::ASC_UPALPHA,
291 : : /* 85 U */ KParseTokens::ASC_UPALPHA,
292 : : /* 86 V */ KParseTokens::ASC_UPALPHA,
293 : : /* 87 W */ KParseTokens::ASC_UPALPHA,
294 : : /* 88 X */ KParseTokens::ASC_UPALPHA,
295 : : /* 89 Y */ KParseTokens::ASC_UPALPHA,
296 : : /* 90 Z */ KParseTokens::ASC_UPALPHA,
297 : : /* 91 [ */ KParseTokens::ASC_OTHER,
298 : : /* 92 \ */ KParseTokens::ASC_OTHER,
299 : : /* 93 ] */ KParseTokens::ASC_OTHER,
300 : : /* 94 ^ */ KParseTokens::ASC_OTHER,
301 : : /* 95 _ */ KParseTokens::ASC_UNDERSCORE,
302 : : /* 96 ` */ KParseTokens::ASC_OTHER,
303 : : //for ( i = 97; i < 123; i++ )
304 : : /* 97 a */ KParseTokens::ASC_LOALPHA,
305 : : /* 98 b */ KParseTokens::ASC_LOALPHA,
306 : : /* 99 c */ KParseTokens::ASC_LOALPHA,
307 : : /* 100 d */ KParseTokens::ASC_LOALPHA,
308 : : /* 101 e */ KParseTokens::ASC_LOALPHA,
309 : : /* 102 f */ KParseTokens::ASC_LOALPHA,
310 : : /* 103 g */ KParseTokens::ASC_LOALPHA,
311 : : /* 104 h */ KParseTokens::ASC_LOALPHA,
312 : : /* 105 i */ KParseTokens::ASC_LOALPHA,
313 : : /* 106 j */ KParseTokens::ASC_LOALPHA,
314 : : /* 107 k */ KParseTokens::ASC_LOALPHA,
315 : : /* 108 l */ KParseTokens::ASC_LOALPHA,
316 : : /* 109 m */ KParseTokens::ASC_LOALPHA,
317 : : /* 110 n */ KParseTokens::ASC_LOALPHA,
318 : : /* 111 o */ KParseTokens::ASC_LOALPHA,
319 : : /* 112 p */ KParseTokens::ASC_LOALPHA,
320 : : /* 113 q */ KParseTokens::ASC_LOALPHA,
321 : : /* 114 r */ KParseTokens::ASC_LOALPHA,
322 : : /* 115 s */ KParseTokens::ASC_LOALPHA,
323 : : /* 116 t */ KParseTokens::ASC_LOALPHA,
324 : : /* 117 u */ KParseTokens::ASC_LOALPHA,
325 : : /* 118 v */ KParseTokens::ASC_LOALPHA,
326 : : /* 119 w */ KParseTokens::ASC_LOALPHA,
327 : : /* 120 x */ KParseTokens::ASC_LOALPHA,
328 : : /* 121 y */ KParseTokens::ASC_LOALPHA,
329 : : /* 122 z */ KParseTokens::ASC_LOALPHA,
330 : : /* 123 { */ KParseTokens::ASC_OTHER,
331 : : /* 124 | */ KParseTokens::ASC_OTHER,
332 : : /* 125 } */ KParseTokens::ASC_OTHER,
333 : : /* 126 ~ */ KParseTokens::ASC_OTHER,
334 : : /* 127 */ KParseTokens::ASC_OTHER
335 : : };
336 : :
337 : :
338 : : // static
339 : 45 : const sal_Unicode* cclass_Unicode::StrChr( const sal_Unicode* pStr, sal_Unicode c )
340 : : {
341 [ - + ]: 45 : if ( !pStr )
342 : 0 : return NULL;
343 [ + + ]: 135 : while ( *pStr )
344 : : {
345 [ - + ]: 90 : if ( *pStr == c )
346 : 0 : return pStr;
347 : 90 : pStr++;
348 : : }
349 : 45 : return NULL;
350 : : }
351 : :
352 : :
353 : 211712 : sal_Int32 cclass_Unicode::getParseTokensType( const sal_Unicode* aStr, sal_Int32 nPos )
354 : : {
355 : 211712 : sal_Unicode c = aStr[nPos];
356 [ + + ]: 211712 : if ( c < nDefCnt )
357 : 210596 : return pParseTokensType[ sal_uInt8(c) ];
358 : : else
359 : : {
360 : :
361 : : //! all KParseTokens::UNI_... must be matched
362 [ - + - - : 1116 : switch ( u_charType( (sal_uInt32) c ) )
- - - - -
+ ]
363 : : {
364 : : case U_UPPERCASE_LETTER :
365 : 0 : return KParseTokens::UNI_UPALPHA;
366 : : case U_LOWERCASE_LETTER :
367 : 558 : return KParseTokens::UNI_LOALPHA;
368 : : case U_TITLECASE_LETTER :
369 : 0 : return KParseTokens::UNI_TITLE_ALPHA;
370 : : case U_MODIFIER_LETTER :
371 : 0 : return KParseTokens::UNI_MODIFIER_LETTER;
372 : : case U_OTHER_LETTER :
373 : : // Non_Spacing_Mark could not be as leading character
374 [ # # ]: 0 : if (nPos == 0) break;
375 : : // fall through, treat it as Other_Letter.
376 : : case U_NON_SPACING_MARK :
377 : 0 : return KParseTokens::UNI_OTHER_LETTER;
378 : : case U_DECIMAL_DIGIT_NUMBER :
379 : 0 : return KParseTokens::UNI_DIGIT;
380 : : case U_LETTER_NUMBER :
381 : 0 : return KParseTokens::UNI_LETTER_NUMBER;
382 : : case U_OTHER_NUMBER :
383 : 0 : return KParseTokens::UNI_OTHER_NUMBER;
384 : : }
385 : :
386 : 211712 : return KParseTokens::UNI_OTHER;
387 : : }
388 : : }
389 : :
390 : 27776 : sal_Bool cclass_Unicode::setupInternational( const Locale& rLocale )
391 : : {
392 : 27776 : sal_Bool bChanged = (aParserLocale.Language != rLocale.Language
393 : 2238 : || aParserLocale.Country != rLocale.Country
394 [ - + ]: 30014 : || aParserLocale.Variant != rLocale.Variant);
[ + + + - ]
395 [ + + ]: 27776 : if ( bChanged )
396 : : {
397 : 25538 : aParserLocale.Language = rLocale.Language;
398 : 25538 : aParserLocale.Country = rLocale.Country;
399 : 25538 : aParserLocale.Variant = rLocale.Variant;
400 : : }
401 [ + + ][ + - ]: 27776 : if ( !xLocaleData.is() && xMSF.is() )
[ + + ]
402 : : {
403 : : Reference <
404 : : XInterface > xI =
405 [ + - ]: 25538 : xMSF->createInstance( OUString(
406 [ + - ][ + - ]: 25538 : RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.i18n.LocaleData" ) ) );
407 [ + - ]: 25538 : if ( xI.is() )
408 : : {
409 [ + - ][ + - ]: 25538 : Any x = xI->queryInterface( getCppuType((const Reference< XLocaleData>*)0) );
[ + - ]
410 [ + - ]: 25538 : x >>= xLocaleData;
411 : 25538 : }
412 : : }
413 : 27776 : return bChanged;
414 : : }
415 : :
416 : :
417 : 52982 : void cclass_Unicode::setupParserTable( const Locale& rLocale, sal_Int32 startCharTokenType,
418 : : const OUString& userDefinedCharactersStart, sal_Int32 contCharTokenType,
419 : : const OUString& userDefinedCharactersCont )
420 : : {
421 : 52982 : bool bIntlEqual = (rLocale.Language == aParserLocale.Language &&
422 : 27444 : rLocale.Country == aParserLocale.Country &&
423 [ + - ]: 80426 : rLocale.Variant == aParserLocale.Variant);
[ + + + - ]
424 [ + + ][ + - ]: 103394 : if ( !pTable || !bIntlEqual ||
[ + + ][ + -
+ - - + ]
[ + + ]
425 : : startCharTokenType != nStartTypes ||
426 : : contCharTokenType != nContTypes ||
427 : 25206 : userDefinedCharactersStart != aStartChars ||
428 : 25206 : userDefinedCharactersCont != aContChars )
429 : : initParserTable( rLocale, startCharTokenType, userDefinedCharactersStart,
430 : 27776 : contCharTokenType, userDefinedCharactersCont );
431 : 52982 : }
432 : :
433 : :
434 : 27776 : void cclass_Unicode::initParserTable( const Locale& rLocale, sal_Int32 startCharTokenType,
435 : : const OUString& userDefinedCharactersStart, sal_Int32 contCharTokenType,
436 : : const OUString& userDefinedCharactersCont )
437 : : {
438 : : // (Re)Init
439 : 27776 : setupInternational( rLocale );
440 : : // Memory of pTable is reused.
441 [ + + ]: 27776 : if ( !pTable )
442 : 25538 : pTable = new UPT_FLAG_TYPE[nDefCnt];
443 : 27776 : memcpy( pTable, pDefaultParserTable, sizeof(UPT_FLAG_TYPE) * nDefCnt );
444 : : // Start and cont tables only need reallocation if different length.
445 [ + + ][ + - ]: 27776 : if ( pStart && userDefinedCharactersStart.getLength() != aStartChars.getLength() )
[ + + ]
446 : : {
447 [ + - ]: 3 : delete [] pStart;
448 : 3 : pStart = NULL;
449 : : }
450 [ + + ][ + - ]: 27776 : if ( pCont && userDefinedCharactersCont.getLength() != aContChars.getLength() )
[ + + ]
451 : : {
452 [ + - ]: 3 : delete [] pCont;
453 : 3 : pCont = NULL;
454 : : }
455 : 27776 : nStartTypes = startCharTokenType;
456 : 27776 : nContTypes = contCharTokenType;
457 : 27776 : aStartChars = userDefinedCharactersStart;
458 : 27776 : aContChars = userDefinedCharactersCont;
459 : :
460 : : // specials
461 [ + - ]: 27776 : if( xLocaleData.is() )
462 : : {
463 : : LocaleDataItem aItem =
464 [ + - ][ + - ]: 27776 : xLocaleData->getLocaleItem( aParserLocale );
465 : : //!TODO: theoretically separators may be a string, adjustment would have to be
466 : : //! done here and in parsing and in ::rtl::math::stringToDouble()
467 : 27776 : cGroupSep = aItem.thousandSeparator.getStr()[0];
468 : 27776 : cDecimalSep = aItem.decimalSeparator.getStr()[0];
469 : : }
470 : :
471 [ + - ]: 27776 : if ( cGroupSep < nDefCnt )
472 : 27776 : pTable[cGroupSep] |= TOKEN_VALUE;
473 [ + - ]: 27776 : if ( cDecimalSep < nDefCnt )
474 : 27776 : pTable[cDecimalSep] |= TOKEN_CHAR_VALUE | TOKEN_VALUE;
475 : :
476 : : // Modify characters according to KParseTokens definitions.
477 : : {
478 : : using namespace KParseTokens;
479 : : sal_uInt8 i;
480 : :
481 [ + + ]: 27776 : if ( !(nStartTypes & ASC_UPALPHA) )
482 [ + + ]: 60264 : for ( i = 65; i < 91; i++ )
483 : 58032 : pTable[i] &= ~TOKEN_CHAR_WORD; // not allowed as start character
484 [ + + ]: 27776 : if ( !(nContTypes & ASC_UPALPHA) )
485 [ + + ]: 60264 : for ( i = 65; i < 91; i++ )
486 : 58032 : pTable[i] &= ~TOKEN_WORD; // not allowed as cont character
487 : :
488 [ + + ]: 27776 : if ( !(nStartTypes & ASC_LOALPHA) )
489 [ + + ]: 60264 : for ( i = 97; i < 123; i++ )
490 : 58032 : pTable[i] &= ~TOKEN_CHAR_WORD; // not allowed as start character
491 [ + + ]: 27776 : if ( !(nContTypes & ASC_LOALPHA) )
492 [ + + ]: 60264 : for ( i = 97; i < 123; i++ )
493 : 58032 : pTable[i] &= ~TOKEN_WORD; // not allowed as cont character
494 : :
495 [ + - ]: 27776 : if ( nStartTypes & ASC_DIGIT )
496 [ + + ]: 305536 : for ( i = 48; i < 58; i++ )
497 : 277760 : pTable[i] |= TOKEN_CHAR_WORD; // allowed as start character
498 [ - + ]: 27776 : if ( !(nContTypes & ASC_DIGIT) )
499 [ # # ]: 0 : for ( i = 48; i < 58; i++ )
500 : 0 : pTable[i] &= ~TOKEN_WORD; // not allowed as cont character
501 : :
502 [ + + ]: 27776 : if ( !(nStartTypes & ASC_UNDERSCORE) )
503 : 27736 : pTable[95] &= ~TOKEN_CHAR_WORD; // not allowed as start character
504 [ + + ]: 27776 : if ( !(nContTypes & ASC_UNDERSCORE) )
505 : 27736 : pTable[95] &= ~TOKEN_WORD; // not allowed as cont character
506 : :
507 [ + + ]: 27776 : if ( nStartTypes & ASC_DOLLAR )
508 : 3 : pTable[36] |= TOKEN_CHAR_WORD; // allowed as start character
509 [ + + ]: 27776 : if ( nContTypes & ASC_DOLLAR )
510 : 3 : pTable[36] |= TOKEN_WORD; // allowed as cont character
511 : :
512 [ - + ]: 27776 : if ( nStartTypes & ASC_DOT )
513 : 0 : pTable[46] |= TOKEN_CHAR_WORD; // allowed as start character
514 [ + + ]: 27776 : if ( nContTypes & ASC_DOT )
515 : 27747 : pTable[46] |= TOKEN_WORD; // allowed as cont character
516 : :
517 [ - + ]: 27776 : if ( nStartTypes & ASC_COLON )
518 : 0 : pTable[58] |= TOKEN_CHAR_WORD; // allowed as start character
519 [ - + ]: 27776 : if ( nContTypes & ASC_COLON )
520 : 0 : pTable[58] |= TOKEN_WORD; // allowed as cont character
521 : :
522 [ - + ]: 27776 : if ( nStartTypes & ASC_CONTROL )
523 [ # # ]: 0 : for ( i = 1; i < 32; i++ )
524 : 0 : pTable[i] |= TOKEN_CHAR_WORD; // allowed as start character
525 [ - + ]: 27776 : if ( nContTypes & ASC_CONTROL )
526 [ # # ]: 0 : for ( i = 1; i < 32; i++ )
527 : 0 : pTable[i] |= TOKEN_WORD; // allowed as cont character
528 : :
529 [ - + ]: 27776 : if ( nStartTypes & ASC_ANY_BUT_CONTROL )
530 [ # # ]: 0 : for ( i = 32; i < nDefCnt; i++ )
531 : 0 : pTable[i] |= TOKEN_CHAR_WORD; // allowed as start character
532 [ - + ]: 27776 : if ( nContTypes & ASC_ANY_BUT_CONTROL )
533 [ # # ]: 0 : for ( i = 32; i < nDefCnt; i++ )
534 : 0 : pTable[i] |= TOKEN_WORD; // allowed as cont character
535 : :
536 : : }
537 : :
538 : : // Merge in (positively override with) user defined characters.
539 : : // StartChars
540 : 27776 : sal_Int32 nLen = aStartChars.getLength();
541 [ + + ]: 27776 : if ( nLen )
542 : : {
543 [ + - ]: 3 : if ( !pStart )
544 : 3 : pStart = new UPT_FLAG_TYPE[ nLen ];
545 : 3 : const sal_Unicode* p = aStartChars.getStr();
546 [ + + ]: 9 : for ( sal_Int32 j=0; j<nLen; j++, p++ )
547 : : {
548 : 6 : pStart[j] = TOKEN_CHAR_WORD;
549 [ + - ]: 6 : if ( *p < nDefCnt )
550 : 6 : pTable[*p] |= TOKEN_CHAR_WORD;
551 : : }
552 : : }
553 : : // ContChars
554 : 27776 : nLen = aContChars.getLength();
555 [ + + ]: 27776 : if ( nLen )
556 : : {
557 [ + - ]: 3 : if ( !pCont )
558 : 3 : pCont = new UPT_FLAG_TYPE[ nLen ];
559 : 3 : const sal_Unicode* p = aContChars.getStr();
560 [ + + ]: 9 : for ( sal_Int32 j=0; j<nLen; j++ )
561 : : {
562 : 6 : pCont[j] = TOKEN_WORD;
563 [ + - ]: 6 : if ( *p < nDefCnt )
564 : 6 : pTable[*p] |= TOKEN_WORD;
565 : : }
566 : : }
567 : 27776 : }
568 : :
569 : :
570 : 34612 : void cclass_Unicode::destroyParserTable()
571 : : {
572 [ - + ]: 34612 : if ( pCont )
573 [ # # ]: 0 : delete [] pCont;
574 [ - + ]: 34612 : if ( pStart )
575 [ # # ]: 0 : delete [] pStart;
576 [ + + ]: 34612 : if ( pTable )
577 [ + - ]: 25519 : delete [] pTable;
578 : 34612 : }
579 : :
580 : :
581 : 211712 : UPT_FLAG_TYPE cclass_Unicode::getFlags( const sal_Unicode* aStr, sal_Int32 nPos )
582 : : {
583 : : UPT_FLAG_TYPE nMask;
584 : 211712 : sal_Unicode c = aStr[nPos];
585 [ + + ]: 211712 : if ( c < nDefCnt )
586 : 210596 : nMask = pTable[ sal_uInt8(c) ];
587 : : else
588 : 1116 : nMask = getFlagsExtended( aStr, nPos );
589 [ + + + ]: 211712 : switch ( eState )
590 : : {
591 : : case ssGetChar :
592 : : case ssRewindFromValue :
593 : : case ssIgnoreLeadingInRewind :
594 : : case ssGetWordFirstChar :
595 [ + + ]: 52994 : if ( !(nMask & TOKEN_CHAR_WORD) )
596 : : {
597 : 14116 : nMask |= getStartCharsFlags( c );
598 [ - + ]: 14116 : if ( nMask & TOKEN_CHAR_WORD )
599 : 0 : nMask &= ~TOKEN_EXCLUDED;
600 : : }
601 : 52994 : break;
602 : : case ssGetValue :
603 : : case ssGetWord :
604 [ + + ]: 158454 : if ( !(nMask & TOKEN_WORD) )
605 : : {
606 : 13575 : nMask |= getContCharsFlags( c );
607 [ - + ]: 13575 : if ( nMask & TOKEN_WORD )
608 : 0 : nMask &= ~TOKEN_EXCLUDED;
609 : : }
610 : 158454 : break;
611 : : default:
612 : : ; // other cases aren't needed, no compiler warning
613 : : }
614 : 211712 : return nMask;
615 : : }
616 : :
617 : :
618 : 1116 : UPT_FLAG_TYPE cclass_Unicode::getFlagsExtended( const sal_Unicode* aStr, sal_Int32 nPos )
619 : : {
620 : 1116 : sal_Unicode c = aStr[nPos];
621 [ - + ]: 1116 : if ( c == cGroupSep )
622 : 0 : return TOKEN_VALUE;
623 [ - + ]: 1116 : else if ( c == cDecimalSep )
624 : 0 : return TOKEN_CHAR_VALUE | TOKEN_VALUE;
625 : : using namespace i18n;
626 : : bool bStart = (eState == ssGetChar || eState == ssGetWordFirstChar ||
627 [ + + ][ + - ]: 1116 : eState == ssRewindFromValue || eState == ssIgnoreLeadingInRewind);
[ + - ][ - + ]
628 [ + + ]: 1116 : sal_Int32 nTypes = (bStart ? nStartTypes : nContTypes);
629 : :
630 : : //! all KParseTokens::UNI_... must be matched
631 [ - + - - : 1116 : switch ( u_charType( (sal_uInt32) c ) )
- - - - -
- + ]
632 : : {
633 : : case U_UPPERCASE_LETTER :
634 : : return (nTypes & KParseTokens::UNI_UPALPHA) ?
635 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
636 [ # # ][ # # ]: 0 : TOKEN_ILLEGAL;
637 : : case U_LOWERCASE_LETTER :
638 : : return (nTypes & KParseTokens::UNI_LOALPHA) ?
639 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
640 [ + - ][ + + ]: 558 : TOKEN_ILLEGAL;
641 : : case U_TITLECASE_LETTER :
642 : : return (nTypes & KParseTokens::UNI_TITLE_ALPHA) ?
643 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
644 [ # # ][ # # ]: 0 : TOKEN_ILLEGAL;
645 : : case U_MODIFIER_LETTER :
646 : : return (nTypes & KParseTokens::UNI_MODIFIER_LETTER) ?
647 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
648 [ # # ][ # # ]: 0 : TOKEN_ILLEGAL;
649 : : case U_NON_SPACING_MARK :
650 : : case U_COMBINING_SPACING_MARK :
651 : : // Non_Spacing_Mark can't be a leading character,
652 : : // nor can a spacing combining mark.
653 [ # # ]: 0 : if (bStart)
654 : 0 : return TOKEN_ILLEGAL;
655 : : // fall through, treat it as Other_Letter.
656 : : case U_OTHER_LETTER :
657 : : return (nTypes & KParseTokens::UNI_OTHER_LETTER) ?
658 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
659 [ # # ][ # # ]: 0 : TOKEN_ILLEGAL;
660 : : case U_DECIMAL_DIGIT_NUMBER :
661 : : return ((nTypes & KParseTokens::UNI_DIGIT) ?
662 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
663 [ # # ][ # # ]: 0 : TOKEN_ILLEGAL) | TOKEN_DIGIT_FLAGS;
664 : : case U_LETTER_NUMBER :
665 : : return ((nTypes & KParseTokens::UNI_LETTER_NUMBER) ?
666 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
667 [ # # ][ # # ]: 0 : TOKEN_ILLEGAL) | TOKEN_DIGIT_FLAGS;
668 : : case U_OTHER_NUMBER :
669 : : return ((nTypes & KParseTokens::UNI_OTHER_NUMBER) ?
670 : : (bStart ? TOKEN_CHAR_WORD : TOKEN_WORD) :
671 [ # # ][ # # ]: 0 : TOKEN_ILLEGAL) | TOKEN_DIGIT_FLAGS;
672 : : case U_SPACE_SEPARATOR :
673 : : return ((nTypes & KParseTokens::IGNORE_LEADING_WS) ?
674 [ # # ][ # # ]: 0 : TOKEN_CHAR_DONTCARE : (bStart ? TOKEN_CHAR_WORD : (TOKEN_CHAR_DONTCARE | TOKEN_WORD_SEP | TOKEN_VALUE_SEP) ));
675 : : }
676 : :
677 : 1116 : return TOKEN_ILLEGAL;
678 : : }
679 : :
680 : :
681 : 14116 : UPT_FLAG_TYPE cclass_Unicode::getStartCharsFlags( sal_Unicode c )
682 : : {
683 [ - + ]: 14116 : if ( pStart )
684 : : {
685 : 0 : const sal_Unicode* pStr = aStartChars.getStr();
686 : 0 : const sal_Unicode* p = StrChr( pStr, c );
687 [ # # ]: 0 : if ( p )
688 : 0 : return pStart[ p - pStr ];
689 : : }
690 : 14116 : return TOKEN_ILLEGAL;
691 : : }
692 : :
693 : :
694 : 13575 : UPT_FLAG_TYPE cclass_Unicode::getContCharsFlags( sal_Unicode c )
695 : : {
696 [ + + ]: 13575 : if ( pCont )
697 : : {
698 : 45 : const sal_Unicode* pStr = aContChars.getStr();
699 : 45 : const sal_Unicode* p = StrChr( pStr, c );
700 [ - + ]: 45 : if ( p )
701 : 0 : return pCont[ p - pStr ];
702 : : }
703 : 13575 : return TOKEN_ILLEGAL;
704 : : }
705 : :
706 : :
707 : 52982 : void cclass_Unicode::parseText( ParseResult& r, const OUString& rText, sal_Int32 nPos, sal_Int32 nTokenType )
708 : : {
709 : : using namespace i18n;
710 : 52982 : const sal_Unicode* const pTextStart = rText.getStr() + nPos;
711 : 52982 : eState = ssGetChar;
712 : :
713 : : //! All the variables below (plus ParseResult) have to be resetted on ssRewindFromValue!
714 : 52982 : const sal_Unicode* pSym = pTextStart;
715 : 52982 : const sal_Unicode* pSrc = pSym;
716 : 52982 : OUString aSymbol;
717 : 52982 : sal_Unicode c = *pSrc;
718 : 52982 : sal_Unicode cLast = 0;
719 : 52982 : int nDecSeps = 0;
720 : 52982 : bool bQuote = false;
721 : 52982 : bool bMightBeWord = true;
722 : 52982 : bool bMightBeWordLast = true;
723 : : //! All the variables above (plus ParseResult) have to be resetted on ssRewindFromValue!
724 : :
725 [ + + ][ + + ]: 264694 : while ( (c != 0) && (eState != ssStop) )
[ + + ]
726 : : {
727 [ + - ]: 211712 : UPT_FLAG_TYPE nMask = getFlags( pTextStart, pSrc - pTextStart );
728 [ - + ]: 211712 : if ( nMask & TOKEN_EXCLUDED )
729 : 0 : eState = ssBounce;
730 [ + + ]: 211712 : if ( bMightBeWord )
731 : : { // only relevant for ssGetValue fall back
732 [ + + ][ + - ]: 211412 : if ( eState == ssGetChar || eState == ssRewindFromValue ||
[ - + ]
733 : : eState == ssIgnoreLeadingInRewind )
734 : 52994 : bMightBeWord = ((nMask & TOKEN_CHAR_WORD) != 0);
735 : : else
736 : 211412 : bMightBeWord = ((nMask & TOKEN_WORD) != 0);
737 : : }
738 [ + - ]: 211712 : sal_Int32 nParseTokensType = getParseTokensType( pTextStart, pSrc - pTextStart );
739 : 211712 : pSrc++;
740 [ + + - + : 211712 : switch (eState)
+ + - - ]
741 : : {
742 : : case ssGetChar :
743 : : case ssRewindFromValue :
744 : : case ssIgnoreLeadingInRewind :
745 : : {
746 [ + + ][ + - ]: 52994 : if ( (nMask & TOKEN_CHAR_VALUE) && eState != ssRewindFromValue
[ + - ]
747 : : && eState != ssIgnoreLeadingInRewind )
748 : : { //! must be first, may fall back to ssGetWord via bMightBeWord
749 : 4500 : eState = ssGetValue;
750 [ + - ]: 9000 : if ( nMask & TOKEN_VALUE_DIGIT )
751 : : {
752 [ - + ]: 4500 : if ( 128 <= c )
753 : 0 : r.TokenType = KParseType::UNI_NUMBER;
754 : : else
755 : 4500 : r.TokenType = KParseType::ASC_NUMBER;
756 : : }
757 [ # # ]: 0 : else if ( c == cDecimalSep )
758 : : {
759 [ # # ]: 0 : if ( *pSrc )
760 : 0 : ++nDecSeps;
761 : : else
762 : 0 : eState = ssRewindFromValue;
763 : : // retry for ONE_SINGLE_CHAR or others
764 : : }
765 : : }
766 [ + + ]: 48494 : else if ( nMask & TOKEN_CHAR_WORD )
767 : : {
768 : 34378 : eState = ssGetWord;
769 : 34378 : r.TokenType = KParseType::IDENTNAME;
770 : : }
771 [ - + ]: 14116 : else if ( nMask & TOKEN_NAME_SEP )
772 : : {
773 : 0 : eState = ssGetWordFirstChar;
774 : 0 : bQuote = true;
775 : 0 : pSym++;
776 : 0 : nParseTokensType = 0; // will be taken of first real character
777 : 0 : r.TokenType = KParseType::SINGLE_QUOTE_NAME;
778 : : }
779 [ + + ]: 14116 : else if ( nMask & TOKEN_CHAR_STRING )
780 : : {
781 : 6 : eState = ssGetString;
782 : 6 : pSym++;
783 : 6 : nParseTokensType = 0; // will be taken of first real character
784 : 6 : r.TokenType = KParseType::DOUBLE_QUOTE_STRING;
785 : : }
786 [ + + ]: 14110 : else if ( nMask & TOKEN_CHAR_DONTCARE )
787 : : {
788 [ + - ]: 12 : if ( nStartTypes & KParseTokens::IGNORE_LEADING_WS )
789 : : {
790 [ - + ]: 12 : if (eState == ssRewindFromValue)
791 : 0 : eState = ssIgnoreLeadingInRewind;
792 : 12 : r.LeadingWhiteSpace++;
793 : 12 : pSym++;
794 : 12 : nParseTokensType = 0; // wait until real character
795 : 12 : bMightBeWord = true;
796 : : }
797 : : else
798 : 0 : eState = ssBounce;
799 : : }
800 [ + + ]: 14098 : else if ( nMask & TOKEN_CHAR_BOOL )
801 : : {
802 : 252 : eState = ssGetBool;
803 : 252 : r.TokenType = KParseType::BOOLEAN;
804 : : }
805 [ + + ]: 13846 : else if ( nMask & TOKEN_CHAR )
806 : : { //! must be last
807 : 13324 : eState = ssStop;
808 : 13324 : r.TokenType = KParseType::ONE_SINGLE_CHAR;
809 : : }
810 : : else
811 : 522 : eState = ssBounce; // not known
812 : : }
813 : 52994 : break;
814 : : case ssGetValue :
815 : : {
816 [ - + ]: 4536 : if ( nMask & TOKEN_VALUE_DIGIT )
817 : : {
818 [ # # ]: 0 : if ( 128 <= c )
819 : 0 : r.TokenType = KParseType::UNI_NUMBER;
820 [ # # ]: 0 : else if ( r.TokenType != KParseType::UNI_NUMBER )
821 : 0 : r.TokenType = KParseType::ASC_NUMBER;
822 : : }
823 [ + + ]: 4536 : if ( nMask & TOKEN_VALUE )
824 : : {
825 [ - + ][ # # ]: 36 : if ( c == cDecimalSep && ++nDecSeps > 1 )
[ - + ]
826 : : {
827 [ # # ]: 0 : if ( pSrc - pTextStart == 2 )
828 : 0 : eState = ssRewindFromValue;
829 : : // consecutive separators
830 : : else
831 : 0 : eState = ssStopBack;
832 : : }
833 : : // else keep it going
834 : : }
835 [ + - ][ - + ]: 4500 : else if ( c == 'E' || c == 'e' )
836 : : {
837 [ # # ]: 0 : UPT_FLAG_TYPE nNext = getFlags( pTextStart, pSrc - pTextStart );
838 [ # # ]: 0 : if ( nNext & TOKEN_VALUE_EXP )
839 : : ; // keep it going
840 [ # # ][ # # ]: 0 : else if ( bMightBeWord && ((nNext & TOKEN_WORD) || !*pSrc) )
[ # # ]
841 : : { // might be a numerical name (1.2efg)
842 : 0 : eState = ssGetWord;
843 : 0 : r.TokenType = KParseType::IDENTNAME;
844 : : }
845 : : else
846 : 0 : eState = ssStopBack;
847 : : }
848 [ + + ]: 4500 : else if ( nMask & TOKEN_VALUE_SIGN )
849 : : {
850 [ + - ][ - + ]: 108 : if ( (cLast == 'E') || (cLast == 'e') )
851 : : {
852 [ # # ]: 0 : UPT_FLAG_TYPE nNext = getFlags( pTextStart, pSrc - pTextStart );
853 [ # # ]: 0 : if ( nNext & TOKEN_VALUE_EXP_VALUE )
854 : : ; // keep it going
855 [ # # ][ # # ]: 0 : else if ( bMightBeWord && ((nNext & TOKEN_WORD) || !*pSrc) )
[ # # ]
856 : : { // might be a numerical name (1.2e+fg)
857 : 0 : eState = ssGetWord;
858 : 0 : r.TokenType = KParseType::IDENTNAME;
859 : : }
860 : : else
861 : 0 : eState = ssStopBack;
862 : : }
863 [ - + ]: 108 : else if ( bMightBeWord )
864 : : { // might be a numerical name (1.2+fg)
865 : 0 : eState = ssGetWord;
866 : 0 : r.TokenType = KParseType::IDENTNAME;
867 : : }
868 : : else
869 : 108 : eState = ssStopBack;
870 : : }
871 [ - + ][ # # ]: 4392 : else if ( bMightBeWord && (nMask & TOKEN_WORD) )
872 : : { // might be a numerical name (1995.A1)
873 : 0 : eState = ssGetWord;
874 : 0 : r.TokenType = KParseType::IDENTNAME;
875 : : }
876 : : else
877 : 4392 : eState = ssStopBack;
878 : : }
879 : 4536 : break;
880 : : case ssGetWordFirstChar :
881 : 0 : eState = ssGetWord;
882 : : // fall thru
883 : : case ssGetWord :
884 : : {
885 [ + + ]: 153918 : if ( nMask & TOKEN_WORD )
886 : : ; // keep it going
887 [ - + ]: 9039 : else if ( nMask & TOKEN_NAME_SEP )
888 : : {
889 [ # # ]: 0 : if ( bQuote )
890 : : {
891 [ # # ]: 0 : if ( cLast == '\\' )
892 : : { // escaped
893 : 0 : aSymbol += OUString( pSym, pSrc - pSym - 2 );
894 : 0 : aSymbol += OUString( &c, 1);
895 : : }
896 : : else
897 : : {
898 : 0 : eState = ssStop;
899 : 0 : aSymbol += OUString( pSym, pSrc - pSym - 1 );
900 : : }
901 : 0 : pSym = pSrc;
902 : : }
903 : : else
904 : 0 : eState = ssStopBack;
905 : : }
906 [ + - ]: 9039 : else if ( bQuote )
907 : : ; // keep it going
908 : : else
909 : 9039 : eState = ssStopBack;
910 : : }
911 : 153918 : break;
912 : : case ssGetString :
913 : : {
914 [ + + ]: 12 : if ( nMask & TOKEN_STRING_SEP )
915 : : {
916 [ - + ]: 6 : if ( cLast == '\\' )
917 : : { // escaped
918 : 0 : aSymbol += OUString( pSym, pSrc - pSym - 2 );
919 : 0 : aSymbol += OUString( &c, 1);
920 : : }
921 [ - + ][ # # ]: 6 : else if ( c == *pSrc &&
922 : 0 : !(nContTypes & KParseTokens::TWO_DOUBLE_QUOTES_BREAK_STRING) )
923 : : { // "" => literal " escaped
924 : 0 : aSymbol += OUString( pSym, pSrc - pSym );
925 : 0 : pSrc++;
926 : : }
927 : : else
928 : : {
929 : 6 : eState = ssStop;
930 : 6 : aSymbol += OUString( pSym, pSrc - pSym - 1 );
931 : : }
932 : 6 : pSym = pSrc;
933 : : }
934 : : }
935 : 12 : break;
936 : : case ssGetBool :
937 : : {
938 [ - + ]: 252 : if ( (nMask & TOKEN_BOOL) )
939 : 0 : eState = ssStop; // maximum 2: <, >, <>, <=, >=
940 : : else
941 : 252 : eState = ssStopBack;
942 : : }
943 : 252 : break;
944 : : case ssStopBack :
945 : : case ssBounce :
946 : : case ssStop :
947 : : ; // nothing, no compiler warning
948 : 0 : break;
949 : : }
950 [ - + ]: 211712 : if ( eState == ssRewindFromValue )
951 : : {
952 : 0 : r = ParseResult();
953 : 0 : pSym = pTextStart;
954 : 0 : pSrc = pSym;
955 : 0 : aSymbol = OUString();
956 : 0 : c = *pSrc;
957 : 0 : cLast = 0;
958 : 0 : nDecSeps = 0;
959 : 0 : bQuote = false;
960 : 0 : bMightBeWord = true;
961 : 0 : bMightBeWordLast = true;
962 : : }
963 : : else
964 : : {
965 [ + + ]: 211712 : if ( !(r.TokenType & nTokenType) )
966 : : {
967 [ - + ][ # # ]: 534 : if ( (r.TokenType & (KParseType::ASC_NUMBER | KParseType::UNI_NUMBER))
[ # # ]
968 : : && (nTokenType & KParseType::IDENTNAME) && bMightBeWord )
969 : : ; // keep a number that might be a word
970 [ + + ]: 534 : else if ( r.LeadingWhiteSpace == (pSrc - pTextStart) )
971 : : ; // keep ignored white space
972 [ + - ][ - + ]: 522 : else if ( !r.TokenType && eState == ssGetValue && (nMask & TOKEN_VALUE_SEP) )
[ # # ]
973 : : ; // keep uncertain value
974 : : else
975 : 534 : eState = ssBounce;
976 : : }
977 [ + + ]: 211712 : if ( eState == ssBounce )
978 : : {
979 : 522 : r.TokenType = 0;
980 : 522 : eState = ssStopBack;
981 : : }
982 [ + + ]: 211712 : if ( eState == ssStopBack )
983 : : { // put back
984 : 14313 : pSrc--;
985 : 14313 : bMightBeWord = bMightBeWordLast;
986 : 14313 : eState = ssStop;
987 : : }
988 [ + + ]: 211712 : if ( eState != ssStop )
989 : : {
990 [ + + ]: 184069 : if ( !r.StartFlags )
991 : 39154 : r.StartFlags |= nParseTokensType;
992 : : else
993 : 144915 : r.ContFlags |= nParseTokensType;
994 : : }
995 : 211712 : bMightBeWordLast = bMightBeWord;
996 : 211712 : cLast = c;
997 : 211712 : c = *pSrc;
998 : : }
999 : : }
1000 : : // r.CharLen is the length in characters (not code points) of the parsed
1001 : : // token not including any leading white space, change this calculation if
1002 : : // multi-code-point Unicode characters are to be supported.
1003 : 52982 : r.CharLen = pSrc - pTextStart - r.LeadingWhiteSpace;
1004 : 52982 : r.EndPos = nPos + (pSrc - pTextStart);
1005 [ + + ]: 52982 : if ( r.TokenType & KParseType::ASC_NUMBER )
1006 : : {
1007 : : r.Value = rtl_math_uStringToDouble( pTextStart + r.LeadingWhiteSpace,
1008 : 4500 : pTextStart + r.EndPos, cDecimalSep, cGroupSep, NULL, NULL );
1009 [ + + ]: 4500 : if ( bMightBeWord )
1010 : 4464 : r.TokenType |= KParseType::IDENTNAME;
1011 : : }
1012 [ - + ]: 48482 : else if ( r.TokenType & KParseType::UNI_NUMBER )
1013 : : {
1014 [ # # ]: 0 : if ( !xNatNumSup.is() )
1015 : : {
1016 : : #define NATIVENUMBERSUPPLIER_SERVICENAME "com.sun.star.i18n.NativeNumberSupplier"
1017 [ # # ]: 0 : if ( xMSF.is() )
1018 : : {
1019 : : xNatNumSup = Reference< XNativeNumberSupplier > (
1020 [ # # ]: 0 : xMSF->createInstance( OUString(
1021 : : RTL_CONSTASCII_USTRINGPARAM(
1022 : 0 : NATIVENUMBERSUPPLIER_SERVICENAME ) ) ),
1023 [ # # ][ # # ]: 0 : UNO_QUERY );
[ # # ][ # # ]
1024 : : }
1025 [ # # ]: 0 : if ( !xNatNumSup.is() )
1026 : : {
1027 : : throw RuntimeException( OUString(
1028 : : #ifdef DBG_UTIL
1029 : : RTL_CONSTASCII_USTRINGPARAM(
1030 : : "cclass_Unicode::parseText: can't instanciate "
1031 : : NATIVENUMBERSUPPLIER_SERVICENAME )
1032 : : #endif
1033 [ # # ][ # # ]: 0 : ), *this );
1034 : : }
1035 : : #undef NATIVENUMBERSUPPLIER_SERVICENAME
1036 : : }
1037 : : OUString aTmp( pTextStart + r.LeadingWhiteSpace, r.EndPos - nPos +
1038 : 0 : r.LeadingWhiteSpace );
1039 : : // transliterate to ASCII
1040 [ # # ]: 0 : aTmp = xNatNumSup->getNativeNumberString( aTmp, aParserLocale,
1041 [ # # ]: 0 : NativeNumberMode::NATNUM0 );
1042 : 0 : r.Value = ::rtl::math::stringToDouble( aTmp, cDecimalSep, cGroupSep, NULL, NULL );
1043 [ # # ]: 0 : if ( bMightBeWord )
1044 : 0 : r.TokenType |= KParseType::IDENTNAME;
1045 : : }
1046 [ + + ]: 48482 : else if ( r.TokenType & (KParseType::SINGLE_QUOTE_NAME | KParseType::DOUBLE_QUOTE_STRING) )
1047 : : {
1048 [ - + ]: 6 : if ( pSym < pSrc )
1049 : : { //! open quote
1050 : 0 : aSymbol += OUString( pSym, pSrc - pSym );
1051 : 0 : r.TokenType |= KParseType::MISSING_QUOTE;
1052 : : }
1053 : 6 : r.DequotedNameOrString = aSymbol;
1054 : 52982 : }
1055 : 52982 : }
1056 : :
1057 : : } } } }
1058 : :
1059 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
