?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lok: vcl: fix multiple floatwin removal case more robustly.
[LibreOffice.git] / svl / source / numbers / zforfind.cxx
blobdfb66e3de2359a188e1817b4b3074cd8acf7a74b
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <cstdlib>
21 #include <float.h>
22 #include <errno.h>
23 #include <comphelper/string.hxx>
24 #include <sal/log.hxx>
25 #include <tools/date.hxx>
26 #include <rtl/math.hxx>
27 #include <rtl/character.hxx>
28 #include <unotools/charclass.hxx>
29 #include <unotools/calendarwrapper.hxx>
30 #include <unotools/localedatawrapper.hxx>
31 #include <com/sun/star/i18n/CalendarFieldIndex.hpp>
32 #include <com/sun/star/i18n/LocaleCalendar2.hpp>
33 #include <unotools/digitgroupingiterator.hxx>
34 #include <comphelper/sequence.hxx>
35
36 #include <svl/zforlist.hxx>
37 #include "zforscan.hxx"
38 #include <svl/zformat.hxx>
39
40 #include "zforfind.hxx"
41
42 #ifndef DBG_UTIL
43 #define NF_TEST_CALENDAR 0
44 #else
45 #define NF_TEST_CALENDAR 0
46 #endif
47 #if NF_TEST_CALENDAR
48 #include <comphelper/processfactory.hxx>
49 #include <com/sun/star/i18n/XCalendar4.hpp>
50 #endif
51
52
53 const sal_uInt8 ImpSvNumberInputScan::nMatchedEndString = 0x01;
54 const sal_uInt8 ImpSvNumberInputScan::nMatchedMidString = 0x02;
55 const sal_uInt8 ImpSvNumberInputScan::nMatchedStartString = 0x04;
56 const sal_uInt8 ImpSvNumberInputScan::nMatchedVirgin = 0x08;
57 const sal_uInt8 ImpSvNumberInputScan::nMatchedUsedAsReturn = 0x10;
58
59 /* It is not clear how we want timezones to be handled. Convert them to local
60 * time isn't wanted, as it isn't done in any other place and timezone
61 * information isn't stored anywhere. Ignoring them and pretending local time
62 * may be wrong too and might not be what the user expects. Keep the input as
63 * string so that no information is lost.
64 * Anyway, defining NF_RECOGNIZE_ISO8601_TIMEZONES to 1 would be the way how it
65 * would work, together with the nTimezonePos handling in GetTimeRef(). */
66 #define NF_RECOGNIZE_ISO8601_TIMEZONES 0
67
68 static const sal_Unicode cNoBreakSpace = 0xA0;
69 static const sal_Unicode cNarrowNoBreakSpace = 0x202F;
70 static const bool kDefaultEra = true; // Gregorian CE, positive year
71
72 ImpSvNumberInputScan::ImpSvNumberInputScan( SvNumberFormatter* pFormatterP )
73 :
74 bTextInitialized( false ),
75 bScanGenitiveMonths( false ),
76 bScanPartitiveMonths( false ),
77 eScannedType( SvNumFormatType::UNDEFINED ),
78 eSetType( SvNumFormatType::UNDEFINED )
79 {
80 pFormatter = pFormatterP;
81 pNullDate.reset( new Date(30,12,1899) );
82 nYear2000 = SvNumberFormatter::GetYear2000Default();
83 Reset();
84 ChangeIntl();
85 }
86
87
88 ImpSvNumberInputScan::~ImpSvNumberInputScan()
89 {
90 }
91
92
93 void ImpSvNumberInputScan::Reset()
94 {
95 mpFormat = nullptr;
96 nMonth = 0;
97 nMonthPos = 0;
98 nDayOfWeek = 0;
99 nTimePos = 0;
100 nSign = 0;
101 nESign = 0;
102 nDecPos = 0;
103 bNegCheck = false;
104 nStringsCnt = 0;
105 nNumericsCnt = 0;
106 nThousand = 0;
107 eScannedType = SvNumFormatType::UNDEFINED;
108 nAmPm = 0;
109 nPosThousandString = 0;
110 nLogical = 0;
111 mbEraCE = kDefaultEra;
112 nStringScanNumFor = 0;
113 nStringScanSign = 0;
114 nMatchedAllStrings = nMatchedVirgin;
115 nMayBeIso8601 = 0;
116 bIso8601Tsep = false;
117 nMayBeMonthDate = 0;
118 nAcceptedDatePattern = -2;
119 nDatePatternStart = 0;
120 nDatePatternNumbers = 0;
121
122 for (sal_uInt32 i = 0; i < SV_MAX_COUNT_INPUT_STRINGS; i++)
123 {
124 IsNum[i] = false;
125 nNums[i] = 0;
126 }
127 }
128
129 // native number transliteration if necessary
130 static void TransformInput( SvNumberFormatter const * pFormatter, OUString& rStr )
131 {
132 sal_Int32 nPos, nLen;
133 for ( nPos = 0, nLen = rStr.getLength(); nPos < nLen; ++nPos )
134 {
135 if ( 256 <= rStr[ nPos ] &&
136 pFormatter->GetCharClass()->isDigit( rStr, nPos ) )
137 {
138 break;
139 }
140 }
141 if ( nPos < nLen )
142 {
143 rStr = pFormatter->GetNatNum()->getNativeNumberString( rStr,
144 pFormatter->GetLanguageTag().getLocale(), 0 );
145 }
146 }
147
148
149 /**
150 * Only simple unsigned floating point values without any error detection,
151 * decimal separator has to be '.'
152 */
153 double ImpSvNumberInputScan::StringToDouble( const OUString& rStr, bool bForceFraction )
154 {
155 double fNum = 0.0;
156 double fFrac = 0.0;
157 int nExp = 0;
158 sal_Int32 nPos = 0;
159 sal_Int32 nLen = rStr.getLength();
160 bool bPreSep = !bForceFraction;
161
162 while (nPos < nLen)
163 {
164 if (rStr[nPos] == '.')
165 {
166 bPreSep = false;
167 }
168 else if (bPreSep)
169 {
170 fNum = fNum * 10.0 + static_cast<double>(rStr[nPos] - '0');
171 }
172 else
173 {
174 fFrac = fFrac * 10.0 + static_cast<double>(rStr[nPos] - '0');
175 --nExp;
176 }
177 nPos++;
178 }
179 if ( fFrac )
180 {
181 return fNum + ::rtl::math::pow10Exp( fFrac, nExp );
182 }
183 return fNum;
184 }
185
186
187 /**
188 * Splits up the input into numbers and strings for further processing
189 * (by the Turing machine).
190 *
191 * Starting state = GetChar
192 * ---------------+-------------------+-----------------------------+---------------
193 * Old State | Character read | Event | New state
194 * ---------------+-------------------+-----------------------------+---------------
195 * GetChar | Number | Symbol = Character | GetValue
196 * | Else | Symbol = Character | GetString
197 * ---------------|-------------------+-----------------------------+---------------
198 * GetValue | Number | Symbol = Symbol + Character | GetValue
199 * | Else | Dec(CharPos) | Stop
200 * ---------------+-------------------+-----------------------------+---------------
201 * GetString | Number | Dec(CharPos) | Stop
202 * | Else | Symbol = Symbol + Character | GetString
203 * ---------------+-------------------+-----------------------------+---------------
204 */
205 enum ScanState // States of the Turing machine
206 {
207 SsStop = 0,
208 SsStart = 1,
209 SsGetValue = 2,
210 SsGetString = 3
211 };
212
213 bool ImpSvNumberInputScan::NextNumberStringSymbol( const sal_Unicode*& pStr,
214 OUString& rSymbol )
215 {
216 bool isNumber = false;
217 sal_Unicode cToken;
218 ScanState eState = SsStart;
219 const sal_Unicode* pHere = pStr;
220 sal_Int32 nChars = 0;
221
222 while ( ((cToken = *pHere) != 0) && eState != SsStop)
223 {
224 pHere++;
225 switch (eState)
226 {
227 case SsStart:
228 if ( rtl::isAsciiDigit( cToken ) )
229 {
230 eState = SsGetValue;
231 isNumber = true;
232 }
233 else
234 {
235 eState = SsGetString;
236 }
237 nChars++;
238 break;
239 case SsGetValue:
240 if ( rtl::isAsciiDigit( cToken ) )
241 {
242 nChars++;
243 }
244 else
245 {
246 eState = SsStop;
247 pHere--;
248 }
249 break;
250 case SsGetString:
251 if ( !rtl::isAsciiDigit( cToken ) )
252 {
253 nChars++;
254 }
255 else
256 {
257 eState = SsStop;
258 pHere--;
259 }
260 break;
261 default:
262 break;
263 } // switch
264 } // while
265
266 if ( nChars )
267 {
268 rSymbol = OUString( pStr, nChars );
269 }
270 else
271 {
272 rSymbol.clear();
273 }
274
275 pStr = pHere;
276
277 return isNumber;
278 }
279
280
281 // FIXME: should be grouping; it is only used though in case nStringsCnt is
282 // near SV_MAX_COUNT_INPUT_STRINGS, in NumberStringDivision().
283
284 bool ImpSvNumberInputScan::SkipThousands( const sal_Unicode*& pStr,
285 OUString& rSymbol ) const
286 {
287 bool res = false;
288 OUStringBuffer sBuff(rSymbol);
289 sal_Unicode cToken;
290 const OUString& rThSep = pFormatter->GetNumThousandSep();
291 const sal_Unicode* pHere = pStr;
292 ScanState eState = SsStart;
293 sal_Int32 nCounter = 0; // counts 3 digits
294
295 while ( ((cToken = *pHere) != 0) && eState != SsStop)
296 {
297 pHere++;
298 switch (eState)
299 {
300 case SsStart:
301 if ( StringPtrContains( rThSep, pHere-1, 0 ) )
302 {
303 nCounter = 0;
304 eState = SsGetValue;
305 pHere += rThSep.getLength() - 1;
306 }
307 else
308 {
309 eState = SsStop;
310 pHere--;
311 }
312 break;
313 case SsGetValue:
314 if ( rtl::isAsciiDigit( cToken ) )
315 {
316 sBuff.append(cToken);
317 nCounter++;
318 if (nCounter == 3)
319 {
320 eState = SsStart;
321 res = true; // .000 combination found
322 }
323 }
324 else
325 {
326 eState = SsStop;
327 pHere--;
328 }
329 break;
330 default:
331 break;
332 } // switch
333 } // while
334
335 if (eState == SsGetValue) // break with less than 3 digits
336 {
337 if ( nCounter )
338 {
339 sBuff.remove( sBuff.getLength() - nCounter, nCounter );
340 }
341 pHere -= nCounter + rThSep.getLength(); // put back ThSep also
342 }
343 rSymbol = sBuff.makeStringAndClear();
344 pStr = pHere;
345
346 return res;
347 }
348
349
350 void ImpSvNumberInputScan::NumberStringDivision( const OUString& rString )
351 {
352 const sal_Unicode* pStr = rString.getStr();
353 const sal_Unicode* const pEnd = pStr + rString.getLength();
354 while ( pStr < pEnd && nStringsCnt < SV_MAX_COUNT_INPUT_STRINGS )
355 {
356 if ( NextNumberStringSymbol( pStr, sStrArray[nStringsCnt] ) )
357 { // Number
358 IsNum[nStringsCnt] = true;
359 nNums[nNumericsCnt] = nStringsCnt;
360 nNumericsCnt++;
361 if (nStringsCnt >= SV_MAX_COUNT_INPUT_STRINGS - 7 &&
362 nPosThousandString == 0) // Only once
363 {
364 if ( SkipThousands( pStr, sStrArray[nStringsCnt] ) )
365 {
366 nPosThousandString = nStringsCnt;
367 }
368 }
369 }
370 else
371 {
372 IsNum[nStringsCnt] = false;
373 }
374 nStringsCnt++;
375 }
376 }
377
378
379 /**
380 * Whether rString contains rWhat at nPos
381 */
382 bool ImpSvNumberInputScan::StringContainsImpl( const OUString& rWhat,
383 const OUString& rString, sal_Int32 nPos )
384 {
385 if ( nPos + rWhat.getLength() <= rString.getLength() )
386 {
387 return StringPtrContainsImpl( rWhat, rString.getStr(), nPos );
388 }
389 return false;
390 }
391
392
393 /**
394 * Whether pString contains rWhat at nPos
395 */
396 bool ImpSvNumberInputScan::StringPtrContainsImpl( const OUString& rWhat,
397 const sal_Unicode* pString, sal_Int32 nPos )
398 {
399 if ( rWhat.isEmpty() )
400 {
401 return false;
402 }
403 const sal_Unicode* pWhat = rWhat.getStr();
404 const sal_Unicode* const pEnd = pWhat + rWhat.getLength();
405 const sal_Unicode* pStr = pString + nPos;
406 while ( pWhat < pEnd )
407 {
408 if ( *pWhat != *pStr )
409 {
410 return false;
411 }
412 pWhat++;
413 pStr++;
414 }
415 return true;
416 }
417
418
419 /**
420 * Whether rString contains word rWhat at nPos
421 */
422 bool ImpSvNumberInputScan::StringContainsWord( const OUString& rWhat,
423 const OUString& rString, sal_Int32 nPos ) const
424 {
425 if (rWhat.isEmpty() || rString.getLength() < nPos + rWhat.getLength())
426 return false;
427
428 if (StringPtrContainsImpl( rWhat, rString.getStr(), nPos))
429 {
430 nPos += rWhat.getLength();
431 if (nPos == rString.getLength())
432 return true; // word at end of string
433
434 /* TODO: we COULD invoke bells and whistles word break iterator to find
435 * the next boundary, but really ... this is called for date input, so
436 * how many languages do not separate the day and month names in some
437 * form? */
438
439 // Check simple ASCII first before invoking i18n or anything else.
440 const sal_Unicode c = rString[nPos];
441
442 // Common separating ASCII characters in date context.
443 switch (c)
444 {
445 case ' ':
446 case '-':
447 case '.':
448 case '/':
449 return true;
450 default:
451 ; // nothing
452 }
453
454 if (rtl::isAsciiAlphanumeric( c ))
455 return false; // Alpha or numeric is not word gap.
456
457 sal_Int32 nIndex = nPos;
458 rString.iterateCodePoints( &nIndex);
459 if (nPos+1 < nIndex)
460 return true; // Surrogate, assume these to be new words.
461
462 const sal_Int32 nType = pFormatter->GetCharClass()->getCharacterType( rString, nPos);
463 using namespace ::com::sun::star::i18n;
464
465 if ((nType & (KCharacterType::UPPER | KCharacterType::LOWER | KCharacterType::DIGIT)) != 0)
466 return false; // Alpha or numeric is not word gap.
467
468 if (nType & KCharacterType::LETTER)
469 return true; // Letter other than alpha is new word. (Is it?)
470
471 return true; // Catch all remaining as gap until we know better.
472 }
473
474 return false;
475 }
476
477
478 /**
479 * Skips the supplied char
480 */
481 inline bool ImpSvNumberInputScan::SkipChar( sal_Unicode c, const OUString& rString,
482 sal_Int32& nPos )
483 {
484 if ((nPos < rString.getLength()) && (rString[nPos] == c))
485 {
486 nPos++;
487 return true;
488 }
489 return false;
490 }
491
492
493 /**
494 * Skips blanks
495 */
496 inline void ImpSvNumberInputScan::SkipBlanks( const OUString& rString,
497 sal_Int32& nPos )
498 {
499 if ( nPos < rString.getLength() )
500 {
501 const sal_Unicode* p = rString.getStr() + nPos;
502 while ( *p == ' ' || *p == cNoBreakSpace || *p == cNarrowNoBreakSpace )
503 {
504 nPos++;
505 p++;
506 }
507 }
508 }
509
510
511 /**
512 * jump over rWhat in rString at nPos
513 */
514 inline bool ImpSvNumberInputScan::SkipString( const OUString& rWhat,
515 const OUString& rString, sal_Int32& nPos )
516 {
517 if ( StringContains( rWhat, rString, nPos ) )
518 {
519 nPos = nPos + rWhat.getLength();
520 return true;
521 }
522 return false;
523 }
524
525
526 /**
527 * Recognizes exactly ,111 in {3} and {3,2} or ,11 in {3,2} grouping
528 */
529 inline bool ImpSvNumberInputScan::GetThousandSep( const OUString& rString,
530 sal_Int32& nPos,
531 sal_uInt16 nStringPos ) const
532 {
533 const OUString& rSep = pFormatter->GetNumThousandSep();
534 // Is it an ordinary space instead of a no-break space?
535 bool bSpaceBreak = (rSep[0] == cNoBreakSpace || rSep[0] == cNarrowNoBreakSpace) &&
536 rString[0] == u' ' &&
537 rSep.getLength() == 1 && rString.getLength() == 1;
538 if (!((rString == rSep || bSpaceBreak) && // nothing else
539 nStringPos < nStringsCnt - 1 && // safety first!
540 IsNum[ nStringPos + 1 ] )) // number follows
541 {
542 return false; // no? => out
543 }
544
545 utl::DigitGroupingIterator aGrouping( pFormatter->GetLocaleData()->getDigitGrouping());
546 // Match ,### in {3} or ,## in {3,2}
547 /* FIXME: this could be refined to match ,## in {3,2} only if ,##,## or
548 * ,##,### and to match ,### in {3,2} only if it's the last. However,
549 * currently there is no track kept where group separators occur. In {3,2}
550 * #,###,### and #,##,## would be valid input, which maybe isn't even bad
551 * for #,###,###. Other combinations such as #,###,## maybe not. */
552 sal_Int32 nLen = sStrArray[ nStringPos + 1 ].getLength();
553 if (nLen == aGrouping.get() || // with 3 (or so) digits
554 nLen == aGrouping.advance().get() || // or with 2 (or 3 or so) digits
555 nPosThousandString == nStringPos + 1 ) // or concatenated
556 {
557 nPos = nPos + rSep.getLength();
558 return true;
559 }
560 return false;
561 }
562
563
564 /**
565 * Conversion of text to logical value
566 * "true" => 1:
567 * "false"=> -1:
568 * else => 0:
569 */
570 short ImpSvNumberInputScan::GetLogical( const OUString& rString ) const
571 {
572 short res;
573
574 const ImpSvNumberformatScan* pFS = pFormatter->GetFormatScanner();
575 if ( rString == pFS->GetTrueString() )
576 {
577 res = 1;
578 }
579 else if ( rString == pFS->GetFalseString() )
580 {
581 res = -1;
582 }
583 else
584 {
585 res = 0;
586 }
587 return res;
588 }
589
590
591 /**
592 * Converts a string containing a month name (JAN, January) at nPos into the
593 * month number (negative if abbreviated), returns 0 if nothing found
594 */
595 short ImpSvNumberInputScan::GetMonth( const OUString& rString, sal_Int32& nPos )
596 {
597 short res = 0; // no month found
598
599 if (rString.getLength() > nPos) // only if needed
600 {
601 if ( !bTextInitialized )
602 {
603 InitText();
604 }
605 sal_Int16 nMonths = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
606 for ( sal_Int16 i = 0; i < nMonths; i++ )
607 {
608 if ( bScanGenitiveMonths && StringContainsWord( pUpperGenitiveMonthText[i], rString, nPos ) )
609 { // genitive full names first
610 nPos = nPos + pUpperGenitiveMonthText[i].getLength();
611 res = i + 1;
612 break; // for
613 }
614 else if ( bScanGenitiveMonths && StringContainsWord( pUpperGenitiveAbbrevMonthText[i], rString, nPos ) )
615 { // genitive abbreviated
616 nPos = nPos + pUpperGenitiveAbbrevMonthText[i].getLength();
617 res = sal::static_int_cast< short >(-(i+1)); // negative
618 break; // for
619 }
620 else if ( bScanPartitiveMonths && StringContainsWord( pUpperPartitiveMonthText[i], rString, nPos ) )
621 { // partitive full names
622 nPos = nPos + pUpperPartitiveMonthText[i].getLength();
623 res = i+1;
624 break; // for
625 }
626 else if ( bScanPartitiveMonths && StringContainsWord( pUpperPartitiveAbbrevMonthText[i], rString, nPos ) )
627 { // partitive abbreviated
628 nPos = nPos + pUpperPartitiveAbbrevMonthText[i].getLength();
629 res = sal::static_int_cast< short >(-(i+1)); // negative
630 break; // for
631 }
632 else if ( StringContainsWord( pUpperMonthText[i], rString, nPos ) )
633 { // noun full names
634 nPos = nPos + pUpperMonthText[i].getLength();
635 res = i+1;
636 break; // for
637 }
638 else if ( StringContainsWord( pUpperAbbrevMonthText[i], rString, nPos ) )
639 { // noun abbreviated
640 nPos = nPos + pUpperAbbrevMonthText[i].getLength();
641 res = sal::static_int_cast< short >(-(i+1)); // negative
642 break; // for
643 }
644 else if ( i == 8 && pUpperAbbrevMonthText[i] == "SEPT" &&
645 StringContainsWord( "SEP", rString, nPos ) )
646 { // #102136# The correct English form of month September abbreviated is
647 // SEPT, but almost every data contains SEP instead.
648 nPos = nPos + 3;
649 res = sal::static_int_cast< short >(-(i+1)); // negative
650 break; // for
651 }
652 }
653 if (!res)
654 {
655 // Brutal hack for German locales that know "Januar" or "Jänner".
656 /* TODO: add alternative month names to locale data? if there are
657 * more languages.. */
658 const LanguageTag& rLanguageTag = pFormatter->GetLanguageTag();
659 if (rLanguageTag.getLanguage() == "de")
660 {
661 if (rLanguageTag.getCountry() == "AT")
662 {
663 // Locale data has Jänner/Jän
664 assert(pUpperMonthText[0] == u"J\u00C4NNER");
665 if (StringContainsWord( "JANUAR", rString, nPos))
666 {
667 nPos += 6;
668 res = 1;
669 }
670 else if (StringContainsWord( "JAN", rString, nPos))
671 {
672 nPos += 3;
673 res = -1;
674 }
675 }
676 else
677 {
678 // Locale data has Januar/Jan
679 assert(pUpperMonthText[0] == "JANUAR");
680 if (StringContainsWord( u"J\u00C4NNER", rString, nPos))
681 {
682 nPos += 6;
683 res = 1;
684 }
685 else if (StringContainsWord( u"J\u00C4N", rString, nPos))
686 {
687 nPos += 3;
688 res = -1;
689 }
690 }
691 }
692 }
693 }
694
695 return res;
696 }
697
698
699 /**
700 * Converts a string containing a DayOfWeek name (Mon, Monday) at nPos into the
701 * DayOfWeek number + 1 (negative if abbreviated), returns 0 if nothing found
702 */
703 int ImpSvNumberInputScan::GetDayOfWeek( const OUString& rString, sal_Int32& nPos )
704 {
705 int res = 0; // no day found
706
707 if (rString.getLength() > nPos) // only if needed
708 {
709 if ( !bTextInitialized )
710 {
711 InitText();
712 }
713 sal_Int16 nDays = pFormatter->GetCalendar()->getNumberOfDaysInWeek();
714 for ( sal_Int16 i = 0; i < nDays; i++ )
715 {
716 if ( StringContainsWord( pUpperDayText[i], rString, nPos ) )
717 { // full names first
718 nPos = nPos + pUpperDayText[i].getLength();
719 res = i + 1;
720 break; // for
721 }
722 if ( StringContainsWord( pUpperAbbrevDayText[i], rString, nPos ) )
723 { // abbreviated
724 nPos = nPos + pUpperAbbrevDayText[i].getLength();
725 res = -(i + 1); // negative
726 break; // for
727 }
728 }
729 }
730
731 return res;
732 }
733
734
735 /**
736 * Reading a currency symbol
737 * '$' => true
738 * else => false
739 */
740 bool ImpSvNumberInputScan::GetCurrency( const OUString& rString, sal_Int32& nPos )
741 {
742 if ( rString.getLength() > nPos )
743 {
744 if ( !aUpperCurrSymbol.getLength() )
745 { // If no format specified the currency of the currently active locale.
746 LanguageType eLang = (mpFormat ? mpFormat->GetLanguage() :
747 pFormatter->GetLocaleData()->getLanguageTag().getLanguageType());
748 aUpperCurrSymbol = pFormatter->GetCharClass()->uppercase(
749 SvNumberFormatter::GetCurrencyEntry( eLang ).GetSymbol() );
750 }
751 if ( StringContains( aUpperCurrSymbol, rString, nPos ) )
752 {
753 nPos = nPos + aUpperCurrSymbol.getLength();
754 return true;
755 }
756 if ( mpFormat )
757 {
758 OUString aSymbol, aExtension;
759 if ( mpFormat->GetNewCurrencySymbol( aSymbol, aExtension ) )
760 {
761 if ( aSymbol.getLength() <= rString.getLength() - nPos )
762 {
763 aSymbol = pFormatter->GetCharClass()->uppercase(aSymbol);
764 if ( StringContains( aSymbol, rString, nPos ) )
765 {
766 nPos = nPos + aSymbol.getLength();
767 return true;
768 }
769 }
770 }
771 }
772 }
773
774 return false;
775 }
776
777
778 /**
779 * Reading the time period specifier (AM/PM) for the 12 hour clock
780 *
781 * Returns:
782 * "AM" or "PM" => true
783 * else => false
784 *
785 * nAmPos:
786 * "AM" => 1
787 * "PM" => -1
788 * else => 0
789 */
790 bool ImpSvNumberInputScan::GetTimeAmPm( const OUString& rString, sal_Int32& nPos )
791 {
792
793 if ( rString.getLength() > nPos )
794 {
795 const CharClass* pChr = pFormatter->GetCharClass();
796 const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
797 if ( StringContains( pChr->uppercase( pLoc->getTimeAM() ), rString, nPos ) )
798 {
799 nAmPm = 1;
800 nPos = nPos + pLoc->getTimeAM().getLength();
801 return true;
802 }
803 else if ( StringContains( pChr->uppercase( pLoc->getTimePM() ), rString, nPos ) )
804 {
805 nAmPm = -1;
806 nPos = nPos + pLoc->getTimePM().getLength();
807 return true;
808 }
809 }
810
811 return false;
812 }
813
814
815 /**
816 * Read a decimal separator (',')
817 * ',' => true
818 * else => false
819 */
820 inline bool ImpSvNumberInputScan::GetDecSep( const OUString& rString, sal_Int32& nPos ) const
821 {
822 if ( rString.getLength() > nPos )
823 {
824 const OUString& rSep = pFormatter->GetNumDecimalSep();
825 if ( rString.match( rSep, nPos) )
826 {
827 nPos = nPos + rSep.getLength();
828 return true;
829 }
830 const OUString& rSepAlt = pFormatter->GetNumDecimalSepAlt();
831 if ( !rSepAlt.isEmpty() && rString.match( rSepAlt, nPos) )
832 {
833 nPos = nPos + rSepAlt.getLength();
834 return true;
835 }
836 }
837 return false;
838 }
839
840
841 /**
842 * Reading a hundredth seconds separator
843 */
844 inline bool ImpSvNumberInputScan::GetTime100SecSep( const OUString& rString, sal_Int32& nPos ) const
845 {
846 if ( rString.getLength() > nPos )
847 {
848 if (bIso8601Tsep)
849 {
850 // ISO 8601 specifies both '.' dot and ',' comma as fractional
851 // separator.
852 if (rString[nPos] == '.' || rString[nPos] == ',')
853 {
854 ++nPos;
855 return true;
856 }
857 }
858 // Even in an otherwise ISO 8601 string be lenient and accept the
859 // locale defined separator.
860 const OUString& rSep = pFormatter->GetLocaleData()->getTime100SecSep();
861 if ( rString.match( rSep, nPos ))
862 {
863 nPos = nPos + rSep.getLength();
864 return true;
865 }
866 }
867 return false;
868 }
869
870
871 /**
872 * Read a sign including brackets
873 * '+' => 1
874 * '-' => -1
875 * '(' => -1, bNegCheck = 1
876 * else => 0
877 */
878 int ImpSvNumberInputScan::GetSign( const OUString& rString, sal_Int32& nPos )
879 {
880 if (rString.getLength() > nPos)
881 switch (rString[ nPos ])
882 {
883 case '+':
884 nPos++;
885 return 1;
886 case '(': // '(' similar to '-' ?!?
887 bNegCheck = true;
888 SAL_FALLTHROUGH;
889 case '-':
890 nPos++;
891 return -1;
892 default:
893 break;
894 }
895
896 return 0;
897 }
898
899
900 /**
901 * Read a sign with an exponent
902 * '+' => 1
903 * '-' => -1
904 * else => 0
905 */
906 short ImpSvNumberInputScan::GetESign( const OUString& rString, sal_Int32& nPos )
907 {
908 if (rString.getLength() > nPos)
909 {
910 switch (rString[nPos])
911 {
912 case '+':
913 nPos++;
914 return 1;
915 case '-':
916 nPos++;
917 return -1;
918 default:
919 break;
920 }
921 }
922 return 0;
923 }
924
925
926 /**
927 * i counts string portions, j counts numbers thereof.
928 * It should had been called SkipNumber instead.
929 */
930 inline bool ImpSvNumberInputScan::GetNextNumber( sal_uInt16& i, sal_uInt16& j ) const
931 {
932 if ( i < nStringsCnt && IsNum[i] )
933 {
934 j++;
935 i++;
936 return true;
937 }
938 return false;
939 }
940
941
942 bool ImpSvNumberInputScan::GetTimeRef( double& fOutNumber,
943 sal_uInt16 nIndex, // j-value of the first numeric time part of input, default 0
944 sal_uInt16 nCnt ) const // count of numeric time parts
945 {
946 bool bRet = true;
947 sal_uInt16 nHour;
948 sal_uInt16 nMinute = 0;
949 sal_uInt16 nSecond = 0;
950 double fSecond100 = 0.0;
951 sal_uInt16 nStartIndex = nIndex;
952
953 if (nDecPos == 2 && (nCnt == 3 || nCnt == 2)) // 20:45.5 or 45.5
954 {
955 nHour = 0;
956 }
957 else if (nIndex - nStartIndex < nCnt)
958 {
959 nHour = static_cast<sal_uInt16>(sStrArray[nNums[nIndex++]].toInt32());
960 }
961 else
962 {
963 nHour = 0;
964 bRet = false;
965 SAL_WARN( "svl.numbers", "ImpSvNumberInputScan::GetTimeRef: bad number index");
966 }
967 if (nDecPos == 2 && nCnt == 2) // 45.5
968 {
969 nMinute = 0;
970 }
971 else if (nIndex - nStartIndex < nCnt)
972 {
973 nMinute = static_cast<sal_uInt16>(sStrArray[nNums[nIndex++]].toInt32());
974 }
975 if (nIndex - nStartIndex < nCnt)
976 {
977 nSecond = static_cast<sal_uInt16>(sStrArray[nNums[nIndex++]].toInt32());
978 }
979 if (nIndex - nStartIndex < nCnt)
980 {
981 fSecond100 = StringToDouble( sStrArray[nNums[nIndex]], true );
982 }
983 if (nAmPm && nHour > 12) // not a valid AM/PM clock time
984 {
985 bRet = false;
986 }
987 else if (nAmPm == -1 && nHour != 12) // PM
988 {
989 nHour += 12;
990 }
991 else if (nAmPm == 1 && nHour == 12) // 12 AM
992 {
993 nHour = 0;
994 }
995 fOutNumber = (static_cast<double>(nHour)*3600 +
996 static_cast<double>(nMinute)*60 +
997 static_cast<double>(nSecond) +
998 fSecond100)/86400.0;
999 return bRet;
1000 }
1001
1002
1003 sal_uInt16 ImpSvNumberInputScan::ImplGetDay( sal_uInt16 nIndex ) const
1004 {
1005 sal_uInt16 nRes = 0;
1006
1007 if (sStrArray[nNums[nIndex]].getLength() <= 2)
1008 {
1009 sal_uInt16 nNum = static_cast<sal_uInt16>(sStrArray[nNums[nIndex]].toInt32());
1010 if (nNum <= 31)
1011 {
1012 nRes = nNum;
1013 }
1014 }
1015
1016 return nRes;
1017 }
1018
1019
1020 sal_uInt16 ImpSvNumberInputScan::ImplGetMonth( sal_uInt16 nIndex ) const
1021 {
1022 // Preset invalid month number
1023 sal_uInt16 nRes = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
1024
1025 if (sStrArray[nNums[nIndex]].getLength() <= 2)
1026 {
1027 sal_uInt16 nNum = static_cast<sal_uInt16>(sStrArray[nNums[nIndex]].toInt32());
1028 if ( 0 < nNum && nNum <= nRes )
1029 {
1030 nRes = nNum - 1; // zero based for CalendarFieldIndex::MONTH
1031 }
1032 }
1033
1034 return nRes;
1035 }
1036
1037
1038 /**
1039 * 30 -> 1930, 29 -> 2029, or 56 -> 1756, 55 -> 1855, ...
1040 */
1041 sal_uInt16 ImpSvNumberInputScan::ImplGetYear( sal_uInt16 nIndex )
1042 {
1043 sal_uInt16 nYear = 0;
1044
1045 sal_Int32 nLen = sStrArray[nNums[nIndex]].getLength();
1046 // 16-bit integer year width can have 5 digits, allow for one additional
1047 // leading zero as convention.
1048 if (nLen <= 6)
1049 {
1050 nYear = static_cast<sal_uInt16>(sStrArray[nNums[nIndex]].toInt32());
1051 // A year in another, not Gregorian CE era is never expanded.
1052 // A year < 100 entered with at least 3 digits with leading 0 is taken
1053 // as is without expansion.
1054 if (mbEraCE == kDefaultEra && nYear < 100 && nLen < 3)
1055 {
1056 nYear = SvNumberFormatter::ExpandTwoDigitYear( nYear, nYear2000 );
1057 }
1058 }
1059
1060 return nYear;
1061 }
1062
1063
1064 bool ImpSvNumberInputScan::MayBeIso8601()
1065 {
1066 if (nMayBeIso8601 == 0)
1067 {
1068 nMayBeIso8601 = 1;
1069 sal_Int32 nLen = ((nNumericsCnt >= 1 && nNums[0] < nStringsCnt) ? sStrArray[nNums[0]].getLength() : 0);
1070 if (nLen)
1071 {
1072 sal_Int32 n;
1073 if (nNumericsCnt >= 3 && nNums[2] < nStringsCnt &&
1074 sStrArray[nNums[0]+1] == "-" && // separator year-month
1075 (n = sStrArray[nNums[1]].toInt32()) >= 1 && n <= 12 && // month
1076 sStrArray[nNums[1]+1] == "-" && // separator month-day
1077 (n = sStrArray[nNums[2]].toInt32()) >= 1 && n <= 31) // day
1078 {
1079 // Year (nNums[0]) value not checked, may be anything, but
1080 // length (number of digits) is checked.
1081 nMayBeIso8601 = (nLen >= 4 ? 4 : (nLen == 3 ? 3 : (nLen > 0 ? 2 : 1)));
1082 }
1083 }
1084 }
1085 return nMayBeIso8601 > 1;
1086 }
1087
1088
1089 bool ImpSvNumberInputScan::CanForceToIso8601( DateOrder eDateOrder )
1090 {
1091 int nCanForceToIso8601 = 0;
1092 if (!MayBeIso8601())
1093 {
1094 return false;
1095 }
1096 else if (nMayBeIso8601 >= 3)
1097 {
1098 return true; // at least 3 digits in year
1099 }
1100 else
1101 {
1102 if (eDateOrder == DateOrder::Invalid)
1103 {
1104 // As if any of the cases below can be applied, but only if a
1105 // locale dependent date pattern was not matched.
1106 if ((GetDatePatternNumbers() == nNumericsCnt) && IsDatePatternNumberOfType(0,'Y'))
1107 return false;
1108 eDateOrder = GetDateOrder();
1109 }
1110
1111 nCanForceToIso8601 = 1;
1112 }
1113
1114 sal_Int32 n;
1115 switch (eDateOrder)
1116 {
1117 case DateOrder::DMY: // "day" value out of range => ISO 8601 year
1118 if ((n = sStrArray[nNums[0]].toInt32()) < 1 || n > 31)
1119 {
1120 nCanForceToIso8601 = 2;
1121 }
1122 break;
1123 case DateOrder::MDY: // "month" value out of range => ISO 8601 year
1124 if ((n = sStrArray[nNums[0]].toInt32()) < 1 || n > 12)
1125 {
1126 nCanForceToIso8601 = 2;
1127 }
1128 break;
1129 case DateOrder::YMD: // always possible
1130 nCanForceToIso8601 = 2;
1131 break;
1132 default: break;
1133 }
1134 return nCanForceToIso8601 > 1;
1135 }
1136
1137
1138 bool ImpSvNumberInputScan::IsAcceptableIso8601()
1139 {
1140 if (mpFormat && (mpFormat->GetType() & SvNumFormatType::DATE))
1141 {
1142 switch (pFormatter->GetEvalDateFormat())
1143 {
1144 case NF_EVALDATEFORMAT_INTL:
1145 return CanForceToIso8601( GetDateOrder());
1146 case NF_EVALDATEFORMAT_FORMAT:
1147 return CanForceToIso8601( mpFormat->GetDateOrder());
1148 default:
1149 return CanForceToIso8601( GetDateOrder()) || CanForceToIso8601( mpFormat->GetDateOrder());
1150 }
1151 }
1152 return CanForceToIso8601( GetDateOrder());
1153 }
1154
1155
1156 bool ImpSvNumberInputScan::MayBeMonthDate()
1157 {
1158 if (nMayBeMonthDate == 0)
1159 {
1160 nMayBeMonthDate = 1;
1161 if (nNumericsCnt >= 2 && nNums[1] < nStringsCnt)
1162 {
1163 // "-Jan-"
1164 const OUString& rM = sStrArray[ nNums[ 0 ] + 1 ];
1165 if (rM.getLength() >= 3 && rM[0] == '-' && rM[ rM.getLength() - 1] == '-')
1166 {
1167 // Check year length assuming at least 3 digits (including
1168 // leading zero). Two digit years 1..31 are out of luck here
1169 // and may be taken as day of month.
1170 bool bYear1 = (sStrArray[nNums[0]].getLength() >= 3);
1171 bool bYear2 = (sStrArray[nNums[1]].getLength() >= 3);
1172 sal_Int32 n;
1173 bool bDay1 = !bYear1;
1174 if (bDay1)
1175 {
1176 n = sStrArray[nNums[0]].toInt32();
1177 bDay1 = n >= 1 && n <= 31;
1178 }
1179 bool bDay2 = !bYear2;
1180 if (bDay2)
1181 {
1182 n = sStrArray[nNums[1]].toInt32();
1183 bDay2 = n >= 1 && n <= 31;
1184 }
1185
1186 if (bDay1 && !bDay2)
1187 {
1188 nMayBeMonthDate = 2; // dd-month-yy
1189 }
1190 else if (!bDay1 && bDay2)
1191 {
1192 nMayBeMonthDate = 3; // yy-month-dd
1193 }
1194 else if (bDay1 && bDay2)
1195 {
1196 // Ambiguous ##-MMM-## date, but some big vendor's database
1197 // reports write this crap, assume this always to be
1198 nMayBeMonthDate = 2; // dd-month-yy
1199 }
1200 }
1201 }
1202 }
1203 return nMayBeMonthDate > 1;
1204 }
1205
1206
1207 /** If a string is a separator plus '-' minus sign preceding a 'Y' year in
1208 a date pattern at position nPat.
1209 */
1210 static bool lcl_IsSignedYearSep( const OUString& rStr, const OUString& rPat, sal_Int32 nPat )
1211 {
1212 bool bOk = false;
1213 sal_Int32 nLen = rStr.getLength();
1214 if (nLen > 1 && rStr[nLen-1] == '-')
1215 {
1216 --nLen;
1217 if (nPat + nLen < rPat.getLength() && rPat[nPat+nLen] == 'Y')
1218 {
1219 // Signed year is possible.
1220 bOk = (rPat.indexOf( rStr.copy( 0, nLen), nPat) == nPat);
1221 }
1222 }
1223 return bOk;
1224 }
1225
1226
1227 bool ImpSvNumberInputScan::IsAcceptedDatePattern( sal_uInt16 nStartPatternAt )
1228 {
1229 if (nAcceptedDatePattern >= -1)
1230 {
1231 return (nAcceptedDatePattern >= 0);
1232 }
1233 if (!nNumericsCnt)
1234 {
1235 nAcceptedDatePattern = -1;
1236 }
1237 else if (!sDateAcceptancePatterns.getLength())
1238 {
1239 // The current locale is the format's locale, if a format is present.
1240 const NfEvalDateFormat eEDF = pFormatter->GetEvalDateFormat();
1241 if (!mpFormat || eEDF == NF_EVALDATEFORMAT_FORMAT || mpFormat->GetLanguage() == pFormatter->GetLanguage())
1242 {
1243 sDateAcceptancePatterns = pFormatter->GetLocaleData()->getDateAcceptancePatterns();
1244 }
1245 else
1246 {
1247 OnDemandLocaleDataWrapper& xLocaleData = pFormatter->GetOnDemandLocaleDataWrapper(
1248 SvNumberFormatter::InputScannerPrivateAccess());
1249 const LanguageTag aSaveLocale( xLocaleData->getLanguageTag() );
1250 assert(mpFormat->GetLanguage() == aSaveLocale.getLanguageType()); // prerequisite
1251 // Obtain formatter's locale's (e.g. system) patterns.
1252 xLocaleData.changeLocale( LanguageTag( pFormatter->GetLanguage()));
1253 const css::uno::Sequence<OUString> aLocalePatterns( xLocaleData->getDateAcceptancePatterns());
1254 // Reset to format's locale.
1255 xLocaleData.changeLocale( aSaveLocale);
1256 // When concatenating don't care about duplicates, combining
1257 // weeding those out reallocs yet another time and probably doesn't
1258 // take less time than looping over two additional patterns below..
1259 switch (eEDF)
1260 {
1261 case NF_EVALDATEFORMAT_FORMAT:
1262 assert(!"shouldn't reach here");
1263 break;
1264 case NF_EVALDATEFORMAT_INTL:
1265 sDateAcceptancePatterns = aLocalePatterns;
1266 break;
1267 case NF_EVALDATEFORMAT_INTL_FORMAT:
1268 sDateAcceptancePatterns = comphelper::concatSequences(
1269 aLocalePatterns,
1270 xLocaleData->getDateAcceptancePatterns());
1271 break;
1272 case NF_EVALDATEFORMAT_FORMAT_INTL:
1273 sDateAcceptancePatterns = comphelper::concatSequences(
1274 xLocaleData->getDateAcceptancePatterns(),
1275 aLocalePatterns);
1276 break;
1277 }
1278 }
1279 SAL_WARN_IF( !sDateAcceptancePatterns.getLength(), "svl.numbers", "ImpSvNumberInputScan::IsAcceptedDatePattern: no date acceptance patterns");
1280 nAcceptedDatePattern = (sDateAcceptancePatterns.getLength() ? -2 : -1);
1281 }
1282
1283 if (nAcceptedDatePattern == -1)
1284 {
1285 return false;
1286 }
1287 nDatePatternStart = nStartPatternAt; // remember start particle
1288
1289 const sal_Int32 nMonthsInYear = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
1290
1291 for (sal_Int32 nPattern=0; nPattern < sDateAcceptancePatterns.getLength(); ++nPattern)
1292 {
1293 sal_uInt16 nNext = nDatePatternStart;
1294 nDatePatternNumbers = 0;
1295 bool bOk = true;
1296 const OUString& rPat = sDateAcceptancePatterns[nPattern];
1297 sal_Int32 nPat = 0;
1298 for ( ; nPat < rPat.getLength() && bOk && nNext < nStringsCnt; ++nPat, ++nNext)
1299 {
1300 const sal_Unicode c = rPat[nPat];
1301 switch (c)
1302 {
1303 case 'Y':
1304 case 'M':
1305 case 'D':
1306 bOk = IsNum[nNext];
1307 if (bOk && (c == 'M' || c == 'D'))
1308 {
1309 // Check the D and M cases for plausibility. This also
1310 // prevents recognition of date instead of number with a
1311 // numeric group input if date separator is identical to
1312 // group separator, for example with D.M as a pattern and
1313 // #.### as a group.
1314 sal_Int32 nMaxLen, nMaxVal;
1315 switch (c)
1316 {
1317 case 'M':
1318 nMaxLen = 2;
1319 nMaxVal = nMonthsInYear;
1320 break;
1321 case 'D':
1322 nMaxLen = 2;
1323 nMaxVal = 31;
1324 break;
1325 default:
1326 // This merely exists against
1327 // -Werror=maybe-uninitialized, which is nonsense
1328 // after the (c == 'M' || c == 'D') check above,
1329 // but ...
1330 nMaxLen = 2;
1331 nMaxVal = 31;
1332 }
1333 bOk = (sStrArray[nNext].getLength() <= nMaxLen);
1334 if (bOk)
1335 {
1336 sal_Int32 nNum = sStrArray[nNext].toInt32();
1337 bOk = (1 <= nNum && nNum <= nMaxVal);
1338 }
1339 }
1340 if (bOk)
1341 ++nDatePatternNumbers;
1342 break;
1343 default:
1344 bOk = !IsNum[nNext];
1345 if (bOk)
1346 {
1347 const sal_Int32 nLen = sStrArray[nNext].getLength();
1348 bOk = (rPat.indexOf( sStrArray[nNext], nPat) == nPat);
1349 if (bOk)
1350 {
1351 nPat += nLen - 1;
1352 }
1353 else if ((bOk = lcl_IsSignedYearSep( sStrArray[nNext], rPat, nPat)))
1354 {
1355 nPat += nLen - 2;
1356 }
1357 else if (nPat + nLen > rPat.getLength() && sStrArray[nNext][ nLen - 1 ] == ' ')
1358 {
1359 using namespace comphelper::string;
1360 // Trailing blanks in input.
1361 OUStringBuffer aBuf(sStrArray[nNext]);
1362 aBuf.stripEnd();
1363 // Expand again in case of pattern "M. D. " and
1364 // input "M. D. ", maybe fetched far, but..
1365 padToLength(aBuf, rPat.getLength() - nPat, ' ');
1366 OUString aStr = aBuf.makeStringAndClear();
1367 bOk = (rPat.indexOf( aStr, nPat) == nPat);
1368 if (bOk)
1369 {
1370 nPat += aStr.getLength() - 1;
1371 }
1372 }
1373 }
1374 break;
1375 }
1376 }
1377 if (bOk)
1378 {
1379 // Check for trailing characters mismatch.
1380 if (nNext < nStringsCnt)
1381 {
1382 // Pattern end but not input end.
1383 // A trailing blank may be part of the current pattern input,
1384 // if pattern is "D.M." and input is "D.M. hh:mm" last was
1385 // ". ", or may be following the current pattern input, if
1386 // pattern is "D.M" and input is "D.M hh:mm" last was "M".
1387 sal_Int32 nPos = 0;
1388 sal_uInt16 nCheck;
1389 if (nPat > 0 && nNext > 0)
1390 {
1391 // nPat is one behind after the for loop.
1392 sal_Int32 nPatCheck = nPat - 1;
1393 switch (rPat[nPatCheck])
1394 {
1395 case 'Y':
1396 case 'M':
1397 case 'D':
1398 nCheck = nNext;
1399 break;
1400 default:
1401 {
1402 nCheck = nNext - 1;
1403 // Advance position in input to match length of
1404 // non-YMD (separator) characters in pattern.
1405 sal_Unicode c;
1406 do
1407 {
1408 ++nPos;
1409 } while ((c = rPat[--nPatCheck]) != 'Y' && c != 'M' && c != 'D');
1410 }
1411 }
1412 }
1413 else
1414 {
1415 nCheck = nNext;
1416 }
1417 if (!IsNum[nCheck])
1418 {
1419 // Trailing (or separating if time follows) blanks are ok.
1420 SkipBlanks( sStrArray[nCheck], nPos);
1421 if (nPos == sStrArray[nCheck].getLength())
1422 {
1423 nAcceptedDatePattern = nPattern;
1424 return true;
1425 }
1426 }
1427 }
1428 else if (nPat == rPat.getLength())
1429 {
1430 // Input end and pattern end => match.
1431 nAcceptedDatePattern = nPattern;
1432 return true;
1433 }
1434 // else Input end but not pattern end, no match.
1435 }
1436 }
1437 nAcceptedDatePattern = -1;
1438 return false;
1439 }
1440
1441
1442 bool ImpSvNumberInputScan::SkipDatePatternSeparator( sal_uInt16 nParticle, sal_Int32 & rPos, bool & rSignedYear )
1443 {
1444 // If not initialized yet start with first number, if any.
1445 if (!IsAcceptedDatePattern( nNumericsCnt ? nNums[0] : 0 ))
1446 {
1447 return false;
1448 }
1449 if (nParticle < nDatePatternStart || nParticle >= nStringsCnt || IsNum[nParticle])
1450 {
1451 return false;
1452 }
1453 sal_uInt16 nNext = nDatePatternStart;
1454 const OUString& rPat = sDateAcceptancePatterns[nAcceptedDatePattern];
1455 for (sal_Int32 nPat = 0; nPat < rPat.getLength() && nNext < nStringsCnt; ++nPat, ++nNext)
1456 {
1457 switch (rPat[nPat])
1458 {
1459 case 'Y':
1460 case 'M':
1461 case 'D':
1462 break;
1463 default:
1464 if (nNext == nParticle)
1465 {
1466 const sal_Int32 nLen = sStrArray[nNext].getLength();
1467 bool bOk = (rPat.indexOf( sStrArray[nNext], nPat) == nPat);
1468 if (!bOk)
1469 {
1470 bOk = lcl_IsSignedYearSep( sStrArray[nNext], rPat, nPat);
1471 if (bOk)
1472 rSignedYear = true;
1473 }
1474 if (!bOk && (nPat + nLen > rPat.getLength() && sStrArray[nNext][ nLen - 1 ] == ' '))
1475 {
1476 // The same ugly trailing blanks check as in
1477 // IsAcceptedDatePattern().
1478 using namespace comphelper::string;
1479 OUStringBuffer aBuf(sStrArray[nNext]);
1480 aBuf.stripEnd();
1481 padToLength(aBuf, rPat.getLength() - nPat, ' ');
1482 bOk = (rPat.indexOf( aBuf.makeStringAndClear(), nPat) == nPat);
1483 }
1484 if (bOk)
1485 {
1486 rPos = nLen; // yes, set, not add!
1487 return true;
1488 }
1489 else
1490 return false;
1491 }
1492 nPat += sStrArray[nNext].getLength() - 1;
1493 break;
1494 }
1495 }
1496 return false;
1497 }
1498
1499
1500 sal_uInt16 ImpSvNumberInputScan::GetDatePatternNumbers()
1501 {
1502 // If not initialized yet start with first number, if any.
1503 if (!IsAcceptedDatePattern( nNumericsCnt ? nNums[0] : 0 ))
1504 {
1505 return 0;
1506 }
1507 return nDatePatternNumbers;
1508 }
1509
1510
1511 bool ImpSvNumberInputScan::IsDatePatternNumberOfType( sal_uInt16 nNumber, sal_Unicode cType )
1512 {
1513 if (GetDatePatternNumbers() <= nNumber)
1514 return false;
1515
1516 sal_uInt16 nNum = 0;
1517 const OUString& rPat = sDateAcceptancePatterns[nAcceptedDatePattern];
1518 for (sal_Int32 nPat = 0; nPat < rPat.getLength(); ++nPat)
1519 {
1520 switch (rPat[nPat])
1521 {
1522 case 'Y':
1523 case 'M':
1524 case 'D':
1525 if (nNum == nNumber)
1526 return rPat[nPat] == cType;
1527 ++nNum;
1528 break;
1529 }
1530 }
1531 return false;
1532 }
1533
1534
1535 sal_uInt32 ImpSvNumberInputScan::GetDatePatternOrder()
1536 {
1537 // If not initialized yet start with first number, if any.
1538 if (!IsAcceptedDatePattern( nNumericsCnt ? nNums[0] : 0 ))
1539 {
1540 return 0;
1541 }
1542 sal_uInt32 nOrder = 0;
1543 const OUString& rPat = sDateAcceptancePatterns[nAcceptedDatePattern];
1544 for (sal_Int32 nPat = 0; nPat < rPat.getLength() && !(nOrder & 0xff0000); ++nPat)
1545 {
1546 switch (rPat[nPat])
1547 {
1548 case 'Y':
1549 case 'M':
1550 case 'D':
1551 nOrder = (nOrder << 8) | rPat[nPat];
1552 break;
1553 }
1554 }
1555 return nOrder;
1556 }
1557
1558
1559 DateOrder ImpSvNumberInputScan::GetDateOrder()
1560 {
1561 sal_uInt32 nOrder = GetDatePatternOrder();
1562 if (!nOrder)
1563 {
1564 return pFormatter->GetLocaleData()->getDateOrder();
1565 }
1566 switch ((nOrder & 0xff0000) >> 16)
1567 {
1568 case 'Y':
1569 if ((((nOrder & 0xff00) >> 8) == 'M') && ((nOrder & 0xff) == 'D'))
1570 {
1571 return DateOrder::YMD;
1572 }
1573 break;
1574 case 'M':
1575 if ((((nOrder & 0xff00) >> 8) == 'D') && ((nOrder & 0xff) == 'Y'))
1576 {
1577 return DateOrder::MDY;
1578 }
1579 break;
1580 case 'D':
1581 if ((((nOrder & 0xff00) >> 8) == 'M') && ((nOrder & 0xff) == 'Y'))
1582 {
1583 return DateOrder::DMY;
1584 }
1585 break;
1586 default:
1587 case 0:
1588 switch ((nOrder & 0xff00) >> 8)
1589 {
1590 case 'Y':
1591 switch (nOrder & 0xff)
1592 {
1593 case 'M':
1594 return DateOrder::YMD;
1595 }
1596 break;
1597 case 'M':
1598 switch (nOrder & 0xff)
1599 {
1600 case 'Y':
1601 return DateOrder::DMY;
1602 case 'D':
1603 return DateOrder::MDY;
1604 }
1605 break;
1606 case 'D':
1607 switch (nOrder & 0xff)
1608 {
1609 case 'Y':
1610 return DateOrder::MDY;
1611 case 'M':
1612 return DateOrder::DMY;
1613 }
1614 break;
1615 default:
1616 case 0:
1617 switch (nOrder & 0xff)
1618 {
1619 case 'Y':
1620 return DateOrder::YMD;
1621 case 'M':
1622 return DateOrder::MDY;
1623 case 'D':
1624 return DateOrder::DMY;
1625 }
1626 break;
1627 }
1628 }
1629 SAL_WARN( "svl.numbers", "ImpSvNumberInputScan::GetDateOrder: undefined, falling back to locale's default");
1630 return pFormatter->GetLocaleData()->getDateOrder();
1631 }
1632
1633 bool ImpSvNumberInputScan::GetDateRef( double& fDays, sal_uInt16& nCounter )
1634 {
1635 using namespace ::com::sun::star::i18n;
1636 NfEvalDateFormat eEDF;
1637 int nFormatOrder;
1638 if ( mpFormat && (mpFormat->GetType() & SvNumFormatType::DATE) )
1639 {
1640 eEDF = pFormatter->GetEvalDateFormat();
1641 switch ( eEDF )
1642 {
1643 case NF_EVALDATEFORMAT_INTL :
1644 case NF_EVALDATEFORMAT_FORMAT :
1645 nFormatOrder = 1; // only one loop
1646 break;
1647 default:
1648 nFormatOrder = 2;
1649 if ( nMatchedAllStrings )
1650 {
1651 eEDF = NF_EVALDATEFORMAT_FORMAT_INTL;
1652 // we have a complete match, use it
1653 }
1654 }
1655 }
1656 else
1657 {
1658 eEDF = NF_EVALDATEFORMAT_INTL;
1659 nFormatOrder = 1;
1660 }
1661 bool res = true;
1662
1663 const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
1664 CalendarWrapper* pCal = pFormatter->GetCalendar();
1665 for ( int nTryOrder = 1; nTryOrder <= nFormatOrder; nTryOrder++ )
1666 {
1667 pCal->setGregorianDateTime( Date( Date::SYSTEM ) ); // today
1668 OUString aOrgCalendar; // empty => not changed yet
1669 DateOrder DateFmt;
1670 bool bFormatTurn;
1671 switch ( eEDF )
1672 {
1673 case NF_EVALDATEFORMAT_INTL :
1674 bFormatTurn = false;
1675 DateFmt = GetDateOrder();
1676 break;
1677 case NF_EVALDATEFORMAT_FORMAT :
1678 bFormatTurn = true;
1679 DateFmt = mpFormat->GetDateOrder();
1680 break;
1681 case NF_EVALDATEFORMAT_INTL_FORMAT :
1682 if ( nTryOrder == 1 )
1683 {
1684 bFormatTurn = false;
1685 DateFmt = GetDateOrder();
1686 }
1687 else
1688 {
1689 bFormatTurn = true;
1690 DateFmt = mpFormat->GetDateOrder();
1691 }
1692 break;
1693 case NF_EVALDATEFORMAT_FORMAT_INTL :
1694 if ( nTryOrder == 2 )
1695 {
1696 bFormatTurn = false;
1697 DateFmt = GetDateOrder();
1698 }
1699 else
1700 {
1701 bFormatTurn = true;
1702 // Even if the format pattern is to be preferred, the input may
1703 // have matched a pattern of the current locale, which then
1704 // again is to be preferred. Both date orders can be different
1705 // so we need to obtain the actual match. For example ISO
1706 // YYYY-MM-DD format vs locale's DD.MM.YY input.
1707 if (!GetDatePatternOrder())
1708 {
1709 // No pattern match => format match.
1710 DateFmt = mpFormat->GetDateOrder();
1711 }
1712 else
1713 {
1714 // Pattern match. Note that patterns may have been
1715 // constructed from the format's locale and prepended to
1716 // the current locale's patterns, it doesn't necessarily
1717 // mean a current locale's pattern was matched, but may if
1718 // the format's locale's patterns didn't match, which were
1719 // tried first.
1720 DateFmt = GetDateOrder();
1721 }
1722 }
1723 break;
1724 default:
1725 SAL_WARN( "svl.numbers", "ImpSvNumberInputScan::GetDateRef: unknown NfEvalDateFormat" );
1726 DateFmt = DateOrder::YMD;
1727 bFormatTurn = false;
1728 }
1729 if ( bFormatTurn )
1730 {
1731 /* TODO:
1732 We are currently not able to fully support a switch to another calendar during
1733 input for the following reasons:
1734 1. We do have a problem if both (locale's default and format's) calendars
1735 define the same YMD order and use the same date separator, there is no way
1736 to distinguish between them if the input results in valid calendar input for
1737 both calendars. How to solve? Would NfEvalDateFormat be sufficient? Should
1738 it always be set to NF_EVALDATEFORMAT_FORMAT_INTL and thus the format's
1739 calendar be preferred? This could be confusing if a Calc cell was formatted
1740 different to the locale's default and has no content yet, then the user has
1741 no clue about the format or calendar being set.
1742 2. In Calc cell edit mode a date is always displayed and edited using the
1743 default edit format of the default calendar (normally being Gregorian). If
1744 input was ambiguous due to issue #1 we'd need a mechanism to tell that a
1745 date was edited and not newly entered. Not feasible. Otherwise we'd need a
1746 mechanism to use a specific edit format with a specific calendar according
1747 to the format set.
1748 3. For some calendars like Japanese Gengou we'd need era input, which isn't
1749 implemented at all. Though this is a rare and special case, forcing a
1750 calendar dependent edit format as suggested in item #2 might require era
1751 input, if it shouldn't result in a fallback to Gregorian calendar.
1752 4. Last and least: the GetMonth() method currently only matches month names of
1753 the default calendar. Alternating month names of the actual format's
1754 calendar would have to be implemented. No problem.
1755
1756 */
1757 #ifdef THE_FUTURE
1758 if ( mpFormat->IsOtherCalendar( nStringScanNumFor ) )
1759 {
1760 mpFormat->SwitchToOtherCalendar( aOrgCalendar, fOrgDateTime );
1761 }
1762 else
1763 {
1764 mpFormat->SwitchToSpecifiedCalendar( aOrgCalendar, fOrgDateTime,
1765 nStringScanNumFor );
1766 }
1767 #endif
1768 }
1769
1770 res = true;
1771 nCounter = 0;
1772 // For incomplete dates, always assume first day of month if not specified.
1773 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
1774
1775 switch (nNumericsCnt) // count of numbers in string
1776 {
1777 case 0: // none
1778 if (nMonthPos) // only month (Jan)
1779 {
1780 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
1781 }
1782 else
1783 {
1784 res = false;
1785 }
1786 break;
1787
1788 case 1: // only one number
1789 nCounter = 1;
1790 switch (nMonthPos) // where is the month
1791 {
1792 case 0: // not found
1793 {
1794 // If input matched a date pattern, use the pattern
1795 // to determine if it is a day, month or year. The
1796 // pattern should have only one single value then,
1797 // 'D-', 'M-' or 'Y-'. If input did not match a
1798 // pattern assume the usual day of current month.
1799 sal_uInt32 nDateOrder = (bFormatTurn ?
1800 mpFormat->GetExactDateOrder() :
1801 GetDatePatternOrder());
1802 switch (nDateOrder)
1803 {
1804 case 'Y':
1805 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
1806 break;
1807 case 'M':
1808 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
1809 break;
1810 case 'D':
1811 default:
1812 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
1813 break;
1814 }
1815 break;
1816 }
1817 case 1: // month at the beginning (Jan 01)
1818 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
1819 switch (DateFmt)
1820 {
1821 case DateOrder::MDY:
1822 case DateOrder::YMD:
1823 {
1824 sal_uInt16 nDay = ImplGetDay(0);
1825 sal_uInt16 nYear = ImplGetYear(0);
1826 if (nDay == 0 || nDay > 32)
1827 {
1828 pCal->setValue( CalendarFieldIndex::YEAR, nYear);
1829 }
1830 else
1831 {
1832 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
1833 }
1834 break;
1835 }
1836 case DateOrder::DMY:
1837 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
1838 break;
1839 default:
1840 res = false;
1841 break;
1842 }
1843 break;
1844 case 3: // month at the end (10 Jan)
1845 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
1846 switch (DateFmt)
1847 {
1848 case DateOrder::DMY:
1849 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
1850 break;
1851 case DateOrder::YMD:
1852 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
1853 break;
1854 default:
1855 res = false;
1856 break;
1857 }
1858 break;
1859 default:
1860 res = false;
1861 break;
1862 } // switch (nMonthPos)
1863 break;
1864
1865 case 2: // 2 numbers
1866 nCounter = 2;
1867 switch (nMonthPos) // where is the month
1868 {
1869 case 0: // not found
1870 {
1871 sal_uInt32 nExactDateOrder = (bFormatTurn ?
1872 mpFormat->GetExactDateOrder() :
1873 GetDatePatternOrder());
1874 bool bIsExact = (0xff < nExactDateOrder && nExactDateOrder <= 0xffff);
1875 if (!bIsExact && bFormatTurn && IsAcceptedDatePattern( nNums[0]))
1876 {
1877 // If input does not match format but pattern, use pattern
1878 // instead, even if eEDF==NF_EVALDATEFORMAT_FORMAT_INTL.
1879 // For example, format has "Y-M-D" and pattern is "D.M.",
1880 // input with 2 numbers can't match format and 31.12. would
1881 // lead to 1931-12-01 (fdo#54344)
1882 nExactDateOrder = GetDatePatternOrder();
1883 bIsExact = (0xff < nExactDateOrder && nExactDateOrder <= 0xffff);
1884 }
1885 bool bHadExact;
1886 if (bIsExact)
1887 {
1888 // formatted as date and exactly 2 parts
1889 bHadExact = true;
1890 switch ( (nExactDateOrder >> 8) & 0xff )
1891 {
1892 case 'Y':
1893 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
1894 break;
1895 case 'M':
1896 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
1897 break;
1898 case 'D':
1899 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
1900 break;
1901 default:
1902 bHadExact = false;
1903 }
1904 switch ( nExactDateOrder & 0xff )
1905 {
1906 case 'Y':
1907 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
1908 break;
1909 case 'M':
1910 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
1911 break;
1912 case 'D':
1913 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
1914 break;
1915 default:
1916 bHadExact = false;
1917 }
1918 SAL_WARN_IF( !bHadExact, "svl.numbers", "ImpSvNumberInputScan::GetDateRef: error in exact date order");
1919 }
1920 else
1921 {
1922 bHadExact = false;
1923 }
1924 // If input matched against a date acceptance pattern
1925 // do not attempt to mess around with guessing the
1926 // order, either it matches or it doesn't.
1927 if ((bFormatTurn || !bIsExact) && (!bHadExact || !pCal->isValid()))
1928 {
1929 if ( !bHadExact && nExactDateOrder )
1930 {
1931 pCal->setGregorianDateTime( Date( Date::SYSTEM ) ); // reset today
1932 }
1933 switch (DateFmt)
1934 {
1935 case DateOrder::MDY:
1936 // M D
1937 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
1938 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
1939 if ( !pCal->isValid() ) // 2nd try
1940 { // M Y
1941 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
1942 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
1943 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
1944 }
1945 break;
1946 case DateOrder::DMY:
1947 // D M
1948 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
1949 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
1950 if ( !pCal->isValid() ) // 2nd try
1951 { // M Y
1952 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
1953 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
1954 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
1955 }
1956 break;
1957 case DateOrder::YMD:
1958 // M D
1959 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
1960 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
1961 if ( !pCal->isValid() ) // 2nd try
1962 { // Y M
1963 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
1964 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
1965 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
1966 }
1967 break;
1968 default:
1969 res = false;
1970 break;
1971 }
1972 }
1973 }
1974 break;
1975 case 1: // month at the beginning (Jan 01 01)
1976 {
1977 // The input is valid as MDY in almost any
1978 // constellation, there is no date order (M)YD except if
1979 // set in a format applied.
1980 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
1981 sal_uInt32 nExactDateOrder = (bFormatTurn ? mpFormat->GetExactDateOrder() : 0);
1982 if ((((nExactDateOrder >> 8) & 0xff) == 'Y') && ((nExactDateOrder & 0xff) == 'D'))
1983 {
1984 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
1985 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
1986 }
1987 else
1988 {
1989 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
1990 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
1991 }
1992 break;
1993 }
1994 case 2: // month in the middle (10 Jan 94)
1995 {
1996 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
1997 DateOrder eDF = (MayBeMonthDate() ? (nMayBeMonthDate == 2 ? DateOrder::DMY : DateOrder::YMD) : DateFmt);
1998 switch (eDF)
1999 {
2000 case DateOrder::DMY:
2001 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
2002 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
2003 break;
2004 case DateOrder::YMD:
2005 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
2006 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
2007 break;
2008 default:
2009 res = false;
2010 break;
2011 }
2012 break;
2013 }
2014 default: // else, e.g. month at the end (94 10 Jan)
2015 res = false;
2016 break;
2017 } // switch (nMonthPos)
2018 break;
2019
2020 default: // more than two numbers (31.12.94 8:23) (31.12. 8:23)
2021 switch (nMonthPos) // where is the month
2022 {
2023 case 0: // not found
2024 {
2025 nCounter = 3;
2026 if ( nTimePos > 1 )
2027 { // find first time number index (should only be 3 or 2 anyway)
2028 for ( sal_uInt16 j = 0; j < nNumericsCnt; j++ )
2029 {
2030 if ( nNums[j] == nTimePos - 2 )
2031 {
2032 nCounter = j;
2033 break; // for
2034 }
2035 }
2036 }
2037 // ISO 8601 yyyy-mm-dd forced recognition
2038 DateOrder eDF = (CanForceToIso8601( DateFmt) ? DateOrder::YMD : DateFmt);
2039 switch (eDF)
2040 {
2041 case DateOrder::MDY:
2042 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
2043 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(0) );
2044 if ( nCounter > 2 )
2045 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(2) );
2046 break;
2047 case DateOrder::DMY:
2048 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
2049 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
2050 if ( nCounter > 2 )
2051 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(2) );
2052 break;
2053 case DateOrder::YMD:
2054 if ( nCounter > 2 )
2055 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(2) );
2056 pCal->setValue( CalendarFieldIndex::MONTH, ImplGetMonth(1) );
2057 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
2058 break;
2059 default:
2060 res = false;
2061 break;
2062 }
2063 break;
2064 }
2065 case 1: // month at the beginning (Jan 01 01 8:23)
2066 nCounter = 2;
2067 switch (DateFmt)
2068 {
2069 case DateOrder::MDY:
2070 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
2071 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
2072 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
2073 break;
2074 default:
2075 res = false;
2076 break;
2077 }
2078 break;
2079 case 2: // month in the middle (10 Jan 94 8:23)
2080 nCounter = 2;
2081 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
2082 switch (DateFmt)
2083 {
2084 case DateOrder::DMY:
2085 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(0) );
2086 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(1) );
2087 break;
2088 case DateOrder::YMD:
2089 pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, ImplGetDay(1) );
2090 pCal->setValue( CalendarFieldIndex::YEAR, ImplGetYear(0) );
2091 break;
2092 default:
2093 res = false;
2094 break;
2095 }
2096 break;
2097 default: // else, e.g. month at the end (94 10 Jan 8:23)
2098 nCounter = 2;
2099 res = false;
2100 break;
2101 } // switch (nMonthPos)
2102 break;
2103 } // switch (nNumericsCnt)
2104
2105 if (mbEraCE != kDefaultEra)
2106 pCal->setValue( CalendarFieldIndex::ERA, mbEraCE ? 1 : 0);
2107
2108 if ( res && pCal->isValid() )
2109 {
2110 double fDiff = DateTime(*pNullDate) - pCal->getEpochStart();
2111 fDays = ::rtl::math::approxFloor( pCal->getLocalDateTime() );
2112 fDays -= fDiff;
2113 nTryOrder = nFormatOrder; // break for
2114 }
2115 else
2116 {
2117 res = false;
2118 }
2119 if ( aOrgCalendar.getLength() )
2120 {
2121 pCal->loadCalendar( aOrgCalendar, pLoc->getLanguageTag().getLocale() ); // restore calendar
2122 }
2123 #if NF_TEST_CALENDAR
2124 {
2125 using namespace ::com::sun::star;
2126 struct entry { const char* lan; const char* cou; const char* cal; };
2127 const entry cals[] = {
2128 { "en", "US", "gregorian" },
2129 { "ar", "TN", "hijri" },
2130 { "he", "IL", "jewish" },
2131 { "ja", "JP", "gengou" },
2132 { "ko", "KR", "hanja_yoil" },
2133 { "th", "TH", "buddhist" },
2134 { "zh", "TW", "ROC" },
2135 {0,0,0}
2136 };
2137 lang::Locale aLocale;
2138 bool bValid;
2139 sal_Int16 nDay, nMyMonth, nYear, nHour, nMinute, nSecond;
2140 sal_Int16 nDaySet, nMonthSet, nYearSet, nHourSet, nMinuteSet, nSecondSet;
2141 sal_Int16 nZO, nDST1, nDST2, nDST, nZOmillis, nDST1millis, nDST2millis, nDSTmillis;
2142 sal_Int32 nZoneInMillis, nDST1InMillis, nDST2InMillis;
2143 uno::Reference< uno::XComponentContext > xContext =
2144 ::comphelper::getProcessComponentContext();
2145 uno::Reference< i18n::XCalendar4 > xCal = i18n::LocaleCalendar2::create(xContext);
2146 for ( const entry* p = cals; p->lan; ++p )
2147 {
2148 aLocale.Language = OUString::createFromAscii( p->lan );
2149 aLocale.Country = OUString::createFromAscii( p->cou );
2150 xCal->loadCalendar( OUString::createFromAscii( p->cal ),
2151 aLocale );
2152 double nDateTime = 0.0; // 1-Jan-1970 00:00:00
2153 nZO = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET );
2154 nZOmillis = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS );
2155 nZoneInMillis = static_cast<sal_Int32>(nZO) * 60000 +
2156 (nZO < 0 ? -1 : 1) * static_cast<sal_uInt16>(nZOmillis);
2157 nDST1 = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
2158 nDST1millis = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS );
2159 nDST1InMillis = static_cast<sal_Int32>(nDST1) * 60000 +
2160 (nDST1 < 0 ? -1 : 1) * static_cast<sal_uInt16>(nDST1millis);
2161 nDateTime -= (double)(nZoneInMillis + nDST1InMillis) / 1000.0 / 60.0 / 60.0 / 24.0;
2162 xCal->setDateTime( nDateTime );
2163 nDST2 = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
2164 nDST2millis = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS );
2165 nDST2InMillis = static_cast<sal_Int32>(nDST2) * 60000 +
2166 (nDST2 < 0 ? -1 : 1) * static_cast<sal_uInt16>(nDST2millis);
2167 if ( nDST1InMillis != nDST2InMillis )
2168 {
2169 nDateTime = 0.0 - (double)(nZoneInMillis + nDST2InMillis) / 1000.0 / 60.0 / 60.0 / 24.0;
2170 xCal->setDateTime( nDateTime );
2171 }
2172 nDaySet = xCal->getValue( i18n::CalendarFieldIndex::DAY_OF_MONTH );
2173 nMonthSet = xCal->getValue( i18n::CalendarFieldIndex::MONTH );
2174 nYearSet = xCal->getValue( i18n::CalendarFieldIndex::YEAR );
2175 nHourSet = xCal->getValue( i18n::CalendarFieldIndex::HOUR );
2176 nMinuteSet = xCal->getValue( i18n::CalendarFieldIndex::MINUTE );
2177 nSecondSet = xCal->getValue( i18n::CalendarFieldIndex::SECOND );
2178 nZO = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET );
2179 nZOmillis = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS );
2180 nDST = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET );
2181 nDSTmillis = xCal->getValue( i18n::CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS );
2182 xCal->setValue( i18n::CalendarFieldIndex::DAY_OF_MONTH, nDaySet );
2183 xCal->setValue( i18n::CalendarFieldIndex::MONTH, nMonthSet );
2184 xCal->setValue( i18n::CalendarFieldIndex::YEAR, nYearSet );
2185 xCal->setValue( i18n::CalendarFieldIndex::HOUR, nHourSet );
2186 xCal->setValue( i18n::CalendarFieldIndex::MINUTE, nMinuteSet );
2187 xCal->setValue( i18n::CalendarFieldIndex::SECOND, nSecondSet );
2188 bValid = xCal->isValid();
2189 nDay = xCal->getValue( i18n::CalendarFieldIndex::DAY_OF_MONTH );
2190 nMyMonth= xCal->getValue( i18n::CalendarFieldIndex::MONTH );
2191 nYear = xCal->getValue( i18n::CalendarFieldIndex::YEAR );
2192 nHour = xCal->getValue( i18n::CalendarFieldIndex::HOUR );
2193 nMinute = xCal->getValue( i18n::CalendarFieldIndex::MINUTE );
2194 nSecond = xCal->getValue( i18n::CalendarFieldIndex::SECOND );
2195 bValid = bValid && nDay == nDaySet && nMyMonth == nMonthSet && nYear ==
2196 nYearSet && nHour == nHourSet && nMinute == nMinuteSet && nSecond
2197 == nSecondSet;
2198 }
2199 }
2200 #endif // NF_TEST_CALENDAR
2201
2202 }
2203
2204 return res;
2205 }
2206
2207
2208 /**
2209 * Analyze first string
2210 * All gone => true
2211 * else => false
2212 */
2213 bool ImpSvNumberInputScan::ScanStartString( const OUString& rString )
2214 {
2215 sal_Int32 nPos = 0;
2216
2217 // First of all, eat leading blanks
2218 SkipBlanks(rString, nPos);
2219
2220 // Yes, nMatchedAllStrings should know about the sign position
2221 nSign = GetSign(rString, nPos);
2222 if ( nSign ) // sign?
2223 {
2224 SkipBlanks(rString, nPos);
2225 }
2226 // #102371# match against format string only if start string is not a sign character
2227 if ( nMatchedAllStrings && !(nSign && rString.getLength() == 1) )
2228 {
2229 // Match against format in any case, so later on for a "x1-2-3" input
2230 // we may distinguish between a xy-m-d (or similar) date and a x0-0-0
2231 // format. No sign detection here!
2232 if ( ScanStringNumFor( rString, nPos, 0, true ) )
2233 {
2234 nMatchedAllStrings |= nMatchedStartString;
2235 }
2236 else
2237 {
2238 nMatchedAllStrings = 0;
2239 }
2240 }
2241
2242 // Bail out early for just a sign.
2243 if (nSign && nPos == rString.getLength())
2244 return true;
2245
2246 if ( GetDecSep(rString, nPos) ) // decimal separator in start string
2247 {
2248 nDecPos = 1;
2249 SkipBlanks(rString, nPos);
2250 }
2251 else if ( GetCurrency(rString, nPos) ) // currency (DM 1)?
2252 {
2253 eScannedType = SvNumFormatType::CURRENCY; // !!! it IS currency !!!
2254 SkipBlanks(rString, nPos);
2255 if (nSign == 0) // no sign yet
2256 {
2257 nSign = GetSign(rString, nPos);
2258 if ( nSign ) // DM -1
2259 {
2260 SkipBlanks(rString, nPos);
2261 }
2262 }
2263 if ( GetDecSep(rString, nPos) ) // decimal separator follows currency
2264 {
2265 nDecPos = 1;
2266 SkipBlanks(rString, nPos);
2267 }
2268 }
2269 else
2270 {
2271 const sal_Int32 nMonthStart = nPos;
2272 short nTempMonth = GetMonth(rString, nPos);
2273 if (nTempMonth < 0)
2274 {
2275 // Short month and day names may be identical in some locales, e.g.
2276 // "mar" for "martes" or "marzo" in Spanish.
2277 // Do not let a month name immediately take precedence if a day
2278 // name was meant instead. Assume that both could be valid, until
2279 // encountered differently or the final evaluation in
2280 // IsNumberFormat() checks, but continue with weighing the month
2281 // name higher unless we have both day of week and month name here.
2282 sal_Int32 nTempPos = nMonthStart;
2283 nDayOfWeek = GetDayOfWeek( rString, nTempPos);
2284 if (nDayOfWeek < 0)
2285 {
2286 SkipChar( '.', rString, nTempPos ); // abbreviated
2287 SkipString( pFormatter->GetLocaleData()->getLongDateDayOfWeekSep(), rString, nTempPos );
2288 SkipBlanks( rString, nTempPos);
2289 short nTempTempMonth = GetMonth( rString, nTempPos);
2290 if (nTempTempMonth)
2291 {
2292 // Fall into the else branch below that handles both.
2293 nTempMonth = 0;
2294 nPos = nMonthStart;
2295 nDayOfWeek = 0;
2296 // Do not set nDayOfWeek hereafter, anywhere.
2297 }
2298 }
2299 }
2300 if ( nTempMonth ) // month (Jan 1)?
2301 {
2302 // Jan1 without separator is not a date, unless it is followed by a
2303 // separator and a (year) number.
2304 if (nPos < rString.getLength() || (nStringsCnt >= 4 && nNumericsCnt >= 2))
2305 {
2306 eScannedType = SvNumFormatType::DATE; // !!! it IS a date !!!
2307 nMonth = nTempMonth;
2308 nMonthPos = 1; // month at the beginning
2309 if ( nMonth < 0 )
2310 {
2311 SkipChar( '.', rString, nPos ); // abbreviated
2312 }
2313 SkipBlanks(rString, nPos);
2314 }
2315 else
2316 {
2317 nPos = nMonthStart; // rewind month
2318 }
2319 }
2320 else
2321 {
2322 int nTempDayOfWeek = GetDayOfWeek( rString, nPos );
2323 if ( nTempDayOfWeek )
2324 {
2325 // day of week is just parsed away
2326 eScannedType = SvNumFormatType::DATE; // !!! it IS a date !!!
2327 if ( nPos < rString.getLength() )
2328 {
2329 if ( nTempDayOfWeek < 0 )
2330 {
2331 // abbreviated
2332 if ( rString[ nPos ] == '.' )
2333 {
2334 ++nPos;
2335 }
2336 }
2337 else
2338 {
2339 // full long name
2340 SkipBlanks(rString, nPos);
2341 SkipString( pFormatter->GetLocaleData()->getLongDateDayOfWeekSep(), rString, nPos );
2342 }
2343 SkipBlanks(rString, nPos);
2344 nTempMonth = GetMonth(rString, nPos);
2345 if ( nTempMonth ) // month (Jan 1)?
2346 {
2347 // Jan1 without separator is not a date, unless it is followed by a
2348 // separator and a (year) number.
2349 if (nPos < rString.getLength() || (nStringsCnt >= 4 && nNumericsCnt >= 2))
2350 {
2351 nMonth = nTempMonth;
2352 nMonthPos = 1; // month a the beginning
2353 if ( nMonth < 0 )
2354 {
2355 SkipChar( '.', rString, nPos ); // abbreviated
2356 }
2357 SkipBlanks(rString, nPos);
2358 }
2359 else
2360 {
2361 nPos = nMonthStart; // rewind month
2362 }
2363 }
2364 }
2365 if (!nMonth)
2366 {
2367 // Determine and remember following date pattern, if any.
2368 IsAcceptedDatePattern( 1);
2369 }
2370 }
2371 }
2372 }
2373
2374 // skip any trailing '-' or '/' chars
2375 if (nPos < rString.getLength())
2376 {
2377 while (SkipChar ('-', rString, nPos) || SkipChar ('/', rString, nPos))
2378 ; // do nothing
2379 }
2380 if (nPos < rString.getLength()) // not everything consumed
2381 {
2382 // Does input StartString equal StartString of format?
2383 // This time with sign detection!
2384 if ( !ScanStringNumFor( rString, nPos, 0 ) )
2385 {
2386 return MatchedReturn();
2387 }
2388 }
2389
2390 return true;
2391 }
2392
2393
2394 /**
2395 * Analyze string in the middle
2396 * All gone => true
2397 * else => false
2398 */
2399 bool ImpSvNumberInputScan::ScanMidString( const OUString& rString, sal_uInt16 nStringPos )
2400 {
2401 sal_Int32 nPos = 0;
2402 SvNumFormatType eOldScannedType = eScannedType;
2403
2404 if ( nMatchedAllStrings )
2405 { // Match against format in any case, so later on for a "1-2-3-4" input
2406 // we may distinguish between a y-m-d (or similar) date and a 0-0-0-0
2407 // format.
2408 if ( ScanStringNumFor( rString, 0, nStringPos ) )
2409 {
2410 nMatchedAllStrings |= nMatchedMidString;
2411 }
2412 else
2413 {
2414 nMatchedAllStrings = 0;
2415 }
2416 }
2417
2418 SkipBlanks(rString, nPos);
2419 if (GetDecSep(rString, nPos)) // decimal separator?
2420 {
2421 if (nDecPos == 1 || nDecPos == 3) // .12.4 or 1.E2.1
2422 {
2423 return MatchedReturn();
2424 }
2425 else if (nDecPos == 2) // . dup: 12.4.
2426 {
2427 bool bSignedYear = false;
2428 if (bDecSepInDateSeps || // . also date separator
2429 SkipDatePatternSeparator( nStringPos, nPos, bSignedYear))
2430 {
2431 if ( eScannedType != SvNumFormatType::UNDEFINED &&
2432 eScannedType != SvNumFormatType::DATE &&
2433 eScannedType != SvNumFormatType::DATETIME) // already another type
2434 {
2435 return MatchedReturn();
2436 }
2437 if (eScannedType == SvNumFormatType::UNDEFINED)
2438 {
2439 eScannedType = SvNumFormatType::DATE; // !!! it IS a date
2440 }
2441 SkipBlanks(rString, nPos);
2442 }
2443 else
2444 {
2445 return MatchedReturn();
2446 }
2447 }
2448 else
2449 {
2450 nDecPos = 2; // . in mid string
2451 SkipBlanks(rString, nPos);
2452 }
2453 }
2454 else if ( (eScannedType & SvNumFormatType::TIME) &&
2455 GetTime100SecSep( rString, nPos ) )
2456 { // hundredth seconds separator
2457 if ( nDecPos )
2458 {
2459 return MatchedReturn();
2460 }
2461 nDecPos = 2; // . in mid string
2462
2463 // If this is exactly an ISO 8601 fractional seconds separator, bail
2464 // out early to not get confused by later checks for group separator or
2465 // other.
2466 if (bIso8601Tsep && nPos == rString.getLength() &&
2467 eScannedType == SvNumFormatType::DATETIME && (rString == "." || rString == ","))
2468 return true;
2469
2470 SkipBlanks(rString, nPos);
2471 }
2472
2473 if (SkipChar('/', rString, nPos)) // fraction?
2474 {
2475 if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
2476 eScannedType != SvNumFormatType::DATE) // except date
2477 {
2478 return MatchedReturn(); // => jan/31/1994
2479 }
2480 else if (eScannedType != SvNumFormatType::DATE && // analyzed no date until now
2481 ( eSetType == SvNumFormatType::FRACTION || // and preset was fraction
2482 (nNumericsCnt == 3 && // or 3 numbers
2483 (nStringPos == 3 || // and 3rd string particle
2484 (nStringPos == 4 && nSign))))) // or 4th if signed
2485 {
2486 SkipBlanks(rString, nPos);
2487 if (nPos == rString.getLength())
2488 {
2489 eScannedType = SvNumFormatType::FRACTION; // !!! it IS a fraction (so far)
2490 if (eSetType == SvNumFormatType::FRACTION &&
2491 nNumericsCnt == 2 &&
2492 (nStringPos == 1 || // for 4/5
2493 (nStringPos == 2 && nSign))) // or signed -4/5
2494 {
2495 return true; // don't fall into date trap
2496 }
2497 }
2498 }
2499 else
2500 {
2501 nPos--; // put '/' back
2502 }
2503 }
2504
2505 if (GetThousandSep(rString, nPos, nStringPos)) // 1,000
2506 {
2507 if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
2508 eScannedType != SvNumFormatType::CURRENCY) // except currency
2509 {
2510 return MatchedReturn();
2511 }
2512 nThousand++;
2513 }
2514
2515 const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
2516 bool bSignedYear = false;
2517 bool bDate = SkipDatePatternSeparator( nStringPos, nPos, bSignedYear); // 12/31 31.12. 12/31/1999 31.12.1999
2518 if (!bDate)
2519 {
2520 const OUString& rDate = pFormatter->GetDateSep();
2521 SkipBlanks(rString, nPos);
2522 bDate = SkipString( rDate, rString, nPos); // 10. 10- 10/
2523 }
2524 if (bDate || ((MayBeIso8601() || MayBeMonthDate()) && // 1999-12-31 31-Dec-1999
2525 SkipChar( '-', rString, nPos)))
2526 {
2527 if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
2528 eScannedType != SvNumFormatType::DATE) // except date
2529 {
2530 return MatchedReturn();
2531 }
2532 SkipBlanks(rString, nPos);
2533 eScannedType = SvNumFormatType::DATE; // !!! it IS a date
2534 short nTmpMonth = GetMonth(rString, nPos); // 10. Jan 94
2535 if (nMonth && nTmpMonth) // month dup
2536 {
2537 return MatchedReturn();
2538 }
2539 if (nTmpMonth)
2540 {
2541 nMonth = nTmpMonth;
2542 nMonthPos = 2; // month in the middle
2543 if ( nMonth < 0 && SkipChar( '.', rString, nPos ) )
2544 ; // short month may be abbreviated Jan.
2545 else if ( SkipChar( '-', rString, nPos ) )
2546 ; // #79632# recognize 17-Jan-2001 to be a date
2547 // #99065# short and long month name
2548 else
2549 {
2550 SkipString( pLoc->getLongDateMonthSep(), rString, nPos );
2551 }
2552 SkipBlanks(rString, nPos);
2553 }
2554 if (bSignedYear)
2555 {
2556 if (mbEraCE != kDefaultEra) // signed year twice?
2557 return MatchedReturn();
2558
2559 mbEraCE = false; // BCE
2560 }
2561 }
2562
2563 const sal_Int32 nMonthStart = nPos;
2564 short nTempMonth = GetMonth(rString, nPos); // month in the middle (10 Jan 94)
2565 if (nTempMonth)
2566 {
2567 if (nMonth != 0) // month dup
2568 {
2569 return MatchedReturn();
2570 }
2571 if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
2572 eScannedType != SvNumFormatType::DATE) // except date
2573 {
2574 return MatchedReturn();
2575 }
2576 if (nMonthStart > 0 && nPos < rString.getLength()) // 10Jan or Jan94 without separator are not dates
2577 {
2578 eScannedType = SvNumFormatType::DATE; // !!! it IS a date
2579 nMonth = nTempMonth;
2580 nMonthPos = 2; // month in the middle
2581 if ( nMonth < 0 )
2582 {
2583 SkipChar( '.', rString, nPos ); // abbreviated
2584 }
2585 SkipString( pLoc->getLongDateMonthSep(), rString, nPos );
2586 SkipBlanks(rString, nPos);
2587 }
2588 else
2589 {
2590 nPos = nMonthStart; // rewind month
2591 }
2592 }
2593
2594 if ( SkipChar('E', rString, nPos) || // 10E, 10e, 10,Ee
2595 SkipChar('e', rString, nPos) )
2596 {
2597 if (eScannedType != SvNumFormatType::UNDEFINED) // already another type
2598 {
2599 return MatchedReturn();
2600 }
2601 else
2602 {
2603 SkipBlanks(rString, nPos);
2604 eScannedType = SvNumFormatType::SCIENTIFIC; // !!! it IS scientific
2605 if ( nThousand+2 == nNumericsCnt && nDecPos == 2 ) // special case 1.E2
2606 {
2607 nDecPos = 3; // 1,100.E2 1,100,100.E3
2608 }
2609 }
2610 nESign = GetESign(rString, nPos); // signed exponent?
2611 SkipBlanks(rString, nPos);
2612 }
2613
2614 const OUString& rTime = pLoc->getTimeSep();
2615 if ( SkipString(rTime, rString, nPos) ) // time separator?
2616 {
2617 if (nDecPos) // already . => maybe error
2618 {
2619 if (bDecSepInDateSeps) // . also date sep
2620 {
2621 if ( eScannedType != SvNumFormatType::DATE && // already another type than date
2622 eScannedType != SvNumFormatType::DATETIME) // or date time
2623 {
2624 return MatchedReturn();
2625 }
2626 if (eScannedType == SvNumFormatType::DATE)
2627 {
2628 nDecPos = 0; // reset for time transition
2629 }
2630 }
2631 else
2632 {
2633 return MatchedReturn();
2634 }
2635 }
2636 if ((eScannedType == SvNumFormatType::DATE || // already date type
2637 eScannedType == SvNumFormatType::DATETIME) && // or date time
2638 nNumericsCnt > 3) // and more than 3 numbers? (31.Dez.94 8:23)
2639 {
2640 SkipBlanks(rString, nPos);
2641 eScannedType = SvNumFormatType::DATETIME; // !!! it IS date with time
2642 }
2643 else if ( eScannedType != SvNumFormatType::UNDEFINED && // already another type
2644 eScannedType != SvNumFormatType::TIME) // except time
2645 {
2646 return MatchedReturn();
2647 }
2648 else
2649 {
2650 SkipBlanks(rString, nPos);
2651 eScannedType = SvNumFormatType::TIME; // !!! it IS a time
2652 }
2653 if ( !nTimePos )
2654 {
2655 nTimePos = nStringPos + 1;
2656 }
2657 }
2658
2659 if (nPos < rString.getLength())
2660 {
2661 switch (eScannedType)
2662 {
2663 case SvNumFormatType::DATE:
2664 if (nMonthPos == 1 && pLoc->getLongDateOrder() == DateOrder::MDY)
2665 {
2666 // #68232# recognize long date separators like ", " in "September 5, 1999"
2667 if (SkipString( pLoc->getLongDateDaySep(), rString, nPos ))
2668 {
2669 SkipBlanks( rString, nPos );
2670 }
2671 }
2672 else if (nPos == 0 && rString.getLength() == 1 && MayBeIso8601())
2673 {
2674 if ( (nStringPos == 5 && rString[0] == 'T') ||
2675 (nStringPos == 6 && rString[0] == 'T' && sStrArray[0] == "-"))
2676 {
2677 // ISO 8601 combined date and time, yyyy-mm-ddThh:mm or -yyyy-mm-ddThh:mm
2678 ++nPos;
2679 bIso8601Tsep = true;
2680 }
2681 else if (nStringPos == 7 && rString[0] == ':')
2682 {
2683 // ISO 8601 combined date and time, the time part; we reach
2684 // here if the locale's separator is not ':' so it couldn't
2685 // be detected above in the time block.
2686 if (nNumericsCnt >= 5)
2687 eScannedType = SvNumFormatType::DATETIME;
2688 ++nPos;
2689 }
2690 }
2691 break;
2692 case SvNumFormatType::DATETIME:
2693 if (nPos == 0 && rString.getLength() == 1 && MayBeIso8601())
2694 {
2695 if (nStringPos == 9 && rString[0] == ':')
2696 {
2697 // ISO 8601 combined date and time, the time part continued.
2698 ++nPos;
2699 }
2700 }
2701 #if NF_RECOGNIZE_ISO8601_TIMEZONES
2702 else if (nPos == 0 && rString.getLength() == 1 && nStringPos >= 9 && MayBeIso8601())
2703 {
2704 // ISO 8601 timezone offset
2705 switch (rString[ 0 ])
2706 {
2707 case '+':
2708 case '-':
2709 if (nStringPos == nStringsCnt - 2 ||
2710 nStringPos == nStringsCnt - 4)
2711 {
2712 ++nPos; // yyyy-mm-ddThh:mm[:ss]+xx[[:]yy]
2713 // nTimezonePos needed for GetTimeRef()
2714 if (!nTimezonePos)
2715 {
2716 nTimezonePos = nStringPos + 1;
2717 }
2718 }
2719 break;
2720 case ':':
2721 if (nTimezonePos && nStringPos >= 11 &&
2722 nStringPos == nStringsCnt - 2)
2723 {
2724 ++nPos; // yyyy-mm-ddThh:mm[:ss]+xx:yy
2725 }
2726 break;
2727 }
2728 }
2729 #endif
2730 break;
2731 default: break;
2732 }
2733 }
2734
2735 if (nPos < rString.getLength()) // not everything consumed?
2736 {
2737 if ( nMatchedAllStrings & ~nMatchedVirgin )
2738 {
2739 eScannedType = eOldScannedType;
2740 }
2741 else
2742 {
2743 return false;
2744 }
2745 }
2746
2747 return true;
2748 }
2749
2750
2751 /**
2752 * Analyze the end
2753 * All gone => true
2754 * else => false
2755 */
2756 bool ImpSvNumberInputScan::ScanEndString( const OUString& rString )
2757 {
2758 sal_Int32 nPos = 0;
2759
2760 if ( nMatchedAllStrings )
2761 { // Match against format in any case, so later on for a "1-2-3-4" input
2762 // we may distinguish between a y-m-d (or similar) date and a 0-0-0-0
2763 // format.
2764 if ( ScanStringNumFor( rString, 0, 0xFFFF ) )
2765 {
2766 nMatchedAllStrings |= nMatchedEndString;
2767 }
2768 else
2769 {
2770 nMatchedAllStrings = 0;
2771 }
2772 }
2773
2774 SkipBlanks(rString, nPos);
2775 if (GetDecSep(rString, nPos)) // decimal separator?
2776 {
2777 if (nDecPos == 1 || nDecPos == 3) // .12.4 or 12.E4.
2778 {
2779 return MatchedReturn();
2780 }
2781 else if (nDecPos == 2) // . dup: 12.4.
2782 {
2783 bool bSignedYear = false;
2784 if (bDecSepInDateSeps || // . also date separator
2785 SkipDatePatternSeparator( nStringsCnt-1, nPos, bSignedYear))
2786 {
2787 if ( eScannedType != SvNumFormatType::UNDEFINED &&
2788 eScannedType != SvNumFormatType::DATE &&
2789 eScannedType != SvNumFormatType::DATETIME) // already another type
2790 {
2791 return MatchedReturn();
2792 }
2793 if (eScannedType == SvNumFormatType::UNDEFINED)
2794 {
2795 eScannedType = SvNumFormatType::DATE; // !!! it IS a date
2796 }
2797 SkipBlanks(rString, nPos);
2798 }
2799 else
2800 {
2801 return MatchedReturn();
2802 }
2803 }
2804 else
2805 {
2806 nDecPos = 3; // . in end string
2807 SkipBlanks(rString, nPos);
2808 }
2809 }
2810
2811 bool bSignDetectedHere = false;
2812 if ( nSign == 0 && // conflict - not signed
2813 eScannedType != SvNumFormatType::DATE) // and not date
2814 //!? catch time too?
2815 { // not signed yet
2816 nSign = GetSign(rString, nPos); // 1- DM
2817 if (bNegCheck) // '(' as sign
2818 {
2819 return MatchedReturn();
2820 }
2821 if (nSign)
2822 {
2823 bSignDetectedHere = true;
2824 }
2825 }
2826
2827 SkipBlanks(rString, nPos);
2828 if (bNegCheck && SkipChar(')', rString, nPos)) // skip ')' if appropriate
2829 {
2830 bNegCheck = false;
2831 SkipBlanks(rString, nPos);
2832 }
2833
2834 if ( GetCurrency(rString, nPos) ) // currency symbol?
2835 {
2836 if (eScannedType != SvNumFormatType::UNDEFINED) // currency dup
2837 {
2838 return MatchedReturn();
2839 }
2840 else
2841 {
2842 SkipBlanks(rString, nPos);
2843 eScannedType = SvNumFormatType::CURRENCY;
2844 } // behind currency a '-' is allowed
2845 if (nSign == 0) // not signed yet
2846 {
2847 nSign = GetSign(rString, nPos); // DM -
2848 SkipBlanks(rString, nPos);
2849 if (bNegCheck) // 3 DM (
2850 {
2851 return MatchedReturn();
2852 }
2853 }
2854 if ( bNegCheck && eScannedType == SvNumFormatType::CURRENCY &&
2855 SkipChar(')', rString, nPos) )
2856 {
2857 bNegCheck = false; // ')' skipped
2858 SkipBlanks(rString, nPos); // only if currency
2859 }
2860 }
2861
2862 if ( SkipChar('%', rString, nPos) ) // 1%
2863 {
2864 if (eScannedType != SvNumFormatType::UNDEFINED) // already another type
2865 {
2866 return MatchedReturn();
2867 }
2868 SkipBlanks(rString, nPos);
2869 eScannedType = SvNumFormatType::PERCENT;
2870 }
2871
2872 const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
2873 const OUString& rTime = pLoc->getTimeSep();
2874 if ( SkipString(rTime, rString, nPos) ) // 10:
2875 {
2876 if (nDecPos) // already , => error
2877 {
2878 return MatchedReturn();
2879 }
2880 if (eScannedType == SvNumFormatType::DATE && nNumericsCnt > 2) // 31.Dez.94 8:
2881 {
2882 SkipBlanks(rString, nPos);
2883 eScannedType = SvNumFormatType::DATETIME;
2884 }
2885 else if (eScannedType != SvNumFormatType::UNDEFINED &&
2886 eScannedType != SvNumFormatType::TIME) // already another type
2887 {
2888 return MatchedReturn();
2889 }
2890 else
2891 {
2892 SkipBlanks(rString, nPos);
2893 eScannedType = SvNumFormatType::TIME;
2894 }
2895 if ( !nTimePos )
2896 {
2897 nTimePos = nStringsCnt;
2898 }
2899 }
2900
2901 bool bSignedYear = false;
2902 bool bDate = SkipDatePatternSeparator( nStringsCnt-1, nPos, bSignedYear); // 12/31 31.12. 12/31/1999 31.12.1999
2903 if (!bDate)
2904 {
2905 const OUString& rDate = pFormatter->GetDateSep();
2906 bDate = SkipString( rDate, rString, nPos); // 10. 10- 10/
2907 }
2908 if (bDate && bSignDetectedHere)
2909 {
2910 nSign = 0; // 'D-' takes precedence over signed date
2911 }
2912 if (bDate || ((MayBeIso8601() || MayBeMonthDate())
2913 && SkipChar( '-', rString, nPos)))
2914 {
2915 if (eScannedType != SvNumFormatType::UNDEFINED &&
2916 eScannedType != SvNumFormatType::DATE) // already another type
2917 {
2918 return MatchedReturn();
2919 }
2920 else
2921 {
2922 SkipBlanks(rString, nPos);
2923 eScannedType = SvNumFormatType::DATE;
2924 }
2925 short nTmpMonth = GetMonth(rString, nPos); // 10. Jan
2926 if (nMonth && nTmpMonth) // month dup
2927 {
2928 return MatchedReturn();
2929 }
2930 if (nTmpMonth)
2931 {
2932 nMonth = nTmpMonth;
2933 nMonthPos = 3; // month at end
2934 if ( nMonth < 0 )
2935 {
2936 SkipChar( '.', rString, nPos ); // abbreviated
2937 }
2938 SkipBlanks(rString, nPos);
2939 }
2940 }
2941
2942 const sal_Int32 nMonthStart = nPos;
2943 short nTempMonth = GetMonth(rString, nPos); // 10 Jan
2944 if (nTempMonth)
2945 {
2946 if (nMonth) // month dup
2947 {
2948 return MatchedReturn();
2949 }
2950 if (eScannedType != SvNumFormatType::UNDEFINED &&
2951 eScannedType != SvNumFormatType::DATE) // already another type
2952 {
2953 return MatchedReturn();
2954 }
2955 if (nMonthStart > 0) // 10Jan without separator is not a date
2956 {
2957 eScannedType = SvNumFormatType::DATE;
2958 nMonth = nTempMonth;
2959 nMonthPos = 3; // month at end
2960 if ( nMonth < 0 )
2961 {
2962 SkipChar( '.', rString, nPos ); // abbreviated
2963 }
2964 SkipBlanks(rString, nPos);
2965 }
2966 else
2967 {
2968 nPos = nMonthStart; // rewind month
2969 }
2970 }
2971
2972 sal_Int32 nOrigPos = nPos;
2973 if (GetTimeAmPm(rString, nPos))
2974 {
2975 if (eScannedType != SvNumFormatType::UNDEFINED &&
2976 eScannedType != SvNumFormatType::TIME &&
2977 eScannedType != SvNumFormatType::DATETIME) // already another type
2978 {
2979 return MatchedReturn();
2980 }
2981 else
2982 {
2983 // If not already scanned as time, 6.78am does not result in 6
2984 // seconds and 78 hundredths in the morning. Keep as suffix.
2985 if (eScannedType != SvNumFormatType::TIME && nDecPos == 2 && nNumericsCnt == 2)
2986 {
2987 nPos = nOrigPos; // rewind am/pm
2988 }
2989 else
2990 {
2991 SkipBlanks(rString, nPos);
2992 if ( eScannedType != SvNumFormatType::DATETIME )
2993 {
2994 eScannedType = SvNumFormatType::TIME;
2995 }
2996 }
2997 }
2998 }
2999
3000 if ( bNegCheck && SkipChar(')', rString, nPos) )
3001 {
3002 if (eScannedType == SvNumFormatType::CURRENCY) // only if currency
3003 {
3004 bNegCheck = false; // skip ')'
3005 SkipBlanks(rString, nPos);
3006 }
3007 else
3008 {
3009 return MatchedReturn();
3010 }
3011 }
3012
3013 if ( nPos < rString.getLength() &&
3014 (eScannedType == SvNumFormatType::DATE ||
3015 eScannedType == SvNumFormatType::DATETIME) )
3016 {
3017 // day of week is just parsed away
3018 sal_Int32 nOldPos = nPos;
3019 const OUString& rSep = pFormatter->GetLocaleData()->getLongDateDayOfWeekSep();
3020 if ( StringContains( rSep, rString, nPos ) )
3021 {
3022 nPos = nPos + rSep.getLength();
3023 SkipBlanks(rString, nPos);
3024 }
3025 int nTempDayOfWeek = GetDayOfWeek( rString, nPos );
3026 if ( nTempDayOfWeek )
3027 {
3028 if ( nPos < rString.getLength() )
3029 {
3030 if ( nTempDayOfWeek < 0 )
3031 { // short
3032 if ( rString[ nPos ] == '.' )
3033 {
3034 ++nPos;
3035 }
3036 }
3037 SkipBlanks(rString, nPos);
3038 }
3039 }
3040 else
3041 {
3042 nPos = nOldPos;
3043 }
3044 }
3045
3046 #if NF_RECOGNIZE_ISO8601_TIMEZONES
3047 if (nPos == 0 && eScannedType == SvNumFormatType::DATETIME &&
3048 rString.getLength() == 1 && rString[ 0 ] == 'Z' && MayBeIso8601())
3049 {
3050 // ISO 8601 timezone UTC yyyy-mm-ddThh:mmZ
3051 ++nPos;
3052 }
3053 #endif
3054
3055 if (nPos < rString.getLength()) // everything consumed?
3056 {
3057 // does input EndString equal EndString in Format?
3058 if ( !ScanStringNumFor( rString, nPos, 0xFFFF ) )
3059 {
3060 return false;
3061 }
3062 }
3063
3064 return true;
3065 }
3066
3067
3068 bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString, // String to scan
3069 sal_Int32 nPos, // Position until which was consumed
3070 sal_uInt16 nString, // Substring of format, 0xFFFF => last
3071 bool bDontDetectNegation) // Suppress sign detection
3072 {
3073 if ( !mpFormat )
3074 {
3075 return false;
3076 }
3077 const ::utl::TransliterationWrapper* pTransliteration = pFormatter->GetTransliteration();
3078 const OUString* pStr;
3079 OUString aString( rString );
3080 bool bFound = false;
3081 bool bFirst = true;
3082 bool bContinue = true;
3083 sal_uInt16 nSub;
3084 do
3085 {
3086 // Don't try "lower" subformats ff the very first match was the second
3087 // or third subformat.
3088 nSub = nStringScanNumFor;
3089 do
3090 { // Step through subformats, first positive, then negative, then
3091 // other, but not the last (text) subformat.
3092 pStr = mpFormat->GetNumForString( nSub, nString, true );
3093 if ( pStr && pTransliteration->isEqual( aString, *pStr ) )
3094 {
3095 bFound = true;
3096 bContinue = false;
3097 }
3098 else if ( nSub < 2 )
3099 {
3100 ++nSub;
3101 }
3102 else
3103 {
3104 bContinue = false;
3105 }
3106 }
3107 while ( bContinue );
3108 if ( !bFound && bFirst && nPos )
3109 {
3110 // try remaining substring
3111 bFirst = false;
3112 aString = aString.copy(nPos);
3113 bContinue = true;
3114 }
3115 }
3116 while ( bContinue );
3117
3118 if ( !bFound )
3119 {
3120 if ( !bDontDetectNegation && (nString == 0) &&
3121 !bFirst && (nSign < 0) && mpFormat->IsSecondSubformatRealNegative() )
3122 {
3123 // simply negated twice? --1
3124 aString = aString.replaceAll(" ", "");
3125 if ( (aString.getLength() == 1) && (aString[0] == '-') )
3126 {
3127 bFound = true;
3128 nStringScanSign = -1;
3129 nSub = 0; //! not 1
3130 }
3131 }
3132 if ( !bFound )
3133 {
3134 return false;
3135 }
3136 }
3137 else if ( !bDontDetectNegation && (nSub == 1) &&
3138 mpFormat->IsSecondSubformatRealNegative() )
3139 {
3140 // negative
3141 if ( nStringScanSign < 0 )
3142 {
3143 if ( (nSign < 0) && (nStringScanNumFor != 1) )
3144 {
3145 nStringScanSign = 1; // triple negated --1 yyy
3146 }
3147 }
3148 else if ( nStringScanSign == 0 )
3149 {
3150 if ( nSign < 0 )
3151 { // nSign and nStringScanSign will be combined later,
3152 // flip sign if doubly negated
3153 if ( (nString == 0) && !bFirst &&
3154 SvNumberformat::HasStringNegativeSign( aString ) )
3155 {
3156 nStringScanSign = -1; // direct double negation
3157 }
3158 else if ( mpFormat->IsNegativeWithoutSign() )
3159 {
3160 nStringScanSign = -1; // indirect double negation
3161 }
3162 }
3163 else
3164 {
3165 nStringScanSign = -1;
3166 }
3167 }
3168 else // > 0
3169 {
3170 nStringScanSign = -1;
3171 }
3172 }
3173 nStringScanNumFor = nSub;
3174 return true;
3175 }
3176
3177
3178 /**
3179 * Recognizes types of number, exponential, fraction, percent, currency, date, time.
3180 * Else text => return false
3181 */
3182 bool ImpSvNumberInputScan::IsNumberFormatMain( const OUString& rString, // string to be analyzed
3183 const SvNumberformat* pFormat ) // maybe number format set to match against
3184 {
3185 Reset();
3186 mpFormat = pFormat;
3187 NumberStringDivision( rString ); // breakdown into strings and numbers
3188 if (nStringsCnt >= SV_MAX_COUNT_INPUT_STRINGS) // too many elements
3189 {
3190 return false; // Njet, Nope, ...
3191 }
3192 if (nNumericsCnt == 0) // no number in input
3193 {
3194 if ( nStringsCnt > 0 )
3195 {
3196 // Here we may change the original, we don't need it anymore.
3197 // This saves copies and ToUpper() in GetLogical() and is faster.
3198 sStrArray[0] = comphelper::string::strip(sStrArray[0], ' ');
3199 OUString& rStrArray = sStrArray[0];
3200 nLogical = GetLogical( rStrArray );
3201 if ( nLogical )
3202 {
3203 eScannedType = SvNumFormatType::LOGICAL; // !!! it's a BOOLEAN
3204 nMatchedAllStrings &= ~nMatchedVirgin;
3205 return true;
3206 }
3207 else
3208 {
3209 return false; // simple text
3210 }
3211 }
3212 else
3213 {
3214 return false; // simple text
3215 }
3216 }
3217
3218 sal_uInt16 i = 0; // mark any symbol
3219 sal_uInt16 j = 0; // mark only numbers
3220
3221 switch ( nNumericsCnt )
3222 {
3223 case 1 : // Exactly 1 number in input
3224 // nStringsCnt >= 1
3225 if (GetNextNumber(i,j)) // i=1,0
3226 { // Number at start
3227 if (eSetType == SvNumFormatType::FRACTION) // Fraction 1 = 1/1
3228 {
3229 if (i >= nStringsCnt || // no end string nor decimal separator
3230 pFormatter->IsDecimalSep( sStrArray[i]))
3231 {
3232 eScannedType = SvNumFormatType::FRACTION;
3233 nMatchedAllStrings &= ~nMatchedVirgin;
3234 return true;
3235 }
3236 }
3237 }
3238 else
3239 { // Analyze start string
3240 if (!ScanStartString( sStrArray[i] )) // i=0
3241 {
3242 return false; // already an error
3243 }
3244 i++; // next symbol, i=1
3245 }
3246 GetNextNumber(i,j); // i=1,2
3247 if (eSetType == SvNumFormatType::FRACTION) // Fraction -1 = -1/1
3248 {
3249 if (nSign && !bNegCheck && // Sign +, -
3250 eScannedType == SvNumFormatType::UNDEFINED && // not date or currency
3251 nDecPos == 0 && // no previous decimal separator
3252 (i >= nStringsCnt || // no end string nor decimal separator
3253 pFormatter->IsDecimalSep( sStrArray[i]))
3254 )
3255 {
3256 eScannedType = SvNumFormatType::FRACTION;
3257 nMatchedAllStrings &= ~nMatchedVirgin;
3258 return true;
3259 }
3260 }
3261 if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
3262 {
3263 return false;
3264 }
3265 break;
3266 case 2 : // Exactly 2 numbers in input
3267 // nStringsCnt >= 3
3268 if (!GetNextNumber(i,j)) // i=1,0
3269 { // Analyze start string
3270 if (!ScanStartString( sStrArray[i] ))
3271 return false; // already an error
3272 i++; // i=1
3273 }
3274 GetNextNumber(i,j); // i=1,2
3275 if ( !ScanMidString( sStrArray[i], i ) )
3276 {
3277 return false;
3278 }
3279 i++; // next symbol, i=2,3
3280 GetNextNumber(i,j); // i=3,4
3281 if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
3282 {
3283 return false;
3284 }
3285 if (eSetType == SvNumFormatType::FRACTION) // -1,200. as fraction
3286 {
3287 if (!bNegCheck && // no sign '('
3288 eScannedType == SvNumFormatType::UNDEFINED &&
3289 (nDecPos == 0 || nDecPos == 3) // no decimal separator or at end
3290 )
3291 {
3292 eScannedType = SvNumFormatType::FRACTION;
3293 nMatchedAllStrings &= ~nMatchedVirgin;
3294 return true;
3295 }
3296 }
3297 break;
3298 case 3 : // Exactly 3 numbers in input
3299 // nStringsCnt >= 5
3300 if (!GetNextNumber(i,j)) // i=1,0
3301 { // Analyze start string
3302 if (!ScanStartString( sStrArray[i] ))
3303 {
3304 return false; // already an error
3305 }
3306 i++; // i=1
3307 if (nDecPos == 1) // decimal separator at start => error
3308 {
3309 return false;
3310 }
3311 }
3312 GetNextNumber(i,j); // i=1,2
3313 if ( !ScanMidString( sStrArray[i], i ) )
3314 {
3315 return false;
3316 }
3317 i++; // i=2,3
3318 if (eScannedType == SvNumFormatType::SCIENTIFIC) // E only at end
3319 {
3320 return false;
3321 }
3322 GetNextNumber(i,j); // i=3,4
3323 if ( !ScanMidString( sStrArray[i], i ) )
3324 {
3325 return false;
3326 }
3327 i++; // i=4,5
3328 GetNextNumber(i,j); // i=5,6
3329 if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
3330 {
3331 return false;
3332 }
3333 if (eSetType == SvNumFormatType::FRACTION) // -1,200,100. as fraction
3334 {
3335 if (!bNegCheck && // no sign '('
3336 eScannedType == SvNumFormatType::UNDEFINED &&
3337 (nDecPos == 0 || nDecPos == 3) // no decimal separator or at end
3338 )
3339 {
3340 eScannedType = SvNumFormatType::FRACTION;
3341 nMatchedAllStrings &= ~nMatchedVirgin;
3342 return true;
3343 }
3344 }
3345 if ( eScannedType == SvNumFormatType::FRACTION && nDecPos )
3346 {
3347 return false; // #36857# not a real fraction
3348 }
3349 break;
3350 default: // More than 3 numbers in input
3351 // nStringsCnt >= 7
3352 if (!GetNextNumber(i,j)) // i=1,0
3353 { // Analyze startstring
3354 if (!ScanStartString( sStrArray[i] ))
3355 return false; // already an error
3356 i++; // i=1
3357 if (nDecPos == 1) // decimal separator at start => error
3358 return false;
3359 }
3360 GetNextNumber(i,j); // i=1,2
3361 if ( !ScanMidString( sStrArray[i], i ) )
3362 {
3363 return false;
3364 }
3365 i++; // i=2,3
3366 {
3367 sal_uInt16 nThOld = 10; // just not 0 or 1
3368 while (nThOld != nThousand && j < nNumericsCnt-1) // Execute at least one time
3369 // but leave one number.
3370 { // Loop over group separators
3371 nThOld = nThousand;
3372 if (eScannedType == SvNumFormatType::SCIENTIFIC) // E only at end
3373 {
3374 return false;
3375 }
3376 GetNextNumber(i,j);
3377 if ( i < nStringsCnt && !ScanMidString( sStrArray[i], i ) )
3378 {
3379 return false;
3380 }
3381 i++;
3382 }
3383 }
3384 if (eScannedType == SvNumFormatType::DATE || // long date or
3385 eScannedType == SvNumFormatType::TIME || // long time or
3386 eScannedType == SvNumFormatType::UNDEFINED) // long number
3387 {
3388 for (sal_uInt16 k = j; k < nNumericsCnt-1; k++)
3389 {
3390 if (eScannedType == SvNumFormatType::SCIENTIFIC) // E only at endd
3391 {
3392 return false;
3393 }
3394 GetNextNumber(i,j);
3395 if ( i < nStringsCnt && !ScanMidString( sStrArray[i], i ) )
3396 {
3397 return false;
3398 }
3399 i++;
3400 }
3401 }
3402 GetNextNumber(i,j);
3403 if (i < nStringsCnt && !ScanEndString( sStrArray[i] ))
3404 {
3405 return false;
3406 }
3407 if (eSetType == SvNumFormatType::FRACTION) // -1,200,100. as fraction
3408 {
3409 if (!bNegCheck && // no sign '('
3410 eScannedType == SvNumFormatType::UNDEFINED &&
3411 (nDecPos == 0 || nDecPos == 3) // no decimal separator or at end
3412 )
3413 {
3414 eScannedType = SvNumFormatType::FRACTION;
3415 nMatchedAllStrings &= ~nMatchedVirgin;
3416 return true;
3417 }
3418 }
3419 if ( eScannedType == SvNumFormatType::FRACTION && nDecPos )
3420 {
3421 return false; // #36857# not a real fraction
3422 }
3423 break;
3424 }
3425
3426 if (eScannedType == SvNumFormatType::UNDEFINED)
3427 {
3428 nMatchedAllStrings &= ~nMatchedVirgin;
3429 // did match including nMatchedUsedAsReturn
3430 bool bDidMatch = (nMatchedAllStrings != 0);
3431 if ( nMatchedAllStrings )
3432 {
3433 bool bMatch = mpFormat && mpFormat->IsNumForStringElementCountEqual(
3434 nStringScanNumFor, nStringsCnt, nNumericsCnt );
3435 if ( !bMatch )
3436 {
3437 nMatchedAllStrings = 0;
3438 }
3439 }
3440 if ( nMatchedAllStrings )
3441 {
3442 // A type DEFINED means that no category could be assigned to the
3443 // overall format because of mixed type subformats. Use the scan
3444 // matched subformat's type if any.
3445 SvNumFormatType eForType = eSetType;
3446 if ((eForType == SvNumFormatType::UNDEFINED || eForType == SvNumFormatType::DEFINED) && mpFormat)
3447 eForType = mpFormat->GetNumForInfoScannedType( nStringScanNumFor);
3448 if (eForType != SvNumFormatType::UNDEFINED && eForType != SvNumFormatType::DEFINED)
3449 eScannedType = eForType;
3450 else
3451 eScannedType = SvNumFormatType::NUMBER;
3452 }
3453 else if ( bDidMatch )
3454 {
3455 return false;
3456 }
3457 else
3458 {
3459 eScannedType = SvNumFormatType::NUMBER;
3460 // everything else should have been recognized by now
3461 }
3462 }
3463 else if ( eScannedType == SvNumFormatType::DATE )
3464 {
3465 // the very relaxed date input checks may interfere with a preset format
3466 nMatchedAllStrings &= ~nMatchedVirgin;
3467 bool bWasReturn = ((nMatchedAllStrings & nMatchedUsedAsReturn) != 0);
3468 if ( nMatchedAllStrings )
3469 {
3470 bool bMatch = mpFormat && mpFormat->IsNumForStringElementCountEqual(
3471 nStringScanNumFor, nStringsCnt, nNumericsCnt );
3472 if ( !bMatch )
3473 {
3474 nMatchedAllStrings = 0;
3475 }
3476 }
3477 if ( nMatchedAllStrings )
3478 {
3479 // A type DEFINED means that no category could be assigned to the
3480 // overall format because of mixed type subformats. Do not override
3481 // the scanned type in this case. Otherwise in IsNumberFormat() the
3482 // first numeric particle would be accepted as number.
3483 SvNumFormatType eForType = eSetType;
3484 if ((eForType == SvNumFormatType::UNDEFINED || eForType == SvNumFormatType::DEFINED) && mpFormat)
3485 eForType = mpFormat->GetNumForInfoScannedType( nStringScanNumFor);
3486 if (eForType != SvNumFormatType::UNDEFINED && eForType != SvNumFormatType::DEFINED)
3487 eScannedType = eForType;
3488 }
3489 else if ( bWasReturn )
3490 {
3491 return false;
3492 }
3493 }
3494 else
3495 {
3496 nMatchedAllStrings = 0; // reset flag to no substrings matched
3497 }
3498 return true;
3499 }
3500
3501
3502 /**
3503 * Return true or false depending on the nMatched... state and remember usage
3504 */
3505 bool ImpSvNumberInputScan::MatchedReturn()
3506 {
3507 if ( nMatchedAllStrings & ~nMatchedVirgin )
3508 {
3509 nMatchedAllStrings |= nMatchedUsedAsReturn;
3510 return true;
3511 }
3512 return false;
3513 }
3514
3515
3516 /**
3517 * Initialize uppercase months and weekdays
3518 */
3519 void ImpSvNumberInputScan::InitText()
3520 {
3521 sal_Int32 j, nElems;
3522 const CharClass* pChrCls = pFormatter->GetCharClass();
3523 const CalendarWrapper* pCal = pFormatter->GetCalendar();
3524
3525 pUpperMonthText.reset();
3526 pUpperAbbrevMonthText.reset();
3527 css::uno::Sequence< css::i18n::CalendarItem2 > xElems = pCal->getMonths();
3528 nElems = xElems.getLength();
3529 pUpperMonthText.reset( new OUString[nElems] );
3530 pUpperAbbrevMonthText.reset( new OUString[nElems] );
3531 for ( j = 0; j < nElems; j++ )
3532 {
3533 pUpperMonthText[j] = pChrCls->uppercase( xElems[j].FullName );
3534 pUpperAbbrevMonthText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
3535 }
3536
3537 pUpperGenitiveMonthText.reset();
3538 pUpperGenitiveAbbrevMonthText.reset();
3539 xElems = pCal->getGenitiveMonths();
3540 bScanGenitiveMonths = (nElems != xElems.getLength());
3541 nElems = xElems.getLength();
3542 pUpperGenitiveMonthText.reset( new OUString[nElems] );
3543 pUpperGenitiveAbbrevMonthText.reset( new OUString[nElems] );
3544 for ( j = 0; j < nElems; j++ )
3545 {
3546 pUpperGenitiveMonthText[j] = pChrCls->uppercase( xElems[j].FullName );
3547 pUpperGenitiveAbbrevMonthText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
3548 if (!bScanGenitiveMonths &&
3549 (pUpperGenitiveMonthText[j] != pUpperMonthText[j] ||
3550 pUpperGenitiveAbbrevMonthText[j] != pUpperAbbrevMonthText[j]))
3551 {
3552 bScanGenitiveMonths = true;
3553 }
3554 }
3555
3556 pUpperPartitiveMonthText.reset();
3557 pUpperPartitiveAbbrevMonthText.reset();
3558 xElems = pCal->getPartitiveMonths();
3559 bScanPartitiveMonths = (nElems != xElems.getLength());
3560 nElems = xElems.getLength();
3561 pUpperPartitiveMonthText.reset( new OUString[nElems] );
3562 pUpperPartitiveAbbrevMonthText.reset( new OUString[nElems] );
3563 for ( j = 0; j < nElems; j++ )
3564 {
3565 pUpperPartitiveMonthText[j] = pChrCls->uppercase( xElems[j].FullName );
3566 pUpperPartitiveAbbrevMonthText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
3567 if (!bScanPartitiveMonths &&
3568 (pUpperPartitiveMonthText[j] != pUpperGenitiveMonthText[j] ||
3569 pUpperPartitiveAbbrevMonthText[j] != pUpperGenitiveAbbrevMonthText[j]))
3570 {
3571 bScanPartitiveMonths = true;
3572 }
3573 }
3574
3575 pUpperDayText.reset();
3576 pUpperAbbrevDayText.reset();
3577 xElems = pCal->getDays();
3578 nElems = xElems.getLength();
3579 pUpperDayText.reset( new OUString[nElems] );
3580 pUpperAbbrevDayText.reset( new OUString[nElems] );
3581 for ( j = 0; j < nElems; j++ )
3582 {
3583 pUpperDayText[j] = pChrCls->uppercase( xElems[j].FullName );
3584 pUpperAbbrevDayText[j] = pChrCls->uppercase( xElems[j].AbbrevName );
3585 }
3586
3587 bTextInitialized = true;
3588 }
3589
3590
3591 /**
3592 * MUST be called if International/Locale is changed
3593 */
3594 void ImpSvNumberInputScan::ChangeIntl()
3595 {
3596 sal_Unicode cDecSep = pFormatter->GetNumDecimalSep()[0];
3597 bDecSepInDateSeps = ( cDecSep == '-' ||
3598 cDecSep == pFormatter->GetDateSep()[0] );
3599 if (!bDecSepInDateSeps)
3600 {
3601 sal_Unicode cDecSepAlt = pFormatter->GetNumDecimalSepAlt().toChar();
3602 bDecSepInDateSeps = cDecSepAlt && (cDecSepAlt == '-' || cDecSepAlt == pFormatter->GetDateSep()[0]);
3603 }
3604 bTextInitialized = false;
3605 aUpperCurrSymbol.clear();
3606 InvalidateDateAcceptancePatterns();
3607 }
3608
3609
3610 void ImpSvNumberInputScan::InvalidateDateAcceptancePatterns()
3611 {
3612 if (sDateAcceptancePatterns.getLength())
3613 {
3614 sDateAcceptancePatterns = css::uno::Sequence< OUString >();
3615 }
3616 }
3617
3618
3619 void ImpSvNumberInputScan::ChangeNullDate( const sal_uInt16 Day,
3620 const sal_uInt16 Month,
3621 const sal_Int16 Year )
3622 {
3623 if ( pNullDate )
3624 {
3625 *pNullDate = Date(Day, Month, Year);
3626 }
3627 else
3628 {
3629 pNullDate.reset(new Date(Day, Month, Year));
3630 }
3631 }
3632
3633
3634 /**
3635 * Does rString represent a number (also date, time et al)
3636 */
3637 bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString, // string to be analyzed
3638 SvNumFormatType& F_Type, // IN: old type, OUT: new type
3639 double& fOutNumber, // OUT: number if convertible
3640 const SvNumberformat* pFormat ) // maybe a number format to match against
3641 {
3642 OUString aString;
3643 bool res; // return value
3644 sal_uInt16 k;
3645 eSetType = F_Type; // old type set
3646
3647 if ( !rString.getLength() )
3648 {
3649 res = false;
3650 }
3651 else if (rString.getLength() > 308) // arbitrary
3652 {
3653 res = false;
3654 }
3655 else
3656 {
3657 // NoMoreUpperNeeded, all comparisons on UpperCase
3658 aString = pFormatter->GetCharClass()->uppercase( rString );
3659 // convert native number to ASCII if necessary
3660 TransformInput(pFormatter, aString);
3661 res = IsNumberFormatMain( aString, pFormat );
3662 }
3663
3664 if (res)
3665 {
3666 // Accept signed date only for ISO date with at least four digits in
3667 // year to not have an input of -M-D-Y arbitrarily recognized. The
3668 // final order is only determined in GetDateRef().
3669 // Also accept for Y/M/D date pattern match, i.e. if the first number
3670 // is year.
3671 // Accept only if the year immediately follows the sign character with
3672 // no space in between.
3673 if (nSign && (eScannedType == SvNumFormatType::DATE ||
3674 eScannedType == SvNumFormatType::DATETIME) && mbEraCE == kDefaultEra &&
3675 (IsDatePatternNumberOfType(0,'Y') || (MayBeIso8601() && sStrArray[nNums[0]].getLength() >= 4)))
3676 {
3677 const sal_Unicode c = sStrArray[0][sStrArray[0].getLength()-1];
3678 if (c == '-' || c == '+')
3679 {
3680 // A '+' sign doesn't change the era.
3681 if (nSign < 0)
3682 mbEraCE = false; // BCE
3683 nSign = 0;
3684 }
3685 }
3686 if ( bNegCheck || // ')' not found for '('
3687 (nSign && (eScannedType == SvNumFormatType::DATE ||
3688 eScannedType == SvNumFormatType::DATETIME))) // signed date/datetime
3689 {
3690 res = false;
3691 }
3692 else
3693 { // check count of partial number strings
3694 switch (eScannedType)
3695 {
3696 case SvNumFormatType::PERCENT:
3697 case SvNumFormatType::CURRENCY:
3698 case SvNumFormatType::NUMBER:
3699 if (nDecPos == 1) // .05
3700 {
3701 // matched MidStrings function like group separators
3702 if ( nMatchedAllStrings )
3703 {
3704 nThousand = nNumericsCnt - 1;
3705 }
3706 else if ( nNumericsCnt != 1 )
3707 {
3708 res = false;
3709 }
3710 }
3711 else if (nDecPos == 2) // 1.05
3712 {
3713 // matched MidStrings function like group separators
3714 if ( nMatchedAllStrings )
3715 {
3716 nThousand = nNumericsCnt - 1;
3717 }
3718 else if ( nNumericsCnt != nThousand+2 )
3719 {
3720 res = false;
3721 }
3722 }
3723 else // 1,100 or 1,100.
3724 {
3725 // matched MidStrings function like group separators
3726 if ( nMatchedAllStrings )
3727 {
3728 nThousand = nNumericsCnt - 1;
3729 }
3730 else if ( nNumericsCnt != nThousand+1 )
3731 {
3732 res = false;
3733 }
3734 }
3735 break;
3736
3737 case SvNumFormatType::SCIENTIFIC: // 1.0e-2
3738 if (nDecPos == 1) // .05
3739 {
3740 if (nNumericsCnt != 2)
3741 {
3742 res = false;
3743 }
3744 }
3745 else if (nDecPos == 2) // 1.05
3746 {
3747 if (nNumericsCnt != nThousand+3)
3748 {
3749 res = false;
3750 }
3751 }
3752 else // 1,100 or 1,100.
3753 {
3754 if (nNumericsCnt != nThousand+2)
3755 {
3756 res = false;
3757 }
3758 }
3759 break;
3760
3761 case SvNumFormatType::DATE:
3762 if (nMonth < 0 && nDayOfWeek < 0 && nNumericsCnt == 3)
3763 {
3764 // If both, short month name and day of week name were
3765 // detected, and also numbers for full date, assume that we
3766 // have a day of week instead of month name.
3767 nMonth = 0;
3768 nMonthPos = 0;
3769 }
3770 if (nMonth)
3771 { // month name and numbers
3772 if (nNumericsCnt > 2)
3773 {
3774 res = false;
3775 }
3776 }
3777 else
3778 {
3779 if (nNumericsCnt > 3)
3780 {
3781 res = false;
3782 }
3783 else
3784 {
3785 // Even if a date pattern was matched, for abbreviated
3786 // pattern like "D.M." an input of "D.M. #" was
3787 // accepted because # could had been a time. Here we do
3788 // not have a combined date/time input though and #
3789 // would be taken as Year in this example, which it is
3790 // not. The count of numbers in pattern must match the
3791 // count of numbers in input.
3792 res = (GetDatePatternNumbers() == nNumericsCnt)
3793 || IsAcceptableIso8601() || nMatchedAllStrings;
3794 }
3795 }
3796 break;
3797
3798 case SvNumFormatType::TIME:
3799 if (nDecPos)
3800 { // hundredth seconds included
3801 if (nNumericsCnt > 4)
3802 {
3803 res = false;
3804 }
3805 }
3806 else
3807 {
3808 if (nNumericsCnt > 3)
3809 {
3810 res = false;
3811 }
3812 }
3813 break;
3814
3815 case SvNumFormatType::DATETIME:
3816 if (nMonth < 0 && nDayOfWeek < 0 && nNumericsCnt >= 5)
3817 {
3818 // If both, abbreviated month name and day of week name
3819 // were detected, and also at least numbers for full date
3820 // plus time including minutes, assume that we have a day
3821 // of week instead of month name.
3822 nMonth = 0;
3823 nMonthPos = 0;
3824 }
3825 if (nMonth)
3826 { // month name and numbers
3827 if (nDecPos)
3828 { // hundredth seconds included
3829 if (nNumericsCnt > 6)
3830 {
3831 res = false;
3832 }
3833 }
3834 else
3835 {
3836 if (nNumericsCnt > 5)
3837 {
3838 res = false;
3839 }
3840 }
3841 }
3842 else
3843 {
3844 if (nDecPos)
3845 { // hundredth seconds included
3846 if (nNumericsCnt > 7)
3847 {
3848 res = false;
3849 }
3850 }
3851 else
3852 {
3853 if (nNumericsCnt > 6)
3854 {
3855 res = false;
3856 }
3857 }
3858 if (res)
3859 {
3860 res = IsAcceptedDatePattern( nNums[0]) || MayBeIso8601() || nMatchedAllStrings;
3861 }
3862 }
3863 break;
3864
3865 default:
3866 break;
3867 } // switch
3868 } // else
3869 } // if (res)
3870
3871 OUStringBuffer sResString;
3872
3873 if (res)
3874 { // we finally have a number
3875 switch (eScannedType)
3876 {
3877 case SvNumFormatType::LOGICAL:
3878 if (nLogical == 1)
3879 {
3880 fOutNumber = 1.0; // True
3881 }
3882 else if (nLogical == -1)
3883 {
3884 fOutNumber = 0.0; // False
3885 }
3886 else
3887 {
3888 res = false; // Oops
3889 }
3890 break;
3891
3892 case SvNumFormatType::PERCENT:
3893 case SvNumFormatType::CURRENCY:
3894 case SvNumFormatType::NUMBER:
3895 case SvNumFormatType::SCIENTIFIC:
3896 case SvNumFormatType::DEFINED: // if no category detected handle as number
3897 if ( nDecPos == 1 ) // . at start
3898 {
3899 sResString.append("0.");
3900 }
3901
3902 for ( k = 0; k <= nThousand; k++)
3903 {
3904 sResString.append(sStrArray[nNums[k]]); // integer part
3905 }
3906 if ( nDecPos == 2 && k < nNumericsCnt ) // . somewhere
3907 {
3908 sResString.append('.');
3909 sal_uInt16 nStop = (eScannedType == SvNumFormatType::SCIENTIFIC ?
3910 nNumericsCnt-1 : nNumericsCnt);
3911 for ( ; k < nStop; k++)
3912 {
3913 sResString.append(sStrArray[nNums[k]]); // fractional part
3914 }
3915 }
3916
3917 if (eScannedType != SvNumFormatType::SCIENTIFIC)
3918 {
3919 fOutNumber = StringToDouble(sResString.makeStringAndClear());
3920 }
3921 else
3922 { // append exponent
3923 sResString.append('E');
3924 if ( nESign == -1 )
3925 {
3926 sResString.append('-');
3927 }
3928 sResString.append(sStrArray[nNums[nNumericsCnt-1]]);
3929 rtl_math_ConversionStatus eStatus;
3930 fOutNumber = ::rtl::math::stringToDouble( sResString.makeStringAndClear(), '.', ',', &eStatus );
3931 if ( eStatus == rtl_math_ConversionStatus_OutOfRange )
3932 {
3933 F_Type = SvNumFormatType::TEXT; // overflow/underflow -> Text
3934 if (nESign == -1)
3935 {
3936 fOutNumber = 0.0;
3937 }
3938 else
3939 {
3940 fOutNumber = DBL_MAX;
3941 }
3942 return true;
3943 }
3944 }
3945
3946 if ( nStringScanSign )
3947 {
3948 if ( nSign )
3949 {
3950 nSign *= nStringScanSign;
3951 }
3952 else
3953 {
3954 nSign = nStringScanSign;
3955 }
3956 }
3957 if ( nSign < 0 )
3958 {
3959 fOutNumber = -fOutNumber;
3960 }
3961
3962 if (eScannedType == SvNumFormatType::PERCENT)
3963 {
3964 fOutNumber/= 100.0;
3965 }
3966 break;
3967
3968 case SvNumFormatType::FRACTION:
3969 if (nNumericsCnt == 1)
3970 {
3971 fOutNumber = StringToDouble(sStrArray[nNums[0]]);
3972 }
3973 else if (nNumericsCnt == 2)
3974 {
3975 if (nThousand == 1)
3976 {
3977 sResString = sStrArray[nNums[0]];
3978 sResString.append(sStrArray[nNums[1]]); // integer part
3979 fOutNumber = StringToDouble(sResString.makeStringAndClear());
3980 }
3981 else
3982 {
3983 double fNumerator = StringToDouble(sStrArray[nNums[0]]);
3984 double fDenominator = StringToDouble(sStrArray[nNums[1]]);
3985 if (fDenominator != 0.0)
3986 {
3987 fOutNumber = fNumerator/fDenominator;
3988 }
3989 else
3990 {
3991 res = false;
3992 }
3993 }
3994 }
3995 else // nNumericsCnt > 2
3996 {
3997 k = 1;
3998 sResString = sStrArray[nNums[0]];
3999 if (nThousand > 0)
4000 {
4001 for (; k <= nThousand; k++)
4002 {
4003 sResString.append(sStrArray[nNums[k]]);
4004 }
4005 }
4006 fOutNumber = StringToDouble(sResString.makeStringAndClear());
4007
4008 if (k == nNumericsCnt-2)
4009 {
4010 double fNumerator = StringToDouble(sStrArray[nNums[k]]);
4011 double fDenominator = StringToDouble(sStrArray[nNums[k + 1]]);
4012 if (fDenominator != 0.0)
4013 {
4014 fOutNumber += fNumerator/fDenominator;
4015 }
4016 else
4017 {
4018 res = false;
4019 }
4020 }
4021 }
4022
4023 if ( nStringScanSign )
4024 {
4025 if ( nSign )
4026 {
4027 nSign *= nStringScanSign;
4028 }
4029 else
4030 {
4031 nSign = nStringScanSign;
4032 }
4033 }
4034 if ( nSign < 0 )
4035 {
4036 fOutNumber = -fOutNumber;
4037 }
4038 break;
4039
4040 case SvNumFormatType::TIME:
4041 res = GetTimeRef(fOutNumber, 0, nNumericsCnt);
4042 if ( nSign < 0 )
4043 {
4044 fOutNumber = -fOutNumber;
4045 }
4046 break;
4047
4048 case SvNumFormatType::DATE:
4049 res = GetDateRef( fOutNumber, k );
4050 break;
4051
4052 case SvNumFormatType::DATETIME:
4053 res = GetDateRef( fOutNumber, k );
4054 if ( res )
4055 {
4056 double fTime;
4057 res = GetTimeRef( fTime, k, nNumericsCnt - k );
4058 fOutNumber += fTime;
4059 }
4060 break;
4061
4062 default:
4063 SAL_WARN( "svl.numbers", "Some number recognized but what's it?" );
4064 fOutNumber = 0.0;
4065 break;
4066 }
4067 }
4068
4069 if (res) // overflow/underflow -> Text
4070 {
4071 if (fOutNumber < -DBL_MAX) // -1.7E308
4072 {
4073 F_Type = SvNumFormatType::TEXT;
4074 fOutNumber = -DBL_MAX;
4075 return true;
4076 }
4077 else if (fOutNumber > DBL_MAX) // 1.7E308
4078 {
4079 F_Type = SvNumFormatType::TEXT;
4080 fOutNumber = DBL_MAX;
4081 return true;
4082 }
4083 }
4084
4085 if (!res)
4086 {
4087 eScannedType = SvNumFormatType::TEXT;
4088 fOutNumber = 0.0;
4089 }
4090
4091 F_Type = eScannedType;
4092 return res;
4093 }
4094
4095 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE