/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svl.hxx"
#ifndef GCC
#endif
#include <stdlib.h>
#include <tools/debug.hxx>
#include <i18npool/mslangid.hxx>
#include <unotools/charclass.hxx>
#include <unotools/localedatawrapper.hxx>
#include <unotools/numberformatcodewrapper.hxx>
#include <rtl/instance.hxx>
#include <svl/zforlist.hxx>
#include <svl/zformat.hxx>
#include <unotools/digitgroupingiterator.hxx>
#define _ZFORSCAN_CXX
#include "zforscan.hxx"
#undef _ZFORSCAN_CXX
#include <svl/nfsymbol.hxx>
using namespace svt;
const sal_Unicode cNonBreakingSpace = 0xA0;
namespace
{
struct ImplEnglishColors
{
const String* operator()()
{
static const String aEnglishColors[NF_MAX_DEFAULT_COLORS] =
{
String( RTL_CONSTASCII_USTRINGPARAM( "BLACK" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "BLUE" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "GREEN" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "CYAN" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "RED" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "MAGENTA" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "BROWN" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "GREY" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "YELLOW" ) ),
String( RTL_CONSTASCII_USTRINGPARAM( "WHITE" ) )
};
return &aEnglishColors[0];
}
};
struct theEnglishColors
: public rtl::StaticAggregate< const String, ImplEnglishColors> {};
}
ImpSvNumberformatScan::ImpSvNumberformatScan( SvNumberFormatter* pFormatterP )
{
pFormatter = pFormatterP;
bConvertMode = sal_False;
//! All keywords MUST be UPPERCASE!
sKeyword[NF_KEY_E].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "E" ) ); // Exponent
sKeyword[NF_KEY_AMPM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AM/PM" ) ); // AM/PM
sKeyword[NF_KEY_AP].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "A/P" ) ); // AM/PM short
sKeyword[NF_KEY_MI].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "M" ) ); // Minute
sKeyword[NF_KEY_MMI].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MM" ) ); // Minute 02
sKeyword[NF_KEY_S].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "S" ) ); // Second
sKeyword[NF_KEY_SS].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "SS" ) ); // Second 02
sKeyword[NF_KEY_Q].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Q" ) ); // Quarter short 'Q'
sKeyword[NF_KEY_QQ].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "QQ" ) ); // Quarter long
sKeyword[NF_KEY_NN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NN" ) ); // Day of week short
sKeyword[NF_KEY_NNN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NNN" ) ); // Day of week long
sKeyword[NF_KEY_NNNN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NNNN" ) ); // Day of week long incl. separator
sKeyword[NF_KEY_WW].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "WW" ) ); // Week of year
sKeyword[NF_KEY_CCC].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "CCC" ) ); // Currency abbreviation
bKeywordsNeedInit = sal_True; // locale dependent keywords
bCompatCurNeedInit = sal_True; // locale dependent compatibility currency strings
StandardColor[0] = Color(COL_BLACK);
StandardColor[1] = Color(COL_LIGHTBLUE);
StandardColor[2] = Color(COL_LIGHTGREEN);
StandardColor[3] = Color(COL_LIGHTCYAN);
StandardColor[4] = Color(COL_LIGHTRED);
StandardColor[5] = Color(COL_LIGHTMAGENTA);
StandardColor[6] = Color(COL_BROWN);
StandardColor[7] = Color(COL_GRAY);
StandardColor[8] = Color(COL_YELLOW);
StandardColor[9] = Color(COL_WHITE);
pNullDate = new Date(30,12,1899);
nStandardPrec = 2;
sErrStr.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "###" ) );
Reset();
}
ImpSvNumberformatScan::~ImpSvNumberformatScan()
{
delete pNullDate;
Reset();
}
void ImpSvNumberformatScan::ChangeIntl()
{
bKeywordsNeedInit = sal_True;
bCompatCurNeedInit = sal_True;
// may be initialized by InitSpecialKeyword()
sKeyword[NF_KEY_TRUE].Erase();
sKeyword[NF_KEY_FALSE].Erase();
}
void ImpSvNumberformatScan::InitSpecialKeyword( NfKeywordIndex eIdx ) const
{
switch ( eIdx )
{
case NF_KEY_TRUE :
((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_TRUE] =
pFormatter->GetCharClass()->upper(
pFormatter->GetLocaleData()->getTrueWord() );
if ( !sKeyword[NF_KEY_TRUE].Len() )
{
DBG_ERRORFILE( "InitSpecialKeyword: TRUE_WORD?" );
((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_TRUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "sal_True" ) );
}
break;
case NF_KEY_FALSE :
((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_FALSE] =
pFormatter->GetCharClass()->upper(
pFormatter->GetLocaleData()->getFalseWord() );
if ( !sKeyword[NF_KEY_FALSE].Len() )
{
DBG_ERRORFILE( "InitSpecialKeyword: FALSE_WORD?" );
((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_FALSE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "sal_False" ) );
}
break;
default:
DBG_ERRORFILE( "InitSpecialKeyword: unknown request" );
}
}
void ImpSvNumberformatScan::InitCompatCur() const
{
ImpSvNumberformatScan* pThis = (ImpSvNumberformatScan*)this;
// currency symbol for old style ("automatic") compatibility format codes
pFormatter->GetCompatibilityCurrency( pThis->sCurSymbol, pThis->sCurAbbrev );
// currency symbol upper case
pThis->sCurString = pFormatter->GetCharClass()->upper( sCurSymbol );
bCompatCurNeedInit = sal_False;
}
void ImpSvNumberformatScan::InitKeywords() const
{
if ( !bKeywordsNeedInit )
return ;
((ImpSvNumberformatScan*)this)->SetDependentKeywords();
bKeywordsNeedInit = sal_False;
}
/** Extract the name of General, Standard, Whatever, ignoring leading modifiers
such as [NatNum1]. */
static String lcl_extractStandardGeneralName( const ::rtl::OUString & rCode )
{
String aStr;
const sal_Unicode* p = rCode.getStr();
const sal_Unicode* const pStop = p + rCode.getLength();
const sal_Unicode* pBeg = p; // name begins here
bool bMod = false;
bool bDone = false;
while (p < pStop && !bDone)
{
switch (*p)
{
case '[':
bMod = true;
break;
case ']':
if (bMod)
{
bMod = false;
pBeg = p+1;
}
// else: would be a locale data error, easily to be spotted in
// UI dialog
break;
case ';':
if (!bMod)
{
bDone = true;
--p; // put back, increment by one follows
}
break;
}
++p;
if (bMod)
pBeg = p;
}
if (pBeg < p)
aStr = rCode.copy( pBeg - rCode.getStr(), p - pBeg);
return aStr;
}
void ImpSvNumberformatScan::SetDependentKeywords()
{
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
const CharClass* pCharClass = pFormatter->GetCharClass();
const LocaleDataWrapper* pLocaleData = pFormatter->GetLocaleData();
// #80023# be sure to generate keywords for the loaded Locale, not for the
// requested Locale, otherwise number format codes might not match
lang::Locale aLoadedLocale = pLocaleData->getLoadedLocale();
LanguageType eLang = MsLangId::convertLocaleToLanguage( aLoadedLocale );
NumberFormatCodeWrapper aNumberFormatCode( pFormatter->GetServiceManager(), aLoadedLocale );
i18n::NumberFormatCode aFormat = aNumberFormatCode.getFormatCode( NF_NUMBER_STANDARD );
sNameStandardFormat = lcl_extractStandardGeneralName( aFormat.Code);
sKeyword[NF_KEY_GENERAL] = pCharClass->upper( sNameStandardFormat );
// preset new calendar keywords
sKeyword[NF_KEY_AAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AAA" ) );
sKeyword[NF_KEY_AAAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AAAA" ) );
sKeyword[NF_KEY_EC].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "E" ) );
sKeyword[NF_KEY_EEC].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "EE" ) );
sKeyword[NF_KEY_G].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "G" ) );
sKeyword[NF_KEY_GG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GG" ) );
sKeyword[NF_KEY_GGG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGG" ) );
sKeyword[NF_KEY_R].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "R" ) );
sKeyword[NF_KEY_RR].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "RR" ) );
// Thai T NatNum special. Other locale's small letter 't' results in upper
// case comparison not matching but length does in conversion mode. Ugly.
if (eLang == LANGUAGE_THAI)
sKeyword[NF_KEY_THAI_T].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T"));
else
sKeyword[NF_KEY_THAI_T].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "t"));
switch ( eLang )
{
case LANGUAGE_GERMAN:
case LANGUAGE_GERMAN_SWISS:
case LANGUAGE_GERMAN_AUSTRIAN:
case LANGUAGE_GERMAN_LUXEMBOURG:
case LANGUAGE_GERMAN_LIECHTENSTEIN:
{
//! all capital letters
sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "M" ) ); // month 1
sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MM" ) ); // month 01
sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMM" ) ); // month Jan
sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMM" ) ); // month Januar
sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMMM" ) );// month J
sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "H" ) ); // hour 2
sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "HH" ) ); // hour 02
sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T" ) );
sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TT" ) );
sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TTT" ) );
sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TTTT" ) );
sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
sKeyword[NF_KEY_BOOLEAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "LOGISCH" ) );
sKeyword[NF_KEY_COLOR].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "FARBE" ) );
sKeyword[NF_KEY_BLACK].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "SCHWARZ" ) );
sKeyword[NF_KEY_BLUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BLAU" ) );
sKeyword[NF_KEY_GREEN] = UniString( "GR" "\xDC" "N", RTL_TEXTENCODING_ISO_8859_1 );
sKeyword[NF_KEY_CYAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "CYAN" ) );
sKeyword[NF_KEY_RED].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "ROT" ) );
sKeyword[NF_KEY_MAGENTA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MAGENTA" ) );
sKeyword[NF_KEY_BROWN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BRAUN" ) );
sKeyword[NF_KEY_GREY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GRAU" ) );
sKeyword[NF_KEY_YELLOW].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GELB" ) );
sKeyword[NF_KEY_WHITE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "WEISS" ) );
}
break;
default:
{
// day
switch ( eLang )
{
case LANGUAGE_ITALIAN :
case LANGUAGE_ITALIAN_SWISS :
sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "G" ) );
sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GG" ) );
sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGG" ) );
sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGGG" ) );
// must exchange the era code, same as Xcl
sKeyword[NF_KEY_G].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "X" ) );
sKeyword[NF_KEY_GG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "XX" ) );
sKeyword[NF_KEY_GGG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "XXX" ) );
break;
case LANGUAGE_FRENCH :
case LANGUAGE_FRENCH_BELGIAN :
case LANGUAGE_FRENCH_CANADIAN :
case LANGUAGE_FRENCH_SWISS :
case LANGUAGE_FRENCH_LUXEMBOURG :
case LANGUAGE_FRENCH_MONACO :
sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "J" ) );
sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJ" ) );
sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
break;
case LANGUAGE_FINNISH :
sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "P" ) );
sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PP" ) );
sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PPP" ) );
sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PPPP" ) );
break;
default:
sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D" ) );
sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DD" ) );
sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDD" ) );
sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDDD" ) );
}
// month
switch ( eLang )
{
case LANGUAGE_FINNISH :
sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "K" ) );
sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KK" ) );
sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKK" ) );
sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKKK" ) );
sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKKKK" ) );
break;
default:
sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "M" ) );
sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MM" ) );
sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMM" ) );
sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMM" ) );
sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMMM" ) );
}
// year
switch ( eLang )
{
case LANGUAGE_ITALIAN :
case LANGUAGE_ITALIAN_SWISS :
case LANGUAGE_FRENCH :
case LANGUAGE_FRENCH_BELGIAN :
case LANGUAGE_FRENCH_CANADIAN :
case LANGUAGE_FRENCH_SWISS :
case LANGUAGE_FRENCH_LUXEMBOURG :
case LANGUAGE_FRENCH_MONACO :
case LANGUAGE_PORTUGUESE :
case LANGUAGE_PORTUGUESE_BRAZILIAN :
case LANGUAGE_SPANISH_MODERN :
case LANGUAGE_SPANISH_DATED :
case LANGUAGE_SPANISH_MEXICAN :
case LANGUAGE_SPANISH_GUATEMALA :
case LANGUAGE_SPANISH_COSTARICA :
case LANGUAGE_SPANISH_PANAMA :
case LANGUAGE_SPANISH_DOMINICAN_REPUBLIC :
case LANGUAGE_SPANISH_VENEZUELA :
case LANGUAGE_SPANISH_COLOMBIA :
case LANGUAGE_SPANISH_PERU :
case LANGUAGE_SPANISH_ARGENTINA :
case LANGUAGE_SPANISH_ECUADOR :
case LANGUAGE_SPANISH_CHILE :
case LANGUAGE_SPANISH_URUGUAY :
case LANGUAGE_SPANISH_PARAGUAY :
case LANGUAGE_SPANISH_BOLIVIA :
case LANGUAGE_SPANISH_EL_SALVADOR :
case LANGUAGE_SPANISH_HONDURAS :
case LANGUAGE_SPANISH_NICARAGUA :
case LANGUAGE_SPANISH_PUERTO_RICO :
sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AA" ) );
sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AAAA" ) );
// must exchange the day of week name code, same as Xcl
sKeyword[NF_KEY_AAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "OOO" ) );
sKeyword[NF_KEY_AAAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "OOOO" ) );
break;
case LANGUAGE_DUTCH :
case LANGUAGE_DUTCH_BELGIAN :
sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
break;
case LANGUAGE_FINNISH :
sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "VV" ) );
sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "VVVV" ) );
break;
default:
sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YY" ) );
sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YYYY" ) );
}
// hour
switch ( eLang )
{
case LANGUAGE_DUTCH :
case LANGUAGE_DUTCH_BELGIAN :
sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "U" ) );
sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "UU" ) );
break;
case LANGUAGE_FINNISH :
case LANGUAGE_SWEDISH :
case LANGUAGE_SWEDISH_FINLAND :
case LANGUAGE_DANISH :
case LANGUAGE_NORWEGIAN :
case LANGUAGE_NORWEGIAN_BOKMAL :
case LANGUAGE_NORWEGIAN_NYNORSK :
sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T" ) );
sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TT" ) );
break;
default:
sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "H" ) );
sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "HH" ) );
}
// boolean
sKeyword[NF_KEY_BOOLEAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BOOLEAN" ) );
// colours
sKeyword[NF_KEY_COLOR].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "COLOR" ) );
sKeyword[NF_KEY_BLACK].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BLACK" ) );
sKeyword[NF_KEY_BLUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BLUE" ) );
sKeyword[NF_KEY_GREEN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GREEN" ) );
sKeyword[NF_KEY_CYAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "CYAN" ) );
sKeyword[NF_KEY_RED].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "RED" ) );
sKeyword[NF_KEY_MAGENTA].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MAGENTA" ) );
sKeyword[NF_KEY_BROWN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BROWN" ) );
sKeyword[NF_KEY_GREY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GREY" ) );
sKeyword[NF_KEY_YELLOW].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YELLOW" ) );
sKeyword[NF_KEY_WHITE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "WHITE" ) );
}
break;
}
// boolean keyords
InitSpecialKeyword( NF_KEY_TRUE );
InitSpecialKeyword( NF_KEY_FALSE );
// compatibility currency strings
InitCompatCur();
}
void ImpSvNumberformatScan::ChangeNullDate(sal_uInt16 nDay, sal_uInt16 nMonth, sal_uInt16 nYear)
{
if ( pNullDate )
*pNullDate = Date(nDay, nMonth, nYear);
else
pNullDate = new Date(nDay, nMonth, nYear);
}
void ImpSvNumberformatScan::ChangeStandardPrec(sal_uInt16 nPrec)
{
nStandardPrec = nPrec;
}
Color* ImpSvNumberformatScan::GetColor(String& sStr)
{
String sString = pFormatter->GetCharClass()->upper(sStr);
const NfKeywordTable & rKeyword = GetKeywords();
size_t i = 0;
while (i < NF_MAX_DEFAULT_COLORS &&
sString != rKeyword[NF_KEY_FIRSTCOLOR+i] )
i++;
if ( i >= NF_MAX_DEFAULT_COLORS )
{
const String* pEnglishColors = theEnglishColors::get();
size_t j = 0;
while ( j < NF_MAX_DEFAULT_COLORS &&
sString != pEnglishColors[j] )
++j;
if ( j < NF_MAX_DEFAULT_COLORS )
i = j;
}
Color* pResult = NULL;
if (i >= NF_MAX_DEFAULT_COLORS)
{
const String& rColorWord = rKeyword[NF_KEY_COLOR];
xub_StrLen nPos = sString.Match(rColorWord);
if (nPos > 0)
{
sStr.Erase(0, nPos);
sStr.EraseLeadingChars();
sStr.EraseTrailingChars();
if (bConvertMode)
{
pFormatter->ChangeIntl(eNewLnge);
sStr.Insert( GetKeywords()[NF_KEY_COLOR], 0 ); // Color -> FARBE
pFormatter->ChangeIntl(eTmpLnge);
}
else
sStr.Insert(rColorWord,0);
sString.Erase(0, nPos);
sString.EraseLeadingChars();
sString.EraseTrailingChars();
if ( CharClass::isAsciiNumeric( sString ) )
{
long nIndex = sString.ToInt32();
if (nIndex > 0 && nIndex <= 64)
pResult = pFormatter->GetUserDefColor((sal_uInt16)nIndex-1);
}
}
}
else
{
sStr.Erase();
if (bConvertMode)
{
pFormatter->ChangeIntl(eNewLnge);
sStr = GetKeywords()[NF_KEY_FIRSTCOLOR+i]; // red -> rot
pFormatter->ChangeIntl(eTmpLnge);
}
else
sStr = rKeyword[NF_KEY_FIRSTCOLOR+i];
pResult = &(StandardColor[i]);
}
return pResult;
}
short ImpSvNumberformatScan::GetKeyWord( const String& sSymbol, xub_StrLen nPos )
{
String sString = pFormatter->GetCharClass()->toUpper( sSymbol, nPos, sSymbol.Len() - nPos );
const NfKeywordTable & rKeyword = GetKeywords();
// #77026# for the Xcl perverts: the GENERAL keyword is recognized anywhere
if ( sString.Search( rKeyword[NF_KEY_GENERAL] ) == 0 )
return NF_KEY_GENERAL;
//! MUST be a reverse search to find longer strings first
short i = NF_KEYWORD_ENTRIES_COUNT-1;
sal_Bool bFound = sal_False;
for ( ; i > NF_KEY_LASTKEYWORD_SO5; --i )
{
bFound = sString.Search(rKeyword[i]) == 0;
if ( bFound )
{
break;
}
}
// new keywords take precedence over old keywords
if ( !bFound )
{ // skip the gap of colors et al between new and old keywords and search on
i = NF_KEY_LASTKEYWORD;
while ( i > 0 && sString.Search(rKeyword[i]) != 0 )
i--;
if ( i > NF_KEY_LASTOLDKEYWORD && sString != rKeyword[i] )
{ // found something, but maybe it's something else?
// e.g. new NNN is found in NNNN, for NNNN we must search on
short j = i - 1;
while ( j > 0 && sString.Search(rKeyword[j]) != 0 )
j--;
if ( j && rKeyword[j].Len() > rKeyword[i].Len() )
return j;
}
}
// The Thai T NatNum modifier during Xcl import.
if (i == 0 && bConvertMode && sString.GetChar(0) == 'T' && eTmpLnge ==
LANGUAGE_ENGLISH_US && MsLangId::getRealLanguage( eNewLnge) ==
LANGUAGE_THAI)
i = NF_KEY_THAI_T;
return i; // 0 => not found
}
//---------------------------------------------------------------------------
// Next_Symbol
//---------------------------------------------------------------------------
// Zerlegt die Eingabe in Symbole fuer die weitere
// Verarbeitung (Turing-Maschine).
//---------------------------------------------------------------------------
// Ausgangs Zustand = SsStart
//---------------+-------------------+-----------------------+---------------
// Alter Zustand | gelesenes Zeichen | Aktion | Neuer Zustand
//---------------+-------------------+-----------------------+---------------
// SsStart | Buchstabe | Symbol=Zeichen | SsGetWord
// | " | Typ = String | SsGetString
// | \ | Typ = String | SsGetChar
// | * | Typ = Star | SsGetStar
// | _ | Typ = Blank | SsGetBlank
// | @ # 0 ? / . , % [ | Symbol = Zeichen; |
// | ] ' Blank | Typ = Steuerzeichen | SsStop
// | $ - + ( ) : | Typ = String; |
// | | | Typ = Comment | SsStop
// | Sonst | Symbol = Zeichen | SsStop
//---------------|-------------------+-----------------------+---------------
// SsGetChar | Sonst | Symbol=Zeichen | SsStop
//---------------+-------------------+-----------------------+---------------
// GetString | " | | SsStop
// | Sonst | Symbol+=Zeichen | GetString
//---------------+-------------------+-----------------------+---------------
// SsGetWord | Buchstabe | Symbol += Zeichen |
// | + - (E+ E-)| Symbol += Zeichen | SsStop
// | / (AM/PM)| Symbol += Zeichen |
// | Sonst | Pos--, if Key Typ=Word| SsStop
//---------------+-------------------+-----------------------+---------------
// SsGetStar | Sonst | Symbol+=Zeichen | SsStop
// | | markiere Sonderfall * |
//---------------+-------------------+-----------------------+---------------
// SsGetBlank | Sonst | Symbol+=Zeichen | SsStop
// | | markiere Sonderfall _ |
//---------------+-------------------+-----------------------+---------------
// Wurde im State SsGetWord ein Schluesselwort erkannt (auch als
// Anfangsteilwort des Symbols)
// so werden die restlichen Buchstaben zurueckgeschrieben !!
enum ScanState
{
SsStop = 0,
SsStart = 1,
SsGetChar = 2,
SsGetString = 3,
SsGetWord = 4,
SsGetStar = 5,
SsGetBlank = 6
};
short ImpSvNumberformatScan::Next_Symbol( const String& rStr,
xub_StrLen& nPos, String& sSymbol )
{
if ( bKeywordsNeedInit )
InitKeywords();
const CharClass* pChrCls = pFormatter->GetCharClass();
const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
const xub_StrLen nStart = nPos;
short eType = 0;
ScanState eState = SsStart;
sSymbol.Erase();
while ( nPos < rStr.Len() && eState != SsStop )
{
sal_Unicode cToken = rStr.GetChar( nPos++ );
switch (eState)
{
case SsStart:
{
// Fetch any currency longer than one character and don't get
// confused later on by "E/" or other combinations of letters
// and meaningful symbols. Necessary for old automatic currency.
// #96158# But don't do it if we're starting a "[...]" section,
// for example a "[$...]" new currency symbol to not parse away
// "$U" (symbol) of "[$UYU]" (abbreviation).
if ( nCurrPos != STRING_NOTFOUND && sCurString.Len() > 1 &&
nPos-1 + sCurString.Len() <= rStr.Len() &&
!(nPos > 1 && rStr.GetChar( nPos-2 ) == '[') )
{
String aTest( rStr.Copy( nPos-1, sCurString.Len() ) );
pChrCls->toUpper( aTest );
if ( aTest == sCurString )
{
sSymbol = rStr.Copy( --nPos, sCurString.Len() );
nPos = nPos + sSymbol.Len();
eState = SsStop;
eType = NF_SYMBOLTYPE_STRING;
return eType;
}
}
switch (cToken)
{
case '#':
case '0':
case '?':
case '%':
case '@':
case '[':
case ']':
case ',':
case '.':
case '/':
case '\'':
case ' ':
case ':':
case '-':
{
eType = NF_SYMBOLTYPE_DEL;
sSymbol += cToken;
eState = SsStop;
}
break;
case '*':
{
eType = NF_SYMBOLTYPE_STAR;
sSymbol += cToken;
eState = SsGetStar;
}
break;
case '_':
{
eType = NF_SYMBOLTYPE_BLANK;
sSymbol += cToken;
eState = SsGetBlank;
}
break;
#if NF_COMMENT_IN_FORMATSTRING
case '{':
eType = NF_SYMBOLTYPE_COMMENT;
eState = SsStop;
sSymbol.Append( rStr.GetBuffer() + (nPos-1), rStr.Len() - (nPos-1) );
nPos = rStr.Len();
break;
#endif
case '"':
eType = NF_SYMBOLTYPE_STRING;
eState = SsGetString;
sSymbol += cToken;
break;
case '\\':
eType = NF_SYMBOLTYPE_STRING;
eState = SsGetChar;
sSymbol += cToken;
break;
case '$':
case '+':
case '(':
case ')':
eType = NF_SYMBOLTYPE_STRING;
eState = SsStop;
sSymbol += cToken;
break;
default :
{
if (StringEqualsChar( pFormatter->GetNumDecimalSep(), cToken) ||
StringEqualsChar( pFormatter->GetNumThousandSep(), cToken) ||
StringEqualsChar( pFormatter->GetDateSep(), cToken) ||
StringEqualsChar( pLoc->getTimeSep(), cToken) ||
StringEqualsChar( pLoc->getTime100SecSep(), cToken))
{
// Another separator than pre-known ASCII
eType = NF_SYMBOLTYPE_DEL;
sSymbol += cToken;
eState = SsStop;
}
else if ( pChrCls->isLetter( rStr, nPos-1 ) )
{
short nTmpType = GetKeyWord( rStr, nPos-1 );
if ( nTmpType )
{
sal_Bool bCurrency = sal_False;
// "Automatic" currency may start with keyword,
// like "R" (Rand) and 'R' (era)
if ( nCurrPos != STRING_NOTFOUND &&
nPos-1 + sCurString.Len() <= rStr.Len() &&
sCurString.Search( sKeyword[nTmpType] ) == 0 )
{
String aTest( rStr.Copy( nPos-1, sCurString.Len() ) );
pChrCls->toUpper( aTest );
if ( aTest == sCurString )
bCurrency = sal_True;
}
if ( bCurrency )
{
eState = SsGetWord;
sSymbol += cToken;
}
else
{
eType = nTmpType;
xub_StrLen nLen = sKeyword[eType].Len();
sSymbol = rStr.Copy( nPos-1, nLen );
if ( eType == NF_KEY_E || IsAmbiguousE( eType ) )
{
sal_Unicode cNext = rStr.GetChar(nPos);
switch ( cNext )
{
case '+' :
case '-' : // E+ E- combine to one symbol
sSymbol += cNext;
eType = NF_KEY_E;
nPos++;
break;
case '0' :
case '#' : // scientific E without sign
eType = NF_KEY_E;
break;
}
}
nPos--;
nPos = nPos + nLen;
eState = SsStop;
}
}
else
{
eState = SsGetWord;
sSymbol += cToken;
}
}
else
{
eType = NF_SYMBOLTYPE_STRING;
eState = SsStop;
sSymbol += cToken;
}
}
break;
}
}
break;
case SsGetChar:
{
sSymbol += cToken;
eState = SsStop;
}
break;
case SsGetString:
{
if (cToken == '"')
eState = SsStop;
sSymbol += cToken;
}
break;
case SsGetWord:
{
if ( pChrCls->isLetter( rStr, nPos-1 ) )
{
short nTmpType = GetKeyWord( rStr, nPos-1 );
if ( nTmpType )
{ // beginning of keyword, stop scan and put back
eType = NF_SYMBOLTYPE_STRING;
eState = SsStop;
nPos--;
}
else
sSymbol += cToken;
}
else
{
sal_Bool bDontStop = sal_False;
switch (cToken)
{
case '/': // AM/PM, A/P
{
sal_Unicode cNext = rStr.GetChar(nPos);
if ( cNext == 'P' || cNext == 'p' )
{
xub_StrLen nLen = sSymbol.Len();
if ( 1 <= nLen
&& (sSymbol.GetChar(0) == 'A' || sSymbol.GetChar(0) == 'a')
&& (nLen == 1 || (nLen == 2
&& (sSymbol.GetChar(1) == 'M' || sSymbol.GetChar(1) == 'm')
&& (rStr.GetChar(nPos+1) == 'M' || rStr.GetChar(nPos+1) == 'm'))) )
{
sSymbol += cToken;
bDontStop = sal_True;
}
}
}
break;
}
// anything not recognized will stop the scan
if ( eState != SsStop && !bDontStop )
{
eState = SsStop;
nPos--;
eType = NF_SYMBOLTYPE_STRING;
}
}
}
break;
case SsGetStar:
{
eState = SsStop;
sSymbol += cToken;
nRepPos = (nPos - nStart) - 1; // every time > 0!!
}
break;
case SsGetBlank:
{
eState = SsStop;
sSymbol += cToken;
}
break;
default:
break;
} // of switch
} // of while
if (eState == SsGetWord)
eType = NF_SYMBOLTYPE_STRING;
return eType;
}
xub_StrLen ImpSvNumberformatScan::Symbol_Division(const String& rString)
{
nCurrPos = STRING_NOTFOUND;
// Ist Waehrung im Spiel?
String sString = pFormatter->GetCharClass()->upper(rString);
xub_StrLen nCPos = 0;
while (nCPos != STRING_NOTFOUND)
{
nCPos = sString.Search(GetCurString(),nCPos);
if (nCPos != STRING_NOTFOUND)
{
// in Quotes?
xub_StrLen nQ = SvNumberformat::GetQuoteEnd( sString, nCPos );
if ( nQ == STRING_NOTFOUND )
{
sal_Unicode c;
if ( nCPos == 0 ||
((c = sString.GetChar(xub_StrLen(nCPos-1))) != '"'
&& c != '\\') ) // dm kann durch "dm
{ // \d geschuetzt werden
nCurrPos = nCPos;
nCPos = STRING_NOTFOUND; // Abbruch
}
else
nCPos++; // weitersuchen
}
else
nCPos = nQ + 1; // weitersuchen
}
}
nAnzStrings = 0;
sal_Bool bStar = sal_False; // wird bei '*'Detektion gesetzt
Reset();
xub_StrLen nPos = 0;
const xub_StrLen nLen = rString.Len();
while (nPos < nLen && nAnzStrings < NF_MAX_FORMAT_SYMBOLS)
{
nTypeArray[nAnzStrings] = Next_Symbol(rString, nPos, sStrArray[nAnzStrings]);
if (nTypeArray[nAnzStrings] == NF_SYMBOLTYPE_STAR)
{ // Ueberwachung des '*'
if (bStar)
return nPos; // Fehler: doppelter '*'
else
bStar = sal_True;
}
nAnzStrings++;
}
return 0; // 0 => ok
}
void ImpSvNumberformatScan::SkipStrings(sal_uInt16& i, xub_StrLen& nPos)
{
while (i < nAnzStrings && ( nTypeArray[i] == NF_SYMBOLTYPE_STRING
|| nTypeArray[i] == NF_SYMBOLTYPE_BLANK
|| nTypeArray[i] == NF_SYMBOLTYPE_STAR) )
{
nPos = nPos + sStrArray[i].Len();
i++;
}
}
sal_uInt16 ImpSvNumberformatScan::PreviousKeyword(sal_uInt16 i)
{
short res = 0;
if (i > 0 && i < nAnzStrings)
{
i--;
while (i > 0 && nTypeArray[i] <= 0)
i--;
if (nTypeArray[i] > 0)
res = nTypeArray[i];
}
return res;
}
sal_uInt16 ImpSvNumberformatScan::NextKeyword(sal_uInt16 i)
{
short res = 0;
if (i < nAnzStrings-1)
{
i++;
while (i < nAnzStrings-1 && nTypeArray[i] <= 0)
i++;
if (nTypeArray[i] > 0)
res = nTypeArray[i];
}
return res;
}
short ImpSvNumberformatScan::PreviousType( sal_uInt16 i )
{
if ( i > 0 && i < nAnzStrings )
{
do
{
i--;
} while ( i > 0 && nTypeArray[i] == NF_SYMBOLTYPE_EMPTY );
return nTypeArray[i];
}
return 0;
}
sal_Unicode ImpSvNumberformatScan::PreviousChar(sal_uInt16 i)
{
sal_Unicode res = ' ';
if (i > 0 && i < nAnzStrings)
{
i--;
while (i > 0 && ( nTypeArray[i] == NF_SYMBOLTYPE_EMPTY
|| nTypeArray[i] == NF_SYMBOLTYPE_STRING
|| nTypeArray[i] == NF_SYMBOLTYPE_STAR
|| nTypeArray[i] == NF_SYMBOLTYPE_BLANK ) )
i--;
if (sStrArray[i].Len() > 0)
res = sStrArray[i].GetChar(xub_StrLen(sStrArray[i].Len()-1));
}
return res;
}
sal_Unicode ImpSvNumberformatScan::NextChar(sal_uInt16 i)
{
sal_Unicode res = ' ';
if (i < nAnzStrings-1)
{
i++;
while (i < nAnzStrings-1 &&
( nTypeArray[i] == NF_SYMBOLTYPE_EMPTY
|| nTypeArray[i] == NF_SYMBOLTYPE_STRING
|| nTypeArray[i] == NF_SYMBOLTYPE_STAR
|| nTypeArray[i] == NF_SYMBOLTYPE_BLANK))
i++;
if (sStrArray[i].Len() > 0)
res = sStrArray[i].GetChar(0);
}
return res;
}
sal_Bool ImpSvNumberformatScan::IsLastBlankBeforeFrac(sal_uInt16 i)
{
sal_Bool res = sal_True;
if (i < nAnzStrings-1)
{
sal_Bool bStop = sal_False;
i++;
while (i < nAnzStrings-1 && !bStop)
{
i++;
if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
sStrArray[i].GetChar(0) == '/')
bStop = sal_True;
else if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
sStrArray[i].GetChar(0) == ' ')
res = sal_False;
}
if (!bStop) // kein '/'
res = sal_False;
}
else
res = sal_False; // kein '/' mehr
return res;
}
void ImpSvNumberformatScan::Reset()
{
nAnzStrings = 0;
nAnzResStrings = 0;
#if 0
// ER 20.06.97 14:05 nicht noetig, wenn nAnzStrings beachtet wird
for (size_t i = 0; i < NF_MAX_FORMAT_SYMBOLS; i++)
{
sStrArray[i].Erase();
nTypeArray[i] = 0;
}
#endif
eScannedType = NUMBERFORMAT_UNDEFINED;
nRepPos = 0;
bExp = sal_False;
bThousand = sal_False;
nThousand = 0;
bDecSep = sal_False;
nDecPos = -1;
nExpPos = (sal_uInt16) -1;
nBlankPos = (sal_uInt16) -1;
nCntPre = 0;
nCntPost = 0;
nCntExp = 0;
bFrac = sal_False;
bBlank = sal_False;
nNatNumModifier = 0;
}
sal_Bool ImpSvNumberformatScan::Is100SecZero( sal_uInt16 i, sal_Bool bHadDecSep )
{
sal_uInt16 nIndexPre = PreviousKeyword( i );
return (nIndexPre == NF_KEY_S || nIndexPre == NF_KEY_SS)
&& (bHadDecSep // S, SS ','
|| (i>0 && nTypeArray[i-1] == NF_SYMBOLTYPE_STRING));
// SS"any"00 take "any" as a valid decimal separator
}
xub_StrLen ImpSvNumberformatScan::ScanType(const String&)
{
const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
xub_StrLen nPos = 0;
sal_uInt16 i = 0;
short eNewType;
sal_Bool bMatchBracket = sal_False;
bool bHaveGeneral = false; // if General/Standard encountered
SkipStrings(i, nPos);
while (i < nAnzStrings)
{
if (nTypeArray[i] > 0)
{ // keyword
switch (nTypeArray[i])
{
case NF_KEY_E: // E
eNewType = NUMBERFORMAT_SCIENTIFIC;
break;
case NF_KEY_AMPM: // AM,A,PM,P
case NF_KEY_AP:
case NF_KEY_H: // H
case NF_KEY_HH: // HH
case NF_KEY_S: // S
case NF_KEY_SS: // SS
eNewType = NUMBERFORMAT_TIME;
break;
case NF_KEY_M: // M
case NF_KEY_MM: // MM
{ // minute or month
sal_uInt16 nIndexPre = PreviousKeyword(i);
sal_uInt16 nIndexNex = NextKeyword(i);
sal_Unicode cChar = PreviousChar(i);
if (nIndexPre == NF_KEY_H || // H
nIndexPre == NF_KEY_HH || // HH
nIndexNex == NF_KEY_S || // S
nIndexNex == NF_KEY_SS || // SS
cChar == '[' ) // [M
{
eNewType = NUMBERFORMAT_TIME;
nTypeArray[i] -= 2; // 6 -> 4, 7 -> 5
}
else
eNewType = NUMBERFORMAT_DATE;
}
break;
case NF_KEY_MMM: // MMM
case NF_KEY_MMMM: // MMMM
case NF_KEY_MMMMM: // MMMMM
case NF_KEY_Q: // Q
case NF_KEY_QQ: // QQ
case NF_KEY_D: // D
case NF_KEY_DD: // DD
case NF_KEY_DDD: // DDD
case NF_KEY_DDDD: // DDDD
case NF_KEY_YY: // YY
case NF_KEY_YYYY: // YYYY
case NF_KEY_NN: // NN
case NF_KEY_NNN: // NNN
case NF_KEY_NNNN: // NNNN
case NF_KEY_WW : // WW
case NF_KEY_AAA : // AAA
case NF_KEY_AAAA : // AAAA
case NF_KEY_EC : // E
case NF_KEY_EEC : // EE
case NF_KEY_G : // G
case NF_KEY_GG : // GG
case NF_KEY_GGG : // GGG
case NF_KEY_R : // R
case NF_KEY_RR : // RR
eNewType = NUMBERFORMAT_DATE;
break;
case NF_KEY_CCC: // CCC
eNewType = NUMBERFORMAT_CURRENCY;
break;
case NF_KEY_GENERAL: // Standard
eNewType = NUMBERFORMAT_NUMBER;
bHaveGeneral = true;
break;
default:
eNewType = NUMBERFORMAT_UNDEFINED;
break;
}
}
else
{ // control character
switch ( sStrArray[i].GetChar(0) )
{
case '#':
case '?':
eNewType = NUMBERFORMAT_NUMBER;
break;
case '0':
{
if ( (eScannedType & NUMBERFORMAT_TIME) == NUMBERFORMAT_TIME )
{
if ( Is100SecZero( i, bDecSep ) )
{
bDecSep = sal_True; // subsequent 0's
eNewType = NUMBERFORMAT_TIME;
}
else
return nPos; // Error
}
else
eNewType = NUMBERFORMAT_NUMBER;
}
break;
case '%':
eNewType = NUMBERFORMAT_PERCENT;
break;
case '/':
eNewType = NUMBERFORMAT_FRACTION;
break;
case '[':
{
if ( i < nAnzStrings-1 &&
nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
sStrArray[i+1].GetChar(0) == '$' )
{ // as of SV_NUMBERFORMATTER_VERSION_NEW_CURR
eNewType = NUMBERFORMAT_CURRENCY;
bMatchBracket = sal_True;
}
else if ( i < nAnzStrings-1 &&
nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
sStrArray[i+1].GetChar(0) == '~' )
{ // as of SV_NUMBERFORMATTER_VERSION_CALENDAR
eNewType = NUMBERFORMAT_DATE;
bMatchBracket = sal_True;
}
else
{
sal_uInt16 nIndexNex = NextKeyword(i);
if (nIndexNex == NF_KEY_H || // H
nIndexNex == NF_KEY_HH || // HH
nIndexNex == NF_KEY_M || // M
nIndexNex == NF_KEY_MM || // MM
nIndexNex == NF_KEY_S || // S
nIndexNex == NF_KEY_SS ) // SS
eNewType = NUMBERFORMAT_TIME;
else
return nPos; // Error
}
}
break;
case '@':
eNewType = NUMBERFORMAT_TEXT;
break;
default:
if ( sStrArray[i] == pLoc->getTime100SecSep() )
bDecSep = sal_True; // for SS,0
eNewType = NUMBERFORMAT_UNDEFINED;
break;
}
}
if (eScannedType == NUMBERFORMAT_UNDEFINED)
eScannedType = eNewType;
else if (eScannedType == NUMBERFORMAT_TEXT || eNewType == NUMBERFORMAT_TEXT)
eScannedType = NUMBERFORMAT_TEXT; // Text bleibt immer Text
else if (eNewType == NUMBERFORMAT_UNDEFINED)
{ // bleibt wie bisher
}
else if (eScannedType != eNewType)
{
switch (eScannedType)
{
case NUMBERFORMAT_DATE:
{
switch (eNewType)
{
case NUMBERFORMAT_TIME:
eScannedType = NUMBERFORMAT_DATETIME;
break;
case NUMBERFORMAT_FRACTION: // DD/MM
break;
default:
{
if (nCurrPos != STRING_NOTFOUND)
eScannedType = NUMBERFORMAT_UNDEFINED;
else if ( sStrArray[i] != pFormatter->GetDateSep() )
return nPos;
}
}
}
break;
case NUMBERFORMAT_TIME:
{
switch (eNewType)
{
case NUMBERFORMAT_DATE:
eScannedType = NUMBERFORMAT_DATETIME;
break;
case NUMBERFORMAT_FRACTION: // MM/SS
break;
default:
{
if (nCurrPos != STRING_NOTFOUND)
eScannedType = NUMBERFORMAT_UNDEFINED;
else if ( sStrArray[i] != pLoc->getTimeSep() )
return nPos;
}
}
}
break;
case NUMBERFORMAT_DATETIME:
{
switch (eNewType)
{
case NUMBERFORMAT_TIME:
case NUMBERFORMAT_DATE:
break;
case NUMBERFORMAT_FRACTION: // DD/MM
break;
default:
{
if (nCurrPos != STRING_NOTFOUND)
eScannedType = NUMBERFORMAT_UNDEFINED;
else if ( sStrArray[i] != pFormatter->GetDateSep()
&& sStrArray[i] != pLoc->getTimeSep() )
return nPos;
}
}
}
break;
case NUMBERFORMAT_PERCENT:
{
switch (eNewType)
{
case NUMBERFORMAT_NUMBER: // nur Zahl nach Prozent
break;
default:
return nPos;
}
}
break;
case NUMBERFORMAT_SCIENTIFIC:
{
switch (eNewType)
{
case NUMBERFORMAT_NUMBER: // nur Zahl nach E
break;
default:
return nPos;
}
}
break;
case NUMBERFORMAT_NUMBER:
{
switch (eNewType)
{
case NUMBERFORMAT_SCIENTIFIC:
case NUMBERFORMAT_PERCENT:
case NUMBERFORMAT_FRACTION:
case NUMBERFORMAT_CURRENCY:
eScannedType = eNewType;
break;
default:
if (nCurrPos != STRING_NOTFOUND)
eScannedType = NUMBERFORMAT_UNDEFINED;
else
return nPos;
}
}
break;
case NUMBERFORMAT_FRACTION:
{
switch (eNewType)
{
case NUMBERFORMAT_NUMBER: // nur Zahl nach Bruch
break;
default:
return nPos;
}
}
break;
default:
break;
}
}
nPos = nPos + sStrArray[i].Len(); // Korrekturposition
i++;
if ( bMatchBracket )
{ // no type detection inside of matching brackets if [$...], [~...]
while ( bMatchBracket && i < nAnzStrings )
{
if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL
&& sStrArray[i].GetChar(0) == ']' )
bMatchBracket = sal_False;
else
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
if ( bMatchBracket )
return nPos; // missing closing bracket at end of code
}
SkipStrings(i, nPos);
}
if ((eScannedType == NUMBERFORMAT_NUMBER || eScannedType == NUMBERFORMAT_UNDEFINED)
&& nCurrPos != STRING_NOTFOUND && !bHaveGeneral)
eScannedType = NUMBERFORMAT_CURRENCY; // old "automatic" currency
if (eScannedType == NUMBERFORMAT_UNDEFINED)
eScannedType = NUMBERFORMAT_DEFINED;
return 0; // Alles ok
}
bool ImpSvNumberformatScan::InsertSymbol( sal_uInt16 & nPos, svt::NfSymbolType eType, const String& rStr )
{
if (nAnzStrings >= NF_MAX_FORMAT_SYMBOLS || nPos > nAnzStrings)
return false;
++nAnzResStrings;
if (nPos > 0 && nTypeArray[nPos-1] == NF_SYMBOLTYPE_EMPTY)
--nPos; // reuse position
else
{
++nAnzStrings;
for (size_t i = nAnzStrings; i > nPos; --i)
{
nTypeArray[i] = nTypeArray[i-1];
sStrArray[i] = sStrArray[i-1];
}
}
nTypeArray[nPos] = static_cast<short>(eType);
sStrArray[nPos] = rStr;
return true;
}
int ImpSvNumberformatScan::FinalScanGetCalendar( xub_StrLen& nPos, sal_uInt16& i,
sal_uInt16& rAnzResStrings )
{
if ( sStrArray[i].GetChar(0) == '[' &&
i < nAnzStrings-1 &&
nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
sStrArray[i+1].GetChar(0) == '~' )
{ // [~calendarID]
// as of SV_NUMBERFORMATTER_VERSION_CALENDAR
nPos = nPos + sStrArray[i].Len(); // [
nTypeArray[i] = NF_SYMBOLTYPE_CALDEL;
nPos = nPos + sStrArray[++i].Len(); // ~
sStrArray[i-1] += sStrArray[i]; // [~
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
rAnzResStrings--;
if ( ++i >= nAnzStrings )
return -1; // error
nPos = nPos + sStrArray[i].Len(); // calendarID
String& rStr = sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_CALENDAR; // convert
i++;
while ( i < nAnzStrings &&
sStrArray[i].GetChar(0) != ']' )
{
nPos = nPos + sStrArray[i].Len();
rStr += sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
rAnzResStrings--;
i++;
}
if ( rStr.Len() && i < nAnzStrings &&
sStrArray[i].GetChar(0) == ']' )
{
nTypeArray[i] = NF_SYMBOLTYPE_CALDEL;
nPos = nPos + sStrArray[i].Len();
i++;
}
else
return -1; // error
return 1;
}
return 0;
}
xub_StrLen ImpSvNumberformatScan::FinalScan( String& rString, String& rComment )
{
const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
// save values for convert mode
String sOldDecSep = pFormatter->GetNumDecimalSep();
String sOldThousandSep = pFormatter->GetNumThousandSep();
String sOldDateSep = pFormatter->GetDateSep();
String sOldTimeSep = pLoc->getTimeSep();
String sOldTime100SecSep= pLoc->getTime100SecSep();
String sOldCurSymbol = GetCurSymbol();
String sOldCurString = GetCurString();
sal_Unicode cOldKeyH = sKeyword[NF_KEY_H].GetChar(0);
sal_Unicode cOldKeyMI = sKeyword[NF_KEY_MI].GetChar(0);
sal_Unicode cOldKeyS = sKeyword[NF_KEY_S].GetChar(0);
// If the group separator is a Non-Breaking Space (French) continue with a
// normal space instead so queries on space work correctly.
// The format string is adjusted to allow both.
// For output of the format code string the LocaleData characters are used.
if ( sOldThousandSep.GetChar(0) == cNonBreakingSpace && sOldThousandSep.Len() == 1 )
sOldThousandSep = ' ';
// change locale data et al
if (bConvertMode)
{
pFormatter->ChangeIntl(eNewLnge);
//! pointer may have changed
pLoc = pFormatter->GetLocaleData();
//! init new keywords
InitKeywords();
}
const CharClass* pChrCls = pFormatter->GetCharClass();
xub_StrLen nPos = 0; // error correction position
sal_uInt16 i = 0; // symbol loop counter
sal_uInt16 nCounter = 0; // counts digits
nAnzResStrings = nAnzStrings; // counts remaining symbols
bDecSep = sal_False; // reset in case already used in TypeCheck
bool bThaiT = false; // Thai T NatNum modifier present
switch (eScannedType)
{
case NUMBERFORMAT_TEXT:
case NUMBERFORMAT_DEFINED:
{
while (i < nAnzStrings)
{
switch (nTypeArray[i])
{
case NF_SYMBOLTYPE_BLANK:
case NF_SYMBOLTYPE_STAR:
break;
case NF_SYMBOLTYPE_COMMENT:
{
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
SvNumberformat::EraseCommentBraces( rStr );
rComment += rStr;
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
break;
case NF_KEY_GENERAL : // #77026# "General" is the same as "@"
break;
default:
{
if ( nTypeArray[i] != NF_SYMBOLTYPE_DEL ||
sStrArray[i].GetChar(0) != '@' )
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
}
break;
}
nPos = nPos + sStrArray[i].Len();
i++;
} // of while
}
break;
case NUMBERFORMAT_NUMBER:
case NUMBERFORMAT_PERCENT:
case NUMBERFORMAT_CURRENCY:
case NUMBERFORMAT_SCIENTIFIC:
case NUMBERFORMAT_FRACTION:
{
sal_Unicode cThousandFill = ' ';
while (i < nAnzStrings)
{
if (eScannedType == NUMBERFORMAT_FRACTION && // special case
nTypeArray[i] == NF_SYMBOLTYPE_DEL && // # ### #/#
StringEqualsChar( sOldThousandSep, ' ' ) && // e.g. France or Sweden
StringEqualsChar( sStrArray[i], ' ' ) &&
!bFrac &&
IsLastBlankBeforeFrac(i) )
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING; // del->string
} // kein Taus.p.
if (nTypeArray[i] == NF_SYMBOLTYPE_BLANK ||
nTypeArray[i] == NF_SYMBOLTYPE_STAR ||
nTypeArray[i] == NF_KEY_CCC || // CCC
nTypeArray[i] == NF_KEY_GENERAL ) // Standard
{
if (nTypeArray[i] == NF_KEY_GENERAL)
{
nThousand = FLAG_STANDARD_IN_FORMAT;
if ( bConvertMode )
sStrArray[i] = sNameStandardFormat;
}
nPos = nPos + sStrArray[i].Len();
i++;
}
else if (nTypeArray[i] == NF_SYMBOLTYPE_STRING || // Strings oder
nTypeArray[i] > 0) // Keywords
{
if (eScannedType == NUMBERFORMAT_SCIENTIFIC &&
nTypeArray[i] == NF_KEY_E) // E+
{
if (bExp) // doppelt
return nPos;
bExp = sal_True;
nExpPos = i;
if (bDecSep)
nCntPost = nCounter;
else
nCntPre = nCounter;
nCounter = 0;
nTypeArray[i] = NF_SYMBOLTYPE_EXP;
}
else if (eScannedType == NUMBERFORMAT_FRACTION &&
sStrArray[i].GetChar(0) == ' ')
{
if (!bBlank && !bFrac) // nicht doppelt oder hinter /
{
if (bDecSep && nCounter > 0) // Nachkommastellen
return nPos; // Fehler
bBlank = sal_True;
nBlankPos = i;
nCntPre = nCounter;
nCounter = 0;
}
nTypeArray[i] = NF_SYMBOLTYPE_FRACBLANK;
}
else if (nTypeArray[i] == NF_KEY_THAI_T)
{
bThaiT = true;
sStrArray[i] = sKeyword[nTypeArray[i]];
}
else
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
else if (nTypeArray[i] == NF_SYMBOLTYPE_DEL)
{
sal_Unicode cHere = sStrArray[i].GetChar(0);
// Handle not pre-known separators in switch.
sal_Unicode cSimplified;
if (StringEqualsChar( pFormatter->GetNumThousandSep(), cHere))
cSimplified = ',';
else if (StringEqualsChar( pFormatter->GetNumDecimalSep(), cHere))
cSimplified = '.';
else
cSimplified = cHere;
switch ( cSimplified )
{
case '#':
case '0':
case '?':
{
if (nThousand > 0) // #... #
return nPos; // Fehler
else if (bFrac && cHere == '0')
return nPos; // 0 im Nenner
nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
i++;
nCounter++;
while (i < nAnzStrings &&
(sStrArray[i].GetChar(0) == '#' ||
sStrArray[i].GetChar(0) == '0' ||
sStrArray[i].GetChar(0) == '?')
)
{
nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
nPos = nPos + sStrArray[i].Len();
nCounter++;
i++;
}
}
break;
case '-':
{
if ( bDecSep && nDecPos+1 == i &&
nTypeArray[nDecPos] == NF_SYMBOLTYPE_DECSEP )
{ // "0.--"
nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
i++;
nCounter++;
while (i < nAnzStrings &&
(sStrArray[i].GetChar(0) == '-') )
{
// If more than two dashes are present in
// currency formats the last dash will be
// interpreted literally as a minus sign.
// Has to be this ugly. Period.
if ( eScannedType == NUMBERFORMAT_CURRENCY
&& rStr.Len() >= 2 &&
(i == nAnzStrings-1 ||
sStrArray[i+1].GetChar(0) != '-') )
break;
rStr += sStrArray[i];
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
nCounter++;
i++;
}
}
else
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
}
break;
case '.':
case ',':
case '\'':
case ' ':
{
sal_Unicode cSep = cHere; // remember
if ( StringEqualsChar( sOldThousandSep, cSep ) )
{
// previous char with skip empty
sal_Unicode cPre = PreviousChar(i);
sal_Unicode cNext;
if (bExp || bBlank || bFrac)
{ // after E, / or ' '
if ( !StringEqualsChar( sOldThousandSep, ' ' ) )
{
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++; // eat it
}
else
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
}
else if (i > 0 && i < nAnzStrings-1 &&
(cPre == '#' || cPre == '0') &&
((cNext = NextChar(i)) == '#' || cNext == '0')
) // #,#
{
nPos = nPos + sStrArray[i].Len();
if (!bThousand) // only once
{
bThousand = sal_True;
cThousandFill = sStrArray[i+1].GetChar(0);
}
// Eat it, will be reinserted at proper
// grouping positions further down.
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
else if (i > 0 && (cPre == '#' || cPre == '0')
&& PreviousType(i) == NF_SYMBOLTYPE_DIGIT
&& nThousand < FLAG_STANDARD_IN_FORMAT )
{ // #,,,,
if ( StringEqualsChar( sOldThousandSep, ' ' ) )
{ // strange, those French..
sal_Bool bFirst = sal_True;
String& rStr = sStrArray[i];
// set a hard Non-Breaking Space or ConvertMode
const String& rSepF = pFormatter->GetNumThousandSep();
while ( i < nAnzStrings
&& sStrArray[i] == sOldThousandSep
&& StringEqualsChar( sOldThousandSep, NextChar(i) ) )
{ // last was a space or another space
// is following => separator
nPos = nPos + sStrArray[i].Len();
if ( bFirst )
{
bFirst = sal_False;
rStr = rSepF;
nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
}
else
{
rStr += rSepF;
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
nThousand++;
i++;
}
if ( i < nAnzStrings-1
&& sStrArray[i] == sOldThousandSep )
{ // something following last space
// => space if currency contained,
// else separator
nPos = nPos + sStrArray[i].Len();
if ( (nPos <= nCurrPos &&
nCurrPos < nPos + sStrArray[i+1].Len())
|| nTypeArray[i+1] == NF_KEY_CCC
|| (i < nAnzStrings-2 &&
sStrArray[i+1].GetChar(0) == '[' &&
sStrArray[i+2].GetChar(0) == '$') )
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
}
else
{
if ( bFirst )
{
bFirst = sal_False;
rStr = rSepF;
nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
}
else
{
rStr += rSepF;
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
nThousand++;
}
i++;
}
}
else
{
do
{
nThousand++;
nTypeArray[i] = NF_SYMBOLTYPE_THSEP;
nPos = nPos + sStrArray[i].Len();
sStrArray[i] = pFormatter->GetNumThousandSep();
i++;
} while (i < nAnzStrings &&
sStrArray[i] == sOldThousandSep);
}
}
else // any grsep
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
i++;
while ( i < nAnzStrings &&
sStrArray[i] == sOldThousandSep )
{
rStr += sStrArray[i];
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
}
}
else if ( StringEqualsChar( sOldDecSep, cSep ) )
{
if (bBlank || bFrac) // . behind / or ' '
return nPos; // error
else if (bExp) // behind E
{
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++; // eat it
}
else if (bDecSep) // any .
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
i++;
while ( i < nAnzStrings &&
sStrArray[i] == sOldDecSep )
{
rStr += sStrArray[i];
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
}
else
{
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_DECSEP;
sStrArray[i] = pFormatter->GetNumDecimalSep();
bDecSep = sal_True;
nDecPos = i;
nCntPre = nCounter;
nCounter = 0;
i++;
}
} // of else = DecSep
else // . without meaning
{
if (cSep == ' ' &&
eScannedType == NUMBERFORMAT_FRACTION &&
StringEqualsChar( sStrArray[i], ' ' ) )
{
if (!bBlank && !bFrac) // no dups
{ // or behind /
if (bDecSep && nCounter > 0)// dec.
return nPos; // error
bBlank = sal_True;
nBlankPos = i;
nCntPre = nCounter;
nCounter = 0;
}
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
}
else
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
i++;
while (i < nAnzStrings &&
StringEqualsChar( sStrArray[i], cSep ) )
{
rStr += sStrArray[i];
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
}
}
}
break;
case '/':
{
if (eScannedType == NUMBERFORMAT_FRACTION)
{
if ( i == 0 ||
(nTypeArray[i-1] != NF_SYMBOLTYPE_DIGIT &&
nTypeArray[i-1] != NF_SYMBOLTYPE_EMPTY) )
return nPos ? nPos : 1; // /? not allowed
else if (!bFrac || (bDecSep && nCounter > 0))
{
bFrac = sal_True;
nCntPost = nCounter;
nCounter = 0;
nTypeArray[i] = NF_SYMBOLTYPE_FRAC;
nPos = nPos + sStrArray[i].Len();
i++;
}
else // / doppelt od. , imZaehl
return nPos; // Fehler
}
else
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
}
break;
case '[' :
{
if ( eScannedType == NUMBERFORMAT_CURRENCY &&
i < nAnzStrings-1 &&
nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
sStrArray[i+1].GetChar(0) == '$' )
{ // [$DM-xxx]
// ab SV_NUMBERFORMATTER_VERSION_NEW_CURR
nPos = nPos + sStrArray[i].Len(); // [
nTypeArray[i] = NF_SYMBOLTYPE_CURRDEL;
nPos = nPos + sStrArray[++i].Len(); // $
sStrArray[i-1] += sStrArray[i]; // [$
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
if ( ++i >= nAnzStrings )
return nPos; // Fehler
nPos = nPos + sStrArray[i].Len(); // DM
String& rStr = sStrArray[i];
String* pStr = &sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_CURRENCY; // wandeln
sal_Bool bHadDash = sal_False;
i++;
while ( i < nAnzStrings &&
sStrArray[i].GetChar(0) != ']' )
{
nPos = nPos + sStrArray[i].Len();
if ( bHadDash )
{
*pStr += sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
else
{
if ( sStrArray[i].GetChar(0) == '-' )
{
bHadDash = sal_True;
pStr = &sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_CURREXT;
}
else
{
*pStr += sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
}
i++;
}
if ( rStr.Len() && i < nAnzStrings &&
sStrArray[i].GetChar(0) == ']' )
{
nTypeArray[i] = NF_SYMBOLTYPE_CURRDEL;
nPos = nPos + sStrArray[i].Len();
i++;
}
else
return nPos; // Fehler
}
else
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
}
break;
default: // andere Dels
{
if (eScannedType == NUMBERFORMAT_PERCENT &&
cHere == '%')
nTypeArray[i] = NF_SYMBOLTYPE_PERCENT;
else
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
} // of switch (Del)
} // of else Del
else if ( nTypeArray[i] == NF_SYMBOLTYPE_COMMENT )
{
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
SvNumberformat::EraseCommentBraces( rStr );
rComment += rStr;
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
else
{
DBG_ERRORFILE( "unknown NF_SYMBOLTYPE_..." );
nPos = nPos + sStrArray[i].Len();
i++;
}
} // of while
if (eScannedType == NUMBERFORMAT_FRACTION)
{
if (bFrac)
nCntExp = nCounter;
else if (bBlank)
nCntPost = nCounter;
else
nCntPre = nCounter;
}
else
{
if (bExp)
nCntExp = nCounter;
else if (bDecSep)
nCntPost = nCounter;
else
nCntPre = nCounter;
}
if (bThousand) // Expansion of grouping separators
{
sal_uInt16 nMaxPos;
if (bFrac)
{
if (bBlank)
nMaxPos = nBlankPos;
else
nMaxPos = 0; // no grouping
}
else if (bDecSep) // decimal separator present
nMaxPos = nDecPos;
else if (bExp) // 'E' exponent present
nMaxPos = nExpPos;
else // up to end
nMaxPos = i;
// Insert separators at proper positions.
xub_StrLen nCount = 0;
utl::DigitGroupingIterator aGrouping( pLoc->getDigitGrouping());
size_t nFirstDigitSymbol = nMaxPos;
size_t nFirstGroupingSymbol = nMaxPos;
i = nMaxPos;
while (i-- > 0)
{
if (nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
{
nFirstDigitSymbol = i;
nCount = nCount + sStrArray[i].Len(); // MSC converts += to int and then warns, so ...
// Insert separator only if not leftmost symbol.
if (i > 0 && nCount >= aGrouping.getPos())
{
DBG_ASSERT( sStrArray[i].Len() == 1,
"ImpSvNumberformatScan::FinalScan: combined digits in group separator insertion");
if (!InsertSymbol( i, NF_SYMBOLTYPE_THSEP,
pFormatter->GetNumThousandSep()))
// nPos isn't correct here, but signals error
return nPos;
// i may have been decremented by 1
nFirstDigitSymbol = i + 1;
nFirstGroupingSymbol = i;
aGrouping.advance();
}
}
}
// Generated something like "string",000; remove separator again.
if (nFirstGroupingSymbol < nFirstDigitSymbol)
{
nTypeArray[nFirstGroupingSymbol] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
}
// Combine digits into groups to save memory (Info will be copied
// later, taking only non-empty symbols).
for (i = 0; i < nAnzStrings; ++i)
{
if (nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
{
String& rStr = sStrArray[i];
while (++i < nAnzStrings &&
nTypeArray[i] == NF_SYMBOLTYPE_DIGIT)
{
rStr += sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
}
}
}
break; // of NUMBERFORMAT_NUMBER
case NUMBERFORMAT_DATE:
{
while (i < nAnzStrings)
{
switch (nTypeArray[i])
{
case NF_SYMBOLTYPE_BLANK:
case NF_SYMBOLTYPE_STAR:
case NF_SYMBOLTYPE_STRING:
nPos = nPos + sStrArray[i].Len();
i++;
break;
case NF_SYMBOLTYPE_COMMENT:
{
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
SvNumberformat::EraseCommentBraces( rStr );
rComment += rStr;
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
break;
case NF_SYMBOLTYPE_DEL:
{
int nCalRet;
if (sStrArray[i] == sOldDateSep)
{
nTypeArray[i] = NF_SYMBOLTYPE_DATESEP;
nPos = nPos + sStrArray[i].Len();
if (bConvertMode)
sStrArray[i] = pFormatter->GetDateSep();
i++;
}
else if ( (nCalRet = FinalScanGetCalendar( nPos, i, nAnzResStrings )) != 0 )
{
if ( nCalRet < 0 )
return nPos; // error
}
else
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
}
break;
case NF_KEY_THAI_T :
bThaiT = true;
// fall thru
case NF_KEY_M: // M
case NF_KEY_MM: // MM
case NF_KEY_MMM: // MMM
case NF_KEY_MMMM: // MMMM
case NF_KEY_MMMMM: // MMMMM
case NF_KEY_Q: // Q
case NF_KEY_QQ: // QQ
case NF_KEY_D: // D
case NF_KEY_DD: // DD
case NF_KEY_DDD: // DDD
case NF_KEY_DDDD: // DDDD
case NF_KEY_YY: // YY
case NF_KEY_YYYY: // YYYY
case NF_KEY_NN: // NN
case NF_KEY_NNN: // NNN
case NF_KEY_NNNN: // NNNN
case NF_KEY_WW : // WW
case NF_KEY_AAA : // AAA
case NF_KEY_AAAA : // AAAA
case NF_KEY_EC : // E
case NF_KEY_EEC : // EE
case NF_KEY_G : // G
case NF_KEY_GG : // GG
case NF_KEY_GGG : // GGG
case NF_KEY_R : // R
case NF_KEY_RR : // RR
sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
nPos = nPos + sStrArray[i].Len();
i++;
break;
default: // andere Keywords
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
break;
}
} // of while
}
break; // of NUMBERFORMAT_DATE
case NUMBERFORMAT_TIME:
{
while (i < nAnzStrings)
{
switch (nTypeArray[i])
{
case NF_SYMBOLTYPE_BLANK:
case NF_SYMBOLTYPE_STAR:
{
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
case NF_SYMBOLTYPE_DEL:
{
switch( sStrArray[i].GetChar(0) )
{
case '0':
{
if ( Is100SecZero( i, bDecSep ) )
{
bDecSep = sal_True;
nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
String& rStr = sStrArray[i];
i++;
nPos = nPos + sStrArray[i].Len();
nCounter++;
while (i < nAnzStrings &&
sStrArray[i].GetChar(0) == '0')
{
rStr += sStrArray[i];
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
nCounter++;
i++;
}
}
else
return nPos;
}
break;
case '#':
case '?':
return nPos;
case '[':
{
if (bThousand) // doppelt
return nPos;
bThousand = sal_True; // bei Time frei
sal_Unicode cChar = pChrCls->upper( NextChar(i) ).GetChar(0);
if ( cChar == cOldKeyH )
nThousand = 1; // H
else if ( cChar == cOldKeyMI )
nThousand = 2; // M
else if ( cChar == cOldKeyS )
nThousand = 3; // S
else
return nPos;
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
case ']':
{
if (!bThousand) // kein [ vorher
return nPos;
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
default:
{
nPos = nPos + sStrArray[i].Len();
if ( sStrArray[i] == sOldTimeSep )
{
nTypeArray[i] = NF_SYMBOLTYPE_TIMESEP;
if ( bConvertMode )
sStrArray[i] = pLoc->getTimeSep();
}
else if ( sStrArray[i] == sOldTime100SecSep )
{
bDecSep = sal_True;
nTypeArray[i] = NF_SYMBOLTYPE_TIME100SECSEP;
if ( bConvertMode )
sStrArray[i] = pLoc->getTime100SecSep();
}
else
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
i++;
}
break;
}
}
break;
case NF_SYMBOLTYPE_STRING:
{
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
case NF_SYMBOLTYPE_COMMENT:
{
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
SvNumberformat::EraseCommentBraces( rStr );
rComment += rStr;
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
break;
case NF_KEY_AMPM: // AM/PM
case NF_KEY_AP: // A/P
{
bExp = sal_True; // missbraucht fuer A/P
sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
case NF_KEY_THAI_T :
bThaiT = true;
// fall thru
case NF_KEY_MI: // M
case NF_KEY_MMI: // MM
case NF_KEY_H: // H
case NF_KEY_HH: // HH
case NF_KEY_S: // S
case NF_KEY_SS: // SS
{
sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
default: // andere Keywords
{
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
}
} // of while
nCntPost = nCounter; // Zaehler der Nullen
if (bExp)
nCntExp = 1; // merkt AM/PM
}
break; // of NUMBERFORMAT_TIME
case NUMBERFORMAT_DATETIME:
{
sal_Bool bTimePart = sal_False;
while (i < nAnzStrings)
{
switch (nTypeArray[i])
{
case NF_SYMBOLTYPE_BLANK:
case NF_SYMBOLTYPE_STAR:
case NF_SYMBOLTYPE_STRING:
nPos = nPos + sStrArray[i].Len();
i++;
break;
case NF_SYMBOLTYPE_COMMENT:
{
String& rStr = sStrArray[i];
nPos = nPos + rStr.Len();
SvNumberformat::EraseCommentBraces( rStr );
rComment += rStr;
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
i++;
}
break;
case NF_SYMBOLTYPE_DEL:
{
int nCalRet;
if ( (nCalRet = FinalScanGetCalendar( nPos, i, nAnzResStrings )) != 0 )
{
if ( nCalRet < 0 )
return nPos; // error
}
else
{
switch( sStrArray[i].GetChar(0) )
{
case '0':
{
if ( bTimePart && Is100SecZero( i, bDecSep ) )
{
bDecSep = sal_True;
nTypeArray[i] = NF_SYMBOLTYPE_DIGIT;
String& rStr = sStrArray[i];
i++;
nPos = nPos + sStrArray[i].Len();
nCounter++;
while (i < nAnzStrings &&
sStrArray[i].GetChar(0) == '0')
{
rStr += sStrArray[i];
nPos = nPos + sStrArray[i].Len();
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
nCounter++;
i++;
}
}
else
return nPos;
}
break;
case '#':
case '?':
return nPos;
default:
{
nPos = nPos + sStrArray[i].Len();
if (bTimePart)
{
if ( sStrArray[i] == sOldTimeSep )
{
nTypeArray[i] = NF_SYMBOLTYPE_TIMESEP;
if ( bConvertMode )
sStrArray[i] = pLoc->getTimeSep();
}
else if ( sStrArray[i] == sOldTime100SecSep )
{
bDecSep = sal_True;
nTypeArray[i] = NF_SYMBOLTYPE_TIME100SECSEP;
if ( bConvertMode )
sStrArray[i] = pLoc->getTime100SecSep();
}
else
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
}
else
{
if ( sStrArray[i] == sOldDateSep )
{
nTypeArray[i] = NF_SYMBOLTYPE_DATESEP;
if (bConvertMode)
sStrArray[i] = pFormatter->GetDateSep();
}
else
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
}
i++;
}
}
}
}
break;
case NF_KEY_AMPM: // AM/PM
case NF_KEY_AP: // A/P
{
bTimePart = sal_True;
bExp = sal_True; // missbraucht fuer A/P
sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
nPos = nPos + sStrArray[i].Len();
i++;
}
break;
case NF_KEY_MI: // M
case NF_KEY_MMI: // MM
case NF_KEY_H: // H
case NF_KEY_HH: // HH
case NF_KEY_S: // S
case NF_KEY_SS: // SS
bTimePart = sal_True;
sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
nPos = nPos + sStrArray[i].Len();
i++;
break;
case NF_KEY_M: // M
case NF_KEY_MM: // MM
case NF_KEY_MMM: // MMM
case NF_KEY_MMMM: // MMMM
case NF_KEY_MMMMM: // MMMMM
case NF_KEY_Q: // Q
case NF_KEY_QQ: // QQ
case NF_KEY_D: // D
case NF_KEY_DD: // DD
case NF_KEY_DDD: // DDD
case NF_KEY_DDDD: // DDDD
case NF_KEY_YY: // YY
case NF_KEY_YYYY: // YYYY
case NF_KEY_NN: // NN
case NF_KEY_NNN: // NNN
case NF_KEY_NNNN: // NNNN
case NF_KEY_WW : // WW
case NF_KEY_AAA : // AAA
case NF_KEY_AAAA : // AAAA
case NF_KEY_EC : // E
case NF_KEY_EEC : // EE
case NF_KEY_G : // G
case NF_KEY_GG : // GG
case NF_KEY_GGG : // GGG
case NF_KEY_R : // R
case NF_KEY_RR : // RR
bTimePart = sal_False;
sStrArray[i] = sKeyword[nTypeArray[i]]; // tTtT -> TTTT
nPos = nPos + sStrArray[i].Len();
i++;
break;
case NF_KEY_THAI_T :
bThaiT = true;
sStrArray[i] = sKeyword[nTypeArray[i]];
nPos = nPos + sStrArray[i].Len();
i++;
break;
default: // andere Keywords
nTypeArray[i] = NF_SYMBOLTYPE_STRING;
nPos = nPos + sStrArray[i].Len();
i++;
break;
}
} // of while
nCntPost = nCounter; // decimals (100th seconds)
if (bExp)
nCntExp = 1; // merkt AM/PM
}
break; // of NUMBERFORMAT_DATETIME
default:
break;
}
if (eScannedType == NUMBERFORMAT_SCIENTIFIC &&
(nCntPre + nCntPost == 0 || nCntExp == 0))
return nPos;
else if (eScannedType == NUMBERFORMAT_FRACTION && (nCntExp > 8 || nCntExp == 0))
return nPos;
if (bThaiT && !GetNatNumModifier())
SetNatNumModifier(1);
if ( bConvertMode )
{ // strings containing keywords of the target locale must be quoted, so
// the user sees the difference and is able to edit the format string
for ( i=0; i < nAnzStrings; i++ )
{
if ( nTypeArray[i] == NF_SYMBOLTYPE_STRING &&
sStrArray[i].GetChar(0) != '\"' )
{
if ( bConvertSystemToSystem && eScannedType == NUMBERFORMAT_CURRENCY )
{ // don't stringize automatic currency, will be converted
if ( sStrArray[i] == sOldCurSymbol )
continue; // for
// DM might be splitted into D and M
if ( sStrArray[i].Len() < sOldCurSymbol.Len() &&
pChrCls->toUpper( sStrArray[i], 0, 1 ).GetChar(0) ==
sOldCurString.GetChar(0) )
{
String aTmp( sStrArray[i] );
sal_uInt16 j = i + 1;
while ( aTmp.Len() < sOldCurSymbol.Len() &&
j < nAnzStrings &&
nTypeArray[j] == NF_SYMBOLTYPE_STRING )
{
aTmp += sStrArray[j++];
}
if ( pChrCls->upper( aTmp ) == sOldCurString )
{
sStrArray[i++] = aTmp;
for ( ; i<j; i++ )
{
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
i = j - 1;
continue; // for
}
}
}
String& rStr = sStrArray[i];
xub_StrLen nLen = rStr.Len();
for ( xub_StrLen j=0; j<nLen; j++ )
{
if ( (j == 0 || rStr.GetChar(j-1) != '\\') && GetKeyWord( rStr, j ) )
{
rStr.Insert( '\"', 0 );
rStr += '\"';
break; // for
}
}
}
}
}
// concatenate strings, remove quotes for output, and rebuild the format string
rString.Erase();
i = 0;
while (i < nAnzStrings)
{
switch ( nTypeArray[i] )
{
case NF_SYMBOLTYPE_STRING :
{
xub_StrLen nStringPos = rString.Len();
xub_StrLen nArrPos = 0;
sal_uInt16 iPos = i;
do
{
if (sStrArray[i].Len() == 2 &&
sStrArray[i].GetChar(0) == '\\')
{
// Unescape some simple forms of symbols even in the UI
// visible string to prevent duplicates that differ
// only in notation, originating from import.
// e.g. YYYY-MM-DD and YYYY\-MM\-DD are identical,
// but 0\ 000 0 and 0 000 0 in a French locale are not.
sal_Unicode c = sStrArray[i].GetChar(1);
switch (c)
{
case '+':
case '-':
rString += c;
break;
case ' ':
case '.':
case '/':
if (((eScannedType & NUMBERFORMAT_DATE) == 0)
&& (StringEqualsChar(
pFormatter->GetNumThousandSep(),
c) || StringEqualsChar(
pFormatter->GetNumDecimalSep(),
c) || (c == ' ' &&
StringEqualsChar(
pFormatter->GetNumThousandSep(),
cNonBreakingSpace))))
rString += sStrArray[i];
else if ((eScannedType & NUMBERFORMAT_DATE) &&
StringEqualsChar(
pFormatter->GetDateSep(), c))
rString += sStrArray[i];
else if ((eScannedType & NUMBERFORMAT_TIME) &&
(StringEqualsChar( pLoc->getTimeSep(),
c) ||
StringEqualsChar(
pLoc->getTime100SecSep(), c)))
rString += sStrArray[i];
else if (eScannedType & NUMBERFORMAT_FRACTION)
rString += sStrArray[i];
else
rString += c;
break;
default:
rString += sStrArray[i];
}
}
else
rString += sStrArray[i];
if ( RemoveQuotes( sStrArray[i] ) > 0 )
{ // update currency up to quoted string
if ( eScannedType == NUMBERFORMAT_CURRENCY )
{ // dM -> DM or DM -> $ in old automatic
// currency formats, oh my ..., why did we ever
// introduce them?
String aTmp( pChrCls->toUpper(
sStrArray[iPos], nArrPos,
sStrArray[iPos].Len()-nArrPos ) );
xub_StrLen nCPos = aTmp.Search( sOldCurString );
if ( nCPos != STRING_NOTFOUND )
{
const String& rCur =
bConvertMode && bConvertSystemToSystem ?
GetCurSymbol() : sOldCurSymbol;
sStrArray[iPos].Replace( nArrPos+nCPos,
sOldCurString.Len(), rCur );
rString.Replace( nStringPos+nCPos,
sOldCurString.Len(), rCur );
}
nStringPos = rString.Len();
if ( iPos == i )
nArrPos = sStrArray[iPos].Len();
else
nArrPos = sStrArray[iPos].Len() + sStrArray[i].Len();
}
}
if ( iPos != i )
{
sStrArray[iPos] += sStrArray[i];
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
i++;
} while ( i < nAnzStrings && nTypeArray[i] == NF_SYMBOLTYPE_STRING );
if ( i < nAnzStrings )
i--; // enter switch on next symbol again
if ( eScannedType == NUMBERFORMAT_CURRENCY && nStringPos < rString.Len() )
{ // same as above, since last RemoveQuotes
String aTmp( pChrCls->toUpper(
sStrArray[iPos], nArrPos,
sStrArray[iPos].Len()-nArrPos ) );
xub_StrLen nCPos = aTmp.Search( sOldCurString );
if ( nCPos != STRING_NOTFOUND )
{
const String& rCur =
bConvertMode && bConvertSystemToSystem ?
GetCurSymbol() : sOldCurSymbol;
sStrArray[iPos].Replace( nArrPos+nCPos,
sOldCurString.Len(), rCur );
rString.Replace( nStringPos+nCPos,
sOldCurString.Len(), rCur );
}
}
}
break;
case NF_SYMBOLTYPE_CURRENCY :
{
rString += sStrArray[i];
RemoveQuotes( sStrArray[i] );
}
break;
case NF_KEY_THAI_T:
if (bThaiT && GetNatNumModifier() == 1)
{ // Remove T from format code, will be replaced with a [NatNum1] prefix.
nTypeArray[i] = NF_SYMBOLTYPE_EMPTY;
nAnzResStrings--;
}
else
rString += sStrArray[i];
break;
case NF_SYMBOLTYPE_EMPTY :
// nothing
break;
default:
rString += sStrArray[i];
}
i++;
}
return 0;
}
xub_StrLen ImpSvNumberformatScan::RemoveQuotes( String& rStr )
{
if ( rStr.Len() > 1 )
{
sal_Unicode c = rStr.GetChar(0);
xub_StrLen n;
if ( c == '"' && rStr.GetChar( (n = xub_StrLen(rStr.Len()-1)) ) == '"' )
{
rStr.Erase(n,1);
rStr.Erase(0,1);
return 2;
}
else if ( c == '\\' )
{
rStr.Erase(0,1);
return 1;
}
}
return 0;
}
xub_StrLen ImpSvNumberformatScan::ScanFormat( String& rString, String& rComment )
{
xub_StrLen res = Symbol_Division(rString); //lexikalische Analyse
if (!res)
res = ScanType(rString); // Erkennung des Formattyps
if (!res)
res = FinalScan( rString, rComment ); // Typabhaengige Endanalyse
return res; // res = Kontrollposition
// res = 0 => Format ok
}
void ImpSvNumberformatScan::CopyInfo(ImpSvNumberformatInfo* pInfo, sal_uInt16 nAnz)
{
size_t i,j;
j = 0;
i = 0;
while (i < nAnz && j < NF_MAX_FORMAT_SYMBOLS)
{
if (nTypeArray[j] != NF_SYMBOLTYPE_EMPTY)
{
pInfo->sStrArray[i] = sStrArray[j];
pInfo->nTypeArray[i] = nTypeArray[j];
i++;
}
j++;
}
pInfo->eScannedType = eScannedType;
pInfo->bThousand = bThousand;
pInfo->nThousand = nThousand;
pInfo->nCntPre = nCntPre;
pInfo->nCntPost = nCntPost;
pInfo->nCntExp = nCntExp;
}