/binfilter/bf_svtools/source/numbers/svt_zforfind.cxx
C++ | 2805 lines | 2279 code | 233 blank | 293 comment | 746 complexity | 27d40d3f12fc44484cdaba84e303b2b0 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-3.0, AGPL-1.0, BSD-3-Clause-No-Nuclear-License-2014, GPL-3.0, GPL-2.0, BSD-3-Clause, LGPL-2.1
Large files files are truncated, but you can click here to view the full file
- /*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
- // MARKER(update_precomp.py): autogen include statement, do not remove
- #include <ctype.h>
- #include <stdlib.h>
- #include <float.h>
- #include <errno.h>
- #ifndef _DATE_HXX //autogen
- #include <tools/date.hxx>
- #endif
- #ifndef _DEBUG_HXX //autogen
- #include <tools/debug.hxx>
- #endif
- #ifndef INCLUDED_RTL_MATH_HXX
- #include <rtl/math.hxx>
- #endif
- #ifndef _UNOTOOLS_CHARCLASS_HXX
- #include <unotools/charclass.hxx>
- #endif
- #ifndef _UNOTOOLS_CALENDARWRAPPER_HXX
- #include <unotools/calendarwrapper.hxx>
- #endif
- #ifndef _UNOTOOLS_LOCALEDATAWRAPPER_HXX
- #include <unotools/localedatawrapper.hxx>
- #endif
- #ifndef _COM_SUN_STAR_I18N_CALENDARFIELDINDEX_HPP_
- #include <com/sun/star/i18n/CalendarFieldIndex.hpp>
- #endif
- #include <bf_svtools/zforlist.hxx> // NUMBERFORMAT_XXX
- #include "zforscan.hxx"
- #include <bf_svtools/zformat.hxx>
- #define _ZFORFIND_CXX
- #include "zforfind.hxx"
- #undef _ZFORFIND_CXX
- #ifndef DBG_UTIL
- #define NF_TEST_CALENDAR 0
- #else
- #define NF_TEST_CALENDAR 0
- #endif
- #if NF_TEST_CALENDAR
- #include <comphelper/processfactory.hxx>
- #include <com/sun/star/i18n/XExtendedCalendar.hpp>
- #endif
- namespace binfilter
- {
- const BYTE ImpSvNumberInputScan::nMatchedEndString = 0x01;
- const BYTE ImpSvNumberInputScan::nMatchedMidString = 0x02;
- const BYTE ImpSvNumberInputScan::nMatchedStartString = 0x04;
- const BYTE ImpSvNumberInputScan::nMatchedVirgin = 0x08;
- const BYTE ImpSvNumberInputScan::nMatchedUsedAsReturn = 0x10;
- /* It is not clear how we want timezones to be handled. Convert them to local
- * time isn't wanted, as it isn't done in any other place and timezone
- * information isn't stored anywhere. Ignoring them and pretending local time
- * may be wrong too and might not be what the user expects. Keep the input as
- * string so that no information is lost.
- * Anyway, defining NF_RECOGNIZE_ISO8601_TIMEZONES to 1 would be the way how it
- * would work, together with the nTimezonePos handling in GetTimeRef(). */
- #define NF_RECOGNIZE_ISO8601_TIMEZONES 0
- //---------------------------------------------------------------------------
- // Konstruktor
- ImpSvNumberInputScan::ImpSvNumberInputScan( SvNumberFormatter* pFormatterP )
- :
- pUpperMonthText( NULL ),
- pUpperAbbrevMonthText( NULL ),
- pUpperDayText( NULL ),
- pUpperAbbrevDayText( NULL )
- {
- pFormatter = pFormatterP;
- pNullDate = new Date(30,12,1899);
- nYear2000 = SvNumberFormatter::GetYear2000Default();
- Reset();
- ChangeIntl();
- }
- //---------------------------------------------------------------------------
- // Destruktor
- ImpSvNumberInputScan::~ImpSvNumberInputScan()
- {
- Reset();
- delete pNullDate;
- delete [] pUpperMonthText;
- delete [] pUpperAbbrevMonthText;
- delete [] pUpperDayText;
- delete [] pUpperAbbrevDayText;
- }
- //---------------------------------------------------------------------------
- // Reset
- void ImpSvNumberInputScan::Reset()
- {
- #if 0
- // ER 16.06.97 18:56 Vorbelegung erfolgt jetzt in NumberStringDivision,
- // wozu immer alles loeschen wenn einiges wieder benutzt oder gar nicht
- // gebraucht wird..
- for (USHORT i = 0; i < SV_MAX_ANZ_INPUT_STRINGS; i++)
- {
- sStrArray[i].Erase();
- nNums[i] = SV_MAX_ANZ_INPUT_STRINGS-1;
- IsNum[i] = FALSE;
- }
- #endif
- nMonth = 0;
- nMonthPos = 0;
- nTimePos = 0;
- nSign = 0;
- nESign = 0;
- nDecPos = 0;
- nNegCheck = 0;
- nAnzStrings = 0;
- nAnzNums = 0;
- nThousand = 0;
- eScannedType = NUMBERFORMAT_UNDEFINED;
- nAmPm = 0;
- nPosThousandString = 0;
- nLogical = 0;
- nStringScanNumFor = 0;
- nStringScanSign = 0;
- nMatchedAllStrings = nMatchedVirgin;
- nMayBeIso8601 = 0;
- nTimezonePos = 0;
- }
- //---------------------------------------------------------------------------
- //
- // static
- inline BOOL ImpSvNumberInputScan::MyIsdigit( sal_Unicode c )
- {
- // If the input string wouldn't be converted using TransformInput() we'd
- // to use something similar to the following and to adapt many places.
- #if 0
- // use faster isdigit() if possible
- if ( c < 128 )
- return isdigit( (unsigned char) c ) != 0;
- if ( c < 256 )
- return FALSE;
- String aTmp( c );
- return pFormatter->GetCharClass()->isDigit( aTmp, 0 );
- #else
- return c < 128 && isdigit( (unsigned char) c );
- #endif
- }
- //---------------------------------------------------------------------------
- //
- void ImpSvNumberInputScan::TransformInput( String& rStr )
- {
- xub_StrLen nPos, nLen;
- for ( nPos = 0, nLen = rStr.Len(); nPos < nLen; ++nPos )
- {
- if ( 256 <= rStr.GetChar( nPos ) &&
- pFormatter->GetCharClass()->isDigit( rStr, nPos ) )
- break;
- }
- if ( nPos < nLen )
- rStr = pFormatter->GetNatNum()->getNativeNumberString( rStr,
- pFormatter->GetLocale(), 0 );
- }
- //---------------------------------------------------------------------------
- // StringToDouble
- //
- // Only simple unsigned floating point values without any error detection,
- // decimal separator has to be '.'
- double ImpSvNumberInputScan::StringToDouble( const String& rStr, BOOL bForceFraction )
- {
- double fNum = 0.0;
- double fFrac = 0.0;
- int nExp = 0;
- xub_StrLen nPos = 0;
- xub_StrLen nLen = rStr.Len();
- BOOL bPreSep = !bForceFraction;
- while (nPos < nLen)
- {
- if (rStr.GetChar(nPos) == '.')
- bPreSep = FALSE;
- else if (bPreSep)
- fNum = fNum * 10.0 + (double) (rStr.GetChar(nPos) - '0');
- else
- {
- fFrac = fFrac * 10.0 + (double) (rStr.GetChar(nPos) - '0');
- --nExp;
- }
- nPos++;
- }
- if ( fFrac )
- return fNum + ::rtl::math::pow10Exp( fFrac, nExp );
- return fNum;
- }
- //---------------------------------------------------------------------------
- // NextNumberStringSymbol
- //
- // Zerlegt die Eingabe in Zahlen und Strings fuer die weitere
- // Verarbeitung (Turing-Maschine).
- //---------------------------------------------------------------------------
- // Ausgangs Zustand = GetChar
- //---------------+-------------------+-----------------------+---------------
- // Alter Zustand | gelesenes Zeichen | Aktion | Neuer Zustand
- //---------------+-------------------+-----------------------+---------------
- // GetChar | Ziffer | Symbol=Zeichen | GetValue
- // | Sonst | Symbol=Zeichen | GetString
- //---------------|-------------------+-----------------------+---------------
- // GetValue | Ziffer | Symbol=Symbol+Zeichen | GetValue
- // | Sonst | Dec(CharPos) | Stop
- //---------------+-------------------+-----------------------+---------------
- // GetString | Ziffer | Dec(CharPos) | Stop
- // | Sonst | Symbol=Symbol+Zeichen | GetString
- //---------------+-------------------+-----------------------+---------------
- enum ScanState // States der Turing-Maschine
- {
- SsStop = 0,
- SsStart = 1,
- SsGetValue = 2,
- SsGetString = 3
- };
- BOOL ImpSvNumberInputScan::NextNumberStringSymbol(
- const sal_Unicode*& pStr,
- String& rSymbol )
- {
- BOOL isNumber = FALSE;
- sal_Unicode cToken;
- ScanState eState = SsStart;
- register const sal_Unicode* pHere = pStr;
- register xub_StrLen nChars = 0;
- while ( ((cToken = *pHere) != 0) && eState != SsStop)
- {
- pHere++;
- switch (eState)
- {
- case SsStart:
- if ( MyIsdigit( cToken ) )
- {
- eState = SsGetValue;
- isNumber = TRUE;
- }
- else
- eState = SsGetString;
- nChars++;
- break;
- case SsGetValue:
- if ( MyIsdigit( cToken ) )
- nChars++;
- else
- {
- eState = SsStop;
- pHere--;
- }
- break;
- case SsGetString:
- if ( !MyIsdigit( cToken ) )
- nChars++;
- else
- {
- eState = SsStop;
- pHere--;
- }
- break;
- default:
- break;
- } // switch
- } // while
- if ( nChars )
- rSymbol.Assign( pStr, nChars );
- else
- rSymbol.Erase();
- pStr = pHere;
- return isNumber;
- }
- //---------------------------------------------------------------------------
- // SkipThousands
- BOOL ImpSvNumberInputScan::SkipThousands(
- const sal_Unicode*& pStr,
- String& rSymbol )
- {
- BOOL res = FALSE;
- sal_Unicode cToken;
- const String& rThSep = pFormatter->GetNumThousandSep();
- register const sal_Unicode* pHere = pStr;
- ScanState eState = SsStart;
- xub_StrLen nCounter = 0; // counts 3 digits
- while ( ((cToken = *pHere) != 0) && eState != SsStop)
- {
- pHere++;
- switch (eState)
- {
- case SsStart:
- if ( StringPtrContains( rThSep, pHere-1, 0 ) )
- {
- nCounter = 0;
- eState = SsGetValue;
- pHere += rThSep.Len()-1;
- }
- else
- {
- eState = SsStop;
- pHere--;
- }
- break;
- case SsGetValue:
- if ( MyIsdigit( cToken ) )
- {
- rSymbol += cToken;
- nCounter++;
- if (nCounter == 3)
- {
- eState = SsStart;
- res = TRUE; // .000 combination found
- }
- }
- else
- {
- eState = SsStop;
- pHere--;
- }
- break;
- default:
- break;
- } // switch
- } // while
- if (eState == SsGetValue) // break witth less than 3 digits
- {
- if ( nCounter )
- rSymbol.Erase( rSymbol.Len() - nCounter, nCounter );
- pHere -= nCounter + rThSep.Len(); // put back ThSep also
- }
- pStr = pHere;
- return res;
- }
- //---------------------------------------------------------------------------
- // NumberStringDivision
- void ImpSvNumberInputScan::NumberStringDivision( const String& rString )
- {
- const sal_Unicode* pStr = rString.GetBuffer();
- const sal_Unicode* const pEnd = pStr + rString.Len();
- while ( pStr < pEnd && nAnzStrings < SV_MAX_ANZ_INPUT_STRINGS )
- {
- if ( NextNumberStringSymbol( pStr, sStrArray[nAnzStrings] ) )
- { // Zahl
- IsNum[nAnzStrings] = TRUE;
- nNums[nAnzNums] = nAnzStrings;
- nAnzNums++;
- if (nAnzStrings >= SV_MAX_ANZ_INPUT_STRINGS - 7 &&
- nPosThousandString == 0) // nur einmal
- if ( SkipThousands( pStr, sStrArray[nAnzStrings] ) )
- nPosThousandString = nAnzStrings;
- }
- else
- {
- IsNum[nAnzStrings] = FALSE;
- }
- nAnzStrings++;
- }
- }
- //---------------------------------------------------------------------------
- // Whether rString contains rWhat at nPos
- BOOL ImpSvNumberInputScan::StringContainsImpl( const String& rWhat,
- const String& rString, xub_StrLen nPos )
- {
- if ( nPos + rWhat.Len() <= rString.Len() )
- return StringPtrContainsImpl( rWhat, rString.GetBuffer(), nPos );
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // Whether pString contains rWhat at nPos
- BOOL ImpSvNumberInputScan::StringPtrContainsImpl( const String& rWhat,
- const sal_Unicode* pString, xub_StrLen nPos )
- {
- if ( rWhat.Len() == 0 )
- return FALSE;
- register const sal_Unicode* pWhat = rWhat.GetBuffer();
- register const sal_Unicode* const pEnd = pWhat + rWhat.Len();
- register const sal_Unicode* pStr = pString + nPos;
- while ( pWhat < pEnd )
- {
- if ( *pWhat != *pStr )
- return FALSE;
- pWhat++;
- pStr++;
- }
- return TRUE;
- }
- //---------------------------------------------------------------------------
- // SkipChar
- //
- // ueberspringt genau das angegebene Zeichen
- inline BOOL ImpSvNumberInputScan::SkipChar( sal_Unicode c, const String& rString,
- xub_StrLen& nPos )
- {
- if ((nPos < rString.Len()) && (rString.GetChar(nPos) == c))
- {
- nPos++;
- return TRUE;
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // SkipBlanks
- //
- // Ueberspringt Leerzeichen
- inline void ImpSvNumberInputScan::SkipBlanks( const String& rString,
- xub_StrLen& nPos )
- {
- if ( nPos < rString.Len() )
- {
- register const sal_Unicode* p = rString.GetBuffer() + nPos;
- while ( *p == ' ' )
- {
- nPos++;
- p++;
- }
- }
- }
- //---------------------------------------------------------------------------
- // SkipString
- //
- // jump over rWhat in rString at nPos
- inline BOOL ImpSvNumberInputScan::SkipString( const String& rWhat,
- const String& rString, xub_StrLen& nPos )
- {
- if ( StringContains( rWhat, rString, nPos ) )
- {
- nPos = nPos + rWhat.Len();
- return TRUE;
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // GetThousandSep
- //
- // erkennt genau .111 als Tausenderpunkt
- inline BOOL ImpSvNumberInputScan::GetThousandSep(
- const String& rString,
- xub_StrLen& nPos,
- USHORT nStringPos )
- {
- const String& rSep = pFormatter->GetNumThousandSep();
- // Is it an ordinary space instead of a non-breaking space?
- bool bSpaceBreak = rSep.GetChar(0) == 0xa0 && rString.GetChar(0) == 0x20 &&
- rSep.Len() == 1 && rString.Len() == 1;
- if ( (rString == rSep || bSpaceBreak) // nothing else
- && nStringPos < nAnzStrings - 1 // safety first!
- && IsNum[nStringPos+1] // number follows
- && ( sStrArray[nStringPos+1].Len() == 3 // with 3 digits
- || nPosThousandString == nStringPos+1 ) ) // or concatenated
- {
- nPos = nPos + rSep.Len();
- return TRUE;
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // GetLogical
- //
- // Umwandlung Text in logischen Wert
- // "TRUE" => 1:
- // "FALSE"=> -1:
- // sonst => 0:
- short ImpSvNumberInputScan::GetLogical( const String& rString )
- {
- short res;
- if (rString.Len() < 4) // kein Platz fuer mind 4 Buch.
- res = 0;
- else
- {
- const ImpSvNumberformatScan* pFS = pFormatter->GetFormatScanner();
- if ( rString == pFS->GetTrueString() )
- res = 1;
- else if ( rString == pFS->GetFalseString() )
- res = -1;
- else
- res = 0;
- }
- return res;
- }
- //---------------------------------------------------------------------------
- // GetMonth
- //
- // Converts a string containing a month name (JAN, January) at nPos into the
- // month number (negative if abbreviated), returns 0 if nothing found
- short ImpSvNumberInputScan::GetMonth( const String& rString, xub_StrLen& nPos )
- {
- // #102136# The correct English form of month September abbreviated is
- // SEPT, but almost every data contains SEP instead.
- static const String aSeptCorrect( RTL_CONSTASCII_USTRINGPARAM( "SEPT" ) );
- static const String aSepShortened( RTL_CONSTASCII_USTRINGPARAM( "SEP" ) );
- short res = 0; // no month found
- if (rString.Len() > nPos) // only if needed
- {
- if ( !bTextInitialized )
- InitText();
- sal_Int16 nMonths = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
- for ( sal_Int16 i = 0; i < nMonths; i++ )
- {
- if ( StringContains( pUpperMonthText[i], rString, nPos ) )
- { // full names first
- nPos = nPos + pUpperMonthText[i].Len();
- res = i+1;
- break; // for
- }
- else if ( StringContains( pUpperAbbrevMonthText[i], rString, nPos ) )
- { // abbreviated
- nPos = nPos + pUpperAbbrevMonthText[i].Len();
- res = sal::static_int_cast< short >(-(i+1)); // negative
- break; // for
- }
- else if ( i == 8 && pUpperAbbrevMonthText[i] == aSeptCorrect &&
- StringContains( aSepShortened, rString, nPos ) )
- { // #102136# SEPT/SEP
- nPos = nPos + aSepShortened.Len();
- res = sal::static_int_cast< short >(-(i+1)); // negative
- break; // for
- }
- }
- }
- return res;
- }
- //---------------------------------------------------------------------------
- // GetDayOfWeek
- //
- // Converts a string containing a DayOfWeek name (Mon, Monday) at nPos into the
- // DayOfWeek number + 1 (negative if abbreviated), returns 0 if nothing found
- int ImpSvNumberInputScan::GetDayOfWeek( const String& rString, xub_StrLen& nPos )
- {
- int res = 0; // no day found
- if (rString.Len() > nPos) // only if needed
- {
- if ( !bTextInitialized )
- InitText();
- sal_Int16 nDays = pFormatter->GetCalendar()->getNumberOfDaysInWeek();
- for ( sal_Int16 i = 0; i < nDays; i++ )
- {
- if ( StringContains( pUpperDayText[i], rString, nPos ) )
- { // full names first
- nPos = nPos + pUpperDayText[i].Len();
- res = i + 1;
- break; // for
- }
- if ( StringContains( pUpperAbbrevDayText[i], rString, nPos ) )
- { // abbreviated
- nPos = nPos + pUpperAbbrevDayText[i].Len();
- res = -(i + 1); // negative
- break; // for
- }
- }
- }
- return res;
- }
- //---------------------------------------------------------------------------
- // GetCurrency
- //
- // Lesen eines Waehrungssysmbols
- // '$' => TRUE
- // sonst => FALSE
- BOOL ImpSvNumberInputScan::GetCurrency( const String& rString, xub_StrLen& nPos,
- const SvNumberformat* pFormat )
- {
- if ( rString.Len() > nPos )
- {
- if ( !aUpperCurrSymbol.Len() )
- { // if no format specified the currency of the initialized formatter
- LanguageType eLang = (pFormat ? pFormat->GetLanguage() :
- pFormatter->GetLanguage());
- aUpperCurrSymbol = pFormatter->GetCharClass()->upper(
- SvNumberFormatter::GetCurrencyEntry( eLang ).GetSymbol() );
- }
- if ( StringContains( aUpperCurrSymbol, rString, nPos ) )
- {
- nPos = nPos + aUpperCurrSymbol.Len();
- return TRUE;
- }
- if ( pFormat )
- {
- String aSymbol, aExtension;
- if ( pFormat->GetNewCurrencySymbol( aSymbol, aExtension ) )
- {
- if ( aSymbol.Len() <= rString.Len() - nPos )
- {
- pFormatter->GetCharClass()->toUpper( aSymbol );
- if ( StringContains( aSymbol, rString, nPos ) )
- {
- nPos = nPos + aSymbol.Len();
- return TRUE;
- }
- }
- }
- }
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // GetTimeAmPm
- //
- // Lesen des Zeitsymbols (AM od. PM) f. kurze Zeitangabe
- //
- // Rueckgabe:
- // "AM" od. "PM" => TRUE
- // sonst => FALSE
- //
- // nAmPos:
- // "AM" => 1
- // "PM" => -1
- // sonst => 0
- BOOL ImpSvNumberInputScan::GetTimeAmPm( const String& rString, xub_StrLen& nPos )
- {
- if ( rString.Len() > nPos )
- {
- const CharClass* pChr = pFormatter->GetCharClass();
- const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
- if ( StringContains( pChr->upper( pLoc->getTimeAM() ), rString, nPos ) )
- {
- nAmPm = 1;
- nPos = nPos + pLoc->getTimeAM().Len();
- return TRUE;
- }
- else if ( StringContains( pChr->upper( pLoc->getTimePM() ), rString, nPos ) )
- {
- nAmPm = -1;
- nPos = nPos + pLoc->getTimePM().Len();
- return TRUE;
- }
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // GetDecSep
- //
- // Lesen eines Dezimaltrenners (',')
- // ',' => TRUE
- // sonst => FALSE
- inline BOOL ImpSvNumberInputScan::GetDecSep( const String& rString, xub_StrLen& nPos )
- {
- if ( rString.Len() > nPos )
- {
- const String& rSep = pFormatter->GetNumDecimalSep();
- if ( rString.Equals( rSep, nPos, rSep.Len() ) )
- {
- nPos = nPos + rSep.Len();
- return TRUE;
- }
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // read a hundredth seconds separator
- inline BOOL ImpSvNumberInputScan::GetTime100SecSep( const String& rString, xub_StrLen& nPos )
- {
- if ( rString.Len() > nPos )
- {
- const String& rSep = pFormatter->GetLocaleData()->getTime100SecSep();
- if ( rString.Equals( rSep, nPos, rSep.Len() ) )
- {
- nPos = nPos + rSep.Len();
- return TRUE;
- }
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // GetSign
- //
- // Lesen eines Vorzeichens, auch Klammer !?!
- // '+' => 1
- // '-' => -1
- // '(' => -1, nNegCheck = 1
- // sonst => 0
- int ImpSvNumberInputScan::GetSign( const String& rString, xub_StrLen& nPos )
- {
- if (rString.Len() > nPos)
- switch (rString.GetChar(nPos))
- {
- case '+':
- nPos++;
- return 1;
- case '(': // '(' aehnlich wie '-' ?!?
- nNegCheck = 1;
- //! fallthru
- case '-':
- nPos++;
- return -1;
- default:
- break;
- }
- return 0;
- }
- //---------------------------------------------------------------------------
- // GetESign
- //
- // Lesen eines Vorzeichens, gedacht fuer Exponent ?!?
- // '+' => 1
- // '-' => -1
- // sonst => 0
- short ImpSvNumberInputScan::GetESign( const String& rString, xub_StrLen& nPos )
- {
- if (rString.Len() > nPos)
- switch (rString.GetChar(nPos))
- {
- case '+':
- nPos++;
- return 1;
- case '-':
- nPos++;
- return -1;
- default:
- break;
- }
- return 0;
- }
- //---------------------------------------------------------------------------
- // GetNextNumber
- //
- // i counts string portions, j counts numbers thereof.
- // It should had been called SkipNumber instead.
- inline BOOL ImpSvNumberInputScan::GetNextNumber( USHORT& i, USHORT& j )
- {
- if ( i < nAnzStrings && IsNum[i] )
- {
- j++;
- i++;
- return TRUE;
- }
- return FALSE;
- }
- //---------------------------------------------------------------------------
- // GetTimeRef
- void ImpSvNumberInputScan::GetTimeRef(
- double& fOutNumber,
- USHORT nIndex, // j-value of the first numeric time part of input, default 0
- USHORT nAnz ) // count of numeric time parts
- {
- USHORT nHour;
- USHORT nMinute = 0;
- USHORT nSecond = 0;
- double fSecond100 = 0.0;
- USHORT nStartIndex = nIndex;
- if (nTimezonePos)
- {
- // find first timezone number index and adjust count
- for (USHORT j=0; j<nAnzNums; ++j)
- {
- if (nNums[j] == nTimezonePos)
- {
- // nAnz is not total count, but count of time relevant strings.
- if (nStartIndex < j && j - nStartIndex < nAnz)
- nAnz = j - nStartIndex;
- break; // for
- }
- }
- }
- if (nDecPos == 2 && (nAnz == 3 || nAnz == 2)) // 20:45.5 or 45.5
- nHour = 0;
- else if (nIndex - nStartIndex < nAnz)
- nHour = (USHORT) sStrArray[nNums[nIndex++]].ToInt32();
- else
- {
- nHour = 0;
- DBG_ERRORFILE( "ImpSvNumberInputScan::GetTimeRef: bad number index");
- }
- if (nDecPos == 2 && nAnz == 2) // 45.5
- nMinute = 0;
- else if (nIndex - nStartIndex < nAnz)
- nMinute = (USHORT) sStrArray[nNums[nIndex++]].ToInt32();
- if (nIndex - nStartIndex < nAnz)
- nSecond = (USHORT) sStrArray[nNums[nIndex++]].ToInt32();
- if (nIndex - nStartIndex < nAnz)
- fSecond100 = StringToDouble( sStrArray[nNums[nIndex]], TRUE );
- if (nAmPm == -1 && nHour != 12) // PM
- nHour += 12;
- else if (nAmPm == 1 && nHour == 12) // 12 AM
- nHour = 0;
- fOutNumber = ((double)nHour*3600 +
- (double)nMinute*60 +
- (double)nSecond +
- fSecond100)/86400.0;
- }
- //---------------------------------------------------------------------------
- // ImplGetDay
- USHORT ImpSvNumberInputScan::ImplGetDay( USHORT nIndex )
- {
- USHORT nRes = 0;
- if (sStrArray[nNums[nIndex]].Len() <= 2)
- {
- USHORT nNum = (USHORT) sStrArray[nNums[nIndex]].ToInt32();
- if (nNum <= 31)
- nRes = nNum;
- }
- return nRes;
- }
- //---------------------------------------------------------------------------
- // ImplGetMonth
- USHORT ImpSvNumberInputScan::ImplGetMonth( USHORT nIndex )
- {
- // preset invalid month number
- USHORT nRes = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
- if (sStrArray[nNums[nIndex]].Len() <= 2)
- {
- USHORT nNum = (USHORT) sStrArray[nNums[nIndex]].ToInt32();
- if ( 0 < nNum && nNum <= nRes )
- nRes = nNum - 1; // zero based for CalendarFieldIndex::MONTH
- }
- return nRes;
- }
- //---------------------------------------------------------------------------
- // ImplGetYear
- //
- // 30 -> 1930, 29 -> 2029, oder 56 -> 1756, 55 -> 1855, ...
- USHORT ImpSvNumberInputScan::ImplGetYear( USHORT nIndex )
- {
- USHORT nYear = 0;
- if (sStrArray[nNums[nIndex]].Len() <= 4)
- {
- nYear = (USHORT) sStrArray[nNums[nIndex]].ToInt32();
- nYear = SvNumberFormatter::ExpandTwoDigitYear( nYear, nYear2000 );
- }
- return nYear;
- }
- //---------------------------------------------------------------------------
- bool ImpSvNumberInputScan::MayBeIso8601()
- {
- if (nMayBeIso8601 == 0)
- {
- if (nAnzNums >= 3 && nNums[0] < nAnzStrings &&
- sStrArray[nNums[0]].ToInt32() > 31)
- nMayBeIso8601 = 1;
- else
- nMayBeIso8601 = 2;
- }
- return nMayBeIso8601 == 1;
- }
- //---------------------------------------------------------------------------
- // GetDateRef
- BOOL ImpSvNumberInputScan::GetDateRef( double& fDays, USHORT& nCounter,
- const SvNumberformat* pFormat )
- {
- using namespace ::com::sun::star::i18n;
- NfEvalDateFormat eEDF;
- int nFormatOrder;
- if ( pFormat && ((pFormat->GetType() & NUMBERFORMAT_DATE) == NUMBERFORMAT_DATE) )
- {
- eEDF = pFormatter->GetEvalDateFormat();
- switch ( eEDF )
- {
- case NF_EVALDATEFORMAT_INTL :
- case NF_EVALDATEFORMAT_FORMAT :
- nFormatOrder = 1; // only one loop
- break;
- default:
- nFormatOrder = 2;
- if ( nMatchedAllStrings )
- eEDF = NF_EVALDATEFORMAT_FORMAT_INTL;
- // we have a complete match, use it
- }
- }
- else
- {
- eEDF = NF_EVALDATEFORMAT_INTL;
- nFormatOrder = 1;
- }
- BOOL res = TRUE;
- const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
- CalendarWrapper* pCal = pFormatter->GetCalendar();
- for ( int nTryOrder = 1; nTryOrder <= nFormatOrder; nTryOrder++ )
- {
- pCal->setGregorianDateTime( Date() ); // today
- String aOrgCalendar; // empty => not changed yet
- DateFormat DateFmt;
- BOOL bFormatTurn;
- switch ( eEDF )
- {
- case NF_EVALDATEFORMAT_INTL :
- bFormatTurn = FALSE;
- DateFmt = pLoc->getDateFormat();
- break;
- case NF_EVALDATEFORMAT_FORMAT :
- bFormatTurn = TRUE;
- DateFmt = pFormat->GetDateOrder();
- break;
- case NF_EVALDATEFORMAT_INTL_FORMAT :
- if ( nTryOrder == 1 )
- {
- bFormatTurn = FALSE;
- DateFmt = pLoc->getDateFormat();
- }
- else
- {
- bFormatTurn = TRUE;
- DateFmt = pFormat->GetDateOrder();
- }
- break;
- case NF_EVALDATEFORMAT_FORMAT_INTL :
- if ( nTryOrder == 2 )
- {
- bFormatTurn = FALSE;
- DateFmt = pLoc->getDateFormat();
- }
- else
- {
- bFormatTurn = TRUE;
- DateFmt = pFormat->GetDateOrder();
- }
- break;
- default:
- DBG_ERROR( "ImpSvNumberInputScan::GetDateRef: unknown NfEvalDateFormat" );
- DateFmt = YMD;
- bFormatTurn = FALSE;
- }
- if ( bFormatTurn )
- {
- #if 0
- /* TODO:
- We are currently not able to fully support a switch to another calendar during
- input for the following reasons:
- 1. We do have a problem if both (locale's default and format's) calendars
- define the same YMD order and use the same date separator, there is no way
- to distinguish between them if the input results in valid calendar input for
- both calendars. How to solve? Would NfEvalDateFormat be sufficient? Should
- it always be set to NF_EVALDATEFORMAT_FORMAT_INTL and thus the format's
- calendar be preferred? This could be confusing if a Calc cell was formatted
- different to the locale's default and has no content yet, then the user has
- no clue about the format or calendar being set.
- 2. In Calc cell edit mode a date is always displayed and edited using the
- default edit format of the default calendar (normally being Gregorian). If
- input was ambiguous due to issue #1 we'd need a mechanism to tell that a
- date was edited and not newly entered. Not feasible. Otherwise we'd need a
- mechanism to use a specific edit format with a specific calendar according
- to the format set.
- 3. For some calendars like Japanese Gengou we'd need era input, which isn't
- implemented at all. Though this is a rare and special case, forcing a
- calendar dependent edit format as suggested in item #2 might require era
- input, if it shouldn't result in a fallback to Gregorian calendar.
- 4. Last and least: the GetMonth() method currently only matches month names of
- the default calendar. Alternating month names of the actual format's
- calendar would have to be implemented. No problem.
- */
- if ( pFormat->IsOtherCalendar( nStringScanNumFor ) )
- pFormat->SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
- else
- pFormat->SwitchToSpecifiedCalendar( aOrgCalendar, fOrgDateTime,
- nStringScanNumFor );
- #endif
- }
- res = TRUE;
- nCounter = 0;
- // For incomplete dates, always assume first day of month if not specified.
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
- switch (nAnzNums) // count of numbers in string
- {
- case 0: // none
- if (nMonthPos) // only month (Jan)
- pCal->setValue( CalendarFieldIndex::MONTH, Abs(nMonth)-1 );
- else
- res = FALSE;
- break;
- case 1: // only one number
- nCounter = 1;
- switch (nMonthPos) // where is the month
- {
- case 0: // not found => only day entered
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- break;
- case 1: // month at the beginning (Jan 01)
- pCal->setValue( CalendarFieldIndex::MONTH, Abs(nMonth)-1 );
- switch (DateFmt)
- {
- case MDY:
- case YMD:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- break;
- case DMY:
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- case 3: // month at the end (10 Jan)
- pCal->setValue( CalendarFieldIndex::MONTH, Abs(nMonth)-1 );
- switch (DateFmt)
- {
- case DMY:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- break;
- case YMD:
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- default:
- res = FALSE;
- break;
- } // switch (nMonthPos)
- break;
- case 2: // 2 numbers
- nCounter = 2;
- switch (nMonthPos) // where is the month
- {
- case 0: // not found
- {
- bool bHadExact;
- sal_uInt32 nExactDateOrder = (bFormatTurn ? pFormat->GetExactDateOrder() : 0);
- if ( 0xff < nExactDateOrder && nExactDateOrder <= 0xffff )
- { // formatted as date and exactly 2 parts
- bHadExact = true;
- switch ( (nExactDateOrder >> 8) & 0xff )
- {
- case 'Y':
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- break;
- case 'M':
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
- break;
- case 'D':
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- break;
- default:
- bHadExact = false;
- }
- switch ( nExactDateOrder & 0xff )
- {
- case 'Y':
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
- break;
- case 'M':
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
- break;
- case 'D':
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
- break;
- default:
- bHadExact = false;
- }
- }
- else
- bHadExact = false;
- if ( !bHadExact || !pCal->isValid() )
- {
- if ( !bHadExact && nExactDateOrder )
- pCal->setGregorianDateTime( Date() ); // reset today
- switch (DateFmt)
- {
- case MDY:
- // M D
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
- break;
- case DMY:
- // D M
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
- if ( !pCal->isValid() ) // 2nd try
- { // M Y
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
- }
- break;
- case YMD:
- // M D
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
- if ( !pCal->isValid() ) // 2nd try
- { // Y M
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- }
- break;
- default:
- res = FALSE;
- break;
- }
- }
- }
- break;
- case 1: // month at the beginning (Jan 01 01)
- {
- // The input is valid as MDY in almost any
- // constellation, there is no date order (M)YD except if
- // set in a format applied.
- pCal->setValue( CalendarFieldIndex::MONTH, Abs(nMonth)-1 );
- sal_uInt32 nExactDateOrder = (bFormatTurn ? pFormat->GetExactDateOrder() : 0);
- if ((((nExactDateOrder >> 8) & 0xff) == 'Y') && ((nExactDateOrder & 0xff) == 'D'))
- {
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- }
- else
- {
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
- }
- }
- break;
- case 2: // month in the middle (10 Jan 94)
- pCal->setValue( CalendarFieldIndex::MONTH, Abs(nMonth)-1 );
- switch (DateFmt)
- {
- case MDY: // yes, "10-Jan-94" is valid
- case DMY:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
- break;
- case YMD:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- default: // else, e.g. month at the end (94 10 Jan)
- res = FALSE;
- break;
- } // switch (nMonthPos)
- break;
- default: // more than two numbers (31.12.94 8:23) (31.12. 8:23)
- switch (nMonthPos) // where is the month
- {
- case 0: // not found
- {
- nCounter = 3;
- if ( nTimePos > 1 )
- { // find first time number index (should only be 3 or 2 anyway)
- for ( USHORT j = 0; j < nAnzNums; j++ )
- {
- if ( nNums[j] == nTimePos - 2 )
- {
- nCounter = j;
- break; // for
- }
- }
- }
- // ISO 8601 yyyy-mm-dd forced recognition
- DateFormat eDF = (MayBeIso8601() ? YMD : DateFmt);
- switch (eDF)
- {
- case MDY:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
- if ( nCounter > 2 )
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(2) );
- break;
- case DMY:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
- if ( nCounter > 2 )
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(2) );
- break;
- case YMD:
- if ( nCounter > 2 )
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(2) );
- pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- break;
- default:
- res = FALSE;
- break;
- }
- }
- break;
- case 1: // month at the beginning (Jan 01 01 8:23)
- nCounter = 2;
- switch (DateFmt)
- {
- case MDY:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- pCal->setValue( CalendarFieldIndex::MONTH, Abs(nMonth)-1 );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- case 2: // month in the middle (10 Jan 94 8:23)
- nCounter = 2;
- pCal->setValue( CalendarFieldIndex::MONTH, Abs(nMonth)-1 );
- switch (DateFmt)
- {
- case DMY:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
- break;
- case YMD:
- pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
- pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
- break;
- default:
- res = FALSE;
- break;
- }
- break;
- default: // else, e.g. month at the end (94 10 Jan 8:23)
- nCounter = 2;
- res = FALSE;
- break;
- } // switch (nMonthPos)
- break;
- } // switch (nAnzNums)
- if ( res && pCal->isValid() )
- {
- double fDiff = DateTime(*pNullDate) - pCal->getEpochStart();
- fDays = ::rtl::math::approxFloor( pCal->getLocalDateTime() );
- fDays -= fDiff;
- nTryOrder = nFormatOrder; // break for
- }
- else
- res = FALSE;
- if ( aOrgCalendar.Len() )
- pCal->loadCalendar( aOrgCalendar, pLoc->getLocale() ); // restore calendar
- #if NF_TEST_CALENDAR
- {
- using namespace ::com::sun::star;
- struct entry { const char* lan; const char* cou; const char* cal; };
- const entry cals[] = {
- { "en", "US", "gregorian" },
- { "ar", "TN", "hijri" },
- { "he", "IL", "jewish" },
- { "ja", "JP", "gengou" },
- { "ko", "KR", "hanja_yoil" },
- { "th", "TH", "buddhist" },
- { "zh", "TW", "ROC" },
- 0
- };
- lang::Locale aLocale;
- sal_Bool bValid;
- sal_Int16 nDay, nMonth, nYear, nHour, nMinute, nSecond;
- sal_Int16 nDaySet, nMonthSet, nYearSet, nHourSet, nMinuteSet, nSecondSet;
- sal_Int16 nZO, nDST1, nDST2, nDST;
- uno::Reference< lang::XMultiServiceFactory > xSMgr =
- ::comphelper::getProcessServiceFactory();
- uno::Reference< ::com::sun::star::i18n::XExtendedCalendar > xCal(
- xSMgr->createInstance( ::rtl::OUString(
- RTL_CONSTASCII_USTRINGPARAM(
- "com.sun.star.i18n.LocaleCalendar" ) ) ),
- uno::UNO_QUERY );
- for ( const entry* p = cals; p->lan; ++p )
- {
- aLocale.Language = ::rtl::OUString::createFromAscii( p->lan );
- aLocale.Country = ::rtl::OUString::createFromAscii( p->cou );
- xCal->loadCalendar( ::rtl::OUString::createFromAscii( p->cal ),
- aLocale );
- double nDateTime = 0.0; // 1-Jan-1970 00:00:00
- nZO = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET );
- nDST1 = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
- nDateTime -= (double)(nZO + nDST1) / 60.0 / 24.0;
- xCal->setDateTime( nDateTime );
- nDST2 = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
- if ( nDST1 != nDST2 )
- {
- nDateTime = 0.0 - (double)(nZO + nDST2) / 60.0 / 24.0;
- xCal->setDateTime( nDateTime );
- }
- nDaySet = xCal->getValue( i18n::CalendarFieldIndex::DAY_OF_MONTH );
- nMonthSet = xCal->getValue( i18n::CalendarFieldIndex::MONTH );
- nYearSet = xCal->getValue( i18n::CalendarFieldIndex::YEAR );
- nHourSet = xCal->getValue( i18n::CalendarFieldIndex::HOUR );
- nMinuteSet = xCal->getValue( i18n::CalendarFieldIndex::MINUTE );
- nSecondSet = xCal->getValue( i18n::CalendarFieldIndex…
Large files files are truncated, but you can click here to view the full file