Merge pull request scala#6746 from som-snytt/review/6726-more

Accept .5 for half

Author: SethTisue

src/library/scala/collection/StringParsers.scala

@@ -16,7 +16,6 @@ final private[scala] object StringParsers {
   private final val longOverflowBoundary = -922337203685477580L
   private final val longOverflowDigit = 9
 
-  
   @inline
   private[this] final def decValue(ch: Char): Int = java.lang.Character.digit(ch, 10)
 
@@ -38,6 +37,9 @@ final private[scala] object StringParsers {
     rec(1, agg)
   }
 
+  @inline
+  private[this] final def isDigit(c: Char): Boolean = c >= '0' && c <= '9'
+
   //bool
   @inline
   final def parseBool(from: String): Option[Boolean] =
@@ -164,11 +166,7 @@ final private[scala] object StringParsers {
     //some utilities for working with index bounds into the original string
     @inline
     def forAllBetween(start: Int, end: Int, pred: Char => Boolean): Boolean = {
-      def rec(i: Int): Boolean = {
-        if (i >= end) true
-        else if (pred(format.charAt(i))) rec(i + 1)
-        else false
-      }
+      def rec(i: Int): Boolean = i >= end || pred(format.charAt(i)) && rec(i + 1)
       rec(start)
     }
 
@@ -209,11 +207,11 @@ final private[scala] object StringParsers {
 
       def postfixOK(startIndex: Int, endIndex: Int): Boolean =
         (startIndex < endIndex) && {
-          (forAllBetween(startIndex, endIndex, ch => ch >= '0' && ch <= '9')) || {
+          (forAllBetween(startIndex, endIndex, isDigit)) || {
             val startchar = format.charAt(startIndex)
             (startchar == '+' || startchar == '-') &&
             (endIndex - startIndex > 1) &&
-            forAllBetween(startIndex + 1, endIndex, ch => ch >= '0' && ch <= '9')
+            forAllBetween(startIndex + 1, endIndex, isDigit)
           }
         }
       // prefix [pP] postfix
@@ -224,13 +222,15 @@ final private[scala] object StringParsers {
     def isDecFloatLiteral(startIndex: Int, endIndex: Int): Boolean = {
       //invariant: endIndex > startIndex
 
+      def isExp(c: Char): Boolean = c == 'e' || c == 'E'
+
       def expOK(startIndex: Int, endIndex: Int): Boolean =
         (startIndex < endIndex) && {
           val startChar = format.charAt(startIndex)
           if (startChar == '+' || startChar == '-')
             (endIndex > (startIndex + 1)) &&
-            skipIndexWhile(ch => ch >= '0' && ch <= '9', startIndex + 1, endIndex) == endIndex
-          else skipIndexWhile(ch => ch >= '0' && ch <= '9', startIndex, endIndex) == endIndex
+            skipIndexWhile(isDigit, startIndex + 1, endIndex) == endIndex
+          else skipIndexWhile(isDigit, startIndex, endIndex) == endIndex
         }
 
       //significant can be one of
@@ -240,30 +240,26 @@ final private[scala] object StringParsers {
       //but not just .
       val startChar = format.charAt(startIndex)
       if (startChar == '.') {
-        val noSignificant = skipIndexWhile(ch => ch >= '0' && ch <= '9', startIndex + 1, endIndex)
-        (noSignificant != startIndex + 1) &&  { //not just "." or ".Exxx"
-          val e = format.charAt(noSignificant)
-          (e == 'e' || e == 'E') && expOK(noSignificant + 1, endIndex)
-        }
+        val noSignificant = skipIndexWhile(isDigit, startIndex + 1, endIndex)
+        // a digit is required followed by optional exp
+        (noSignificant > startIndex + 1) && (noSignificant >= endIndex ||
+          isExp(format.charAt(noSignificant)) && expOK(noSignificant + 1, endIndex)
+        )
       }
-      else if (startChar >= '0' && startChar <= '9'){
-         //one set of digits, then optionally a period, then optionally another set of digits, then optionally an exponent
-        val noInt = skipIndexWhile(ch => ch >= '0' && ch <= '9', startIndex, endIndex)
-        (noInt == endIndex) || { //just the digits
-          val afterIntChar = format.charAt(noInt)
-          if (afterIntChar == '.') {
-            val noSignificant = skipIndexWhile(ch => ch >= '0' && ch <= '9', noInt + 1, endIndex)
-            (noSignificant >= endIndex) || { //no exponent
-              val e = format.charAt(noSignificant)
-              (e == 'e' || e == 'E') && expOK(noSignificant + 1, endIndex)
-            }
-          }
-          else if (afterIntChar == 'e' || afterIntChar == 'E') expOK(noInt + 1, endIndex)
-          else false
+      else if (isDigit(startChar)) {
+        // one set of digits, then optionally a period, then optionally another set of digits, then optionally an exponent
+        val noInt = skipIndexWhile(isDigit, startIndex, endIndex)
+        // just the digits
+        (noInt == endIndex) || {
+          if (format.charAt(noInt) == '.') {
+            val noSignificant = skipIndexWhile(isDigit, noInt + 1, endIndex)
+            (noSignificant >= endIndex) || //no exponent
+              isExp(format.charAt(noSignificant)) && expOK(noSignificant + 1, endIndex)
+          } else
+              isExp(format.charAt(noInt)) && expOK(noInt + 1, endIndex)
         }
       }
       else false
- 
     }
 
     //count 0x00 to 0x20 as "whitespace", and nothing else
@@ -307,4 +303,4 @@ final private[scala] object StringParsers {
     if (checkFloatFormat(from)) Some(java.lang.Double.parseDouble(from))
     else None
 
-}
+}

test/junit/scala/collection/StringParsersTest.scala

@@ -13,7 +13,7 @@ class StringParsersTest {
   def doubleOK(str: String): Unit = assertTrue(
     s"str.toDouble <> str.toDoubleOption for $str",
     (str.toDoubleOption, Try(str.toDouble).toOption) match {
-      case (Some(d1), Some(d2)) if d1.isNaN && d2.isNaN => true
+      case (Some(d1), Some(d2)) => d1.isNaN && d2.isNaN || d1 == d2
       case (o1, o2) => o1 == o2
     })
 
@@ -242,10 +242,16 @@ class StringParsersTest {
     "-0x0.000000000000090000000000000000001p-1022",
     "-0x0.00000000000009fffffffffffffffffffffffffffffffffp-1022",
     "-0x0.0000000000000fffffffffffffffffffffffffffffffffffp-1022",
+    "",
+    ".",
+    ".4",
     ".E4",
+    ".E",
+    ".x",
+    ".1E4",
+    "4.",
     "1.1E4",
     "1.E4",
-    ".1E4",
     "1E4",
     "E4",
     "0.0",
@@ -307,4 +313,4 @@ class StringParsersTest {
   @Test
   def nullDouble: Unit = assertThrows[NullPointerException](nullstring.toDoubleOption)
 
-}
+}