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