fix of overflow detection for numeric primitive types

plokhotnyuk · plokhotnyuk · commit 518e1b7ade3e · 2017-10-23T10:33:29.000+02:00
diff --git a/src/main/java/com/jsoniter/IterImpl.java b/src/main/java/com/jsoniter/IterImpl.java
@@ -323,123 +323,136 @@ public static int updateStringCopyBound(final JsonIterator iter, final int bound
         return bound;
     }
 
-    static final int readPositiveInt(final JsonIterator iter, byte c) throws IOException {
+    static final int readInt(final JsonIterator iter, final byte c, final boolean negative) throws IOException {
         int ind = IterImplNumber.intDigits[c];
         if (ind == 0) {
             IterImplForStreaming.assertNotLeadingZero(iter);
             return 0;
         }
         if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
-            throw iter.reportError("readPositiveInt", "expect 0~9");
+            throw iter.reportError("readInt", "expect 0~9");
         }
         if (iter.tail - iter.head > 9) {
             int i = iter.head;
             int ind2 = IterImplNumber.intDigits[iter.buf[i]];
             if (ind2 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind;
+                return negative ? -ind : ind;
             }
             int ind3 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind3 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 10 + ind2;
+                ind = ind * 10 + ind2;
+                return negative ? -ind : ind;
             }
             int ind4 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind4 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 100 + ind2 * 10 + ind3;
+                ind = ind * 100 + ind2 * 10 + ind3;
+                return negative ? -ind : ind;
             }
             int ind5 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind5 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 1000 + ind2 * 100 + ind3 * 10 + ind4;
+                ind = ind * 1000 + ind2 * 100 + ind3 * 10 + ind4;
+                return negative ? -ind : ind;
             }
             int ind6 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind6 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 10000 + ind2 * 1000 + ind3 * 100 + ind4 * 10 + ind5;
+                ind = ind * 10000 + ind2 * 1000 + ind3 * 100 + ind4 * 10 + ind5;
+                return negative ? -ind : ind;
             }
             int ind7 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind7 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 100000 + ind2 * 10000 + ind3 * 1000 + ind4 * 100 + ind5 * 10 + ind6;
+                ind = ind * 100000 + ind2 * 10000 + ind3 * 1000 + ind4 * 100 + ind5 * 10 + ind6;
+                return negative ? -ind : ind;
             }
             int ind8 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind8 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 1000000 + ind2 * 100000 + ind3 * 10000 + ind4 * 1000 + ind5 * 100 + ind6 * 10 + ind7;
+                ind = ind * 1000000 + ind2 * 100000 + ind3 * 10000 + ind4 * 1000 + ind5 * 100 + ind6 * 10 + ind7;
+                return negative ? -ind : ind;
             }
             int ind9 = IterImplNumber.intDigits[iter.buf[++i]];
             ind = ind * 10000000 + ind2 * 1000000 + ind3 * 100000 + ind4 * 10000 + ind5 * 1000 + ind6 * 100 + ind7 * 10 + ind8;
             iter.head = i;
             if (ind9 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
-                return ind;
+                return negative ? -ind : ind;
             }
         }
-        return IterImplForStreaming.readIntSlowPath(iter, ind);
+        return IterImplForStreaming.readIntSlowPath(iter, ind, negative);
     }
 
-    static final long readPositiveLong(final JsonIterator iter, byte c) throws IOException {
+    static final long readLong(final JsonIterator iter, final byte c, final boolean negative) throws IOException {
         long ind = IterImplNumber.intDigits[c];
         if (ind == 0) {
             IterImplForStreaming.assertNotLeadingZero(iter);
             return 0;
         }
         if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
-            throw iter.reportError("readPositiveLong", "expect 0~9");
+            throw iter.reportError("readLong", "expect 0~9");
         }
         if (iter.tail - iter.head > 9) {
             int i = iter.head;
             int ind2 = IterImplNumber.intDigits[iter.buf[i]];
             if (ind2 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind;
+                return negative ? -ind : ind;
             }
             int ind3 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind3 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 10 + ind2;
+                ind = ind * 10 + ind2;
+                return negative ? -ind : ind;
             }
             int ind4 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind4 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 100 + ind2 * 10 + ind3;
+                ind = ind * 100 + ind2 * 10 + ind3;
+                return negative ? -ind : ind;
             }
             int ind5 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind5 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 1000 + ind2 * 100 + ind3 * 10 + ind4;
