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 <stdlib.h>
22 : : #include <comphelper/string.hxx>
23 : : #include <tools/debug.hxx>
24 : : #include <i18npool/mslangid.hxx>
25 : : #include <unotools/charclass.hxx>
26 : : #include <unotools/localedatawrapper.hxx>
27 : : #include <unotools/numberformatcodewrapper.hxx>
28 : : #include <rtl/instance.hxx>
29 : :
30 : : #include <svl/zforlist.hxx>
31 : : #include <svl/zformat.hxx>
32 : : #include <unotools/digitgroupingiterator.hxx>
33 : :
34 : : #define _ZFORSCAN_CXX
35 : : #include "zforscan.hxx"
36 : : #undef _ZFORSCAN_CXX
37 : : #include <svl/nfsymbol.hxx>
38 : : using namespace svt;
39 : :
40 : : const sal_Unicode cNonBreakingSpace = 0xA0;
41 : :
42 : : namespace
43 : : {
44 : : struct ImplEnglishColors
45 : : {
46 : 8 : const String* operator()()
47 : : {
48 : : static const String aEnglishColors[NF_MAX_DEFAULT_COLORS] =
49 : : {
50 : : String( RTL_CONSTASCII_USTRINGPARAM( "BLACK" ) ),
51 : : String( RTL_CONSTASCII_USTRINGPARAM( "BLUE" ) ),
52 : : String( RTL_CONSTASCII_USTRINGPARAM( "GREEN" ) ),
53 : : String( RTL_CONSTASCII_USTRINGPARAM( "CYAN" ) ),
54 : : String( RTL_CONSTASCII_USTRINGPARAM( "RED" ) ),
55 : : String( RTL_CONSTASCII_USTRINGPARAM( "MAGENTA" ) ),
56 : : String( RTL_CONSTASCII_USTRINGPARAM( "BROWN" ) ),
57 : : String( RTL_CONSTASCII_USTRINGPARAM( "GREY" ) ),
58 : : String( RTL_CONSTASCII_USTRINGPARAM( "YELLOW" ) ),
59 : : String( RTL_CONSTASCII_USTRINGPARAM( "WHITE" ) )
60 [ + - ][ + - ]: 96 : };
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ # # # #
# # ][ + + ]
61 : 8 : return &aEnglishColors[0];
62 : : }
63 : : };
64 : :
65 : : struct theEnglishColors
66 : : : public rtl::StaticAggregate< const String, ImplEnglishColors> {};
67 : :
68 : : }
69 : :
70 [ + + ][ + - ]: 243201 : ImpSvNumberformatScan::ImpSvNumberformatScan( SvNumberFormatter* pFormatterP )
[ + - ][ + + ]
[ + - ][ + - ]
[ + - ][ + -
# # # # ]
71 : : {
72 : 2191 : pFormatter = pFormatterP;
73 : 2191 : bConvertMode = false;
74 : : //! All keywords MUST be UPPERCASE!
75 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_E].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "E" ) ); // Exponent
76 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_AMPM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AM/PM" ) ); // AM/PM
77 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_AP].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "A/P" ) ); // AM/PM short
78 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_MI].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "M" ) ); // Minute
79 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_MMI].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MM" ) ); // Minute 02
80 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_S].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "S" ) ); // Second
81 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_SS].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "SS" ) ); // Second 02
82 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_Q].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Q" ) ); // Quarter short 'Q'
83 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_QQ].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "QQ" ) ); // Quarter long
84 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_NN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NN" ) ); // Day of week short
85 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_NNN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NNN" ) ); // Day of week long
86 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_NNNN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NNNN" ) ); // Day of week long incl. separator
87 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_WW].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "WW" ) ); // Week of year
88 [ + - ][ + - ]: 2191 : sKeyword[NF_KEY_CCC].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "CCC" ) ); // Currency abbreviation
89 : 2191 : bKeywordsNeedInit = true; // locale dependent keywords
90 : 2191 : bCompatCurNeedInit = true; // locale dependent compatibility currency strings
91 : :
92 : 2191 : StandardColor[0] = Color(COL_BLACK);
93 : 2191 : StandardColor[1] = Color(COL_LIGHTBLUE);
94 : 2191 : StandardColor[2] = Color(COL_LIGHTGREEN);
95 : 2191 : StandardColor[3] = Color(COL_LIGHTCYAN);
96 : 2191 : StandardColor[4] = Color(COL_LIGHTRED);
97 : 2191 : StandardColor[5] = Color(COL_LIGHTMAGENTA);
98 : 2191 : StandardColor[6] = Color(COL_BROWN);
99 : 2191 : StandardColor[7] = Color(COL_GRAY);
100 : 2191 : StandardColor[8] = Color(COL_YELLOW);
101 : 2191 : StandardColor[9] = Color(COL_WHITE);
102 : :
103 [ + - ]: 2191 : pNullDate = new Date(30,12,1899);
104 : 2191 : nStandardPrec = 2;
105 : :
106 [ + - ]: 2191 : sErrStr.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "###" ) );
107 : 2191 : Reset();
108 [ # # # # ]: 2191 : }
109 : :
110 [ + - ][ + - ]: 202980 : ImpSvNumberformatScan::~ImpSvNumberformatScan()
[ + - ][ + - ]
[ + - ][ + - ]
111 : : {
112 : 1990 : delete pNullDate;
113 : 1990 : Reset();
114 [ + - ][ + + ]: 202980 : }
[ # # # # ]
115 : :
116 : 6677 : void ImpSvNumberformatScan::ChangeIntl()
117 : : {
118 : 6677 : bKeywordsNeedInit = true;
119 : 6677 : bCompatCurNeedInit = true;
120 : : // may be initialized by InitSpecialKeyword()
121 : 6677 : sKeyword[NF_KEY_TRUE].Erase();
122 : 6677 : sKeyword[NF_KEY_FALSE].Erase();
123 : 6677 : }
124 : :
125 : 14656 : void ImpSvNumberformatScan::InitSpecialKeyword( NfKeywordIndex eIdx ) const
126 : : {
127 [ + + - ]: 14656 : switch ( eIdx )
128 : : {
129 : : case NF_KEY_TRUE :
130 [ + - ]: 7328 : ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_TRUE] =
131 : : pFormatter->GetCharClass()->uppercase(
132 [ + - ]: 14656 : pFormatter->GetLocaleData()->getTrueWord() );
133 [ - + ]: 7328 : if ( !sKeyword[NF_KEY_TRUE].Len() )
134 : : {
135 : : SAL_WARN( "svl.numbers", "InitSpecialKeyword: TRUE_WORD?" );
136 : 0 : ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_TRUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TRUE" ) );
137 : : }
138 : 7328 : break;
139 : : case NF_KEY_FALSE :
140 [ + - ]: 7328 : ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_FALSE] =
141 : : pFormatter->GetCharClass()->uppercase(
142 [ + - ]: 14656 : pFormatter->GetLocaleData()->getFalseWord() );
143 [ - + ]: 7328 : if ( !sKeyword[NF_KEY_FALSE].Len() )
144 : : {
145 : : SAL_WARN( "svl.numbers", "InitSpecialKeyword: FALSE_WORD?" );
146 : 0 : ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_FALSE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "FALSE" ) );
147 : : }
148 : 7328 : break;
149 : : default:
150 : : SAL_WARN( "svl.numbers", "InitSpecialKeyword: unknown request" );
151 : : }
152 : 14656 : }
153 : :
154 : 7203 : void ImpSvNumberformatScan::InitCompatCur() const
155 : : {
156 : 7203 : ImpSvNumberformatScan* pThis = (ImpSvNumberformatScan*)this;
157 : : // currency symbol for old style ("automatic") compatibility format codes
158 : 7203 : pFormatter->GetCompatibilityCurrency( pThis->sCurSymbol, pThis->sCurAbbrev );
159 : : // currency symbol upper case
160 [ + - ][ + - ]: 7203 : pThis->sCurString = pFormatter->GetCharClass()->uppercase( sCurSymbol );
161 : 7203 : bCompatCurNeedInit = false;
162 : 7203 : }
163 : :
164 : 9917 : void ImpSvNumberformatScan::InitKeywords() const
165 : : {
166 [ + + ]: 9917 : if ( !bKeywordsNeedInit )
167 : 9917 : return ;
168 : 7203 : ((ImpSvNumberformatScan*)this)->SetDependentKeywords();
169 : 7203 : bKeywordsNeedInit = false;
170 : : }
171 : :
172 : : /** Extract the name of General, Standard, Whatever, ignoring leading modifiers
173 : : such as [NatNum1]. */
174 : 7203 : static String lcl_extractStandardGeneralName( const ::rtl::OUString & rCode )
175 : : {
176 : 7203 : String aStr;
177 : 7203 : const sal_Unicode* p = rCode.getStr();
178 : 7203 : const sal_Unicode* const pStop = p + rCode.getLength();
179 : 7203 : const sal_Unicode* pBeg = p; // name begins here
180 : 7203 : bool bMod = false;
181 : 7203 : bool bDone = false;
182 [ + + ][ + - ]: 57646 : while (p < pStop && !bDone)
[ + + ]
183 : : {
184 [ - - - + ]: 50443 : switch (*p)
185 : : {
186 : : case '[':
187 : 0 : bMod = true;
188 : 0 : break;
189 : : case ']':
190 [ # # ]: 0 : if (bMod)
191 : : {
192 : 0 : bMod = false;
193 : 0 : pBeg = p+1;
194 : : }
195 : : // else: would be a locale data error, easily to be spotted in
196 : : // UI dialog
197 : 0 : break;
198 : : case ';':
199 [ # # ]: 0 : if (!bMod)
200 : : {
201 : 0 : bDone = true;
202 : 0 : --p; // put back, increment by one follows
203 : : }
204 : 0 : break;
205 : : }
206 : 50443 : ++p;
207 [ - + ]: 50443 : if (bMod)
208 : 0 : pBeg = p;
209 : : }
210 [ + - ]: 7203 : if (pBeg < p)
211 [ + - ]: 7203 : aStr = rCode.copy( pBeg - rCode.getStr(), p - pBeg);
212 : 7203 : return aStr;
213 : : }
214 : :
215 : 7203 : void ImpSvNumberformatScan::SetDependentKeywords()
216 : : {
217 : : using namespace ::com::sun::star;
218 : : using namespace ::com::sun::star::uno;
219 : :
220 : 7203 : const CharClass* pCharClass = pFormatter->GetCharClass();
221 : 7203 : const LocaleDataWrapper* pLocaleData = pFormatter->GetLocaleData();
222 : : // #80023# be sure to generate keywords for the loaded Locale, not for the
223 : : // requested Locale, otherwise number format codes might not match
224 [ + - ]: 7203 : lang::Locale aLoadedLocale = pLocaleData->getLoadedLocale();
225 [ + - ]: 7203 : LanguageType eLang = MsLangId::convertLocaleToLanguage( aLoadedLocale );
226 [ + - ][ + - ]: 7203 : NumberFormatCodeWrapper aNumberFormatCode( pFormatter->GetServiceManager(), aLoadedLocale );
227 : :
228 [ + - ]: 7203 : i18n::NumberFormatCode aFormat = aNumberFormatCode.getFormatCode( NF_NUMBER_STANDARD );
229 [ + - ][ + - ]: 7203 : sNameStandardFormat = lcl_extractStandardGeneralName( aFormat.Code);
[ + - ]
230 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_GENERAL] = pCharClass->uppercase( sNameStandardFormat );
[ + - ][ + - ]
231 : :
232 : : // preset new calendar keywords
233 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_AAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AAA" ) );
234 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_AAAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AAAA" ) );
235 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_EC].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "E" ) );
236 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_EEC].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "EE" ) );
237 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_G].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "G" ) );
238 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_GG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GG" ) );
239 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_GGG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGG" ) );
240 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_R].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "R" ) );
241 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_RR].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "RR" ) );
242 : :
243 : : // Thai T NatNum special. Other locale's small letter 't' results in upper
244 : : // case comparison not matching but length does in conversion mode. Ugly.
245 [ - + ]: 7203 : if (eLang == LANGUAGE_THAI)
246 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_THAI_T].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T"));
247 : : else
248 [ + - ][ + - ]: 7203 : sKeyword[NF_KEY_THAI_T].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "t"));
249 : :
250 [ + + ]: 7203 : switch ( eLang )
251 : : {
252 : : case LANGUAGE_GERMAN:
253 : : case LANGUAGE_GERMAN_SWISS:
254 : : case LANGUAGE_GERMAN_AUSTRIAN:
255 : : case LANGUAGE_GERMAN_LUXEMBOURG:
256 : : case LANGUAGE_GERMAN_LIECHTENSTEIN:
257 : : {
258 : : //! all capital letters
259 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "M" ) ); // month 1
260 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MM" ) ); // month 01
261 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMM" ) ); // month Jan
262 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMM" ) ); // month Januar
263 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMMM" ) );// month J
264 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "H" ) ); // hour 2
265 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "HH" ) ); // hour 02
266 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T" ) );
267 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TT" ) );
268 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TTT" ) );
269 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TTTT" ) );
270 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
271 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
272 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_BOOLEAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "LOGISCH" ) );
273 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_COLOR].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "FARBE" ) );
274 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_BLACK].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "SCHWARZ" ) );
275 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_BLUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BLAU" ) );
276 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_GREEN] = UniString( "GR" "\xDC" "N", RTL_TEXTENCODING_ISO_8859_1 );
[ + - ][ + - ]
277 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_CYAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "CYAN" ) );
278 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_RED].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "ROT" ) );
279 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_MAGENTA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MAGENTA" ) );
280 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_BROWN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BRAUN" ) );
281 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_GREY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GRAU" ) );
282 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_YELLOW].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GELB" ) );
283 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_WHITE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "WEISS" ) );
284 : : }
285 : 8 : break;
286 : : default:
287 : : {
288 : : // day
289 [ - + - + ]: 7195 : switch ( eLang )
290 : : {
291 : : case LANGUAGE_ITALIAN :
292 : : case LANGUAGE_ITALIAN_SWISS :
293 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "G" ) );
294 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GG" ) );
295 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGG" ) );
296 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGGG" ) );
297 : : // must exchange the era code, same as Xcl
298 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_G].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "X" ) );
299 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_GG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "XX" ) );
300 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_GGG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "XXX" ) );
301 : 0 : break;
302 : : case LANGUAGE_FRENCH :
303 : : case LANGUAGE_FRENCH_BELGIAN :
304 : : case LANGUAGE_FRENCH_CANADIAN :
305 : : case LANGUAGE_FRENCH_SWISS :
306 : : case LANGUAGE_FRENCH_LUXEMBOURG :
307 : : case LANGUAGE_FRENCH_MONACO :
308 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "J" ) );
309 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
310 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJ" ) );
311 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
312 : 6 : break;
313 : : case LANGUAGE_FINNISH :
314 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "P" ) );
315 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PP" ) );
316 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PPP" ) );
317 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PPPP" ) );
318 : 0 : break;
319 : : default:
320 [ + - ][ + - ]: 7189 : sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D" ) );
321 [ + - ][ + - ]: 7189 : sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DD" ) );
322 [ + - ][ + - ]: 7189 : sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDD" ) );
323 [ + - ][ + - ]: 7189 : sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDDD" ) );
324 : : }
325 : : // month
326 [ - + ]: 7195 : switch ( eLang )
327 : : {
328 : : case LANGUAGE_FINNISH :
329 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "K" ) );
330 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KK" ) );
331 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKK" ) );
332 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKKK" ) );
333 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKKKK" ) );
334 : 0 : break;
335 : : default:
336 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "M" ) );
337 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MM" ) );
338 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMM" ) );
339 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMM" ) );
340 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMMM" ) );
341 : : }
342 : : // year
343 [ + - - + ]: 7195 : switch ( eLang )
344 : : {
345 : : case LANGUAGE_ITALIAN :
346 : : case LANGUAGE_ITALIAN_SWISS :
347 : : case LANGUAGE_FRENCH :
348 : : case LANGUAGE_FRENCH_BELGIAN :
349 : : case LANGUAGE_FRENCH_CANADIAN :
350 : : case LANGUAGE_FRENCH_SWISS :
351 : : case LANGUAGE_FRENCH_LUXEMBOURG :
352 : : case LANGUAGE_FRENCH_MONACO :
353 : : case LANGUAGE_PORTUGUESE :
354 : : case LANGUAGE_PORTUGUESE_BRAZILIAN :
355 : : case LANGUAGE_SPANISH_MODERN :
356 : : case LANGUAGE_SPANISH_DATED :
357 : : case LANGUAGE_SPANISH_MEXICAN :
358 : : case LANGUAGE_SPANISH_GUATEMALA :
359 : : case LANGUAGE_SPANISH_COSTARICA :
360 : : case LANGUAGE_SPANISH_PANAMA :
361 : : case LANGUAGE_SPANISH_DOMINICAN_REPUBLIC :
362 : : case LANGUAGE_SPANISH_VENEZUELA :
363 : : case LANGUAGE_SPANISH_COLOMBIA :
364 : : case LANGUAGE_SPANISH_PERU :
365 : : case LANGUAGE_SPANISH_ARGENTINA :
366 : : case LANGUAGE_SPANISH_ECUADOR :
367 : : case LANGUAGE_SPANISH_CHILE :
368 : : case LANGUAGE_SPANISH_URUGUAY :
369 : : case LANGUAGE_SPANISH_PARAGUAY :
370 : : case LANGUAGE_SPANISH_BOLIVIA :
371 : : case LANGUAGE_SPANISH_EL_SALVADOR :
372 : : case LANGUAGE_SPANISH_HONDURAS :
373 : : case LANGUAGE_SPANISH_NICARAGUA :
374 : : case LANGUAGE_SPANISH_PUERTO_RICO :
375 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AA" ) );
376 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AAAA" ) );
377 : : // must exchange the day of week name code, same as Xcl
378 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_AAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "OOO" ) );
379 [ + - ][ + - ]: 6 : sKeyword[NF_KEY_AAAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "OOOO" ) );
380 : 6 : break;
381 : : case LANGUAGE_DUTCH :
382 : : case LANGUAGE_DUTCH_BELGIAN :
383 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
384 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
385 : 0 : break;
386 : : case LANGUAGE_FINNISH :
387 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "VV" ) );
388 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "VVVV" ) );
389 : 0 : break;
390 : : default:
391 [ + - ][ + - ]: 7189 : sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YY" ) );
392 [ + - ][ + - ]: 7189 : sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YYYY" ) );
393 : : }
394 : : // hour
395 [ - + + ]: 7195 : switch ( eLang )
396 : : {
397 : : case LANGUAGE_DUTCH :
398 : : case LANGUAGE_DUTCH_BELGIAN :
399 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "U" ) );
400 [ # # ][ # # ]: 0 : sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "UU" ) );
401 : 0 : break;
402 : : case LANGUAGE_FINNISH :
403 : : case LANGUAGE_SWEDISH :
404 : : case LANGUAGE_SWEDISH_FINLAND :
405 : : case LANGUAGE_DANISH :
406 : : case LANGUAGE_NORWEGIAN :
407 : : case LANGUAGE_NORWEGIAN_BOKMAL :
408 : : case LANGUAGE_NORWEGIAN_NYNORSK :
409 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T" ) );
410 [ + - ][ + - ]: 8 : sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TT" ) );
411 : 8 : break;
412 : : default:
413 [ + - ][ + - ]: 7187 : sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "H" ) );
414 [ + - ][ + - ]: 7187 : sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "HH" ) );
415 : : }
416 : : // boolean
417 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_BOOLEAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BOOLEAN" ) );
418 : : // colours
419 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_COLOR].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "COLOR" ) );
420 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_BLACK].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BLACK" ) );
421 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_BLUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BLUE" ) );
422 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_GREEN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GREEN" ) );
423 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_CYAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "CYAN" ) );
424 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_RED].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "RED" ) );
425 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_MAGENTA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MAGENTA" ) );
426 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_BROWN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BROWN" ) );
427 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_GREY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GREY" ) );
428 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_YELLOW].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YELLOW" ) );
429 [ + - ][ + - ]: 7195 : sKeyword[NF_KEY_WHITE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "WHITE" ) );
430 : : }
431 : 7195 : break;
432 : : }
433 : :
434 : : // boolean keyords
435 [ + - ]: 7203 : InitSpecialKeyword( NF_KEY_TRUE );
436 [ + - ]: 7203 : InitSpecialKeyword( NF_KEY_FALSE );
437 : :
438 : : // compatibility currency strings
439 [ + - ][ + - ]: 7203 : InitCompatCur();
440 : 7203 : }
441 : :
442 : 1617 : void ImpSvNumberformatScan::ChangeNullDate(sal_uInt16 nDay, sal_uInt16 nMonth, sal_uInt16 nYear)
443 : : {
444 [ + - ]: 1617 : if ( pNullDate )
445 : 1617 : *pNullDate = Date(nDay, nMonth, nYear);
446 : : else
447 : 0 : pNullDate = new Date(nDay, nMonth, nYear);
448 : 1617 : }
449 : :
450 : 2246 : void ImpSvNumberformatScan::ChangeStandardPrec(sal_uInt16 nPrec)
451 : : {
452 : 2246 : nStandardPrec = nPrec;
453 : 2246 : }
454 : :
455 : 16521 : Color* ImpSvNumberformatScan::GetColor(String& sStr)
456 : : {
457 [ + - ][ + - ]: 16521 : String sString = pFormatter->GetCharClass()->uppercase(sStr);
[ + - ]
458 [ + - ]: 16521 : const NfKeywordTable & rKeyword = GetKeywords();
459 : 16521 : size_t i = 0;
460 [ + + ][ + + ]: 179235 : while (i < NF_MAX_DEFAULT_COLORS &&
[ + + ]
461 [ + - ][ + - ]: 88980 : sString != rKeyword[NF_KEY_FIRSTCOLOR+i] )
462 : 73734 : i++;
463 [ + + ]: 16521 : if ( i >= NF_MAX_DEFAULT_COLORS )
464 : : {
465 [ + - ]: 1275 : const String* pEnglishColors = theEnglishColors::get();
466 : 1275 : size_t j = 0;
467 [ + + ][ + - ]: 26775 : while ( j < NF_MAX_DEFAULT_COLORS &&
[ + + ]
468 [ + - ]: 12750 : sString != pEnglishColors[j] )
469 : 12750 : ++j;
470 [ - + ]: 1275 : if ( j < NF_MAX_DEFAULT_COLORS )
471 : 0 : i = j;
472 : : }
473 : :
474 : 16521 : Color* pResult = NULL;
475 [ + + ]: 16521 : if (i >= NF_MAX_DEFAULT_COLORS)
476 : : {
477 [ + - ]: 1275 : const String& rColorWord = rKeyword[NF_KEY_COLOR];
478 [ + - ]: 1275 : xub_StrLen nPos = sString.Match(rColorWord);
479 [ + - ]: 1275 : if (nPos > 0)
480 : : {
481 [ + - ]: 1275 : sStr.Erase(0, nPos);
482 [ + - ][ + - ]: 1275 : sStr = comphelper::string::strip(sStr, ' ');
[ + - ]
483 [ - + ]: 1275 : if (bConvertMode)
484 : : {
485 [ # # ]: 0 : pFormatter->ChangeIntl(eNewLnge);
486 [ # # ][ # # ]: 0 : sStr.Insert( GetKeywords()[NF_KEY_COLOR], 0 ); // Color -> FARBE
[ # # ]
487 [ # # ]: 0 : pFormatter->ChangeIntl(eTmpLnge);
488 : : }
489 : : else
490 [ + - ]: 1275 : sStr.Insert(rColorWord,0);
491 [ + - ]: 1275 : sString.Erase(0, nPos);
492 [ + - ][ + - ]: 1275 : sString = comphelper::string::strip(sString, ' ');
[ + - ]
493 : :
494 [ - + ][ + - ]: 1275 : if ( CharClass::isAsciiNumeric( sString ) )
495 : : {
496 [ # # ]: 0 : long nIndex = sString.ToInt32();
497 [ # # ][ # # ]: 0 : if (nIndex > 0 && nIndex <= 64)
498 [ # # ]: 0 : pResult = pFormatter->GetUserDefColor((sal_uInt16)nIndex-1);
499 : : }
500 : : }
501 : : }
502 : : else
503 : : {
504 [ + - ]: 15246 : sStr.Erase();
505 [ + + ]: 15246 : if (bConvertMode)
506 : : {
507 [ + - ]: 351 : pFormatter->ChangeIntl(eNewLnge);
508 [ + - ][ + - ]: 351 : sStr = GetKeywords()[NF_KEY_FIRSTCOLOR+i]; // red -> rot
[ + - ]
509 [ + - ]: 351 : pFormatter->ChangeIntl(eTmpLnge);
510 : : }
511 : : else
512 [ + - ][ + - ]: 14895 : sStr = rKeyword[NF_KEY_FIRSTCOLOR+i];
513 : :
514 : 15246 : pResult = &(StandardColor[i]);
515 : : }
516 [ + - ]: 16521 : return pResult;
517 : : }
518 : :
519 : 473810 : short ImpSvNumberformatScan::GetKeyWord( const String& sSymbol, xub_StrLen nPos )
520 : : {
521 [ + - ][ + - ]: 473810 : String sString = pFormatter->GetCharClass()->uppercase( sSymbol, nPos, sSymbol.Len() - nPos );
[ + - ]
522 [ + - ]: 473810 : const NfKeywordTable & rKeyword = GetKeywords();
523 : : // #77026# for the Xcl perverts: the GENERAL keyword is recognized anywhere
524 [ + - ][ + - ]: 473810 : if ( sString.Search( rKeyword[NF_KEY_GENERAL] ) == 0 )
[ + + ]
525 : 2481 : return NF_KEY_GENERAL;
526 : : //! MUST be a reverse search to find longer strings first
527 : 471329 : short i = NF_KEYWORD_ENTRIES_COUNT-1;
528 : 471329 : bool bFound = false;
529 [ + + ]: 5032955 : for ( ; i > NF_KEY_LASTKEYWORD_SO5; --i )
530 : : {
531 [ + - ][ + - ]: 4612140 : bFound = sString.Search(rKeyword[i]) == 0;
532 [ + + ]: 4612140 : if ( bFound )
533 : : {
534 : 50514 : break;
535 : : }
536 : : }
537 : : // new keywords take precedence over old keywords
538 [ + + ]: 471329 : if ( !bFound )
539 : : { // skip the gap of colors et al between new and old keywords and search on
540 : 420815 : i = NF_KEY_LASTKEYWORD;
541 [ + + ][ + - ]: 7546322 : while ( i > 0 && sString.Search(rKeyword[i]) != 0 )
[ + - ][ + + ]
[ + + ]
542 : 7125507 : i--;
543 [ + + ][ + - ]: 420815 : if ( i > NF_KEY_LASTOLDKEYWORD && sString != rKeyword[i] )
[ + - ][ + + ]
[ + + ]
544 : : { // found something, but maybe it's something else?
545 : : // e.g. new NNN is found in NNNN, for NNNN we must search on
546 : 4876 : short j = i - 1;
547 [ + - ][ + - ]: 14628 : while ( j > 0 && sString.Search(rKeyword[j]) != 0 )
[ + - ][ + + ]
[ + + ]
548 : 9752 : j--;
549 [ + - ][ + - ]: 4876 : if ( j && rKeyword[j].Len() > rKeyword[i].Len() )
[ + - ][ + - ]
[ + - ]
550 : 4876 : return j;
551 : : }
552 : : }
553 : : // The Thai T NatNum modifier during Xcl import.
554 [ + + ][ + + ]: 466453 : if (i == 0 && bConvertMode && sString.GetChar(0) == 'T' && eTmpLnge ==
[ - + ][ # # ]
[ # # ][ - + ]
555 [ # # ]: 0 : LANGUAGE_ENGLISH_US && MsLangId::getRealLanguage( eNewLnge) ==
556 : : LANGUAGE_THAI)
557 : 0 : i = NF_KEY_THAI_T;
558 [ + - ]: 473810 : return i; // 0 => not found
559 : : }
560 : :
561 : : //---------------------------------------------------------------------------
562 : : // Next_Symbol
563 : : //---------------------------------------------------------------------------
564 : : // Zerlegt die Eingabe in Symbole fuer die weitere
565 : : // Verarbeitung (Turing-Maschine).
566 : : //---------------------------------------------------------------------------
567 : : // Ausgangs Zustand = SsStart
568 : : //---------------+-------------------+-----------------------+---------------
569 : : // Alter Zustand | gelesenes Zeichen | Aktion | Neuer Zustand
570 : : //---------------+-------------------+-----------------------+---------------
571 : : // SsStart | Buchstabe | Symbol=Zeichen | SsGetWord
572 : : // | " | Typ = String | SsGetString
573 : : // | \ | Typ = String | SsGetChar
574 : : // | * | Typ = Star | SsGetStar
575 : : // | _ | Typ = Blank | SsGetBlank
576 : : // | @ # 0 ? / . , % [ | Symbol = Zeichen; |
577 : : // | ] ' Blank | Typ = Steuerzeichen | SsStop
578 : : // | $ - + ( ) : | Typ = String; |
579 : : // | Sonst | Symbol = Zeichen | SsStop
580 : : //---------------|-------------------+-----------------------+---------------
581 : : // SsGetChar | Sonst | Symbol=Zeichen | SsStop
582 : : //---------------+-------------------+-----------------------+---------------
583 : : // GetString | " | | SsStop
584 : : // | Sonst | Symbol+=Zeichen | GetString
585 : : //---------------+-------------------+-----------------------+---------------
586 : : // SsGetWord | Buchstabe | Symbol += Zeichen |
587 : : // | + - (E+ E-)| Symbol += Zeichen | SsStop
588 : : // | / (AM/PM)| Symbol += Zeichen |
589 : : // | Sonst | Pos--, if Key Typ=Word| SsStop
590 : : //---------------+-------------------+-----------------------+---------------
591 : : // SsGetStar | Sonst | Symbol+=Zeichen | SsStop
592 : : // | | markiere Sonderfall * |
593 : : //---------------+-------------------+-----------------------+---------------
594 : : // SsGetBlank | Sonst | Symbol+=Zeichen | SsStop
595 : : // | | markiere Sonderfall _ |
596 : : //---------------+-------------------+-----------------------+---------------
597 : : // Wurde im State SsGetWord ein Schluesselwort erkannt (auch als
598 : : // Anfangsteilwort des Symbols)
599 : : // so werden die restlichen Buchstaben zurueckgeschrieben !!
600 : :
601 : : enum ScanState
602 : : {
603 : : SsStop = 0,
604 : : SsStart = 1,
605 : : SsGetChar = 2,
606 : : SsGetString = 3,
607 : : SsGetWord = 4,
608 : : SsGetStar = 5,
609 : : SsGetBlank = 6
610 : : };
611 : :
612 : 1581808 : short ImpSvNumberformatScan::Next_Symbol( const String& rStr,
613 : : xub_StrLen& nPos, String& sSymbol )
614 : : {
615 [ - + ]: 1581808 : if ( bKeywordsNeedInit )
616 : 0 : InitKeywords();
617 : 1581808 : const CharClass* pChrCls = pFormatter->GetCharClass();
618 : 1581808 : const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
619 : 1581808 : const xub_StrLen nStart = nPos;
620 : 1581808 : short eType = 0;
621 : 1581808 : ScanState eState = SsStart;
622 : 1581808 : sSymbol.Erase();
623 [ + + ][ + + ]: 3246584 : while ( nPos < rStr.Len() && eState != SsStop )
[ + + ]
624 : : {
625 : 1665016 : sal_Unicode cToken = rStr.GetChar( nPos++ );
626 [ + + + + : 1665016 : switch (eState)
+ + - ]
627 : : {
628 : : case SsStart:
629 : : {
630 : : // Fetch any currency longer than one character and don't get
631 : : // confused later on by "E/" or other combinations of letters
632 : : // and meaningful symbols. Necessary for old automatic currency.
633 : : // #96158# But don't do it if we're starting a "[...]" section,
634 : : // for example a "[$...]" new currency symbol to not parse away
635 : : // "$U" (symbol) of "[$UYU]" (abbreviation).
636 [ + + ]: 1587552 : if ( nCurrPos != STRING_NOTFOUND && sCurString.Len() > 1 &&
[ + + + + ]
[ + + ][ + + ]
637 : 3072 : nPos-1 + sCurString.Len() <= rStr.Len() &&
638 [ + + ]: 2672 : !(nPos > 1 && rStr.GetChar( nPos-2 ) == '[') )
639 : : {
640 [ + - ][ + - ]: 2792 : String aTest = pChrCls->uppercase( rStr.Copy( nPos-1, sCurString.Len() ) );
[ + - ][ + - ]
[ + - ]
641 [ + - ][ + + ]: 2792 : if ( aTest == sCurString )
642 : : {
643 [ + - ][ + - ]: 240 : sSymbol = rStr.Copy( --nPos, sCurString.Len() );
[ + - ]
644 : 240 : nPos = nPos + sSymbol.Len();
645 : 240 : eState = SsStop;
646 : 240 : eType = NF_SYMBOLTYPE_STRING;
647 : 2792 : return eType;
648 [ + - ][ + + ]: 2792 : }
649 : : }
650 [ + + + + : 1581568 : switch (cToken)
+ + + ]
651 : : {
652 : : case '#':
653 : : case '0':
654 : : case '?':
655 : : case '%':
656 : : case '@':
657 : : case '[':
658 : : case ']':
659 : : case ',':
660 : : case '.':
661 : : case '/':
662 : : case '\'':
663 : : case ' ':
664 : : case ':':
665 : : case '-':
666 : : {
667 : 1012860 : eType = NF_SYMBOLTYPE_DEL;
668 : 1012860 : sSymbol += cToken;
669 : 1012860 : eState = SsStop;
670 : : }
671 : 1012860 : break;
672 : : case '*':
673 : : {
674 : 672 : eType = NF_SYMBOLTYPE_STAR;
675 : 672 : sSymbol += cToken;
676 : 672 : eState = SsGetStar;
677 : : }
678 : 672 : break;
679 : : case '_':
680 : : {
681 : 6954 : eType = NF_SYMBOLTYPE_BLANK;
682 : 6954 : sSymbol += cToken;
683 : 6954 : eState = SsGetBlank;
684 : : }
685 : 6954 : break;
686 : : case '"':
687 : 1003 : eType = NF_SYMBOLTYPE_STRING;
688 : 1003 : eState = SsGetString;
689 : 1003 : sSymbol += cToken;
690 : 1003 : break;
691 : : case '\\':
692 : 640 : eType = NF_SYMBOLTYPE_STRING;
693 : 640 : eState = SsGetChar;
694 : 640 : sSymbol += cToken;
695 : 640 : break;
696 : : case '$':
697 : : case '+':
698 : : case '(':
699 : : case ')':
700 : 86149 : eType = NF_SYMBOLTYPE_STRING;
701 : 86149 : eState = SsStop;
702 : 86149 : sSymbol += cToken;
703 : 86149 : break;
704 : : default :
705 : : {
706 [ + - + - : 2839740 : if (StringEqualsChar( pFormatter->GetNumDecimalSep(), cToken) ||
+ - + - -
+ ][ - + ]
707 : 473290 : StringEqualsChar( pFormatter->GetNumThousandSep(), cToken) ||
708 : 473290 : StringEqualsChar( pFormatter->GetDateSep(), cToken) ||
709 [ + - ][ + - ]: 946580 : StringEqualsChar( pLoc->getTimeSep(), cToken) ||
[ + - ][ # # ]
710 [ + - ][ + - ]: 946580 : StringEqualsChar( pLoc->getTime100SecSep(), cToken))
[ + - ][ + - ]
[ # # ]
711 : : {
712 : : // Another separator than pre-known ASCII
713 : 0 : eType = NF_SYMBOLTYPE_DEL;
714 : 0 : sSymbol += cToken;
715 : 0 : eState = SsStop;
716 : : }
717 [ + + ]: 473290 : else if ( pChrCls->isLetter( rStr, nPos-1 ) )
718 : : {
719 : 399274 : short nTmpType = GetKeyWord( rStr, nPos-1 );
720 [ + + ]: 399274 : if ( nTmpType )
721 : : {
722 : 354092 : bool bCurrency = false;
723 : : // "Automatic" currency may start with keyword,
724 : : // like "R" (Rand) and 'R' (era)
725 [ + + + - : 356064 : if ( nCurrPos != STRING_NOTFOUND &&
- + ][ - + ]
726 : 986 : nPos-1 + sCurString.Len() <= rStr.Len() &&
727 : 986 : sCurString.Search( sKeyword[nTmpType] ) == 0 )
728 : : {
729 [ # # ][ # # ]: 0 : String aTest = pChrCls->uppercase( rStr.Copy( nPos-1, sCurString.Len() ) );
[ # # ][ # # ]
[ # # ]
730 [ # # ][ # # ]: 0 : if ( aTest == sCurString )
731 [ # # ]: 0 : bCurrency = true;
732 : : }
733 [ - + ]: 354092 : if ( bCurrency )
734 : : {
735 : 0 : eState = SsGetWord;
736 : 0 : sSymbol += cToken;
737 : : }
738 : : else
739 : : {
740 : 354092 : eType = nTmpType;
741 : 354092 : xub_StrLen nLen = sKeyword[eType].Len();
742 [ + - ]: 354092 : sSymbol = rStr.Copy( nPos-1, nLen );
743 [ + + ][ + + ]: 354092 : if ( eType == NF_KEY_E || IsAmbiguousE( eType ) )
[ + - ]
744 : : {
745 : 27728 : sal_Unicode cNext = rStr.GetChar(nPos);
746 [ + - + ]: 27728 : switch ( cNext )
747 : : {
748 : : case '+' :
749 : : case '-' : // E+ E- combine to one symbol
750 : 4976 : sSymbol += cNext;
751 : 4976 : eType = NF_KEY_E;
752 : 4976 : nPos++;
753 : 4976 : break;
754 : : case '0' :
755 : : case '#' : // scientific E without sign
756 : 0 : eType = NF_KEY_E;
757 : 27728 : break;
758 : : }
759 : : }
760 : 354092 : nPos--;
761 : 354092 : nPos = nPos + nLen;
762 : 354092 : eState = SsStop;
763 : : }
764 : : }
765 : : else
766 : : {
767 : 45182 : eState = SsGetWord;
768 : 45182 : sSymbol += cToken;
769 : : }
770 : : }
771 : : else
772 : : {
773 : 74016 : eType = NF_SYMBOLTYPE_STRING;
774 : 74016 : eState = SsStop;
775 : 74016 : sSymbol += cToken;
776 : : }
777 : : }
778 : 473290 : break;
779 : : }
780 : : }
781 : 1581568 : break;
782 : : case SsGetChar:
783 : : {
784 : 640 : sSymbol += cToken;
785 : 640 : eState = SsStop;
786 : : }
787 : 640 : break;
788 : : case SsGetString:
789 : : {
790 [ + + ]: 2602 : if (cToken == '"')
791 : 1003 : eState = SsStop;
792 : 2602 : sSymbol += cToken;
793 : : }
794 : 2602 : break;
795 : : case SsGetWord:
796 : : {
797 [ + + ]: 72340 : if ( pChrCls->isLetter( rStr, nPos-1 ) )
798 : : {
799 : 71820 : short nTmpType = GetKeyWord( rStr, nPos-1 );
800 [ + + ]: 71820 : if ( nTmpType )
801 : : { // beginning of keyword, stop scan and put back
802 : 42200 : eType = NF_SYMBOLTYPE_STRING;
803 : 42200 : eState = SsStop;
804 : 42200 : nPos--;
805 : : }
806 : : else
807 : 29620 : sSymbol += cToken;
808 : : }
809 : : else
810 : : {
811 : 520 : bool bDontStop = false;
812 [ - + ]: 520 : switch (cToken)
813 : : {
814 : : case '/': // AM/PM, A/P
815 : : {
816 : 0 : sal_Unicode cNext = rStr.GetChar(nPos);
817 [ # # ][ # # ]: 0 : if ( cNext == 'P' || cNext == 'p' )
818 : : {
819 : 0 : xub_StrLen nLen = sSymbol.Len();
820 [ # # ][ # # : 0 : if ( 1 <= nLen
# # # # #
# # # ]
[ # # ][ # #
# # # # ]
821 : 0 : && (sSymbol.GetChar(0) == 'A' || sSymbol.GetChar(0) == 'a')
822 : : && (nLen == 1 || (nLen == 2
823 : 0 : && (sSymbol.GetChar(1) == 'M' || sSymbol.GetChar(1) == 'm')
824 : 0 : && (rStr.GetChar(nPos+1) == 'M' || rStr.GetChar(nPos+1) == 'm'))) )
825 : : {
826 : 0 : sSymbol += cToken;
827 : 0 : bDontStop = true;
828 : : }
829 : : }
830 : : }
831 : 0 : break;
832 : : }
833 : : // anything not recognized will stop the scan
834 [ + - ][ + - ]: 520 : if ( eState != SsStop && !bDontStop )
835 : : {
836 : 520 : eState = SsStop;
837 : 520 : nPos--;
838 : 520 : eType = NF_SYMBOLTYPE_STRING;
839 : : }
840 : : }
841 : : }
842 : 72340 : break;
843 : : case SsGetStar:
844 : : {
845 : 672 : eState = SsStop;
846 : 672 : sSymbol += cToken;
847 : 672 : nRepPos = (nPos - nStart) - 1; // everytime > 0!!
848 : : }
849 : 672 : break;
850 : : case SsGetBlank:
851 : : {
852 : 6954 : eState = SsStop;
853 : 6954 : sSymbol += cToken;
854 : : }
855 : 6954 : break;
856 : : default:
857 : 0 : break;
858 : : } // of switch
859 : : } // of while
860 [ + + ]: 1581568 : if (eState == SsGetWord)
861 : 2462 : eType = NF_SYMBOLTYPE_STRING;
862 : 1581808 : return eType;
863 : : }
864 : :
865 : 199160 : xub_StrLen ImpSvNumberformatScan::Symbol_Division(const String& rString)
866 : : {
867 : 199160 : nCurrPos = STRING_NOTFOUND;
868 : : // Ist Waehrung im Spiel?
869 [ + - ][ + - ]: 199160 : String sString = pFormatter->GetCharClass()->uppercase(rString);
[ + - ]
870 : 199160 : xub_StrLen nCPos = 0;
871 [ + + ]: 398608 : while (nCPos != STRING_NOTFOUND)
872 : : {
873 [ + - ][ + - ]: 199448 : nCPos = sString.Search(GetCurString(),nCPos);
874 [ + + ]: 199448 : if (nCPos != STRING_NOTFOUND)
875 : : {
876 : : // in Quotes?
877 [ + - ]: 50699 : xub_StrLen nQ = SvNumberformat::GetQuoteEnd( sString, nCPos );
878 [ + + ]: 50699 : if ( nQ == STRING_NOTFOUND )
879 : : {
880 : : sal_Unicode c;
881 [ + + ][ + - ]: 50435 : if ( nCPos == 0 ||
[ + + ][ + + ]
882 : 38014 : ((c = sString.GetChar(xub_StrLen(nCPos-1))) != '"'
883 : : && c != '\\') ) // dm kann durch "dm
884 : : { // \d geschuetzt werden
885 : 50411 : nCurrPos = nCPos;
886 : 50411 : nCPos = STRING_NOTFOUND; // Abbruch
887 : : }
888 : : else
889 : 24 : nCPos++; // weitersuchen
890 : : }
891 : : else
892 : 264 : nCPos = nQ + 1; // weitersuchen
893 : : }
894 : : }
895 : 199160 : nAnzStrings = 0;
896 : 199160 : bool bStar = false; // wird bei '*'Detektion gesetzt
897 : 199160 : Reset();
898 : :
899 : 199160 : xub_StrLen nPos = 0;
900 : 199160 : const xub_StrLen nLen = rString.Len();
901 [ + + ][ + - ]: 1780968 : while (nPos < nLen && nAnzStrings < NF_MAX_FORMAT_SYMBOLS)
[ + + ]
902 : : {
903 [ + - ]: 1581808 : nTypeArray[nAnzStrings] = Next_Symbol(rString, nPos, sStrArray[nAnzStrings]);
904 [ + + ]: 1581808 : if (nTypeArray[nAnzStrings] == NF_SYMBOLTYPE_STAR)
905 : : { // Ueberwachung des '*'
906 [ - + ]: 672 : if (bStar)
907 : 0 : return nPos; // Fehler: doppelter '*'
908 : : else
909 : 672 : bStar = true;
910 : : }
911 : 1581808 : nAnzStrings++;
912 : : }
913 : :
914 [ + - ]: 199160 : return 0; // 0 => ok
915 : : }
916 : :
917 : 1412308 : void ImpSvNumberformatScan::SkipStrings(sal_uInt16& i, xub_StrLen& nPos)
918 : : {
919 [ + + ][ + + ]: 1466893 : while (i < nAnzStrings && ( nTypeArray[i] == NF_SYMBOLTYPE_STRING
[ + + ][ + + ]
[ + + ]
920 : 1220774 : || nTypeArray[i] == NF_SYMBOLTYPE_BLANK
921 : 1213820 : || nTypeArray[i] == NF_SYMBOLTYPE_STAR) )
922 : : {
923 : 54585 : nPos = nPos + sStrArray[i].Len();
924 : 54585 : i++;
925 : : }
926 : 1412308 : }
927 : :
928 : 61153 : sal_uInt16 ImpSvNumberformatScan::PreviousKeyword(sal_uInt16 i)
929 : : {
930 : 61153 : short res = 0;
931 [ + + ][ + - ]: 61153 : if (i > 0 && i < nAnzStrings)
932 : : {
933 : 40320 : i--;
934 [ + + ][ + + ]: 90560 : while (i > 0 && nTypeArray[i] <= 0)
[ + + ]
935 : 50240 : i--;
936 [ + - ]: 40320 : if (nTypeArray[i] > 0)
937 : 40320 : res = nTypeArray[i];
938 : : }
939 : 61153 : return res;
940 : : }
941 : :
942 : 51233 : sal_uInt16 ImpSvNumberformatScan::NextKeyword(sal_uInt16 i)
943 : : {
944 : 51233 : short res = 0;
945 [ + + ]: 51233 : if (i < nAnzStrings-1)
946 : : {
947 : 48548 : i++;
948 [ + + ][ + + ]: 92056 : while (i < nAnzStrings-1 && nTypeArray[i] <= 0)
[ + + ]
949 : 43508 : i++;
950 [ + - ]: 48548 : if (nTypeArray[i] > 0)
951 : 48548 : res = nTypeArray[i];
952 : : }
953 : 51233 : return res;
954 : : }
955 : :
956 : 51 : short ImpSvNumberformatScan::PreviousType( sal_uInt16 i )
957 : : {
958 [ + - ][ + - ]: 51 : if ( i > 0 && i < nAnzStrings )
959 : : {
960 [ + - ][ - + ]: 51 : do
[ - + ]
961 : : {
962 : 51 : i--;
963 : 51 : } while ( i > 0 && nTypeArray[i] == NF_SYMBOLTYPE_EMPTY );
964 : 51 : return nTypeArray[i];
965 : : }
966 : 51 : return 0;
967 : : }
968 : :
969 : 117203 : sal_Unicode ImpSvNumberformatScan::PreviousChar(sal_uInt16 i)
970 : : {
971 : 117203 : sal_Unicode res = ' ';
972 [ + + ][ + - ]: 117203 : if (i > 0 && i < nAnzStrings)
973 : : {
974 : 96370 : i--;
975 [ + + ][ + + ]: 96382 : while (i > 0 && ( nTypeArray[i] == NF_SYMBOLTYPE_EMPTY
[ + - ][ + - ]
[ - + ][ + + ]
976 : 81015 : || nTypeArray[i] == NF_SYMBOLTYPE_STRING
977 : 81015 : || nTypeArray[i] == NF_SYMBOLTYPE_STAR
978 : 81015 : || nTypeArray[i] == NF_SYMBOLTYPE_BLANK ) )
979 : 12 : i--;
980 [ + - ]: 96370 : if (sStrArray[i].Len() > 0)
981 : 96370 : res = sStrArray[i].GetChar(xub_StrLen(sStrArray[i].Len()-1));
982 : : }
983 : 117203 : return res;
984 : : }
985 : :
986 : 76089 : sal_Unicode ImpSvNumberformatScan::NextChar(sal_uInt16 i)
987 : : {
988 : 76089 : sal_Unicode res = ' ';
989 [ + - ]: 76089 : if (i < nAnzStrings-1)
990 : : {
991 : 76089 : i++;
992 [ + + ][ + - ]: 76089 : while (i < nAnzStrings-1 &&
[ + - ][ + - ]
[ - + ][ - + ]
993 : 76035 : ( nTypeArray[i] == NF_SYMBOLTYPE_EMPTY
994 : 76035 : || nTypeArray[i] == NF_SYMBOLTYPE_STRING
995 : 76035 : || nTypeArray[i] == NF_SYMBOLTYPE_STAR
996 : 76035 : || nTypeArray[i] == NF_SYMBOLTYPE_BLANK))
997 : 0 : i++;
998 [ + - ]: 76089 : if (sStrArray[i].Len() > 0)
999 : 76089 : res = sStrArray[i].GetChar(0);
1000 : : }
1001 : 76089 : return res;
1002 : : }
1003 : :
1004 : 12 : bool ImpSvNumberformatScan::IsLastBlankBeforeFrac(sal_uInt16 i)
1005 : : {
1006 : 12 : bool res = true;
1007 [ + - ]: 12 : if (i < nAnzStrings-1)
1008 : : {
1009 : 12 : bool bStop = false;
1010 : 12 : i++;
1011 [ + - ][ + + ]: 30 : while (i < nAnzStrings-1 && !bStop)
[ + + ]
1012 : : {
1013 : 18 : i++;
1014 [ + - + + ]: 36 : if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
[ + + ]
1015 : 18 : sStrArray[i].GetChar(0) == '/')
1016 : 12 : bStop = true;
1017 [ + - - + ]: 12 : else if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
[ - + ]
1018 : 6 : sStrArray[i].GetChar(0) == ' ')
1019 : 0 : res = false;
1020 : : }
1021 [ - + ]: 12 : if (!bStop) // kein '/'
1022 : 0 : res = false;
1023 : : }
1024 : : else
1025 : 0 : res = false; // kein '/' mehr
1026 : :
1027 : 12 : return res;
1028 : : }
1029 : :
1030 : 203341 : void ImpSvNumberformatScan::Reset()
1031 : : {
1032 : 203341 : nAnzStrings = 0;
1033 : 203341 : nAnzResStrings = 0;
1034 : : #if 0
1035 : : // ER 20.06.97 14:05 nicht noetig, wenn nAnzStrings beachtet wird
1036 : : for (size_t i = 0; i < NF_MAX_FORMAT_SYMBOLS; i++)
1037 : : {
1038 : : sStrArray[i].Erase();
1039 : : nTypeArray[i] = 0;
1040 : : }
1041 : : #endif
1042 : 203341 : eScannedType = NUMBERFORMAT_UNDEFINED;
1043 : 203341 : nRepPos = 0;
1044 : 203341 : bExp = false;
1045 : 203341 : bThousand = false;
1046 : 203341 : nThousand = 0;
1047 : 203341 : bDecSep = false;
1048 : 203341 : nDecPos = -1;
1049 : 203341 : nExpPos = (sal_uInt16) -1;
1050 : 203341 : nBlankPos = (sal_uInt16) -1;
1051 : 203341 : nCntPre = 0;
1052 : 203341 : nCntPost = 0;
1053 : 203341 : nCntExp = 0;
1054 : 203341 : bFrac = false;
1055 : 203341 : bBlank = false;
1056 : 203341 : nNatNumModifier = 0;
1057 : 203341 : }
1058 : :
1059 : 14960 : bool ImpSvNumberformatScan::Is100SecZero( sal_uInt16 i, bool bHadDecSep )
1060 : : {
1061 : 14960 : sal_uInt16 nIndexPre = PreviousKeyword( i );
1062 : : return (nIndexPre == NF_KEY_S || nIndexPre == NF_KEY_SS)
1063 : : && (bHadDecSep // S, SS ','
1064 [ + - ][ - + ]: 14960 : || (i>0 && nTypeArray[i-1] == NF_SYMBOLTYPE_STRING));
[ # # ][ # # ]
[ + - ]
1065 : : // SS"any"00 take "any" as a valid decimal separator
1066 : : }
1067 : :
1068 : 199160 : xub_StrLen ImpSvNumberformatScan::ScanType()
1069 : : {
1070 : 199160 : const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
1071 : :
1072 : 199160 : xub_StrLen nPos = 0;
1073 : 199160 : sal_uInt16 i = 0;
1074 : : short eNewType;
1075 : 199160 : bool bMatchBracket = false;
1076 : 199160 : bool bHaveGeneral = false; // if General/Standard encountered
1077 : :
1078 : 199160 : SkipStrings(i, nPos);
1079 [ + + ]: 1412308 : while (i < nAnzStrings)
1080 : : {
1081 [ + + ]: 1213148 : if (nTypeArray[i] > 0)
1082 : : { // keyword
1083 [ + + + + : 294906 : switch (nTypeArray[i])
+ + - ]
1084 : : {
1085 : : case NF_KEY_E: // E
1086 : 4976 : eNewType = NUMBERFORMAT_SCIENTIFIC;
1087 : 4976 : break;
1088 : : case NF_KEY_AMPM: // AM,A,PM,P
1089 : : case NF_KEY_AP:
1090 : : case NF_KEY_H: // H
1091 : : case NF_KEY_HH: // HH
1092 : : case NF_KEY_S: // S
1093 : : case NF_KEY_SS: // SS
1094 : 43309 : eNewType = NUMBERFORMAT_TIME;
1095 : 43309 : break;
1096 : : case NF_KEY_M: // M
1097 : : case NF_KEY_MM: // MM
1098 : : { // minute or month
1099 : 46193 : sal_uInt16 nIndexPre = PreviousKeyword(i);
1100 : 46193 : sal_uInt16 nIndexNex = NextKeyword(i);
1101 : 46193 : sal_Unicode cChar = PreviousChar(i);
1102 [ + + ][ + - ]: 46193 : if (nIndexPre == NF_KEY_H || // H
[ + + ][ - + ]
[ + + ]
1103 : : nIndexPre == NF_KEY_HH || // HH
1104 : : nIndexNex == NF_KEY_S || // S
1105 : : nIndexNex == NF_KEY_SS || // SS
1106 : : cChar == '[' ) // [M
1107 : : {
1108 : 23116 : eNewType = NUMBERFORMAT_TIME;
1109 : 23116 : nTypeArray[i] -= 2; // 6 -> 4, 7 -> 5
1110 : : }
1111 : : else
1112 : 23077 : eNewType = NUMBERFORMAT_DATE;
1113 : : }
1114 : 46193 : break;
1115 : : case NF_KEY_MMM: // MMM
1116 : : case NF_KEY_MMMM: // MMMM
1117 : : case NF_KEY_MMMMM: // MMMMM
1118 : : case NF_KEY_Q: // Q
1119 : : case NF_KEY_QQ: // QQ
1120 : : case NF_KEY_D: // D
1121 : : case NF_KEY_DD: // DD
1122 : : case NF_KEY_DDD: // DDD
1123 : : case NF_KEY_DDDD: // DDDD
1124 : : case NF_KEY_YY: // YY
1125 : : case NF_KEY_YYYY: // YYYY
1126 : : case NF_KEY_NN: // NN
1127 : : case NF_KEY_NNN: // NNN
1128 : : case NF_KEY_NNNN: // NNNN
1129 : : case NF_KEY_WW : // WW
1130 : : case NF_KEY_AAA : // AAA
1131 : : case NF_KEY_AAAA : // AAAA
1132 : : case NF_KEY_EC : // E
1133 : : case NF_KEY_EEC : // EE
1134 : : case NF_KEY_G : // G
1135 : : case NF_KEY_GG : // GG
1136 : : case NF_KEY_GGG : // GGG
1137 : : case NF_KEY_R : // R
1138 : : case NF_KEY_RR : // RR
1139 : 195507 : eNewType = NUMBERFORMAT_DATE;
1140 : 195507 : break;
1141 : : case NF_KEY_CCC: // CCC
1142 : 2440 : eNewType = NUMBERFORMAT_CURRENCY;
1143 : 2440 : break;
1144 : : case NF_KEY_GENERAL: // Standard
1145 : 2481 : eNewType = NUMBERFORMAT_NUMBER;
1146 : 2481 : bHaveGeneral = true;
1147 : 2481 : break;
1148 : : default:
1149 : 0 : eNewType = NUMBERFORMAT_UNDEFINED;
1150 : 294906 : break;
1151 : : }
1152 : : }
1153 : : else
1154 : : { // control character
1155 [ + + + + : 918242 : switch ( sStrArray[i].GetChar(0) )
+ + + ]
1156 : : {
1157 : : case '#':
1158 : : case '?':
1159 : 247482 : eNewType = NUMBERFORMAT_NUMBER;
1160 : 247482 : break;
1161 : : case '0':
1162 : : {
1163 [ + + ]: 199314 : if ( (eScannedType & NUMBERFORMAT_TIME) == NUMBERFORMAT_TIME )
1164 : : {
1165 [ + - ]: 9920 : if ( Is100SecZero( i, bDecSep ) )
1166 : : {
1167 : 9920 : bDecSep = true; // subsequent 0's
1168 : 9920 : eNewType = NUMBERFORMAT_TIME;
1169 : : }
1170 : : else
1171 : 0 : return nPos; // Error
1172 : : }
1173 : : else
1174 : 189394 : eNewType = NUMBERFORMAT_NUMBER;
1175 : : }
1176 : 199314 : break;
1177 : : case '%':
1178 : 4892 : eNewType = NUMBERFORMAT_PERCENT;
1179 : 4892 : break;
1180 : : case '/':
1181 : 41103 : eNewType = NUMBERFORMAT_FRACTION;
1182 : 41103 : break;
1183 : : case '[':
1184 : : {
1185 [ + - ]: 94870 : if ( i < nAnzStrings-1 &&
[ + + + + ]
[ + + ]
1186 : 49955 : nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
1187 : 44915 : sStrArray[i+1].GetChar(0) == '$' )
1188 : : { // as of SV_NUMBERFORMATTER_VERSION_NEW_CURR
1189 : 25515 : eNewType = NUMBERFORMAT_CURRENCY;
1190 : 25515 : bMatchBracket = true;
1191 : : }
1192 [ + - ]: 43840 : else if ( i < nAnzStrings-1 &&
[ + + + - ]
[ + + ]
1193 : 24440 : nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
1194 : 19400 : sStrArray[i+1].GetChar(0) == '~' )
1195 : : { // as of SV_NUMBERFORMATTER_VERSION_CALENDAR
1196 : 19400 : eNewType = NUMBERFORMAT_DATE;
1197 : 19400 : bMatchBracket = true;
1198 : : }
1199 : : else
1200 : : {
1201 : 5040 : sal_uInt16 nIndexNex = NextKeyword(i);
1202 [ - + ][ # # ]: 5040 : if (nIndexNex == NF_KEY_H || // H
[ # # ][ # # ]
[ # # ][ + + ]
1203 : : nIndexNex == NF_KEY_HH || // HH
1204 : : nIndexNex == NF_KEY_M || // M
1205 : : nIndexNex == NF_KEY_MM || // MM
1206 : : nIndexNex == NF_KEY_S || // S
1207 : : nIndexNex == NF_KEY_SS ) // SS
1208 : 5040 : eNewType = NUMBERFORMAT_TIME;
1209 : : else
1210 : 0 : return nPos; // Error
1211 : : }
1212 : : }
1213 : 49955 : break;
1214 : : case '@':
1215 : 2697 : eNewType = NUMBERFORMAT_TEXT;
1216 : 2697 : break;
1217 : : default:
1218 [ + - ][ + - ]: 372799 : if (pLoc->getTime100SecSep().equals(sStrArray[i]))
[ + + ]
1219 : 65779 : bDecSep = true; // for SS,0
1220 : 372799 : eNewType = NUMBERFORMAT_UNDEFINED;
1221 : 372799 : break;
1222 : : }
1223 : : }
1224 [ + + ]: 1213148 : if (eScannedType == NUMBERFORMAT_UNDEFINED)
1225 : 223863 : eScannedType = eNewType;
1226 [ + + ][ - + ]: 989285 : else if (eScannedType == NUMBERFORMAT_TEXT || eNewType == NUMBERFORMAT_TEXT)
1227 : 24 : eScannedType = NUMBERFORMAT_TEXT; // Text bleibt immer Text
1228 [ + + ]: 989261 : else if (eNewType == NUMBERFORMAT_UNDEFINED)
1229 : : { // bleibt wie bisher
1230 : : }
1231 [ + + ]: 641379 : else if (eScannedType != eNewType)
1232 : : {
1233 [ + - + - : 213254 : switch (eScannedType)
+ + + + ]
1234 : : {
1235 : : case NUMBERFORMAT_DATE:
1236 : : {
1237 [ + + - ]: 36334 : switch (eNewType)
1238 : : {
1239 : : case NUMBERFORMAT_TIME:
1240 : 5003 : eScannedType = NUMBERFORMAT_DATETIME;
1241 : 5003 : break;
1242 : : case NUMBERFORMAT_FRACTION: // DD/MM
1243 : 31331 : break;
1244 : : default:
1245 : : {
1246 [ # # ]: 0 : if (nCurrPos != STRING_NOTFOUND)
1247 : 0 : eScannedType = NUMBERFORMAT_UNDEFINED;
1248 [ # # ][ # # ]: 0 : else if ( sStrArray[i] != pFormatter->GetDateSep() )
1249 : 0 : return nPos;
1250 : : }
1251 : : }
1252 : : }
1253 : 36334 : break;
1254 : : case NUMBERFORMAT_TIME:
1255 : : {
1256 [ # # # ]: 0 : switch (eNewType)
1257 : : {
1258 : : case NUMBERFORMAT_DATE:
1259 : 0 : eScannedType = NUMBERFORMAT_DATETIME;
1260 : 0 : break;
1261 : : case NUMBERFORMAT_FRACTION: // MM/SS
1262 : 0 : break;
1263 : : default:
1264 : : {
1265 [ # # ]: 0 : if (nCurrPos != STRING_NOTFOUND)
1266 : 0 : eScannedType = NUMBERFORMAT_UNDEFINED;
1267 [ # # ][ # # ]: 0 : else if (!pLoc->getTimeSep().equals(sStrArray[i]))
[ # # ]
1268 : 0 : return nPos;
1269 : : }
1270 : : }
1271 : : }
1272 : 0 : break;
1273 : : case NUMBERFORMAT_DATETIME:
1274 : : {
1275 [ + - - ]: 9868 : switch (eNewType)
1276 : : {
1277 : : case NUMBERFORMAT_TIME:
1278 : : case NUMBERFORMAT_DATE:
1279 : 9868 : break;
1280 : : case NUMBERFORMAT_FRACTION: // DD/MM
1281 : 0 : break;
1282 : : default:
1283 : : {
1284 [ # # ]: 0 : if (nCurrPos != STRING_NOTFOUND)
1285 : 0 : eScannedType = NUMBERFORMAT_UNDEFINED;
1286 [ # # ]: 0 : else if ( pFormatter->GetDateSep() != sStrArray[i]
[ # # # # ]
[ # # ]
1287 [ # # ][ # # ]: 0 : && !pLoc->getTimeSep().equals(sStrArray[i]) )
[ # # ][ # # ]
1288 : 0 : return nPos;
1289 : : }
1290 : : }
1291 : : }
1292 : 9868 : break;
1293 : : case NUMBERFORMAT_PERCENT:
1294 : : {
1295 [ # # ]: 0 : switch (eNewType)
1296 : : {
1297 : : case NUMBERFORMAT_NUMBER: // nur Zahl nach Prozent
1298 : 0 : break;
1299 : : default:
1300 : 0 : return nPos;
1301 : : }
1302 : : }
1303 : 0 : break;
1304 : : case NUMBERFORMAT_SCIENTIFIC:
1305 : : {
1306 [ + - ]: 12314 : switch (eNewType)
1307 : : {
1308 : : case NUMBERFORMAT_NUMBER: // nur Zahl nach E
1309 : 12314 : break;
1310 : : default:
1311 : 0 : return nPos;
1312 : : }
1313 : : }
1314 : 12314 : break;
1315 : : case NUMBERFORMAT_NUMBER:
1316 : : {
1317 [ + - ]: 22693 : switch (eNewType)
1318 : : {
1319 : : case NUMBERFORMAT_SCIENTIFIC:
1320 : : case NUMBERFORMAT_PERCENT:
1321 : : case NUMBERFORMAT_FRACTION:
1322 : : case NUMBERFORMAT_CURRENCY:
1323 : 22693 : eScannedType = eNewType;
1324 : 22693 : break;
1325 : : default:
1326 [ # # ]: 0 : if (nCurrPos != STRING_NOTFOUND)
1327 : 0 : eScannedType = NUMBERFORMAT_UNDEFINED;
1328 : : else
1329 : 0 : return nPos;
1330 : : }
1331 : : }
1332 : 22693 : break;
1333 : : case NUMBERFORMAT_FRACTION:
1334 : : {
1335 [ + - ]: 12215 : switch (eNewType)
1336 : : {
1337 : : case NUMBERFORMAT_NUMBER: // nur Zahl nach Bruch
1338 : 12215 : break;
1339 : : default:
1340 : 0 : return nPos;
1341 : : }
1342 : : }
1343 : 12215 : break;
1344 : : default:
1345 : 213254 : break;
1346 : : }
1347 : : }
1348 : 1213148 : nPos = nPos + sStrArray[i].Len(); // Korrekturposition
1349 : 1213148 : i++;
1350 [ + + ]: 1213148 : if ( bMatchBracket )
1351 : : { // no type detection inside of matching brackets if [$...], [~...]
1352 [ + + ][ + - ]: 358990 : while ( bMatchBracket && i < nAnzStrings )
[ + + ]
1353 : : {
1354 [ + + + + ]: 408693 : if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL
[ + + ]
1355 : 94618 : && sStrArray[i].GetChar(0) == ']' )
1356 : 44915 : bMatchBracket = false;
1357 : : else
1358 : 269160 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1359 : 314075 : nPos = nPos + sStrArray[i].Len();
1360 : 314075 : i++;
1361 : : }
1362 [ - + ]: 44915 : if ( bMatchBracket )
1363 : 0 : return nPos; // missing closing bracket at end of code
1364 : : }
1365 : 1213148 : SkipStrings(i, nPos);
1366 : : }
1367 : :
1368 [ + + ][ + + ]: 199160 : if ((eScannedType == NUMBERFORMAT_NUMBER || eScannedType == NUMBERFORMAT_UNDEFINED)
[ + + ][ + - ]
1369 : 24896 : && nCurrPos != STRING_NOTFOUND && !bHaveGeneral)
1370 : 24896 : eScannedType = NUMBERFORMAT_CURRENCY; // old "automatic" currency
1371 [ + + ]: 199160 : if (eScannedType == NUMBERFORMAT_UNDEFINED)
1372 : 190 : eScannedType = NUMBERFORMAT_DEFINED;
1373 : 199160 : return 0; // Alles ok
1374 : : }
1375 : :
1376 : 70947 : bool ImpSvNumberformatScan::InsertSymbol( sal_uInt16 & nPos, svt::NfSymbolType eType, const String& rStr )
1377 : : {
1378 [ + - ][ - + ]: 70947 : if (nAnzStrings >= NF_MAX_FORMAT_SYMBOLS || nPos > nAnzStrings)
1379 : 0 : return false;
1380 [ + - ][ + - ]: 70947 : if (nPos > 0 && nTypeArray[nPos-1] == NF_SYMBOLTYPE_EMPTY)
1381 : 70947 : --nPos; // reuse position
1382 : : else
1383 : : {
1384 [ # # ]: 0 : if ((size_t) (nAnzStrings + 1) >= NF_MAX_FORMAT_SYMBOLS)
1385 : 0 : return false;
1386 : 0 : ++nAnzStrings;
1387 [ # # ]: 0 : for (size_t i = nAnzStrings; i > nPos; --i)
1388 : : {
1389 : 0 : nTypeArray[i] = nTypeArray[i-1];
1390 : 0 : sStrArray[i] = sStrArray[i-1];
1391 : : }
1392 : : }
1393 : 70947 : ++nAnzResStrings;
1394 : 70947 : nTypeArray[nPos] = static_cast<short>(eType);
1395 : 70947 : sStrArray[nPos] = rStr;
1396 : 70947 : return true;
1397 : : }
1398 : :
1399 : 176156 : int ImpSvNumberformatScan::FinalScanGetCalendar( xub_StrLen& nPos, sal_uInt16& i,
1400 : : sal_uInt16& rAnzResStrings )
1401 : : {
1402 [ + + ][ + - ]: 195556 : if ( sStrArray[i].GetChar(0) == '[' &&
[ + - + - ]
[ + + ]
1403 : : i < nAnzStrings-1 &&
1404 : 19400 : nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
1405 : 19400 : sStrArray[i+1].GetChar(0) == '~' )
1406 : : { // [~calendarID]
1407 : : // as of SV_NUMBERFORMATTER_VERSION_CALENDAR
1408 : 19400 : nPos = nPos + sStrArray[i].Len(); // [
1409 : 19400 : nTypeArray[i] = NF_SYMBOLTYPE_CALDEL;
1410 : 19400 : nPos = nPos + sStrArray[++i].Len(); // ~
1411 : 19400 : sStrArray[i-1] += sStrArray[i]; // [~
1412 : 19400 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1413 : 19400 : rAnzResStrings--;
1414 [ - + ]: 19400 : if ( ++i >= nAnzStrings )
1415 : 0 : return -1; // error
1416 : 19400 : nPos = nPos + sStrArray[i].Len(); // calendarID
1417 : 19400 : String& rStr = sStrArray[i];
1418 : 19400 : nTypeArray[i] = NF_SYMBOLTYPE_CALENDAR; // convert
1419 : 19400 : i++;
1420 [ + - + + ]: 194000 : while ( i < nAnzStrings &&
[ + + ]
1421 : 97000 : sStrArray[i].GetChar(0) != ']' )
1422 : : {
1423 : 77600 : nPos = nPos + sStrArray[i].Len();
1424 : 77600 : rStr += sStrArray[i];
1425 : 77600 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1426 : 77600 : rAnzResStrings--;
1427 : 77600 : i++;
1428 : : }
1429 [ + - ]: 38800 : if ( rStr.Len() && i < nAnzStrings &&
[ + - + - ]
[ + - ]
1430 : 19400 : sStrArray[i].GetChar(0) == ']' )
1431 : : {
1432 : 19400 : nTypeArray[i] = NF_SYMBOLTYPE_CALDEL;
1433 : 19400 : nPos = nPos + sStrArray[i].Len();
1434 : 19400 : i++;
1435 : : }
1436 : : else
1437 : 0 : return -1; // error
1438 : 19400 : return 1;
1439 : : }
1440 : 176156 : return 0;
1441 : : }
1442 : :
1443 : 199160 : xub_StrLen ImpSvNumberformatScan::FinalScan( String& rString )
1444 : : {
1445 : 199160 : const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
1446 : :
1447 : : // save values for convert mode
1448 [ + - ]: 199160 : String sOldDecSep = pFormatter->GetNumDecimalSep();
1449 [ + - ]: 199160 : String sOldThousandSep = pFormatter->GetNumThousandSep();
1450 [ + - ]: 199160 : String sOldDateSep = pFormatter->GetDateSep();
1451 [ + - ][ + - ]: 199160 : String sOldTimeSep = pLoc->getTimeSep();
1452 [ + - ][ + - ]: 199160 : String sOldTime100SecSep= pLoc->getTime100SecSep();
1453 [ + - ][ + - ]: 199160 : String sOldCurSymbol = GetCurSymbol();
1454 [ + - ][ + - ]: 199160 : rtl::OUString sOldCurString = GetCurString();
1455 [ + - ]: 199160 : sal_Unicode cOldKeyH = sKeyword[NF_KEY_H].GetChar(0);
1456 [ + - ]: 199160 : sal_Unicode cOldKeyMI = sKeyword[NF_KEY_MI].GetChar(0);
1457 [ + - ]: 199160 : sal_Unicode cOldKeyS = sKeyword[NF_KEY_S].GetChar(0);
1458 : :
1459 : : // If the group separator is a Non-Breaking Space (French) continue with a
1460 : : // normal space instead so queries on space work correctly.
1461 : : // The format string is adjusted to allow both.
1462 : : // For output of the format code string the LocaleData characters are used.
1463 [ + - ][ + + ]: 199160 : if ( sOldThousandSep.GetChar(0) == cNonBreakingSpace && sOldThousandSep.Len() == 1 )
[ + + ]
1464 [ + - ]: 201 : sOldThousandSep = ' ';
1465 : :
1466 : : // change locale data et al
1467 [ + + ]: 199160 : if (bConvertMode)
1468 : : {
1469 [ + - ]: 4885 : pFormatter->ChangeIntl(eNewLnge);
1470 : : //! pointer may have changed
1471 : 4885 : pLoc = pFormatter->GetLocaleData();
1472 : : //! init new keywords
1473 [ + - ]: 4885 : InitKeywords();
1474 : : }
1475 : 199160 : const CharClass* pChrCls = pFormatter->GetCharClass();
1476 : :
1477 : 199160 : xub_StrLen nPos = 0; // error correction position
1478 : 199160 : sal_uInt16 i = 0; // symbol loop counter
1479 : 199160 : sal_uInt16 nCounter = 0; // counts digits
1480 : 199160 : nAnzResStrings = nAnzStrings; // counts remaining symbols
1481 : 199160 : bDecSep = false; // reset in case already used in TypeCheck
1482 : 199160 : bool bThaiT = false; // Thai T NatNum modifier present
1483 : :
1484 [ + + + + : 199160 : switch (eScannedType)
+ - ]
1485 : : {
1486 : : case NUMBERFORMAT_TEXT:
1487 : : case NUMBERFORMAT_DEFINED:
1488 : : {
1489 [ + + ]: 6643 : while (i < nAnzStrings)
1490 : : {
1491 [ + - + ]: 3756 : switch (nTypeArray[i])
1492 : : {
1493 : : case NF_SYMBOLTYPE_BLANK:
1494 : : case NF_SYMBOLTYPE_STAR:
1495 : 789 : break;
1496 : : case NF_KEY_GENERAL : // #77026# "General" is the same as "@"
1497 : 0 : break;
1498 : : default:
1499 : : {
1500 [ + + + + ]: 5688 : if ( nTypeArray[i] != NF_SYMBOLTYPE_DEL ||
[ + + ]
1501 : 2721 : sStrArray[i].GetChar(0) != '@' )
1502 : 270 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1503 : : }
1504 : 2967 : break;
1505 : : }
1506 : 3756 : nPos = nPos + sStrArray[i].Len();
1507 : 3756 : i++;
1508 : : } // of while
1509 : : }
1510 : 2887 : break;
1511 : : case NUMBERFORMAT_NUMBER:
1512 : : case NUMBERFORMAT_PERCENT:
1513 : : case NUMBERFORMAT_CURRENCY:
1514 : : case NUMBERFORMAT_SCIENTIFIC:
1515 : : case NUMBERFORMAT_FRACTION:
1516 : : {
1517 [ + + ]: 610175 : while (i < nAnzStrings)
1518 : : {
1519 : : // TODO: rechecking eScannedType is unnecessary.
1520 : : // This switch-case is for eScannedType == NUMBERFORMAT_FRACTION anyway
1521 [ + + ][ + + : 555491 : if (eScannedType == NUMBERFORMAT_FRACTION && // special case
+ + + + ]
[ + - + - ]
[ + + ]
1522 : 58617 : nTypeArray[i] == NF_SYMBOLTYPE_DEL && // # ### #/#
1523 : 43974 : StringEqualsChar( sOldThousandSep, ' ' ) && // e.g. France or Sweden
1524 : 54 : StringEqualsChar( sStrArray[i], ' ' ) &&
1525 : 12 : !bFrac &&
1526 : 12 : IsLastBlankBeforeFrac(i) )
1527 : : {
1528 : 12 : nTypeArray[i] = NF_SYMBOLTYPE_STRING; // del->string
1529 : : } // kein Taus.p.
1530 : :
1531 [ + + ][ + + ]: 511451 : if (nTypeArray[i] == NF_SYMBOLTYPE_BLANK ||
[ + + ][ + + ]
1532 : 505174 : nTypeArray[i] == NF_SYMBOLTYPE_STAR ||
1533 : 504614 : nTypeArray[i] == NF_KEY_CCC || // CCC
1534 : 502174 : nTypeArray[i] == NF_KEY_GENERAL ) // Standard
1535 : : {
1536 [ + + ]: 11758 : if (nTypeArray[i] == NF_KEY_GENERAL)
1537 : : {
1538 : 2481 : nThousand = FLAG_STANDARD_IN_FORMAT;
1539 [ + + ]: 2481 : if ( bConvertMode )
1540 [ + - ]: 39 : sStrArray[i] = sNameStandardFormat;
1541 : : }
1542 : 11758 : nPos = nPos + sStrArray[i].Len();
1543 : 11758 : i++;
1544 : : }
1545 [ + + ][ + + ]: 499693 : else if (nTypeArray[i] == NF_SYMBOLTYPE_STRING || // Strings oder
1546 : 448144 : nTypeArray[i] > 0) // Keywords
1547 : : {
1548 [ + + ][ + - ]: 56525 : if (eScannedType == NUMBERFORMAT_SCIENTIFIC &&
1549 : 4976 : nTypeArray[i] == NF_KEY_E) // E+
1550 : : {
1551 [ - + ]: 4976 : if (bExp) // doppelt
1552 : 0 : return nPos;
1553 : 4976 : bExp = true;
1554 : 4976 : nExpPos = i;
1555 [ + - ]: 4976 : if (bDecSep)
1556 : 4976 : nCntPost = nCounter;
1557 : : else
1558 : 0 : nCntPre = nCounter;
1559 : 4976 : nCounter = 0;
1560 : 4976 : nTypeArray[i] = NF_SYMBOLTYPE_EXP;
1561 : : }
1562 [ + + + + ]: 66204 : else if (eScannedType == NUMBERFORMAT_FRACTION &&
[ + + ]
1563 : 14655 : sStrArray[i].GetChar(0) == ' ')
1564 : : {
1565 [ + + ][ + - ]: 9769 : if (!bBlank && !bFrac) // nicht doppelt oder hinter /
1566 : : {
1567 [ - + ][ # # ]: 12 : if (bDecSep && nCounter > 0) // Nachkommastellen
1568 : 0 : return nPos; // Fehler
1569 : 12 : bBlank = true;
1570 : 12 : nBlankPos = i;
1571 : 12 : nCntPre = nCounter;
1572 : 12 : nCounter = 0;
1573 : : }
1574 : 9769 : nTypeArray[i] = NF_SYMBOLTYPE_FRACBLANK;
1575 : : }
1576 [ - + ]: 41780 : else if (nTypeArray[i] == NF_KEY_THAI_T)
1577 : : {
1578 : 0 : bThaiT = true;
1579 [ # # ][ # # ]: 0 : sStrArray[i] = sKeyword[nTypeArray[i]];
1580 : : }
1581 [ + + + + ]: 47389 : else if (sStrArray[i].GetChar(0) >= '0' &&
[ + + ]
1582 : 5609 : sStrArray[i].GetChar(0) <= '9')
1583 : : {
1584 : 4883 : rtl::OUString sDiv;
1585 : 4883 : sal_uInt16 j = i;
1586 [ + + ]: 14649 : while(j < nAnzStrings)
1587 [ + - ]: 9766 : sDiv += sStrArray[j++];
1588 [ + - ]: 4883 : if (rtl::OUString::valueOf(sDiv.toInt32()) == sDiv)
1589 : : {
1590 : : /* Found a Divisor */
1591 [ + + ]: 14649 : while (i < j)
1592 : 9766 : nTypeArray[i++] = NF_SYMBOLTYPE_FRAC_FDIV;
1593 : 4883 : i = j - 1; // Stop the loop
1594 [ + - ]: 4883 : if (nCntPost)
1595 : 4883 : nCounter = nCntPost;
1596 [ # # ]: 0 : else if (nCntPre)
1597 : 0 : nCounter = nCntPre;
1598 [ + + ]: 4883 : if (!nCntPre)
1599 : 3 : nCntPre++;
1600 : 4883 : }
1601 : : }
1602 : : else
1603 : 36897 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1604 : 56525 : nPos = nPos + sStrArray[i].Len();
1605 : 56525 : i++;
1606 : : }
1607 [ + - ]: 443168 : else if (nTypeArray[i] == NF_SYMBOLTYPE_DEL)
1608 : : {
1609 : 443168 : sal_Unicode cHere = sStrArray[i].GetChar(0);
1610 : : // Handle not pre-known separators in switch.
1611 : : sal_Unicode cSimplified;
1612 [ + + ]: 443168 : if (StringEqualsChar( pFormatter->GetNumThousandSep(), cHere))
1613 : 70875 : cSimplified = ',';
1614 [ + + ]: 372293 : else if (StringEqualsChar( pFormatter->GetNumDecimalSep(), cHere))
1615 : 53448 : cSimplified = '.';
1616 : : else
1617 : 318845 : cSimplified = cHere;
1618 [ + + + + : 443168 : switch ( cSimplified )
+ + ]
1619 : : {
1620 : : case '#':
1621 : : case '0':
1622 : : case '?':
1623 : : {
1624 [ - + ]: 230515 : if (nThousand > 0) // #... #
1625 : 0 : return nPos; // Fehler
1626 [ + + ][ - + ]: 230515 : else if (bFrac && cHere == '0')
1627 : 0 : return nPos; // 0 im Nenner
1628 : 230515 : nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
1629 : 230515 : String& rStr = sStrArray[i];
1630 : 230515 : nPos = nPos + rStr.Len();
1631 : 230515 : i++;
1632 : 230515 : nCounter++;
1633 [ + + + + : 1274538 : while (i < nAnzStrings &&
+ + + + ]
[ + + ]
1634 : 370024 : (sStrArray[i].GetChar(0) == '#' ||
1635 : 296528 : sStrArray[i].GetChar(0) == '0' ||
1636 : 175990 : sStrArray[i].GetChar(0) == '?')
1637 : : )
1638 : : {
1639 : 201481 : nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
1640 : 201481 : nPos = nPos + sStrArray[i].Len();
1641 : 201481 : nCounter++;
1642 : 201481 : i++;
1643 : : }
1644 : : }
1645 : 230515 : break;
1646 : : case '-':
1647 : : {
1648 [ + + ][ + - ]: 34753 : if ( bDecSep && nDecPos+1 == i &&
[ + - ]
1649 : 9760 : nTypeArray[nDecPos] == NF_SYMBOLTYPE_DECSEP )
1650 : : { // "0.--"
1651 : 9760 : nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
1652 : 9760 : String& rStr = sStrArray[i];
1653 : 9760 : nPos = nPos + rStr.Len();
1654 : 9760 : i++;
1655 : 9760 : nCounter++;
1656 [ + + + + ]: 29324 : while (i < nAnzStrings &&
[ + + ]
1657 : 9804 : (sStrArray[i].GetChar(0) == '-') )
1658 : : {
1659 : : // If more than two dashes are present in
1660 : : // currency formats the last dash will be
1661 : : // interpreted literally as a minus sign.
1662 : : // Has to be this ugly. Period.
1663 [ + - - + ]: 19520 : if ( eScannedType == NUMBERFORMAT_CURRENCY
[ # # # # ]
[ - + ]
1664 : 9760 : && rStr.Len() >= 2 &&
1665 : : (i == nAnzStrings-1 ||
1666 : 0 : sStrArray[i+1].GetChar(0) != '-') )
1667 : 0 : break;
1668 [ + - ]: 9760 : rStr += sStrArray[i];
1669 : 9760 : nPos = nPos + sStrArray[i].Len();
1670 : 9760 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1671 : 9760 : nAnzResStrings--;
1672 : 9760 : nCounter++;
1673 : 9760 : i++;
1674 : 9760 : }
1675 : : }
1676 : : else
1677 : : {
1678 : 24993 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1679 : 24993 : nPos = nPos + sStrArray[i].Len();
1680 : 24993 : i++;
1681 : : }
1682 : : }
1683 : 34753 : break;
1684 : : case '.':
1685 : : case ',':
1686 : : case '\'':
1687 : : case ' ':
1688 : : {
1689 : 137721 : sal_Unicode cSep = cHere; // remember
1690 [ + + ]: 137721 : if ( StringEqualsChar( sOldThousandSep, cSep ) )
1691 : : {
1692 : : // previous char with skip empty
1693 : 71010 : sal_Unicode cPre = PreviousChar(i);
1694 : : sal_Unicode cNext;
1695 [ + - ][ - + ]: 71010 : if (bExp || bBlank || bFrac)
[ + - ]
1696 : : { // after E, / or ' '
1697 [ # # ]: 0 : if ( !StringEqualsChar( sOldThousandSep, ' ' ) )
1698 : : {
1699 : 0 : nPos = nPos + sStrArray[i].Len();
1700 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1701 : 0 : nAnzResStrings--;
1702 : 0 : i++; // eat it
1703 : : }
1704 : : else
1705 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1706 : : }
1707 [ + - ][ + - ]: 71010 : else if (i > 0 && i < nAnzStrings-1 &&
[ + + ][ + + ]
[ + + ][ - + ]
[ + + ]
1708 : : (cPre == '#' || cPre == '0') &&
1709 : 70998 : ((cNext = NextChar(i)) == '#' || cNext == '0')
1710 : : ) // #,#
1711 : : {
1712 : 70947 : nPos = nPos + sStrArray[i].Len();
1713 [ + - ]: 70947 : if (!bThousand) // only once
1714 : 70947 : bThousand = true;
1715 : : // Eat it, will be reinserted at proper
1716 : : // grouping positions further down.
1717 : 70947 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1718 : 70947 : nAnzResStrings--;
1719 : 70947 : i++;
1720 : : }
1721 [ + - ][ + - ]: 114 : else if (i > 0 && (cPre == '#' || cPre == '0')
[ + + + - ]
[ + - ][ + + ]
1722 : 51 : && PreviousType(i) == NF_SYMBOLTYPE_DIGIT
1723 : : && nThousand < FLAG_STANDARD_IN_FORMAT )
1724 : : { // #,,,,
1725 [ + - ]: 51 : if ( StringEqualsChar( sOldThousandSep, ' ' ) )
1726 : : { // strange, those French..
1727 : 51 : bool bFirst = true;
1728 : 51 : String& rStr = sStrArray[i];
1729 : : // set a hard Non-Breaking Space or ConvertMode
1730 : 51 : const String& rSepF = pFormatter->GetNumThousandSep();
1731 [ + - ]: 153 : while ( i < nAnzStrings
[ + - - + ]
[ - + ]
1732 [ + - ]: 51 : && sStrArray[i] == sOldThousandSep
1733 : 51 : && StringEqualsChar( sOldThousandSep, NextChar(i) ) )
1734 : : { // last was a space or another space
1735 : : // is following => separator
1736 : 0 : nPos = nPos + sStrArray[i].Len();
1737 [ # # ]: 0 : if ( bFirst )
1738 : : {
1739 : 0 : bFirst = false;
1740 [ # # ]: 0 : rStr = rSepF;
1741 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
1742 : : }
1743 : : else
1744 : : {
1745 [ # # ]: 0 : rStr += rSepF;
1746 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1747 : 0 : nAnzResStrings--;
1748 : : }
1749 : 0 : nThousand++;
1750 : 0 : i++;
1751 : : }
1752 [ + - ][ + - ]: 102 : if ( i < nAnzStrings-1
[ + - ]
1753 [ + - ]: 51 : && sStrArray[i] == sOldThousandSep )
1754 : : { // something following last space
1755 : : // => space if currency contained,
1756 : : // else separator
1757 : 51 : nPos = nPos + sStrArray[i].Len();
1758 [ + + ][ + - : 150 : if ( (nPos <= nCurrPos &&
+ - + - ]
[ + - ]
[ + - + + ]
1759 : 51 : nCurrPos < nPos + sStrArray[i+1].Len())
1760 : 27 : || nTypeArray[i+1] == NF_KEY_CCC
1761 : : || (i < nAnzStrings-2 &&
1762 : 24 : sStrArray[i+1].GetChar(0) == '[' &&
1763 : 24 : sStrArray[i+2].GetChar(0) == '$') )
1764 : : {
1765 : 51 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1766 : : }
1767 : : else
1768 : : {
1769 [ # # ]: 0 : if ( bFirst )
1770 : : {
1771 : 0 : bFirst = false;
1772 [ # # ]: 0 : rStr = rSepF;
1773 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
1774 : : }
1775 : : else
1776 : : {
1777 [ # # ]: 0 : rStr += rSepF;
1778 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1779 : 0 : nAnzResStrings--;
1780 : : }
1781 : 0 : nThousand++;
1782 : : }
1783 : 51 : i++;
1784 : : }
1785 : : }
1786 : : else
1787 : : {
1788 [ # # ][ # # ]: 0 : do
[ # # ]
1789 : : {
1790 : 0 : nThousand++;
1791 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
1792 : 0 : nPos = nPos + sStrArray[i].Len();
1793 [ # # ]: 0 : sStrArray[i] = pFormatter->GetNumThousandSep();
1794 : 0 : i++;
1795 : : } while (i < nAnzStrings &&
1796 [ # # ]: 0 : sStrArray[i] == sOldThousandSep);
1797 : : }
1798 : : }
1799 : : else // any grsep
1800 : : {
1801 : 12 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1802 : 12 : String& rStr = sStrArray[i];
1803 : 12 : nPos = nPos + rStr.Len();
1804 : 12 : i++;
1805 [ + - ][ - + ]: 71022 : while ( i < nAnzStrings &&
[ - + ]
1806 [ + - ]: 12 : sStrArray[i] == sOldThousandSep )
1807 : : {
1808 [ # # ]: 0 : rStr += sStrArray[i];
1809 : 0 : nPos = nPos + sStrArray[i].Len();
1810 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1811 : 0 : nAnzResStrings--;
1812 : 0 : i++;
1813 : : }
1814 : : }
1815 : : }
1816 [ + + ]: 66711 : else if ( StringEqualsChar( sOldDecSep, cSep ) )
1817 : : {
1818 [ + - ][ - + ]: 53448 : if (bBlank || bFrac) // . behind / or ' '
1819 : 0 : return nPos; // error
1820 [ - + ]: 53448 : else if (bExp) // behind E
1821 : : {
1822 : 0 : nPos = nPos + sStrArray[i].Len();
1823 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1824 : 0 : nAnzResStrings--;
1825 : 0 : i++; // eat it
1826 : : }
1827 [ - + ]: 53448 : else if (bDecSep) // any .
1828 : : {
1829 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1830 : 0 : String& rStr = sStrArray[i];
1831 : 0 : nPos = nPos + rStr.Len();
1832 : 0 : i++;
1833 [ # # ][ # # ]: 0 : while ( i < nAnzStrings &&
[ # # ]
1834 [ # # ]: 0 : sStrArray[i] == sOldDecSep )
1835 : : {
1836 [ # # ]: 0 : rStr += sStrArray[i];
1837 : 0 : nPos = nPos + sStrArray[i].Len();
1838 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1839 : 0 : nAnzResStrings--;
1840 : 0 : i++;
1841 : : }
1842 : : }
1843 : : else
1844 : : {
1845 : 53448 : nPos = nPos + sStrArray[i].Len();
1846 : 53448 : nTypeArray[i] = NF_SYMBOLTYPE_DECSEP;
1847 [ + - ]: 53448 : sStrArray[i] = pFormatter->GetNumDecimalSep();
1848 : 53448 : bDecSep = true;
1849 : 53448 : nDecPos = i;
1850 : 53448 : nCntPre = nCounter;
1851 : 53448 : nCounter = 0;
1852 : :
1853 : 53448 : i++;
1854 : : }
1855 : : } // of else = DecSep
1856 : : else // . without meaning
1857 : : {
1858 [ + - ]: 23020 : if (cSep == ' ' &&
[ + + + - ]
[ + + ]
1859 : : eScannedType == NUMBERFORMAT_FRACTION &&
1860 : 9757 : StringEqualsChar( sStrArray[i], ' ' ) )
1861 : : {
1862 [ + - ][ + - ]: 9757 : if (!bBlank && !bFrac) // no dups
1863 : : { // or behind /
1864 [ - + ][ # # ]: 9757 : if (bDecSep && nCounter > 0)// dec.
1865 : 0 : return nPos; // error
1866 : 9757 : bBlank = true;
1867 : 9757 : nBlankPos = i;
1868 : 9757 : nCntPre = nCounter;
1869 : 9757 : nCounter = 0;
1870 : : }
1871 : 9757 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1872 : 9757 : nPos = nPos + sStrArray[i].Len();
1873 : : }
1874 : : else
1875 : : {
1876 : 3506 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1877 : 3506 : String& rStr = sStrArray[i];
1878 : 3506 : nPos = nPos + rStr.Len();
1879 : 3506 : i++;
1880 [ + + - + ]: 6926 : while (i < nAnzStrings &&
[ - + ]
1881 : 3420 : StringEqualsChar( sStrArray[i], cSep ) )
1882 : : {
1883 [ # # ]: 0 : rStr += sStrArray[i];
1884 : 0 : nPos = nPos + sStrArray[i].Len();
1885 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1886 : 0 : nAnzResStrings--;
1887 : 0 : i++;
1888 : : }
1889 : : }
1890 : : }
1891 : : }
1892 : 137721 : break;
1893 : : case '/':
1894 : : {
1895 [ + - ]: 9772 : if (eScannedType == NUMBERFORMAT_FRACTION)
1896 : : {
1897 [ + - ][ - + ]: 9772 : if ( i == 0 ||
[ # # ]
1898 : 9772 : (nTypeArray[i-1] != NF_SYMBOLTYPE_DIGIT &&
1899 : 0 : nTypeArray[i-1] != NF_SYMBOLTYPE_EMPTY) )
1900 [ # # ]: 0 : return nPos ? nPos : 1; // /? not allowed
1901 [ - + ][ # # ]: 9772 : else if (!bFrac || (bDecSep && nCounter > 0))
[ # # ]
1902 : : {
1903 : 9772 : bFrac = true;
1904 : 9772 : nCntPost = nCounter;
1905 : 9772 : nCounter = 0;
1906 : 9772 : nTypeArray[i] = NF_SYMBOLTYPE_FRAC;
1907 : 9772 : nPos = nPos + sStrArray[i].Len();
1908 : 9772 : i++;
1909 : : }
1910 : : else // / doppelt od. , imZaehl
1911 : 0 : return nPos; // Fehler
1912 : : }
1913 : : else
1914 : : {
1915 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1916 : 0 : nPos = nPos + sStrArray[i].Len();
1917 : 0 : i++;
1918 : : }
1919 : : }
1920 : 9772 : break;
1921 : : case '[' :
1922 : : {
1923 [ + - ][ + - ]: 51030 : if ( eScannedType == NUMBERFORMAT_CURRENCY &&
[ + - + - ]
[ + - ]
1924 : : i < nAnzStrings-1 &&
1925 : 25515 : nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
1926 : 25515 : sStrArray[i+1].GetChar(0) == '$' )
1927 : : { // [$DM-xxx]
1928 : : // ab SV_NUMBERFORMATTER_VERSION_NEW_CURR
1929 : 25515 : nPos = nPos + sStrArray[i].Len(); // [
1930 : 25515 : nTypeArray[i] = NF_SYMBOLTYPE_CURRDEL;
1931 : 25515 : nPos = nPos + sStrArray[++i].Len(); // $
1932 [ + - ]: 25515 : sStrArray[i-1] += sStrArray[i]; // [$
1933 : 25515 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1934 : 25515 : nAnzResStrings--;
1935 [ - + ]: 25515 : if ( ++i >= nAnzStrings )
1936 : 0 : return nPos; // Fehler
1937 : 25515 : nPos = nPos + sStrArray[i].Len(); // DM
1938 : 25515 : String& rStr = sStrArray[i];
1939 : 25515 : String* pStr = &sStrArray[i];
1940 : 25515 : nTypeArray[i] = NF_SYMBOLTYPE_CURRENCY; // wandeln
1941 : 25515 : bool bHadDash = false;
1942 : 25515 : i++;
1943 [ + - + + ]: 254490 : while ( i < nAnzStrings &&
[ + + ]
1944 : 127245 : sStrArray[i].GetChar(0) != ']' )
1945 : : {
1946 : 101730 : nPos = nPos + sStrArray[i].Len();
1947 [ + + ]: 101730 : if ( bHadDash )
1948 : : {
1949 [ + - ]: 74538 : *pStr += sStrArray[i];
1950 : 74538 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1951 : 74538 : nAnzResStrings--;
1952 : : }
1953 : : else
1954 : : {
1955 [ + + ]: 27192 : if ( sStrArray[i].GetChar(0) == '-' )
1956 : : {
1957 : 24850 : bHadDash = true;
1958 : 24850 : pStr = &sStrArray[i];
1959 : 24850 : nTypeArray[i] = NF_SYMBOLTYPE_CURREXT;
1960 : : }
1961 : : else
1962 : : {
1963 [ + - ]: 2342 : *pStr += sStrArray[i];
1964 : 2342 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
1965 : 2342 : nAnzResStrings--;
1966 : : }
1967 : : }
1968 : 101730 : i++;
1969 : : }
1970 [ + - ]: 51030 : if ( rStr.Len() && i < nAnzStrings &&
[ + - + - ]
[ + - ]
1971 : 25515 : sStrArray[i].GetChar(0) == ']' )
1972 : : {
1973 : 25515 : nTypeArray[i] = NF_SYMBOLTYPE_CURRDEL;
1974 : 25515 : nPos = nPos + sStrArray[i].Len();
1975 : 25515 : i++;
1976 : : }
1977 : : else
1978 : 0 : return nPos; // Fehler
1979 : : }
1980 : : else
1981 : : {
1982 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1983 : 0 : nPos = nPos + sStrArray[i].Len();
1984 : 0 : i++;
1985 : : }
1986 : : }
1987 : 25515 : break;
1988 : : default: // andere Dels
1989 : : {
1990 [ + - ][ + - ]: 4892 : if (eScannedType == NUMBERFORMAT_PERCENT &&
1991 : : cHere == '%')
1992 : 4892 : nTypeArray[i] = NF_SYMBOLTYPE_PERCENT;
1993 : : else
1994 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
1995 : 4892 : nPos = nPos + sStrArray[i].Len();
1996 : 4892 : i++;
1997 : : }
1998 : 443168 : break;
1999 : : } // of switch (Del)
2000 : : } // of else Del
2001 : : else
2002 : : {
2003 : : SAL_WARN( "svl.numbers", "unknown NF_SYMBOLTYPE_..." );
2004 : 0 : nPos = nPos + sStrArray[i].Len();
2005 : 0 : i++;
2006 : : }
2007 : : } // of while
2008 [ + + ]: 98724 : if (eScannedType == NUMBERFORMAT_FRACTION)
2009 : : {
2010 [ + - ]: 9772 : if (bFrac)
2011 : 9772 : nCntExp = nCounter;
2012 [ # # ]: 0 : else if (bBlank)
2013 : 0 : nCntPost = nCounter;
2014 : : else
2015 : 0 : nCntPre = nCounter;
2016 : : }
2017 : : else
2018 : : {
2019 [ + + ]: 88952 : if (bExp)
2020 : 4976 : nCntExp = nCounter;
2021 [ + + ]: 83976 : else if (bDecSep)
2022 : 48472 : nCntPost = nCounter;
2023 : : else
2024 : 35504 : nCntPre = nCounter;
2025 : : }
2026 [ + + ]: 98724 : if (bThousand) // Expansion of grouping separators
2027 : : {
2028 : : sal_uInt16 nMaxPos;
2029 [ - + ]: 70947 : if (bFrac)
2030 : : {
2031 [ # # ]: 0 : if (bBlank)
2032 : 0 : nMaxPos = nBlankPos;
2033 : : else
2034 : 0 : nMaxPos = 0; // no grouping
2035 : : }
2036 [ + + ]: 70947 : else if (bDecSep) // decimal separator present
2037 : 43087 : nMaxPos = nDecPos;
2038 [ - + ]: 27860 : else if (bExp) // 'E' exponent present
2039 : 0 : nMaxPos = nExpPos;
2040 : : else // up to end
2041 : 27860 : nMaxPos = i;
2042 : : // Insert separators at proper positions.
2043 : 70947 : xub_StrLen nCount = 0;
2044 [ + - ][ + - ]: 70947 : utl::DigitGroupingIterator aGrouping( pLoc->getDigitGrouping());
[ + - ]
2045 : 70947 : size_t nFirstDigitSymbol = nMaxPos;
2046 : 70947 : size_t nFirstGroupingSymbol = nMaxPos;
2047 : 70947 : i = nMaxPos;
2048 [ + + ]: 614826 : while (i-- > 0)
2049 : : {
2050 [ + + ]: 543879 : if (nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
2051 : : {
2052 : 283788 : nFirstDigitSymbol = i;
2053 : 283788 : nCount = nCount + sStrArray[i].Len(); // MSC converts += to int and then warns, so ...
2054 : : // Insert separator only if not leftmost symbol.
2055 [ + + ][ + + ]: 283788 : if (i > 0 && nCount >= aGrouping.getPos())
[ + + ]
2056 : : {
2057 : : DBG_ASSERT( sStrArray[i].Len() == 1,
2058 : : "ImpSvNumberformatScan::FinalScan: combined digits in group separator insertion");
2059 [ - + ]: 70947 : if (!InsertSymbol( i, NF_SYMBOLTYPE_THSEP,
2060 [ + - ]: 70947 : pFormatter->GetNumThousandSep()))
2061 : : // nPos isn't correct here, but signals error
2062 : 0 : return nPos;
2063 : : // i may have been decremented by 1
2064 : 70947 : nFirstDigitSymbol = i + 1;
2065 : 70947 : nFirstGroupingSymbol = i;
2066 [ + - ]: 70947 : aGrouping.advance();
2067 : : }
2068 : : }
2069 : : }
2070 : : // Generated something like "string",000; remove separator again.
2071 [ - + ]: 70947 : if (nFirstGroupingSymbol < nFirstDigitSymbol)
2072 : : {
2073 : 0 : nTypeArray[nFirstGroupingSymbol] = NF_SYMBOLTYPE_EMPTY;
2074 : 70947 : nAnzResStrings--;
2075 [ + - ][ + - ]: 70947 : }
2076 : : }
2077 : : // Combine digits into groups to save memory (Info will be copied
2078 : : // later, taking only non-empty symbols).
2079 [ + + ]: 615033 : for (i = 0; i < nAnzStrings; ++i)
2080 : : {
2081 [ + + ]: 516309 : if (nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
2082 : : {
2083 : 240275 : String& rStr = sStrArray[i];
2084 [ + + ][ + + ]: 441756 : while (++i < nAnzStrings &&
[ + + ]
2085 : 379784 : nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
2086 : : {
2087 [ + - ]: 201481 : rStr += sStrArray[i];
2088 : 201481 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
2089 : 201481 : nAnzResStrings--;
2090 : : }
2091 : : }
2092 : : }
2093 : : }
2094 : 98724 : break; // of NUMBERFORMAT_NUMBER
2095 : : case NUMBERFORMAT_DATE:
2096 : : {
2097 [ + + ]: 455824 : while (i < nAnzStrings)
2098 : : {
2099 [ + + - + : 381399 : switch (nTypeArray[i])
- ]
2100 : : {
2101 : : case NF_SYMBOLTYPE_BLANK:
2102 : : case NF_SYMBOLTYPE_STAR:
2103 : : case NF_SYMBOLTYPE_STRING:
2104 : 4897 : nPos = nPos + sStrArray[i].Len();
2105 : 4897 : i++;
2106 : 4897 : break;
2107 : : case NF_SYMBOLTYPE_DEL:
2108 : : {
2109 : : int nCalRet;
2110 [ + - ][ + + ]: 172911 : if (sStrArray[i] == sOldDateSep)
2111 : : {
2112 : 21597 : nTypeArray[i] = NF_SYMBOLTYPE_DATESEP;
2113 : 21597 : nPos = nPos + sStrArray[i].Len();
2114 [ + + ]: 21597 : if (bConvertMode)
2115 [ + - ]: 1890 : sStrArray[i] = pFormatter->GetDateSep();
2116 : 21597 : i++;
2117 : : }
2118 [ + - ][ + + ]: 151314 : else if ( (nCalRet = FinalScanGetCalendar( nPos, i, nAnzResStrings )) != 0 )
2119 : : {
2120 [ - + ]: 19400 : if ( nCalRet < 0 )
2121 : 0 : return nPos; // error
2122 : : }
2123 : : else
2124 : : {
2125 : 131914 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
2126 : 131914 : nPos = nPos + sStrArray[i].Len();
2127 : 131914 : i++;
2128 : : }
2129 : : }
2130 : 172911 : break;
2131 : : case NF_KEY_THAI_T :
2132 : 0 : bThaiT = true;
2133 : : // fall thru
2134 : : case NF_KEY_M: // M
2135 : : case NF_KEY_MM: // MM
2136 : : case NF_KEY_MMM: // MMM
2137 : : case NF_KEY_MMMM: // MMMM
2138 : : case NF_KEY_MMMMM: // MMMMM
2139 : : case NF_KEY_Q: // Q
2140 : : case NF_KEY_QQ: // QQ
2141 : : case NF_KEY_D: // D
2142 : : case NF_KEY_DD: // DD
2143 : : case NF_KEY_DDD: // DDD
2144 : : case NF_KEY_DDDD: // DDDD
2145 : : case NF_KEY_YY: // YY
2146 : : case NF_KEY_YYYY: // YYYY
2147 : : case NF_KEY_NN: // NN
2148 : : case NF_KEY_NNN: // NNN
2149 : : case NF_KEY_NNNN: // NNNN
2150 : : case NF_KEY_WW : // WW
2151 : : case NF_KEY_AAA : // AAA
2152 : : case NF_KEY_AAAA : // AAAA
2153 : : case NF_KEY_EC : // E
2154 : : case NF_KEY_EEC : // EE
2155 : : case NF_KEY_G : // G
2156 : : case NF_KEY_GG : // GG
2157 : : case NF_KEY_GGG : // GGG
2158 : : case NF_KEY_R : // R
2159 : : case NF_KEY_RR : // RR
2160 [ + - ][ + - ]: 203591 : sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
2161 : 203591 : nPos = nPos + sStrArray[i].Len();
2162 : 203591 : i++;
2163 : 203591 : break;
2164 : : default: // andere Keywords
2165 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
2166 : 0 : nPos = nPos + sStrArray[i].Len();
2167 : 0 : i++;
2168 : 0 : break;
2169 : : }
2170 : : } // of while
2171 : : }
2172 : 74425 : break; // of NUMBERFORMAT_DATE
2173 : : case NUMBERFORMAT_TIME:
2174 : : {
2175 [ + + ]: 123268 : while (i < nAnzStrings)
2176 : : {
2177 [ - + + + : 105147 : switch (nTypeArray[i])
- + - ]
2178 : : {
2179 : : case NF_SYMBOLTYPE_BLANK:
2180 : : case NF_SYMBOLTYPE_STAR:
2181 : : {
2182 : 0 : nPos = nPos + sStrArray[i].Len();
2183 : 0 : i++;
2184 : : }
2185 : 0 : break;
2186 : : case NF_SYMBOLTYPE_DEL:
2187 : : {
2188 [ + - + + : 53587 : switch( sStrArray[i].GetChar(0) )
+ ]
2189 : : {
2190 : : case '0':
2191 : : {
2192 [ + - ]: 5040 : if ( Is100SecZero( i, bDecSep ) )
2193 : : {
2194 : 5040 : bDecSep = true;
2195 : 5040 : nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
2196 : 5040 : String& rStr = sStrArray[i];
2197 : 5040 : i++;
2198 : 5040 : nPos = nPos + sStrArray[i].Len();
2199 : 5040 : nCounter++;
2200 [ + + + - ]: 14800 : while (i < nAnzStrings &&
[ + + ]
2201 : 4880 : sStrArray[i].GetChar(0) == '0')
2202 : : {
2203 [ + - ]: 4880 : rStr += sStrArray[i];
2204 : 4880 : nPos = nPos + sStrArray[i].Len();
2205 : 4880 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
2206 : 4880 : nAnzResStrings--;
2207 : 4880 : nCounter++;
2208 : 4880 : i++;
2209 : : }
2210 : : }
2211 : : else
2212 : 0 : return nPos;
2213 : : }
2214 : 5040 : break;
2215 : : case '#':
2216 : : case '?':
2217 : 0 : return nPos;
2218 : : case '[':
2219 : : {
2220 [ - + ]: 5040 : if (bThousand) // doppelt
2221 : 0 : return nPos;
2222 : 5040 : bThousand = true; // bei Time frei
2223 [ + - ]: 5040 : sal_Unicode cChar = pChrCls->uppercase(rtl::OUString(NextChar(i)))[0];
2224 [ + - ]: 5040 : if ( cChar == cOldKeyH )
2225 : 5040 : nThousand = 1; // H
2226 [ # # ]: 0 : else if ( cChar == cOldKeyMI )
2227 : 0 : nThousand = 2; // M
2228 [ # # ]: 0 : else if ( cChar == cOldKeyS )
2229 : 0 : nThousand = 3; // S
2230 : : else
2231 : 0 : return nPos;
2232 : 5040 : nPos = nPos + sStrArray[i].Len();
2233 : 5040 : i++;
2234 : : }
2235 : 5040 : break;
2236 : : case ']':
2237 : : {
2238 [ - + ]: 5040 : if (!bThousand) // kein [ vorher
2239 : 0 : return nPos;
2240 : 5040 : nPos = nPos + sStrArray[i].Len();
2241 : 5040 : i++;
2242 : : }
2243 : 5040 : break;
2244 : : default:
2245 : : {
2246 : 38467 : nPos = nPos + sStrArray[i].Len();
2247 [ + + ][ + - ]: 38467 : if ( sStrArray[i] == sOldTimeSep )
2248 : : {
2249 : 28427 : nTypeArray[i] = NF_SYMBOLTYPE_TIMESEP;
2250 [ + + ]: 28427 : if ( bConvertMode )
2251 [ + - ][ + - ]: 1507 : sStrArray[i] = pLoc->getTimeSep();
2252 : : }
2253 [ + - ][ + + ]: 10040 : else if ( sStrArray[i] == sOldTime100SecSep )
2254 : : {
2255 : 5040 : bDecSep = true;
2256 : 5040 : nTypeArray[i] = NF_SYMBOLTYPE_TIME100SECSEP;
2257 [ + + ]: 5040 : if ( bConvertMode )
2258 [ + - ][ + - ]: 152 : sStrArray[i] = pLoc->getTime100SecSep();
2259 : : }
2260 : : else
2261 : 5000 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
2262 : 38467 : i++;
2263 : : }
2264 : 38467 : break;
2265 : : }
2266 : : }
2267 : 53587 : break;
2268 : : case NF_SYMBOLTYPE_STRING:
2269 : : {
2270 : 6 : nPos = nPos + sStrArray[i].Len();
2271 : 6 : i++;
2272 : : }
2273 : 6 : break;
2274 : : case NF_KEY_AMPM: // AM/PM
2275 : : case NF_KEY_AP: // A/P
2276 : : {
2277 : 5006 : bExp = true; // missbraucht fuer A/P
2278 [ + - ][ + - ]: 5006 : sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
2279 : 5006 : nPos = nPos + sStrArray[i].Len();
2280 : 5006 : i++;
2281 : : }
2282 : 5006 : break;
2283 : : case NF_KEY_THAI_T :
2284 : 0 : bThaiT = true;
2285 : : // fall thru
2286 : : case NF_KEY_MI: // M
2287 : : case NF_KEY_MMI: // MM
2288 : : case NF_KEY_H: // H
2289 : : case NF_KEY_HH: // HH
2290 : : case NF_KEY_S: // S
2291 : : case NF_KEY_SS: // SS
2292 : : {
2293 [ + - ][ + - ]: 46548 : sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
2294 : 46548 : nPos = nPos + sStrArray[i].Len();
2295 : 46548 : i++;
2296 : : }
2297 : 46548 : break;
2298 : : default: // andere Keywords
2299 : : {
2300 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
2301 : 0 : nPos = nPos + sStrArray[i].Len();
2302 : 0 : i++;
2303 : : }
2304 : 0 : break;
2305 : : }
2306 : : } // of while
2307 : 18121 : nCntPost = nCounter; // Zaehler der Nullen
2308 [ + + ]: 18121 : if (bExp)
2309 : 5006 : nCntExp = 1; // merkt AM/PM
2310 : : }
2311 : 18121 : break; // of NUMBERFORMAT_TIME
2312 : : case NUMBERFORMAT_DATETIME:
2313 : : {
2314 : 5003 : bool bTimePart = false;
2315 [ + + ]: 59736 : while (i < nAnzStrings)
2316 : : {
2317 [ + + + + : 54733 : switch (nTypeArray[i])
+ - - ]
2318 : : {
2319 : : case NF_SYMBOLTYPE_BLANK:
2320 : : case NF_SYMBOLTYPE_STAR:
2321 : : case NF_SYMBOLTYPE_STRING:
2322 : 27 : nPos = nPos + sStrArray[i].Len();
2323 : 27 : i++;
2324 : 27 : break;
2325 : : case NF_SYMBOLTYPE_DEL:
2326 : : {
2327 : : int nCalRet;
2328 [ + - ][ - + ]: 24842 : if ( (nCalRet = FinalScanGetCalendar( nPos, i, nAnzResStrings )) != 0 )
2329 : : {
2330 [ # # ]: 0 : if ( nCalRet < 0 )
2331 : 0 : return nPos; // error
2332 : : }
2333 : : else
2334 : : {
2335 [ - - + ]: 24842 : switch( sStrArray[i].GetChar(0) )
2336 : : {
2337 : : case '0':
2338 : : {
2339 [ # # ][ # # ]: 0 : if ( bTimePart && Is100SecZero( i, bDecSep ) )
[ # # ]
2340 : : {
2341 : 0 : bDecSep = true;
2342 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
2343 : 0 : String& rStr = sStrArray[i];
2344 : 0 : i++;
2345 : 0 : nPos = nPos + sStrArray[i].Len();
2346 : 0 : nCounter++;
2347 [ # # # # ]: 0 : while (i < nAnzStrings &&
[ # # ]
2348 : 0 : sStrArray[i].GetChar(0) == '0')
2349 : : {
2350 [ # # ]: 0 : rStr += sStrArray[i];
2351 : 0 : nPos = nPos + sStrArray[i].Len();
2352 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
2353 : 0 : nAnzResStrings--;
2354 : 0 : nCounter++;
2355 : 0 : i++;
2356 : : }
2357 : : }
2358 : : else
2359 : 0 : return nPos;
2360 : : }
2361 : 0 : break;
2362 : : case '#':
2363 : : case '?':
2364 : 0 : return nPos;
2365 : : default:
2366 : : {
2367 : 24842 : nPos = nPos + sStrArray[i].Len();
2368 [ + + ]: 24842 : if (bTimePart)
2369 : : {
2370 [ + - ][ + + ]: 9860 : if ( sStrArray[i] == sOldTimeSep )
2371 : : {
2372 : 7435 : nTypeArray[i] = NF_SYMBOLTYPE_TIMESEP;
2373 [ + + ]: 7435 : if ( bConvertMode )
2374 [ + - ][ + - ]: 107 : sStrArray[i] = pLoc->getTimeSep();
2375 : : }
2376 [ + - ][ - + ]: 2425 : else if ( sStrArray[i] == sOldTime100SecSep )
2377 : : {
2378 : 0 : bDecSep = true;
2379 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_TIME100SECSEP;
2380 [ # # ]: 0 : if ( bConvertMode )
2381 [ # # ][ # # ]: 0 : sStrArray[i] = pLoc->getTime100SecSep();
2382 : : }
2383 : : else
2384 : 2425 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
2385 : : }
2386 : : else
2387 : : {
2388 [ + - ][ + + ]: 14982 : if ( sStrArray[i] == sOldDateSep )
2389 : : {
2390 : 9990 : nTypeArray[i] = NF_SYMBOLTYPE_DATESEP;
2391 [ + + ]: 9990 : if (bConvertMode)
2392 [ + - ]: 214 : sStrArray[i] = pFormatter->GetDateSep();
2393 : : }
2394 : : else
2395 : 4992 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
2396 : : }
2397 : 24842 : i++;
2398 : : }
2399 : : }
2400 : : }
2401 : : }
2402 : 24842 : break;
2403 : : case NF_KEY_AMPM: // AM/PM
2404 : : case NF_KEY_AP: // A/P
2405 : : {
2406 : 2425 : bTimePart = true;
2407 : 2425 : bExp = true; // missbraucht fuer A/P
2408 [ + - ][ + - ]: 2425 : sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
2409 : 2425 : nPos = nPos + sStrArray[i].Len();
2410 : 2425 : i++;
2411 : : }
2412 : 2425 : break;
2413 : : case NF_KEY_MI: // M
2414 : : case NF_KEY_MMI: // MM
2415 : : case NF_KEY_H: // H
2416 : : case NF_KEY_HH: // HH
2417 : : case NF_KEY_S: // S
2418 : : case NF_KEY_SS: // SS
2419 : 12446 : bTimePart = true;
2420 [ + - ][ + - ]: 12446 : sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
2421 : 12446 : nPos = nPos + sStrArray[i].Len();
2422 : 12446 : i++;
2423 : 12446 : break;
2424 : : case NF_KEY_M: // M
2425 : : case NF_KEY_MM: // MM
2426 : : case NF_KEY_MMM: // MMM
2427 : : case NF_KEY_MMMM: // MMMM
2428 : : case NF_KEY_MMMMM: // MMMMM
2429 : : case NF_KEY_Q: // Q
2430 : : case NF_KEY_QQ: // QQ
2431 : : case NF_KEY_D: // D
2432 : : case NF_KEY_DD: // DD
2433 : : case NF_KEY_DDD: // DDD
2434 : : case NF_KEY_DDDD: // DDDD
2435 : : case NF_KEY_YY: // YY
2436 : : case NF_KEY_YYYY: // YYYY
2437 : : case NF_KEY_NN: // NN
2438 : : case NF_KEY_NNN: // NNN
2439 : : case NF_KEY_NNNN: // NNNN
2440 : : case NF_KEY_WW : // WW
2441 : : case NF_KEY_AAA : // AAA
2442 : : case NF_KEY_AAAA : // AAAA
2443 : : case NF_KEY_EC : // E
2444 : : case NF_KEY_EEC : // EE
2445 : : case NF_KEY_G : // G
2446 : : case NF_KEY_GG : // GG
2447 : : case NF_KEY_GGG : // GGG
2448 : : case NF_KEY_R : // R
2449 : : case NF_KEY_RR : // RR
2450 : 14993 : bTimePart = false;
2451 [ + - ][ + - ]: 14993 : sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
2452 : 14993 : nPos = nPos + sStrArray[i].Len();
2453 : 14993 : i++;
2454 : 14993 : break;
2455 : : case NF_KEY_THAI_T :
2456 : 0 : bThaiT = true;
2457 [ # # ][ # # ]: 0 : sStrArray[i] = sKeyword[nTypeArray[i]];
2458 : 0 : nPos = nPos + sStrArray[i].Len();
2459 : 0 : i++;
2460 : 0 : break;
2461 : : default: // andere Keywords
2462 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_STRING;
2463 : 0 : nPos = nPos + sStrArray[i].Len();
2464 : 0 : i++;
2465 : 0 : break;
2466 : : }
2467 : : } // of while
2468 : 5003 : nCntPost = nCounter; // decimals (100th seconds)
2469 [ + + ]: 5003 : if (bExp)
2470 : 2425 : nCntExp = 1; // merkt AM/PM
2471 : : }
2472 : 5003 : break; // of NUMBERFORMAT_DATETIME
2473 : : default:
2474 : 0 : break;
2475 : : }
2476 [ + + ][ + - ]: 199160 : if (eScannedType == NUMBERFORMAT_SCIENTIFIC &&
[ - + ]
2477 : : (nCntPre + nCntPost == 0 || nCntExp == 0))
2478 : 0 : return nPos;
2479 [ + + ][ + - ]: 199160 : else if (eScannedType == NUMBERFORMAT_FRACTION && (nCntExp > 8 || nCntExp == 0))
[ - + ]
2480 : 0 : return nPos;
2481 : :
2482 [ - + ][ # # ]: 199160 : if (bThaiT && !GetNatNumModifier())
[ - + ]
2483 : 0 : SetNatNumModifier(1);
2484 : :
2485 [ + + ]: 199160 : if ( bConvertMode )
2486 : : { // strings containing keywords of the target locale must be quoted, so
2487 : : // the user sees the difference and is able to edit the format string
2488 [ + + ]: 35829 : for ( i=0; i < nAnzStrings; i++ )
2489 : : {
2490 [ + + + + ]: 34432 : if ( nTypeArray[i] == NF_SYMBOLTYPE_STRING &&
[ + + ]
2491 : 3488 : sStrArray[i].GetChar(0) != '\"' )
2492 : : {
2493 [ - + ][ # # ]: 2716 : if ( bConvertSystemToSystem && eScannedType == NUMBERFORMAT_CURRENCY )
2494 : : { // don't stringize automatic currency, will be converted
2495 [ # # ][ # # ]: 0 : if ( sStrArray[i] == sOldCurSymbol )
2496 : 0 : continue; // for
2497 : : // DM might be splitted into D and M
2498 [ # # # # ]: 0 : if ( sStrArray[i].Len() < sOldCurSymbol.Len() &&
[ # # ]
2499 [ # # ][ # # ]: 0 : pChrCls->uppercase( sStrArray[i], 0, 1 )[0] ==
[ # # ][ # # ]
[ # # # # ]
2500 : 0 : sOldCurString[0] )
2501 : : {
2502 [ # # ]: 0 : String aTmp( sStrArray[i] );
2503 : 0 : sal_uInt16 j = i + 1;
2504 [ # # ][ # # ]: 0 : while ( aTmp.Len() < sOldCurSymbol.Len() &&
[ # # ][ # # ]
2505 : : j < nAnzStrings &&
2506 : 0 : nTypeArray[j] == NF_SYMBOLTYPE_STRING )
2507 : : {
2508 [ # # ]: 0 : aTmp += sStrArray[j++];
2509 : : }
2510 [ # # ][ # # ]: 0 : if ( pChrCls->uppercase( aTmp ) == sOldCurString )
[ # # ]
2511 : : {
2512 [ # # ]: 0 : sStrArray[i++] = aTmp;
2513 [ # # ]: 0 : for ( ; i<j; i++ )
2514 : : {
2515 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
2516 : 0 : nAnzResStrings--;
2517 : : }
2518 : 0 : i = j - 1;
2519 : 0 : continue; // for
2520 [ # # ][ # # ]: 0 : }
2521 : : }
2522 : : }
2523 : 2716 : String& rStr = sStrArray[i];
2524 : 2716 : xub_StrLen nLen = rStr.Len();
2525 [ + + ]: 6072 : for ( xub_StrLen j=0; j<nLen; j++ )
2526 : : {
2527 [ + + ][ - + ]: 3356 : if ( (j == 0 || rStr.GetChar(j-1) != '\\') && GetKeyWord( rStr, j ) )
[ + - ][ - + ]
[ - + ]
2528 : : {
2529 [ # # ]: 0 : rStr.Insert( '\"', 0 );
2530 [ # # ]: 0 : rStr += '\"';
2531 : 0 : break; // for
2532 : : }
2533 : : }
2534 : : }
2535 : : }
2536 : : }
2537 : : // concatenate strings, remove quotes for output, and rebuild the format string
2538 [ + - ]: 199160 : rString.Erase();
2539 : 199160 : i = 0;
2540 [ + + ]: 1738868 : while (i < nAnzStrings)
2541 : : {
2542 [ + + - + : 1539708 : switch ( nTypeArray[i] )
+ ]
2543 : : {
2544 : : case NF_SYMBOLTYPE_STRING :
2545 : : {
2546 : 172890 : xub_StrLen nStringPos = rString.Len();
2547 : 172890 : xub_StrLen nArrPos = 0;
2548 : 172890 : sal_uInt16 iPos = i;
2549 [ + + ][ + + ]: 214990 : do
[ + + ]
2550 : : {
2551 [ + + + + ]: 218202 : if (sStrArray[i].Len() == 2 &&
[ + + ]
2552 : 3212 : sStrArray[i].GetChar(0) == '\\')
2553 : : {
2554 : : // Unescape some simple forms of symbols even in the UI
2555 : : // visible string to prevent duplicates that differ
2556 : : // only in notation, originating from import.
2557 : : // e.g. YYYY-MM-DD and YYYY\-MM\-DD are identical,
2558 : : // but 0\ 000 0 and 0 000 0 in a French locale are not.
2559 : 640 : sal_Unicode c = sStrArray[i].GetChar(1);
2560 [ + + + ]: 640 : switch (c)
2561 : : {
2562 : : case '+':
2563 : : case '-':
2564 [ + - ]: 165 : rString += c;
2565 : 165 : break;
2566 : : case ' ':
2567 : : case '.':
2568 : : case '/':
2569 [ + + + - : 565 : if (((eScannedType & NUMBERFORMAT_DATE) == 0)
+ - ]
[ + - - + ]
[ - + ]
2570 : : && (StringEqualsChar(
2571 : 136 : pFormatter->GetNumThousandSep(),
2572 : 136 : c) || StringEqualsChar(
2573 : 136 : pFormatter->GetNumDecimalSep(),
2574 : 136 : c) || (c == ' ' &&
2575 : : StringEqualsChar(
2576 : 136 : pFormatter->GetNumThousandSep(),
2577 : 136 : cNonBreakingSpace))))
2578 [ # # ]: 0 : rString += sStrArray[i];
2579 [ + + - + ]: 178 : else if ((eScannedType & NUMBERFORMAT_DATE) &&
[ - + ]
2580 : : StringEqualsChar(
2581 : 21 : pFormatter->GetDateSep(), c))
2582 [ # # ]: 0 : rString += sStrArray[i];
2583 [ + + + - : 332 : else if ((eScannedType & NUMBERFORMAT_TIME) &&
- + ][ - + ]
2584 [ + - ]: 9 : (StringEqualsChar( pLoc->getTimeSep(),
2585 [ + - ][ + + ]: 166 : c) ||
[ + - ][ # # ]
2586 : : StringEqualsChar(
2587 [ + - ][ + - ]: 166 : pLoc->getTime100SecSep(), c)))
[ + + ][ + - ]
[ # # ]
2588 [ # # ]: 0 : rString += sStrArray[i];
2589 [ + + ]: 157 : else if (eScannedType & NUMBERFORMAT_FRACTION)
2590 [ + - ]: 3 : rString += sStrArray[i];
2591 : : else
2592 [ + - ]: 154 : rString += c;
2593 : 157 : break;
2594 : : default:
2595 [ + - ]: 640 : rString += sStrArray[i];
2596 : : }
2597 : : }
2598 : : else
2599 [ + - ]: 214350 : rString += sStrArray[i];
2600 [ + - ][ + + ]: 214990 : if ( RemoveQuotes( sStrArray[i] ) > 0 )
2601 : : { // update currency up to quoted string
2602 [ + + ]: 1643 : if ( eScannedType == NUMBERFORMAT_CURRENCY )
2603 : : { // dM -> DM or DM -> $ in old automatic
2604 : : // currency formats, oh my ..., why did we ever
2605 : : // introduce them?
2606 : : String aTmp( pChrCls->uppercase(
2607 : 36 : sStrArray[iPos], nArrPos,
2608 [ + - ][ + - ]: 36 : sStrArray[iPos].Len()-nArrPos ) );
[ + - ]
2609 [ + - ][ + - ]: 36 : xub_StrLen nCPos = aTmp.Search( sOldCurString );
[ + - ]
2610 [ - + ]: 36 : if ( nCPos != STRING_NOTFOUND )
2611 : : {
2612 : : const String& rCur =
2613 : : bConvertMode && bConvertSystemToSystem ?
2614 [ # # ][ # # ]: 0 : GetCurSymbol() : sOldCurSymbol;
[ # # ]
2615 : 0 : sStrArray[iPos].Replace( nArrPos+nCPos,
2616 [ # # ]: 0 : sOldCurString.getLength(), rCur );
2617 : : rString.Replace( nStringPos+nCPos,
2618 [ # # ]: 0 : sOldCurString.getLength(), rCur );
2619 : : }
2620 : 36 : nStringPos = rString.Len();
2621 [ + - ]: 36 : if ( iPos == i )
2622 : 36 : nArrPos = sStrArray[iPos].Len();
2623 : : else
2624 [ + - ]: 36 : nArrPos = sStrArray[iPos].Len() + sStrArray[i].Len();
2625 : : }
2626 : : }
2627 [ + + ]: 214990 : if ( iPos != i )
2628 : : {
2629 [ + - ]: 42100 : sStrArray[iPos] += sStrArray[i];
2630 : 42100 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
2631 : 42100 : nAnzResStrings--;
2632 : : }
2633 : 214990 : i++;
2634 : 206570 : } while ( i < nAnzStrings && nTypeArray[i] == NF_SYMBOLTYPE_STRING );
2635 [ + + ]: 172890 : if ( i < nAnzStrings )
2636 : 164470 : i--; // enter switch on next symbol again
2637 [ + + ][ + + ]: 172890 : if ( eScannedType == NUMBERFORMAT_CURRENCY && nStringPos < rString.Len() )
[ + + ]
2638 : : { // same as above, since last RemoveQuotes
2639 : : String aTmp( pChrCls->uppercase(
2640 : 40973 : sStrArray[iPos], nArrPos,
2641 [ + - ][ + - ]: 40973 : sStrArray[iPos].Len()-nArrPos ) );
[ + - ]
2642 [ + - ][ + - ]: 40973 : xub_StrLen nCPos = aTmp.Search( sOldCurString );
[ + - ]
2643 [ + + ]: 40973 : if ( nCPos != STRING_NOTFOUND )
2644 : : {
2645 : : const String& rCur =
2646 : : bConvertMode && bConvertSystemToSystem ?
2647 [ + + ][ - + ]: 24896 : GetCurSymbol() : sOldCurSymbol;
[ # # ]
2648 : 24896 : sStrArray[iPos].Replace( nArrPos+nCPos,
2649 [ + - ]: 24896 : sOldCurString.getLength(), rCur );
2650 : : rString.Replace( nStringPos+nCPos,
2651 [ + - ]: 24896 : sOldCurString.getLength(), rCur );
2652 [ + - ]: 40973 : }
2653 : : }
2654 : : }
2655 : 172890 : break;
2656 : : case NF_SYMBOLTYPE_CURRENCY :
2657 : : {
2658 [ + - ]: 25515 : rString += sStrArray[i];
2659 [ + - ]: 25515 : RemoveQuotes( sStrArray[i] );
2660 : : }
2661 : 25515 : break;
2662 : : case NF_KEY_THAI_T:
2663 [ # # ][ # # ]: 0 : if (bThaiT && GetNatNumModifier() == 1)
[ # # ]
2664 : : { // Remove T from format code, will be replaced with a [NatNum1] prefix.
2665 : 0 : nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
2666 : 0 : nAnzResStrings--;
2667 : : }
2668 : : else
2669 [ # # ]: 0 : rString += sStrArray[i];
2670 : 0 : break;
2671 : : case NF_SYMBOLTYPE_EMPTY :
2672 : : // nothing
2673 : 415516 : break;
2674 : : default:
2675 [ + - ]: 925787 : rString += sStrArray[i];
2676 : : }
2677 : 1539708 : i++;
2678 : : }
2679 [ + - ][ + - ]: 199160 : return 0;
[ + - ][ + - ]
[ + - ][ + - ]
2680 : : }
2681 : :
2682 : 240505 : xub_StrLen ImpSvNumberformatScan::RemoveQuotes( String& rStr )
2683 : : {
2684 [ + + ]: 240505 : if ( rStr.Len() > 1 )
2685 : : {
2686 : 7224 : sal_Unicode c = rStr.GetChar(0);
2687 : : xub_StrLen n;
2688 [ + - ][ + + ]: 7224 : if ( c == '"' && rStr.GetChar( (n = xub_StrLen(rStr.Len()-1)) ) == '"' )
[ + + ]
2689 : : {
2690 : 1003 : rStr.Erase(n,1);
2691 : 1003 : rStr.Erase(0,1);
2692 : 1003 : return 2;
2693 : : }
2694 [ + + ]: 6221 : else if ( c == '\\' )
2695 : : {
2696 : 640 : rStr.Erase(0,1);
2697 : 640 : return 1;
2698 : : }
2699 : : }
2700 : 240505 : return 0;
2701 : : }
2702 : :
2703 : 199160 : xub_StrLen ImpSvNumberformatScan::ScanFormat( String& rString )
2704 : : {
2705 : 199160 : xub_StrLen res = Symbol_Division(rString); //lexikalische Analyse
2706 [ + - ]: 199160 : if (!res)
2707 : 199160 : res = ScanType(); // Erkennung des Formattyps
2708 [ + - ]: 199160 : if (!res)
2709 : 199160 : res = FinalScan( rString ); // Typabhaengige Endanalyse
2710 : 199160 : return res; // res = Kontrollposition
2711 : : // res = 0 => Format ok
2712 : : }
2713 : :
2714 : 199160 : void ImpSvNumberformatScan::CopyInfo(ImpSvNumberformatInfo* pInfo, sal_uInt16 nAnz)
2715 : : {
2716 : : size_t i,j;
2717 : 199160 : j = 0;
2718 : 199160 : i = 0;
2719 [ + + ][ + - ]: 1684185 : while (i < nAnz && j < NF_MAX_FORMAT_SYMBOLS)
[ + + ]
2720 : : {
2721 [ + + ]: 1485025 : if (nTypeArray[j] != NF_SYMBOLTYPE_EMPTY)
2722 : : {
2723 : 1124192 : pInfo->sStrArray[i] = sStrArray[j];
2724 : 1124192 : pInfo->nTypeArray[i] = nTypeArray[j];
2725 : 1124192 : i++;
2726 : : }
2727 : 1485025 : j++;
2728 : : }
2729 : 199160 : pInfo->eScannedType = eScannedType;
2730 : 199160 : pInfo->bThousand = bThousand;
2731 : 199160 : pInfo->nThousand = nThousand;
2732 : 199160 : pInfo->nCntPre = nCntPre;
2733 : 199160 : pInfo->nCntPost = nCntPost;
2734 : 199160 : pInfo->nCntExp = nCntExp;
2735 : 199160 : }
2736 : :
2737 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
