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