+                ind = ind * 1000 + ind2 * 100 + ind3 * 10 + ind4;
+                return negative ? -ind : ind;
             }
             int ind6 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind6 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 10000 + ind2 * 1000 + ind3 * 100 + ind4 * 10 + ind5;
+                ind = ind * 10000 + ind2 * 1000 + ind3 * 100 + ind4 * 10 + ind5;
+                return negative ? -ind : ind;
             }
             int ind7 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind7 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 100000 + ind2 * 10000 + ind3 * 1000 + ind4 * 100 + ind5 * 10 + ind6;
+                ind = ind * 100000 + ind2 * 10000 + ind3 * 1000 + ind4 * 100 + ind5 * 10 + ind6;
+                return negative ? -ind : ind;
             }
             int ind8 = IterImplNumber.intDigits[iter.buf[++i]];
             if (ind8 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 iter.head = i;
-                return ind * 1000000 + ind2 * 100000 + ind3 * 10000 + ind4 * 1000 + ind5 * 100 + ind6 * 10 + ind7;
+                ind = ind * 1000000 + ind2 * 100000 + ind3 * 10000 + ind4 * 1000 + ind5 * 100 + ind6 * 10 + ind7;
+                return negative ? -ind : ind;
             }
             int ind9 = IterImplNumber.intDigits[iter.buf[++i]];
             ind = ind * 10000000 + ind2 * 1000000 + ind3 * 100000 + ind4 * 10000 + ind5 * 1000 + ind6 * 100 + ind7 * 10 + ind8;
             iter.head = i;
             if (ind9 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
-                return ind;
+                return negative ? -ind : ind;
             }
         }
-        return IterImplForStreaming.readLongSlowPath(iter, ind);
+        return IterImplForStreaming.readLongSlowPath(iter, ind, negative);
     }
 
-    static final double readPositiveDouble(final JsonIterator iter) throws IOException {
+    static final double readDouble(final JsonIterator iter, final boolean negative) throws IOException {
         int oldHead = iter.head;
         try {
             try {
-                long value = IterImplNumber.readLong(iter); // without the dot
+                long value = IterImplNumber.readLong(iter); // without the dot & sign
+                value = negative ? -value : value;
                 if (iter.head == iter.tail) {
                     return value;
                 }
@@ -448,27 +461,29 @@ static final double readPositiveDouble(final JsonIterator iter) throws IOExcepti
                     iter.head++;
                     int start = iter.head;
                     c = iter.buf[iter.head++];
-                    long decimalPart = readPositiveLong(iter, c);
+                    long decimalPart = readLong(iter, c, negative);
                     int decimalPlaces = iter.head - start;
                     if (decimalPlaces > 0 && decimalPlaces < IterImplNumber.POW10.length && (iter.head - oldHead) < 10) {
-                        value = value * IterImplNumber.POW10[decimalPlaces] + decimalPart;
-                        return value / (double) IterImplNumber.POW10[decimalPlaces];
+                        return value + (decimalPart / (double) IterImplNumber.POW10[decimalPlaces]);
                     } else {
                         iter.head = oldHead;
-                        return IterImplForStreaming.readDoubleSlowPath(iter);
+                        double result = IterImplForStreaming.readDoubleSlowPath(iter);
+                        return negative ? -result : result;
                     }
                 } else {
                     return value;
                 }
             } finally {
                 if (iter.head < iter.tail && (iter.buf[iter.head] == 'e' || iter.buf[iter.head] == 'E')) {
                     iter.head = oldHead;
-                    return IterImplForStreaming.readDoubleSlowPath(iter);
+                    double result = IterImplForStreaming.readDoubleSlowPath(iter);
+                    return negative ? -result : result;
                 }
             }
         } catch (JsonException e) {
             iter.head = oldHead;
-            return IterImplForStreaming.readDoubleSlowPath(iter);
+            double result = IterImplForStreaming.readDoubleSlowPath(iter);
+            return negative ? -result : result;
         }
     }
 }
