Translate German comments, fix some WS

Change-Id: Ic52fc416aea9d1ca7235613aed7cf494f17ae21a
Reviewed-on: https://gerrit.libreoffice.org/4361
Reviewed-by: Noel Power <noel.power@suse.com>
Tested-by: Noel Power <noel.power@suse.com>

1 files changed, 217 insertions, 305 deletions

diff --git a/svl/source/numbers/zforfind.cxx b/svl/source/numbers/zforfind.cxx
index 9fdc167bcb9e..5fbb9c628b33 100644
--- a/svl/source/numbers/zforfind.cxx
+++ b/svl/source/numbers/zforfind.cxx
@@ -33,7 +33,7 @@
 #include <com/sun/star/i18n/LocaleCalendar.hpp>
 #include <unotools/digitgroupingiterator.hxx>
 
-#include <svl/zforlist.hxx>         // NUMBERFORMAT_XXX
+#include <svl/zforlist.hxx> // NUMBERFORMAT_XXX
 #include "zforscan.hxx"
 #include <svl/zformat.hxx>
 
@@ -65,9 +65,6 @@ const sal_uInt8 ImpSvNumberInputScan::nMatchedUsedAsReturn = 0x10;
  * would work, together with the nTimezonePos handling in GetTimeRef(). */
 #define NF_RECOGNIZE_ISO8601_TIMEZONES 0
 
-//---------------------------------------------------------------------------
-//      Konstruktor
-
 ImpSvNumberInputScan::ImpSvNumberInputScan( SvNumberFormatter* pFormatterP )
         :
         pUpperMonthText( NULL ),
@@ -92,9 +89,6 @@ ImpSvNumberInputScan::ImpSvNumberInputScan( SvNumberFormatter* pFormatterP )
 }
 
 
-//---------------------------------------------------------------------------
-//      Destruktor
-
 ImpSvNumberInputScan::~ImpSvNumberInputScan()
 {
     Reset();
@@ -110,9 +104,6 @@ ImpSvNumberInputScan::~ImpSvNumberInputScan()
 }
 
 
-//---------------------------------------------------------------------------
-//      Reset
-
 void ImpSvNumberInputScan::Reset()
 {
     nMonth       = 0;
@@ -148,8 +139,6 @@ void ImpSvNumberInputScan::Reset()
 }
 
 
-//---------------------------------------------------------------------------
-//
 // static
 inline bool ImpSvNumberInputScan::MyIsdigit( sal_Unicode c )
 {
@@ -157,8 +146,6 @@ inline bool ImpSvNumberInputScan::MyIsdigit( sal_Unicode c )
 }
 
 
-//---------------------------------------------------------------------------
-//
 void ImpSvNumberInputScan::TransformInput( OUString& rStr )
 {
     sal_Int32 nPos, nLen;
@@ -178,12 +165,10 @@ void ImpSvNumberInputScan::TransformInput( OUString& rStr )
 }
 
 
-//---------------------------------------------------------------------------
-//      StringToDouble
-//
-// Only simple unsigned floating point values without any error detection,
-// decimal separator has to be '.'
-
+/**
+ * Only simple unsigned floating point values without any error detection,
+ * decimal separator has to be '.'
+ */
 double ImpSvNumberInputScan::StringToDouble( const OUString& rStr, bool bForceFraction )
 {
     double fNum = 0.0;
@@ -218,27 +203,25 @@ double ImpSvNumberInputScan::StringToDouble( const OUString& rStr, bool bForceFr
 }
 
 
-//---------------------------------------------------------------------------
-//       NextNumberStringSymbol
-//
-// Zerlegt die Eingabe in Zahlen und Strings fuer die weitere
-// Verarbeitung (Turing-Maschine).
-//---------------------------------------------------------------------------
-// Ausgangs Zustand = GetChar
-//---------------+-------------------+-----------------------+---------------
-// Alter Zustand | gelesenes Zeichen | Aktion                | Neuer Zustand
-//---------------+-------------------+-----------------------+---------------
-// GetChar       | Ziffer            | Symbol=Zeichen        | GetValue
-//               | Sonst             | Symbol=Zeichen        | GetString
-//---------------|-------------------+-----------------------+---------------
-// GetValue      | Ziffer            | Symbol=Symbol+Zeichen | GetValue
-//               | Sonst             | Dec(CharPos)          | Stop
-//---------------+-------------------+-----------------------+---------------
-// GetString     | Ziffer            | Dec(CharPos)          | Stop
-//               | Sonst             | Symbol=Symbol+Zeichen | GetString
-//---------------+-------------------+-----------------------+---------------
-
-enum ScanState              // States der Turing-Maschine
+/**
+ * Splits up the input into numbers and strings for further processing
+ * (by the Turing machine).
+ *
+ * Starting state = GetChar
+ * ---------------+-------------------+-----------------------------+---------------
+ *  Old State     | Character read    | Event                       | New state
+ * ---------------+-------------------+-----------------------------+---------------
+ *  GetChar       | Number            | Symbol = Character          | GetValue
+ *                | Else              | Symbol = Character          | GetString
+ * ---------------|-------------------+-----------------------------+---------------
+ *  GetValue      | Number            | Symbol = Symbol + Character | GetValue
+ *                | Else              | Dec(CharPos)                | Stop
+ * ---------------+-------------------+-----------------------------+---------------
+ *  GetString     | Number            | Dec(CharPos)                | Stop
+ *                | Else              | Symbol = Symbol + Character | GetString
+ * ---------------+-------------------+-----------------------------+---------------
+ */
+enum ScanState  // States of the Turing machine
 {
     SsStop      = 0,
     SsStart     = 1,
@@ -296,8 +279,8 @@ bool ImpSvNumberInputScan::NextNumberStringSymbol( const sal_Unicode*& pStr,
             break;
         default:
             break;
-        }   // switch
-    }   // while
+        } // switch
+    } // while
 
     if ( nChars )
     {
@@ -314,9 +297,6 @@ bool ImpSvNumberInputScan::NextNumberStringSymbol( const sal_Unicode*& pStr,
 }
 
 
-//---------------------------------------------------------------------------
-//      SkipThousands
-
 // FIXME: should be grouping; it is only used though in case nAnzStrings is
 // near SV_MAX_ANZ_INPUT_STRINGS, in NumberStringDivision().
 
@@ -329,7 +309,7 @@ bool ImpSvNumberInputScan::SkipThousands( const sal_Unicode*& pStr,
     const OUString& rThSep = pFormatter->GetNumThousandSep();
     register const sal_Unicode* pHere = pStr;
     ScanState eState = SsStart;
-    sal_Int32 nCounter = 0;                                // counts 3 digits
+    sal_Int32 nCounter = 0; // counts 3 digits
 
     while ( ((cToken = *pHere) != 0) && eState != SsStop)
     {
@@ -357,7 +337,7 @@ bool ImpSvNumberInputScan::SkipThousands( const sal_Unicode*& pStr,
                 if (nCounter == 3)
                 {
                     eState = SsStart;
-                    res = true;                 // .000 combination found
+                    res = true; // .000 combination found
                 }
             }
             else
@@ -368,16 +348,16 @@ bool ImpSvNumberInputScan::SkipThousands( const sal_Unicode*& pStr,
             break;
         default:
             break;
-        }   // switch
-    }   // while
+        } // switch
+    } // while
 
