typos and nitpicks

Change-Id: I596e9f0941dbc9d2106767c19569e9771c42b076

i18npool/source/search/levdis.cxx

@@ -103,12 +103,12 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
         npDistance = aDisMem.NewMem( nArrayLen );
     }
 
-    // calculate start values of the second column(first Pattern-value)
-    // first column (0-Len Pattern) is always zero .. nStringLen * nInsQ0,
+    // Calculate start values of the second column (first pattern value).
+    // First column (0-Len pattern) is always zero .. nStringLen * nInsQ0,
     // therefore the minimum is 0
     if ( nPatternLen == 0 )
     {
-        // Count of deletions, to determine the Pattern
+        // Count of deletions to reach pattern
         for ( sal_Int32 i=0; i <= nStringLen; i++ )
             npDistance[i] = i * nDelR0;
     }
@@ -126,7 +126,7 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
         if ( c == '?' && bpPatIsWild[0] )
             nP = 0;     // a '?' could be any character.
         else
-            // Minimum replace and delete +insert  weighting
+            // Minimum of replacement and deletion+insertion weighting
             nP = Min3( nRepP0, nRepP0, nDelR0 + nInsQ0 );
         npDistance[0] = nInsQ0;     // start with simple insert
         npDistance[1] = nInsQ0;
@@ -136,22 +136,22 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
         for ( sal_Int32 i=1; i <= nStringLen; i++, nDelCnt += nDelR0 )
         {
             if ( cString[i-1] == c )
-                nP = 0;     // Replace from this position with 0
-            // Deletion to determine the Pattern + Replace
+                nP = 0;     // Replace from this position is 0
+            // Deletions to match pattern + Replace
             npDistance[i] = nDelCnt + nP;
             if ( bSplitCount )
             {
                 if ( nReplacePos < 0 && nP )
-                {   // this Position will be replaced
+                {   // this position will be replaced
                     nRepS++;
                     nReplacePos = i;
                 }
                 else if ( nReplacePos > 0 && !nP )
                 {
-                   // same count  c
+                    // same count of c
                     int nBalance = levdisbalance( 0, i-1, c, cString, nStringLen );
                     if ( !nBalance )
-                    {   // an insert was replaced
+                    {   // one was replaced that was an insertion instead
                         nRepS--;
                         nReplacePos = 0;
                     }
@@ -162,7 +162,7 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
     }
 
     // calculate distance matrix
-    sal_Int32 j = 0;        //for all columns of the pattern, till limit is not reached
+    sal_Int32 j = 0;        // for all columns of the pattern, till limit is not reached
     while ( (j < nPatternLen-1)
             && nSPMin <= (bSplitCount ? 2 * nLimit : nLimit) )
     {
@@ -177,20 +177,20 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
             nP = nRepP0;
         if ( c == '*' && bpPatIsWild[j] )
         {
-            nQ = 0;     // instertion/deletion without penalty
+            nQ = 0;     // instertion and deletion without penalty
             nR = 0;
         }
         else
         {
-            nQ = nInsQ0;    //usual weighting
+            nQ = nInsQ0;    // usual weighting
             nR = nDelR0;
         }
         d2 = npDistance[0];
-        // increase insert count to get from null sting to pattern
+        // increase insert count to get from null string to pattern
         npDistance[0] = npDistance[0] + nQ;
         nSPMin = npDistance[0];
-        int nReplacePos = -1;       // tristate Flag
-        // for each pattern column run though the string
+        int nReplacePos = -1;       // tristate flag
+        // for each pattern column run through the string
         for ( sal_Int32 i=1; i <= nStringLen; i++ )
         {
             int d1 = d2;            // WLD( X(i-1), Y(j-1) )
@@ -200,7 +200,7 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
                 nPij = 0;           // p(i,j)
                 if ( nReplacePos < 0 )
                 {
-                    // same quantity c
+                    // same count of c
                     int nBalance = levdisbalance( j, i-1, c, cString, nStringLen );
                     if ( !nBalance )
                         nReplacePos = 0;    // no replacement
@@ -217,7 +217,7 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
             if ( bSplitCount )
             {
                 if ( nReplacePos < 0 && nPij && npDistance[i] == d1 + nPij )
-                {   // this poition will be replaced
+                {   // this position will be replaced
                     nRepS++;
                     nReplacePos = i;
                 }
@@ -225,18 +225,20 @@ int WLevDistance::WLD( const sal_Unicode* cString, sal_Int32 nStringLen )
                 {
                     // character is equal in string and pattern
                     //
-                    //If from this point:
-                    //* pattern and string have the same count of this character
-                    //* and character count is the same before this position
-                    //the replace was none.
-                    //
-                    //Scrambled letters are recognized and the replace is withdrawed.
-                    //Whereby the double limit comes to fuition.
+                    // If from this point:
+                    // * pattern and string have the same count of this
+                    //   character
+                    // * and character count is the same before this position
+                    // then the replace was none.
                     //
-                    //Same quantity c
+                    // Scrambled letters are recognized here and the nRepS
+                    // replacement is withdrawn, whereby the double limit kicks
+                    // in.
+
+                    // Same count of c
                     int nBalance = levdisbalance( j, i-1, c, cString, nStringLen );
                     if ( !nBalance )
-                    {   // insert was replaced
+                    {   // one was replaced that was an insertion instead
                         nRepS--;
                         nReplacePos = 0;
                     }