diff --git a/src/main/java/com/jsoniter/IterImplForStreaming.java b/src/main/java/com/jsoniter/IterImplForStreaming.java
@@ -487,48 +487,56 @@ public final static int readStringSlowPath(JsonIterator iter, int j) throws IOEx
         }
     }
 
-    static long readLongSlowPath(JsonIterator iter, long value) throws IOException {
+    static long readLongSlowPath(final JsonIterator iter, long value, final boolean negative) throws IOException {
+        value = -value; // add negatives to avoid redundant checks for Long.MIN_VALUE on each iteration
+        long limit = negative ? Long.MIN_VALUE : -Long.MAX_VALUE;
+        long multmin = -922337203685477580L; // limit / 10
         for (; ; ) {
             for (int i = iter.head; i < iter.tail; i++) {
                 int ind = IterImplNumber.intDigits[iter.buf[i]];
                 if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                     iter.head = i;
-                    return value;
+                    return negative ? value : -value;
                 }
-                if (value == Long.MIN_VALUE) {
-                    throw iter.reportError("readLongSlowPath", "value is too large for long");
+                if (value < multmin) {
+                    throw iter.reportError("readIntSlowPath", "value is too large for int");
                 }
-                value = (value << 3) + (value << 1) + ind;
-                if (value < 0 && value != Long.MIN_VALUE) {
+                value = (value << 3) + (value << 1);
+                if (value < limit + ind) {
                     throw iter.reportError("readLongSlowPath", "value is too large for long");
                 }
+                value -= ind;
             }
             if (!IterImpl.loadMore(iter)) {
                 iter.head = iter.tail;
-                return value;
+                return negative ? value : -value;
             }
         }
     }
 
-    static int readIntSlowPath(JsonIterator iter, int value) throws IOException {
+    static int readIntSlowPath(final JsonIterator iter, int value, final boolean negative) throws IOException {
+        value = -value; // add negatives to avoid redundant checks for Integer.MIN_VALUE on each iteration
+        int limit = negative ? Integer.MIN_VALUE : -Integer.MAX_VALUE;
+        int multmin = -214748364; // limit / 10
         for (; ; ) {
             for (int i = iter.head; i < iter.tail; i++) {
                 int ind = IterImplNumber.intDigits[iter.buf[i]];
                 if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                     iter.head = i;
-                    return value;
+                    return negative ? value : -value;
                 }
-                if (value == Integer.MIN_VALUE) {
+                if (value < multmin) {
                     throw iter.reportError("readIntSlowPath", "value is too large for int");
                 }
-                value = (value << 3) + (value << 1) + ind;
-                if (value < 0 && value != Integer.MIN_VALUE) {
+                value = (value << 3) + (value << 1);
+                if (value < limit + ind) {
                     throw iter.reportError("readIntSlowPath", "value is too large for int");
                 }
+                value -= ind;
             }
             if (!IterImpl.loadMore(iter)) {
                 iter.head = iter.tail;
-                return value;
+                return negative ? value : -value;
             }
         }
     }
@@ -582,34 +590,33 @@ public static final String readNumber(final JsonIterator iter) throws IOExceptio
         }
     }
 
-
-    static final double readPositiveDouble(final JsonIterator iter) throws IOException {
-        return readDoubleSlowPath(iter);
+    static final double readDouble(final JsonIterator iter, final boolean negative) throws IOException {
+        double result = readDoubleSlowPath(iter);
+        return negative ? -result  : result;
     }
 
-
-    static final long readPositiveLong(final JsonIterator iter, byte c) throws IOException {
+    static final long readLong(final JsonIterator iter, final byte c, final boolean negative) throws IOException {
         long ind = IterImplNumber.intDigits[c];
         if (ind == 0) {
             assertNotLeadingZero(iter);
             return 0;
         }
         if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
-            throw iter.reportError("readPositiveLong", "expect 0~9");
+            throw iter.reportError("readLong", "expect 0~9");
         }
-        return IterImplForStreaming.readLongSlowPath(iter, ind);
+        return IterImplForStreaming.readLongSlowPath(iter, ind, negative);
     }
 
-    static final int readPositiveInt(final JsonIterator iter, byte c) throws IOException {
+    static final int readInt(final JsonIterator iter, final byte c, final boolean negative) throws IOException {
         int ind = IterImplNumber.intDigits[c];
         if (ind == 0) {
             assertNotLeadingZero(iter);
             return 0;
         }
         if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
-            throw iter.reportError("readPositiveInt", "expect 0~9");
+            throw iter.reportError("readInt", "expect 0~9");
         }
-        return IterImplForStreaming.readIntSlowPath(iter, ind);
+        return IterImplForStreaming.readIntSlowPath(iter, ind, negative);
     }
 
     static void assertNotLeadingZero(JsonIterator iter) throws IOException {
@@ -620,7 +627,7 @@ static void assertNotLeadingZero(JsonIterator iter) throws IOException {
             if (ind2 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {
                 return;
             }
-            throw iter.reportError("readPositiveInt", "leading zero is invalid");
+            throw iter.reportError("assertNotLeadingZero", "leading zero is invalid");
         } catch (ArrayIndexOutOfBoundsException e) {
             iter.head = iter.tail;
             return;
diff --git a/src/main/java/com/jsoniter/IterImplNumber.java b/src/main/java/com/jsoniter/IterImplNumber.java
@@ -31,8 +31,6 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  */
 package com.jsoniter;
 
-import com.jsoniter.spi.JsonException;
-
 import java.io.IOException;
 
 class IterImplNumber {
@@ -65,40 +63,26 @@ class IterImplNumber {
 
     public static final double readDouble(final JsonIterator iter) throws IOException {
         final byte c = IterImpl.nextToken(iter);
-        if (c == '-') {
-            return -IterImpl.readPositiveDouble(iter);
-        } else {
+        boolean negative = c == '-';
+        if (!negative) {
             iter.unreadByte();
-            return IterImpl.readPositiveDouble(iter);
         }
+        return IterImpl.readDouble(iter, negative);
     }
 
     public static final float readFloat(final JsonIterator iter) throws IOException {
-        final byte c = IterImpl.nextToken(iter);
-        if (c == '-') {
-            return (float)-IterImpl.readPositiveDouble(iter);
-        } else {
-            iter.unreadByte();
-            return (float) IterImpl.readPositiveDouble(iter);
-        }
+        return (float) IterImplNumber.readDouble(iter);
     }
 
     public static final int readInt(final JsonIterator iter) throws IOException {
         byte c = IterImpl.nextToken(iter);
-        if (c == '-') {
-            return -IterImpl.readPositiveInt(iter, IterImpl.readByte(iter));
-        } else {
-            return IterImpl.readPositiveInt(iter, c);
-        }
+        boolean negative = c == '-';
+        return IterImpl.readInt(iter, negative ? IterImpl.readByte(iter) : c, negative);
     }
 
     public static final long readLong(JsonIterator iter) throws IOException {
         byte c = IterImpl.nextToken(iter);
-        if (c == '-') {
-            return -IterImpl.readPositiveLong(iter, IterImpl.readByte(iter));
-        } else {
-            return IterImpl.readPositiveLong(iter, c);
-        }
+        boolean negative = c == '-';
+        return IterImpl.readLong(iter, negative ? IterImpl.readByte(iter) : c, negative);
     }
-
 }
diff --git a/src/test/java/com/jsoniter/TestFloat.java b/src/test/java/com/jsoniter/TestFloat.java
@@ -34,10 +34,15 @@ public void test_ieee_754() throws IOException {
     public void test_decimal_places() throws IOException {
         assertEquals(Long.MAX_VALUE, parseFloat("9223372036854775807,"), 0.01f);
         assertEquals(Long.MAX_VALUE, parseDouble("9223372036854775807,"), 0.01f);
+        assertEquals(Long.MIN_VALUE, parseDouble("-9223372036854775808,"), 0.01f);
         assertEquals(9923372036854775807f, parseFloat("9923372036854775807,"), 0.01f);
+        assertEquals(-9923372036854775808f, parseFloat("-9923372036854775808,"), 0.01f);
         assertEquals(9923372036854775807d, parseDouble("9923372036854775807,"), 0.01f);
+        assertEquals(-9923372036854775808d, parseDouble("-9923372036854775808,"), 0.01f);
         assertEquals(720368.54775807f, parseFloat("720368.54775807,"), 0.01f);
+        assertEquals(-720368.54775807f, parseFloat("-720368.54775807,"), 0.01f);
         assertEquals(720368.54775807d, parseDouble("720368.54775807,"), 0.01f);
+        assertEquals(-720368.54775807d, parseDouble("-720368.54775807,"), 0.01f);
         assertEquals(72036.854775807f, parseFloat("72036.854775807,"), 0.01f);
         assertEquals(72036.854775807d, parseDouble("72036.854775807,"), 0.01f);
         assertEquals(720368.54775807f, parseFloat("720368.547758075,"), 0.01f);
diff --git a/src/test/java/com/jsoniter/TestInteger.java b/src/test/java/com/jsoniter/TestInteger.java

Original file line number	Diff line number	Diff line change
`@@ -487,48 +487,56 @@ public final static int readStringSlowPath(JsonIterator iter, int j) throws IOEx`
`487`	`487`	`}`
`488`	`488`	`}`
`489`	`489`
`490`		`- static long readLongSlowPath(JsonIterator iter, long value) throws IOException {`
	`490`	`+ static long readLongSlowPath(final JsonIterator iter, long value, final boolean negative) throws IOException {`
	`491`	`+ value = -value; // add negatives to avoid redundant checks for Long.MIN_VALUE on each iteration`
	`492`	`+ long limit = negative ? Long.MIN_VALUE : -Long.MAX_VALUE;`
	`493`	`+ long multmin = -922337203685477580L; // limit / 10`
`491`	`494`	`for (; ; ) {`
`492`	`495`	`for (int i = iter.head; i < iter.tail; i++) {`
`493`	`496`	`int ind = IterImplNumber.intDigits[iter.buf[i]];`
`494`	`497`	`if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {`
`495`	`498`	`iter.head = i;`
`496`		`- return value;`
	`499`	`+ return negative ? value : -value;`
`497`	`500`	`}`
`498`		`- if (value == Long.MIN_VALUE) {`
`499`		`- throw iter.reportError("readLongSlowPath", "value is too large for long");`
	`501`	`+ if (value < multmin) {`
	`502`	`+ throw iter.reportError("readIntSlowPath", "value is too large for int");`
`500`	`503`	`}`
`501`		`- value = (value << 3) + (value << 1) + ind;`
`502`		`- if (value < 0 && value != Long.MIN_VALUE) {`
	`504`	`+ value = (value << 3) + (value << 1);`
	`505`	`+ if (value < limit + ind) {`
`503`	`506`	`throw iter.reportError("readLongSlowPath", "value is too large for long");`
`504`	`507`	`}`
	`508`	`+ value -= ind;`
`505`	`509`	`}`
`506`	`510`	`if (!IterImpl.loadMore(iter)) {`
`507`	`511`	`iter.head = iter.tail;`
`508`		`- return value;`
	`512`	`+ return negative ? value : -value;`
`509`	`513`	`}`
`510`	`514`	`}`
`511`	`515`	`}`
`512`	`516`
`513`		`- static int readIntSlowPath(JsonIterator iter, int value) throws IOException {`
	`517`	`+ static int readIntSlowPath(final JsonIterator iter, int value, final boolean negative) throws IOException {`
	`518`	`+ value = -value; // add negatives to avoid redundant checks for Integer.MIN_VALUE on each iteration`
	`519`	`+ int limit = negative ? Integer.MIN_VALUE : -Integer.MAX_VALUE;`
	`520`	`+ int multmin = -214748364; // limit / 10`
`514`	`521`	`for (; ; ) {`
`515`	`522`	`for (int i = iter.head; i < iter.tail; i++) {`
`516`	`523`	`int ind = IterImplNumber.intDigits[iter.buf[i]];`
`517`	`524`	`if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {`
`518`	`525`	`iter.head = i;`
`519`		`- return value;`
	`526`	`+ return negative ? value : -value;`
`520`	`527`	`}`
`521`		`- if (value == Integer.MIN_VALUE) {`
	`528`	`+ if (value < multmin) {`
`522`	`529`	`throw iter.reportError("readIntSlowPath", "value is too large for int");`
`523`	`530`	`}`
`524`		`- value = (value << 3) + (value << 1) + ind;`
`525`		`- if (value < 0 && value != Integer.MIN_VALUE) {`
	`531`	`+ value = (value << 3) + (value << 1);`
	`532`	`+ if (value < limit + ind) {`
`526`	`533`	`throw iter.reportError("readIntSlowPath", "value is too large for int");`
`527`	`534`	`}`
	`535`	`+ value -= ind;`
`528`	`536`	`}`
`529`	`537`	`if (!IterImpl.loadMore(iter)) {`
`530`	`538`	`iter.head = iter.tail;`
`531`		`- return value;`
	`539`	`+ return negative ? value : -value;`
`532`	`540`	`}`
`533`	`541`	`}`
`534`	`542`	`}`
`@@ -582,34 +590,33 @@ public static final String readNumber(final JsonIterator iter) throws IOExceptio`
`582`	`590`	`}`
`583`	`591`	`}`
`584`	`592`
`585`		`-`
`586`		`- static final double readPositiveDouble(final JsonIterator iter) throws IOException {`
`587`		`- return readDoubleSlowPath(iter);`
	`593`	`+ static final double readDouble(final JsonIterator iter, final boolean negative) throws IOException {`
	`594`	`+ double result = readDoubleSlowPath(iter);`
	`595`	`+ return negative ? -result : result;`
`588`	`596`	`}`
`589`	`597`
`590`		`-`
`591`		`- static final long readPositiveLong(final JsonIterator iter, byte c) throws IOException {`
	`598`	`+ static final long readLong(final JsonIterator iter, final byte c, final boolean negative) throws IOException {`
`592`	`599`	`long ind = IterImplNumber.intDigits[c];`
`593`	`600`	`if (ind == 0) {`
`594`	`601`	`assertNotLeadingZero(iter);`
`595`	`602`	`return 0;`
`596`	`603`	`}`
`597`	`604`	`if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {`
`598`		`- throw iter.reportError("readPositiveLong", "expect 0~9");`
	`605`	`+ throw iter.reportError("readLong", "expect 0~9");`
`599`	`606`	`}`
`600`		`- return IterImplForStreaming.readLongSlowPath(iter, ind);`
	`607`	`+ return IterImplForStreaming.readLongSlowPath(iter, ind, negative);`
`601`	`608`	`}`
`602`	`609`
`603`		`- static final int readPositiveInt(final JsonIterator iter, byte c) throws IOException {`
	`610`	`+ static final int readInt(final JsonIterator iter, final byte c, final boolean negative) throws IOException {`
`604`	`611`	`int ind = IterImplNumber.intDigits[c];`
`605`	`612`	`if (ind == 0) {`
`606`	`613`	`assertNotLeadingZero(iter);`
`607`	`614`	`return 0;`
`608`	`615`	`}`
`609`	`616`	`if (ind == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {`
`610`		`- throw iter.reportError("readPositiveInt", "expect 0~9");`
	`617`	`+ throw iter.reportError("readInt", "expect 0~9");`
`611`	`618`	`}`
`612`		`- return IterImplForStreaming.readIntSlowPath(iter, ind);`
	`619`	`+ return IterImplForStreaming.readIntSlowPath(iter, ind, negative);`
`613`	`620`	`}`
`614`	`621`
`615`	`622`	`static void assertNotLeadingZero(JsonIterator iter) throws IOException {`
`@@ -620,7 +627,7 @@ static void assertNotLeadingZero(JsonIterator iter) throws IOException {`
`620`	`627`	`if (ind2 == IterImplNumber.INVALID_CHAR_FOR_NUMBER) {`
`621`	`628`	`return;`
`622`	`629`	`}`
`623`		`- throw iter.reportError("readPositiveInt", "leading zero is invalid");`
	`630`	`+ throw iter.reportError("assertNotLeadingZero", "leading zero is invalid");`
`624`	`631`	`} catch (ArrayIndexOutOfBoundsException e) {`
`625`	`632`	`iter.head = iter.tail;`
`626`	`633`	`return;`