-    if (eState == SsGetValue)               // break witth less than 3 digits
+    if (eState == SsGetValue) // break witth less than 3 digits
     {
         if ( nCounter )
         {
             sBuff.remove( sBuff.getLength() - nCounter, nCounter );
         }
-        pHere -= nCounter + rThSep.getLength();       // put back ThSep also
+        pHere -= nCounter + rThSep.getLength(); // put back ThSep also
     }
     rSymbol = sBuff.makeStringAndClear();
     pStr = pHere;
@@ -386,9 +366,6 @@ bool ImpSvNumberInputScan::SkipThousands( const sal_Unicode*& pStr,
 }
 
 
-//---------------------------------------------------------------------------
-//      NumberStringDivision
-
 void ImpSvNumberInputScan::NumberStringDivision( const OUString& rString )
 {
     const sal_Unicode* pStr = rString.getStr();
@@ -396,12 +373,12 @@ void ImpSvNumberInputScan::NumberStringDivision( const OUString& rString )
     while ( pStr < pEnd && nAnzStrings < SV_MAX_ANZ_INPUT_STRINGS )
     {
         if ( NextNumberStringSymbol( pStr, sStrArray[nAnzStrings] ) )
-        {                                               // Zahl
+        {   // Number
             IsNum[nAnzStrings] = true;
             nNums[nAnzNums] = nAnzStrings;
             nAnzNums++;
             if (nAnzStrings >= SV_MAX_ANZ_INPUT_STRINGS - 7 &&
-                nPosThousandString == 0)                // nur einmal
+                nPosThousandString == 0) // Only once
             {
                 if ( SkipThousands( pStr, sStrArray[nAnzStrings] ) )
                 {
@@ -418,9 +395,9 @@ void ImpSvNumberInputScan::NumberStringDivision( const OUString& rString )
 }
 
 
-//---------------------------------------------------------------------------
-// Whether rString contains rWhat at nPos
-
+/**
+ * Whether rString contains rWhat at nPos
+ */
 bool ImpSvNumberInputScan::StringContainsImpl( const OUString& rWhat,
                                                const OUString& rString, sal_Int32 nPos )
 {
@@ -432,9 +409,9 @@ bool ImpSvNumberInputScan::StringContainsImpl( const OUString& rWhat,
 }
 
 
-//---------------------------------------------------------------------------
-// Whether pString contains rWhat at nPos
-
+/**
+ * Whether pString contains rWhat at nPos
+ */
 bool ImpSvNumberInputScan::StringPtrContainsImpl( const OUString& rWhat,
                                                   const sal_Unicode* pString, sal_Int32 nPos )
 {
@@ -458,11 +435,9 @@ bool ImpSvNumberInputScan::StringPtrContainsImpl( const OUString& rWhat,
 }
 
 
-//---------------------------------------------------------------------------
-//      SkipChar
-//
-// ueberspringt genau das angegebene Zeichen
-
+/**
+ * Skips the supplied char
+ */
 inline bool ImpSvNumberInputScan::SkipChar( sal_Unicode c, const OUString& rString,
                                             sal_Int32& nPos )
 {
@@ -475,11 +450,9 @@ inline bool ImpSvNumberInputScan::SkipChar( sal_Unicode c, const OUString& rStri
 }
 
 
-//---------------------------------------------------------------------------
-//      SkipBlanks
-//
-// Ueberspringt Leerzeichen
-
+/**
+ * Skips blanks
+ */
 inline void ImpSvNumberInputScan::SkipBlanks( const OUString& rString,
                                               sal_Int32& nPos )
 {
@@ -495,11 +468,9 @@ inline void ImpSvNumberInputScan::SkipBlanks( const OUString& rString,
 }
 
 
-//---------------------------------------------------------------------------
-//      SkipString
-//
-// jump over rWhat in rString at nPos
-
+/**
+ * jump over rWhat in rString at nPos
+ */
 inline bool ImpSvNumberInputScan::SkipString( const OUString& rWhat,
                                               const OUString& rString, sal_Int32& nPos )
 {
@@ -512,11 +483,9 @@ inline bool ImpSvNumberInputScan::SkipString( const OUString& rWhat,
 }
 
 
-//---------------------------------------------------------------------------
-//      GetThousandSep
-//
-// recognizes exactly ,111 in {3} and {3,2} or ,11 in {3,2} grouping
-
+/**
+ * Recognizes exactly ,111 in {3} and {3,2} or ,11 in {3,2} grouping
+ */
 inline bool ImpSvNumberInputScan::GetThousandSep( const OUString& rString,
                                                   sal_Int32& nPos,
                                                   sal_uInt16 nStringPos )
@@ -529,7 +498,7 @@ inline bool ImpSvNumberInputScan::GetThousandSep( const OUString& rString,
            nStringPos < nAnzStrings - 1 &&         // safety first!
            IsNum[ nStringPos + 1 ] ))              // number follows
     {
-        return false;                                   // no? => out
+        return false; // no? => out
     }
 
     utl::DigitGroupingIterator aGrouping( pFormatter->GetLocaleData()->getDigitGrouping());
@@ -551,14 +520,12 @@ inline bool ImpSvNumberInputScan::GetThousandSep( const OUString& rString,
 }
 
 
-//---------------------------------------------------------------------------
-//      GetLogical
-//
-// Conversion of text to logial value
-// "true" =>  1:
-// "false"=> -1:
-// else   =>  0:
-
+/**
+ * Conversion of text to logical value
+ *  "true" =>  1:
+ *  "false"=> -1:
+ *  else   =>  0:
+ */
 short ImpSvNumberInputScan::GetLogical( const OUString& rString )
 {
     short res;
@@ -580,12 +547,10 @@ short ImpSvNumberInputScan::GetLogical( const OUString& rString )
 }
 
 
-//---------------------------------------------------------------------------
-//      GetMonth
-//
-// Converts a string containing a month name (JAN, January) at nPos into the
-// month number (negative if abbreviated), returns 0 if nothing found
-
+/**
+ * Converts a string containing a month name (JAN, January) at nPos into the
+ * month number (negative if abbreviated), returns 0 if nothing found
+ */
 short ImpSvNumberInputScan::GetMonth( const OUString& rString, sal_Int32& nPos )
 {
     // #102136# The correct English form of month September abbreviated is
@@ -593,9 +558,9 @@ short ImpSvNumberInputScan::GetMonth( const OUString& rString, sal_Int32& nPos )
     static const OUString aSeptCorrect("SEPT");
     static const OUString aSepShortened("SEP");
 
-    short res = 0;      // no month found
+    short res = 0; // no month found
 
-    if (rString.getLength() > nPos)                           // only if needed
+    if (rString.getLength() > nPos) // only if needed
     {
         if ( !bTextInitialized )
         {
@@ -605,44 +570,44 @@ short ImpSvNumberInputScan::GetMonth( const OUString& rString, sal_Int32& nPos )
         for ( sal_Int16 i = 0; i < nMonths; i++ )
         {
             if ( bScanGenitiveMonths && StringContains( pUpperGenitiveMonthText[i], rString, nPos ) )
-            {                                           // genitive full names first
+            {   // genitive full names first
                 nPos = nPos + pUpperGenitiveMonthText[i].getLength();
                 res = i + 1;
                 break;  // for
             }
             else if ( bScanGenitiveMonths && StringContains( pUpperGenitiveAbbrevMonthText[i], rString, nPos ) )
-            {                                           // genitive abbreviated
+            {   // genitive abbreviated
                 nPos = nPos + pUpperGenitiveAbbrevMonthText[i].getLength();
                 res = sal::static_int_cast< short >(-(i+1)); // negative
                 break;  // for
             }
             else if ( bScanPartitiveMonths && StringContains( pUpperPartitiveMonthText[i], rString, nPos ) )
-            {                                           // partitive full names
+            {   // partitive full names
                 nPos = nPos + pUpperPartitiveMonthText[i].getLength();
                 res = i+1;
                 break;  // for
             }
             else if ( bScanPartitiveMonths && StringContains( pUpperPartitiveAbbrevMonthText[i], rString, nPos ) )
-            {                                           // partitive abbreviated
+            {   // partitive abbreviated
                 nPos = nPos + pUpperPartitiveAbbrevMonthText[i].getLength();
                 res = sal::static_int_cast< short >(-(i+1)); // negative
                 break;  // for
             }
             else if ( StringContains( pUpperMonthText[i], rString, nPos ) )
-            {                                           // noun full names
+            {   // noun full names
                 nPos = nPos + pUpperMonthText[i].getLength();
                 res = i+1;
                 break;  // for
             }
             else if ( StringContains( pUpperAbbrevMonthText[i], rString, nPos ) )
-            {                                           // noun abbreviated
+            {   // noun abbreviated
                 nPos = nPos + pUpperAbbrevMonthText[i].getLength();
                 res = sal::static_int_cast< short >(-(i+1)); // negative
                 break;  // for
             }
             else if ( i == 8 && pUpperAbbrevMonthText[i] == aSeptCorrect &&
                     StringContains( aSepShortened, rString, nPos ) )
-            {                                           // #102136# SEPT/SEP
+            {   // #102136# SEPT/SEP
                 nPos = nPos + aSepShortened.getLength();
                 res = sal::static_int_cast< short >(-(i+1)); // negative
                 break;  // for
@@ -654,17 +619,15 @@ short ImpSvNumberInputScan::GetMonth( const OUString& rString, sal_Int32& nPos )
 }
 
 
-//---------------------------------------------------------------------------
-//      GetDayOfWeek
-//
-// Converts a string containing a DayOfWeek name (Mon, Monday) at nPos into the
-// DayOfWeek number + 1 (negative if abbreviated), returns 0 if nothing found
-
+/**
+ * Converts a string containing a DayOfWeek name (Mon, Monday) at nPos into the
+ * DayOfWeek number + 1 (negative if abbreviated), returns 0 if nothing found
+ */
 int ImpSvNumberInputScan::GetDayOfWeek( const OUString& rString, sal_Int32& nPos )
 {
-    int res = 0;      // no day found
+    int res = 0; // no day found
 
-    if (rString.getLength() > nPos)                           // only if needed
+    if (rString.getLength() > nPos) // only if needed
     {
         if ( !bTextInitialized )
         {
@@ -674,15 +637,15 @@ int ImpSvNumberInputScan::GetDayOfWeek( const OUString& rString, sal_Int32& nPos
         for ( sal_Int16 i = 0; i < nDays; i++ )
         {
             if ( StringContains( pUpperDayText[i], rString, nPos ) )
-            {                                           // full names first
+            {   // full names first
                 nPos = nPos + pUpperDayText[i].getLength();
                 res = i + 1;
                 break;  // for
             }
             if ( StringContains( pUpperAbbrevDayText[i], rString, nPos ) )
-            {                                           // abbreviated
+            {   // abbreviated
                 nPos = nPos + pUpperAbbrevDayText[i].getLength();
-                res = -(i + 1);                         // negative
+                res = -(i + 1); // negative
                 break;  // for
             }
         }
@@ -692,13 +655,11 @@ int ImpSvNumberInputScan::GetDayOfWeek( const OUString& rString, sal_Int32& nPos
 }
 
 
-//---------------------------------------------------------------------------
-//      GetCurrency
-//
-// Lesen eines Waehrungssysmbols
-// '$'   => true
-// sonst => false
-
+/**
+ * Reading a currency symbol
+ * '$'   => true
+ * else => false
+ */
 bool ImpSvNumberInputScan::GetCurrency( const OUString& rString, sal_Int32& nPos,
                                         const SvNumberformat* pFormat )
 {
@@ -737,20 +698,18 @@ bool ImpSvNumberInputScan::GetCurrency( const OUString& rString, sal_Int32& nPos
 }
 
 
-//---------------------------------------------------------------------------
-//      GetTimeAmPm
-//
-// Lesen des Zeitsymbols (AM od. PM) f. kurze Zeitangabe
-//
-// Rueckgabe:
-//  "AM" od. "PM" => true
-//  sonst         => false
-//
-// nAmPos:
-//  "AM"  =>  1
-//  "PM"  => -1
-//  sonst =>  0
-
+/**
+ * Reading the time period specifier (AM/PM) for the 12 hour clock
+ *
+ *  Returns:
+ *   "AM" or "PM" => true
+ *   else         => false
+ *
+ *  nAmPos:
+ *   "AM"  =>  1
+ *   "PM"  => -1
+ *   else =>  0
+*/
 bool ImpSvNumberInputScan::GetTimeAmPm( const OUString& rString, sal_Int32& nPos )
 {
 
@@ -776,13 +735,11 @@ bool ImpSvNumberInputScan::GetTimeAmPm( const OUString& rString, sal_Int32& nPos
 }
 
 
-//---------------------------------------------------------------------------
-//      GetDecSep
-//
-// Lesen eines Dezimaltrenners (',')
-// ','   => true
-// sonst => false
-
+/**
+ * Read a decimal separator (',')
+ * ','   => true
+ * else => false
+ */
 inline bool ImpSvNumberInputScan::GetDecSep( const OUString& rString, sal_Int32& nPos )
 {
     if ( rString.getLength() > nPos )
@@ -798,9 +755,9 @@ inline bool ImpSvNumberInputScan::GetDecSep( const OUString& rString, sal_Int32&
 }
 
 
-//---------------------------------------------------------------------------
-// read a hundredth seconds separator
-
+/**
+ * Reading a hundredth seconds separator
+ */
 inline bool ImpSvNumberInputScan::GetTime100SecSep( const OUString& rString, sal_Int32& nPos )
 {
     if ( rString.getLength() > nPos )
@@ -816,15 +773,13 @@ inline bool ImpSvNumberInputScan::GetTime100SecSep( const OUString& rString, sal
 }
 
 
-//---------------------------------------------------------------------------
-//      GetSign
-//
-// Lesen eines Vorzeichens, auch Klammer !?!
-// '+'   =>  1
-// '-'   => -1
-// '('   => -1, nNegCheck = 1
-// sonst =>  0
-
+/**
+ * Read a sign including brackets
+ * '+'   =>  1
+ * '-'   => -1
+ *  '('   => -1, nNegCheck = 1
+ * else =>  0
+ */
 int ImpSvNumberInputScan::GetSign( const OUString& rString, sal_Int32& nPos )
 {
     if (rString.getLength() > nPos)
@@ -833,7 +788,7 @@ int ImpSvNumberInputScan::GetSign( const OUString& rString, sal_Int32& nPos )
         case '+':
             nPos++;
             return 1;
-        case '(':               // '(' aehnlich wie '-' ?!?
+        case '(': // '(' similar to '-' ?!?
             nNegCheck = 1;
             //! fallthru
         case '-':
@@ -847,14 +802,12 @@ int ImpSvNumberInputScan::GetSign( const OUString& rString, sal_Int32& nPos )
 }
 
 
-//---------------------------------------------------------------------------
-//      GetESign
-//
-// Lesen eines Vorzeichens, gedacht fuer Exponent ?!?
-// '+'   =>  1
-// '-'   => -1
-// sonst =>  0
-
+/**
+ * Read a sign with an exponent
+ * '+'   =>  1
+ * '-'   => -1
+ * else =>  0
+ */
 short ImpSvNumberInputScan::GetESign( const OUString& rString, sal_Int32& nPos )
 {
     if (rString.getLength() > nPos)
@@ -875,12 +828,10 @@ short ImpSvNumberInputScan::GetESign( const OUString& rString, sal_Int32& nPos )
 }
 
 
-//---------------------------------------------------------------------------
-//      GetNextNumber
-//
-// i counts string portions, j counts numbers thereof.
-// It should had been called SkipNumber instead.
-
+/**
+ * i counts string portions, j counts numbers thereof.
+ * It should had been called SkipNumber instead.
+ */
 inline bool ImpSvNumberInputScan::GetNextNumber( sal_uInt16& i, sal_uInt16& j )
 {
     if ( i < nAnzStrings && IsNum[i] )
@@ -893,12 +844,9 @@ inline bool ImpSvNumberInputScan::GetNextNumber( sal_uInt16& i, sal_uInt16& j )
 }
 
 
-//---------------------------------------------------------------------------
-//      GetTimeRef
-
 bool ImpSvNumberInputScan::GetTimeRef( double& fOutNumber,
-                                       sal_uInt16 nIndex,          // j-value of the first numeric time part of input, default 0
-                                       sal_uInt16 nAnz )           // count of numeric time parts
+                                       sal_uInt16 nIndex, // j-value of the first numeric time part of input, default 0
+                                       sal_uInt16 nAnz )  // count of numeric time parts
 {
     bool bRet = true;
     sal_uInt16 nHour;
@@ -924,7 +872,7 @@ bool ImpSvNumberInputScan::GetTimeRef( double& fOutNumber,
         }
     }
 
-    if (nDecPos == 2 && (nAnz == 3 || nAnz == 2))   // 20:45.5 or 45.5
+    if (nDecPos == 2 && (nAnz == 3 || nAnz == 2)) // 20:45.5 or 45.5
     {
         nHour = 0;
     }
@@ -938,7 +886,7 @@ bool ImpSvNumberInputScan::GetTimeRef( double& fOutNumber,
         bRet = false;
         SAL_WARN( "svl.numbers", "ImpSvNumberInputScan::GetTimeRef: bad number index");
     }
-    if (nDecPos == 2 && nAnz == 2)                  // 45.5
+    if (nDecPos == 2 && nAnz == 2) // 45.5
     {
         nMinute = 0;
     }
@@ -954,15 +902,15 @@ bool ImpSvNumberInputScan::GetTimeRef( double& fOutNumber,
     {
         fSecond100 = StringToDouble( sStrArray[nNums[nIndex]], true );
     }
-    if (nAmPm && nHour > 12)                    // not a valid AM/PM clock time
+    if (nAmPm && nHour > 12) // not a valid AM/PM clock time
     {
         bRet = false;
     }
-    else if (nAmPm == -1 && nHour != 12)        // PM
+    else if (nAmPm == -1 && nHour != 12) // PM
     {
         nHour += 12;
     }
-    else if (nAmPm == 1 && nHour == 12)         // 12 AM
+    else if (nAmPm == 1 && nHour == 12) // 12 AM
     {
         nHour = 0;
     }
@@ -974,9 +922,6 @@ bool ImpSvNumberInputScan::GetTimeRef( double& fOutNumber,
 }
 
 
-//---------------------------------------------------------------------------
-//      ImplGetDay
-
 sal_uInt16 ImpSvNumberInputScan::ImplGetDay( sal_uInt16 nIndex )
 {
     sal_uInt16 nRes = 0;
@@ -994,12 +939,9 @@ sal_uInt16 ImpSvNumberInputScan::ImplGetDay( sal_uInt16 nIndex )
 }
 
 
-//---------------------------------------------------------------------------
-//      ImplGetMonth
-
 sal_uInt16 ImpSvNumberInputScan::ImplGetMonth( sal_uInt16 nIndex )
 {
-    // preset invalid month number
+    // Preset invalid month number
     sal_uInt16 nRes = pFormatter->GetCalendar()->getNumberOfMonthsInYear();
 
     if (sStrArray[nNums[nIndex]].getLength() <= 2)
@@ -1007,7 +949,7 @@ sal_uInt16 ImpSvNumberInputScan::ImplGetMonth( sal_uInt16 nIndex )
         sal_uInt16 nNum = (sal_uInt16) sStrArray[nNums[nIndex]].toInt32();
         if ( 0 < nNum && nNum <= nRes )
         {
-            nRes = nNum - 1;        // zero based for CalendarFieldIndex::MONTH
+            nRes = nNum - 1; // zero based for CalendarFieldIndex::MONTH
         }
     }
 
@@ -1015,11 +957,9 @@ sal_uInt16 ImpSvNumberInputScan::ImplGetMonth( sal_uInt16 nIndex )
 }
 
 
-//---------------------------------------------------------------------------
-//      ImplGetYear
-//
-// 30 -> 1930, 29 -> 2029, oder 56 -> 1756, 55 -> 1855, ...
-
+/**
+ * 30 -> 1930, 29 -> 2029, or 56 -> 1756, 55 -> 1855, ...
+ */
 sal_uInt16 ImpSvNumberInputScan::ImplGetYear( sal_uInt16 nIndex )
 {
     sal_uInt16 nYear = 0;
@@ -1039,7 +979,6 @@ sal_uInt16 ImpSvNumberInputScan::ImplGetYear( sal_uInt16 nIndex )
     return nYear;
 }
 
-//---------------------------------------------------------------------------
 
 bool ImpSvNumberInputScan::MayBeIso8601()
 {
@@ -1065,7 +1004,6 @@ bool ImpSvNumberInputScan::MayBeIso8601()
     return nMayBeIso8601 > 1;
 }
 
-//---------------------------------------------------------------------------
 
 bool ImpSvNumberInputScan::CanForceToIso8601( DateFormat eDateFormat )
 {
@@ -1108,7 +1046,6 @@ bool ImpSvNumberInputScan::CanForceToIso8601( DateFormat eDateFormat )
     return nCanForceToIso8601 > 1;
 }
 
-//---------------------------------------------------------------------------
 
 bool ImpSvNumberInputScan::MayBeMonthDate()
 {
@@ -1155,7 +1092,6 @@ bool ImpSvNumberInputScan::MayBeMonthDate()
     return nMayBeMonthDate > 1;
 }
 
-//---------------------------------------------------------------------------
 
 bool ImpSvNumberInputScan::IsAcceptedDatePattern( sal_uInt16 nStartPatternAt )
 {
@@ -1178,7 +1114,7 @@ bool ImpSvNumberInputScan::IsAcceptedDatePattern( sal_uInt16 nStartPatternAt )
     {
         return false;
     }
-    nDatePatternStart = nStartPatternAt;    // remember start particle
+    nDatePatternStart = nStartPatternAt; // remember start particle
 
     for (sal_Int32 nPattern=0; nPattern < sDateAcceptancePatterns.getLength(); ++nPattern)
     {
@@ -1292,7 +1228,6 @@ bool ImpSvNumberInputScan::IsAcceptedDatePattern( sal_uInt16 nStartPatternAt )
     return false;
 }
 
-//---------------------------------------------------------------------------
 
 bool ImpSvNumberInputScan::SkipDatePatternSeparator( sal_uInt16 nParticle, sal_Int32 & rPos )
 {
@@ -1332,7 +1267,7 @@ bool ImpSvNumberInputScan::SkipDatePatternSeparator( sal_uInt16 nParticle, sal_I
                 }
                 if (bOk)
                 {
-                    rPos = nLen;    // yes, set, not add!
+                    rPos = nLen; // yes, set, not add!
                     return true;
                 }
                 else
@@ -1345,7 +1280,6 @@ bool ImpSvNumberInputScan::SkipDatePatternSeparator( sal_uInt16 nParticle, sal_I
     return false;
 }
 
-//---------------------------------------------------------------------------
 
 sal_uInt16 ImpSvNumberInputScan::GetDatePatternNumbers()
 {
@@ -1357,7 +1291,6 @@ sal_uInt16 ImpSvNumberInputScan::GetDatePatternNumbers()
     return nDatePatternNumbers;
 }
 
-//---------------------------------------------------------------------------
 
 sal_uInt32 ImpSvNumberInputScan::GetDatePatternOrder()
 {
@@ -1382,7 +1315,6 @@ sal_uInt32 ImpSvNumberInputScan::GetDatePatternOrder()
     return nOrder;
 }
 
-//---------------------------------------------------------------------------
 
 DateFormat ImpSvNumberInputScan::GetDateOrder()
 {
@@ -1458,9 +1390,6 @@ DateFormat ImpSvNumberInputScan::GetDateOrder()
     return pFormatter->GetLocaleData()->getDateFormat();
 }
 
-//---------------------------------------------------------------------------
-//      GetDateRef
-
 bool ImpSvNumberInputScan::GetDateRef( double& fDays, sal_uInt16& nCounter,
                                        const SvNumberformat* pFormat )
 {
@@ -1474,7 +1403,7 @@ bool ImpSvNumberInputScan::GetDateRef( double& fDays, sal_uInt16& nCounter,
         {
         case NF_EVALDATEFORMAT_INTL :
         case NF_EVALDATEFORMAT_FORMAT :
-            nFormatOrder = 1;       // only one loop
+            nFormatOrder = 1; // only one loop
             break;
         default:
             nFormatOrder = 2;
@@ -1496,8 +1425,8 @@ bool ImpSvNumberInputScan::GetDateRef( double& fDays, sal_uInt16& nCounter,
     CalendarWrapper* pCal = pFormatter->GetCalendar();
     for ( int nTryOrder = 1; nTryOrder <= nFormatOrder; nTryOrder++ )
     {
-        pCal->setGregorianDateTime( Date( Date::SYSTEM ) );       // today
-        OUString aOrgCalendar;        // empty => not changed yet
+        pCal->setGregorianDateTime( Date( Date::SYSTEM ) ); // today
+        OUString aOrgCalendar; // empty => not changed yet
         DateFormat DateFmt;
         bool bFormatTurn;
         switch ( eEDF )
@@ -1585,10 +1514,10 @@ input for the following reasons:
         // For incomplete dates, always assume first day of month if not specified.
         pCal->setValue( CalendarFieldIndex::DAY_OF_MONTH, 1 );
 
-        switch (nAnzNums)       // count of numbers in string
+        switch (nAnzNums) // count of numbers in string
         {
         case 0:                 // none
-            if (nMonthPos)          // only month (Jan)
+            if (nMonthPos)      // only month (Jan)
             {
                 pCal->setValue( CalendarFieldIndex::MONTH, std::abs(nMonth)-1 );
             }
@@ -1741,7 +1670,7 @@ input for the following reasons:
                 {
                     if ( !bHadExact && nExactDateOrder )
                     {
-                        pCal->setGregorianDateTime( Date( Date::SYSTEM ) );   // reset today
+                        pCal->setGregorianDateTime( Date( Date::SYSTEM ) ); // reset today
                     }
                     switch (DateFmt)
                     {
@@ -1843,7 +1772,7 @@ input for the following reasons:
                         if ( nNums[j] == nTimePos - 2 )
                         {
                             nCounter = j;
-                            break;  // for
+                            break; // for
                         }
                     }
                 }
@@ -1920,7 +1849,7 @@ input for the following reasons:
             double fDiff = DateTime(*pNullDate) - pCal->getEpochStart();
             fDays = ::rtl::math::approxFloor( pCal->getLocalDateTime() );
             fDays -= fDiff;
-            nTryOrder = nFormatOrder;   // break for
+            nTryOrder = nFormatOrder; // break for
         }
         else
         {
@@ -1928,7 +1857,7 @@ input for the following reasons:
         }
         if ( aOrgCalendar.getLength() )
         {
-            pCal->loadCalendar( aOrgCalendar, pLoc->getLanguageTag().getLocale() );  // restore calendar
+            pCal->loadCalendar( aOrgCalendar, pLoc->getLanguageTag().getLocale() ); // restore calendar
         }
 #if NF_TEST_CALENDAR
         {
@@ -1959,7 +1888,7 @@ input for the following reasons:
                 aLocale.Country  = OUString::createFromAscii( p->cou );
                 xCal->loadCalendar( OUString::createFromAscii( p->cal ),
                                     aLocale );
-                double nDateTime = 0.0;     // 1-Jan-1970 00:00:00
+                double nDateTime = 0.0; // 1-Jan-1970 00:00:00
                 nZO           = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET );
                 nZOmillis     = xCal->getValue( i18n::CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS );
                 nZoneInMillis = static_cast<sal_Int32>(nZO) * 60000 +
@@ -2015,13 +1944,11 @@ input for the following reasons:
 }
 
 
-//---------------------------------------------------------------------------
-//      ScanStartString
-//
-// ersten String analysieren
-// Alles weg => true
-// sonst     => false
-
+/**
+ * Analyze first string
+ * All gone => true
+ * else     => false
+ */
 bool ImpSvNumberInputScan::ScanStartString( const OUString& rString,
                                             const SvNumberformat* pFormat )
 {
@@ -2115,7 +2042,7 @@ bool ImpSvNumberInputScan::ScanStartString( const OUString& rString,
                     nMonth = GetMonth(rString, nPos);
                     if ( nMonth ) // month (Jan 1)?
                     {
-                        nMonthPos = 1;                  // month a the beginning
+                        nMonthPos = 1; // month a the beginning
                         if ( nMonth < 0 )
                         {
                             SkipChar( '.', rString, nPos ); // abbreviated
@@ -2138,7 +2065,7 @@ bool ImpSvNumberInputScan::ScanStartString( const OUString& rString,
         while (SkipChar ('-', rString, nPos) || SkipChar ('/', rString, nPos))
             ; // do nothing
     }
-    if (nPos < rString.getLength())                       // not everything consumed
+    if (nPos < rString.getLength()) // not everything consumed
     {
         // Does input StartString equal StartString of format?
         // This time with sign detection!
@@ -2152,13 +2079,11 @@ bool ImpSvNumberInputScan::ScanStartString( const OUString& rString,
 }
 
 
-//---------------------------------------------------------------------------
-//      ScanMidString
-//
-// String in der Mitte analysieren
-// Alles weg => true
-// sonst     => false
-
+/**
+ * Analyze string in the middle
+ * All gone => true
+ * else     => false
+ */
 bool ImpSvNumberInputScan::ScanMidString( const OUString& rString,
                                           sal_uInt16 nStringPos, const SvNumberformat* pFormat )
 {
@@ -2188,7 +2113,7 @@ bool ImpSvNumberInputScan::ScanMidString( const OUString& rString,
         }
         else if (nDecPos == 2)                      // . dup: 12.4.
         {
-            if (bDecSepInDateSeps ||                   // . also date separator
+            if (bDecSepInDateSeps ||                // . also date separator
                 SkipDatePatternSeparator( nStringPos, nPos))
             {
                 if ( eScannedType != NUMBERFORMAT_UNDEFINED &&
@@ -2199,7 +2124,7 @@ bool ImpSvNumberInputScan::ScanMidString( const OUString& rString,
                 }
                 if (eScannedType == NUMBERFORMAT_UNDEFINED)
                 {
-                    eScannedType = NUMBERFORMAT_DATE;   // !!! it IS a date
+                    eScannedType = NUMBERFORMAT_DATE; // !!! it IS a date
                 }
                 SkipBlanks(rString, nPos);
             }
@@ -2449,7 +2374,7 @@ bool ImpSvNumberInputScan::ScanMidString( const OUString& rString,
         }
     }
 
-    if (nPos < rString.getLength())                       // not everything consumed?
+    if (nPos < rString.getLength()) // not everything consumed?
     {
         if ( nMatchedAllStrings & ~nMatchedVirgin )
         {
@@ -2465,13 +2390,11 @@ bool ImpSvNumberInputScan::ScanMidString( const OUString& rString,
 }
 
 
-//---------------------------------------------------------------------------
-//      ScanEndString
-//
-// Schlussteil analysieren
-// Alles weg => true
-// sonst     => false
-
+/**
+ * Analyze the end
+ * All gone => true
+ * else     => false
+ */
 bool ImpSvNumberInputScan::ScanEndString( const OUString& rString,
                                           const SvNumberformat* pFormat )
 {
@@ -2694,7 +2617,7 @@ bool ImpSvNumberInputScan::ScanEndString( const OUString& rString,
             // seconds and 78 hundredths in the morning. Keep as suffix.
             if (eScannedType != NUMBERFORMAT_TIME && nDecPos == 2 && nAnzNums == 2)
             {
-                nPos = nOrigPos;     // rewind am/pm
+                nPos = nOrigPos; // rewind am/pm
             }
             else
             {
@@ -2762,7 +2685,7 @@ bool ImpSvNumberInputScan::ScanEndString( const OUString& rString,
     }
 #endif
 
-    if (nPos < rString.getLength())                       // everything consumed?
+    if (nPos < rString.getLength()) // everything consumed?
     {
         // does input EndString equal EndString in Format?
         if ( !ScanStringNumFor( rString, nPos, pFormat, 0xFFFF ) )
@@ -2775,11 +2698,11 @@ bool ImpSvNumberInputScan::ScanEndString( const OUString& rString,
 }
 
 
-bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString,          // String to scan
+bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString,       // String to scan
                                              sal_Int32 nPos,                // Position until which was consumed
-                                             const SvNumberformat* pFormat,  // The format to match
-                                             sal_uInt16 nString,                 // Substring of format, 0xFFFF => last
-                                             bool bDontDetectNegation)        // Suppress sign detection
+                                             const SvNumberformat* pFormat, // The format to match
+                                             sal_uInt16 nString,            // Substring of format, 0xFFFF => last
+                                             bool bDontDetectNegation)      // Suppress sign detection
 {
     if ( !pFormat )
     {
@@ -2837,7 +2760,7 @@ bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString,          /
             {
                 bFound = true;
                 nStringScanSign = -1;
-                nSub = 0;       //! not 1
+                nSub = 0; //! not 1
             }
         }
         if ( !bFound )
@@ -2853,7 +2776,7 @@ bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString,          /
         {
             if ( (nSign < 0) && (nStringScanNumFor != 1) )
             {
-                nStringScanSign = 1;        // triple negated --1 yyy
+                nStringScanSign = 1; // triple negated --1 yyy
             }
         }
         else if ( nStringScanSign == 0 )
@@ -2864,11 +2787,11 @@ bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString,          /
                 if ( (nString == 0) && !bFirst &&
                      SvNumberformat::HasStringNegativeSign( aString ) )
                 {
-                    nStringScanSign = -1;   // direct double negation
+                    nStringScanSign = -1; // direct double negation
                 }
                 else if ( pFormat->IsNegativeWithoutSign() )
                 {
-                    nStringScanSign = -1;   // indirect double negation
+                    nStringScanSign = -1; // indirect double negation
                 }
             }
             else
@@ -2886,22 +2809,20 @@ bool ImpSvNumberInputScan::ScanStringNumFor( const OUString& rString,          /
 }
 
 
-//---------------------------------------------------------------------------
-//      IsNumberFormatMain
-//
-// Recognizes types of number, exponential, fraction, percent, currency, date, time.
-// Else text => return false
-
-bool ImpSvNumberInputScan::IsNumberFormatMain( const OUString& rString,                  // string to be analyzed
-                                               const SvNumberformat* pFormat )         // maybe number format set to match against
+/**
+ * Recognizes types of number, exponential, fraction, percent, currency, date, time.
+ * Else text => return false
+ */
+bool ImpSvNumberInputScan::IsNumberFormatMain( const OUString& rString,        // string to be analyzed
+                                               const SvNumberformat* pFormat ) // maybe number format set to match against
 {
     Reset();
-    NumberStringDivision( rString );            // breakdown into strings and numbers
+    NumberStringDivision( rString );             // breakdown into strings and numbers
     if (nAnzStrings >= SV_MAX_ANZ_INPUT_STRINGS) // too many elements
     {
-        return false;                           // Njet, Nope, ...
+        return false;                            // Njet, Nope, ...
     }
-    if (nAnzNums == 0)                          // no number in input
+    if (nAnzNums == 0)                           // no number in input
     {
         if ( nAnzStrings > 0 )
         {
@@ -2927,18 +2848,18 @@ bool ImpSvNumberInputScan::IsNumberFormatMain( const OUString& rString,
         }
     }
 
-    sal_uInt16 i = 0;                               // mark any symbol
-    sal_uInt16 j = 0;                               // mark only numbers
+    sal_uInt16 i = 0;                           // mark any symbol
+    sal_uInt16 j = 0;                           // mark only numbers
 
     switch ( nAnzNums )
     {
     case 1 :                                // Exactly 1 number in input
         // nAnzStrings >= 1
-        if (GetNextNumber(i,j))             // i=1,0
-        {                                   // Number at start
+        if (GetNextNumber(i,j)) // i=1,0
+        {   // Number at start
             if (eSetType == NUMBERFORMAT_FRACTION)  // Fraction 1 = 1/1
             {
-                if (i >= nAnzStrings ||     // no end string nor decimal separator
+                if (i >= nAnzStrings || // no end string nor decimal separator
                     sStrArray[i] == pFormatter->GetNumDecimalSep())
                 {
                     eScannedType = NUMBERFORMAT_FRACTION;
@@ -3188,14 +3109,15 @@ bool ImpSvNumberInputScan::IsNumberFormatMain( const OUString& rString,
     }
     else
     {
-        nMatchedAllStrings = 0;  // reset flag to no substrings matched
+        nMatchedAllStrings = 0; // reset flag to no substrings matched
     }
     return true;
 }
 
 
-//---------------------------------------------------------------------------
-// return true or false depending on the nMatched... state and remember usage
+/**
+ * Return true or false depending on the nMatched... state and remember usage
+ */
 bool ImpSvNumberInputScan::MatchedReturn()
 {
     if ( nMatchedAllStrings & ~nMatchedVirgin )
@@ -3207,9 +3129,9 @@ bool ImpSvNumberInputScan::MatchedReturn()
 }
 
 
-//---------------------------------------------------------------------------
-// Initialize uppercase months and weekdays
-
+/**
+ * Initialize uppercase months and weekdays
+ */
 void ImpSvNumberInputScan::InitText()
 {
     sal_Int32 j, nElems;
@@ -3283,14 +3205,9 @@ void ImpSvNumberInputScan::InitText()
 }
 
 
-//===========================================================================
-//          P U B L I C
-
-//---------------------------------------------------------------------------
-//      ChangeIntl
-//
-// MUST be called if International/Locale is changed
-
+/**
+ * MUST be called if International/Locale is changed
+ */
 void ImpSvNumberInputScan::ChangeIntl()
 {
     sal_Unicode cDecSep = pFormatter->GetNumDecimalSep()[0];
@@ -3311,9 +3228,6 @@ void ImpSvNumberInputScan::InvalidateDateAcceptancePatterns()
 }
 
 
-//---------------------------------------------------------------------------
-//      ChangeNullDate
-
 void ImpSvNumberInputScan::ChangeNullDate( const sal_uInt16 Day,
                                            const sal_uInt16 Month,
                                            const sal_uInt16 Year )
@@ -3329,26 +3243,24 @@ void ImpSvNumberInputScan::ChangeNullDate( const sal_uInt16 Day,
 }
 
 
-//---------------------------------------------------------------------------
-//      IsNumberFormat
-//
-// => does rString represent a number (also date, time et al)
-
-bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString,                  // string to be analyzed
-                                           short& F_Type,                          // IN: old type, OUT: new type
-                                           double& fOutNumber,                     // OUT: number if convertible
-                                           const SvNumberformat* pFormat )         // maybe a number format to match against
+/**
+ * Does rString represent a number (also date, time et al)
+ */
+bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString,         // string to be analyzed
+                                           short& F_Type,                   // IN: old type, OUT: new type
+                                           double& fOutNumber,              // OUT: number if convertible
+                                           const SvNumberformat* pFormat )  // maybe a number format to match against
 {
     OUString aString;
-    bool res;                                   // return value
+    bool res; // return value
     sal_uInt16 k;
-    eSetType = F_Type;                          // old type set
+    eSetType = F_Type; // old type set
 
     if ( !rString.getLength() )
     {
         res = false;
     }
-    else if (rString.getLength() > 308)               // arbitrary
+    else if (rString.getLength() > 308) // arbitrary
     {
         res = false;
     }
@@ -3534,7 +3446,7 @@ bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString,
     OUStringBuffer sResString;
 
     if (res)
-    {                                           // we finally have a number
+    {                                       // we finally have a number
         switch (eScannedType)
         {
         case NUMBERFORMAT_LOGICAL:
@@ -3557,7 +3469,7 @@ bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString,
         case NUMBERFORMAT_NUMBER:
         case NUMBERFORMAT_SCIENTIFIC:
         case NUMBERFORMAT_DEFINED:          // if no category detected handle as number
-            if ( nDecPos == 1 )                         // . at start
+            if ( nDecPos == 1 )             // . at start
             {
                 sResString.append("0.");
             }
@@ -3638,7 +3550,7 @@ bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString,
                 if (nThousand == 1)
                 {
                     sResString = sStrArray[nNums[0]];
-                    sResString.append(sStrArray[nNums[1]]);  // integer part
+                    sResString.append(sStrArray[nNums[1]]); // integer part
                     fOutNumber = StringToDouble(sResString.makeStringAndClear());
                 }
                 else
@@ -3655,7 +3567,7 @@ bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString,
                     }
                 }
             }
-            else                                        // nAnzNums > 2
+            else // nAnzNums > 2
             {
                 k = 1;
                 sResString = sStrArray[nNums[0]];
@@ -3729,7 +3641,7 @@ bool ImpSvNumberInputScan::IsNumberFormat( const OUString& rString,
         }
     }
 
-    if (res)        // overflow/underflow -> Text
+    if (res) // overflow/underflow -> Text
     {
         if (fOutNumber < -DBL_MAX) // -1.7E308
         {