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