Avoid comparing smi to mint in smi.toString().

runtime/lib/integers.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(srdjan): fix limitations.
 // - shift amount must be a Smi.
 class _IntegerImplementation {
   factory _IntegerImplementation._uninstantiable() {
     throw new UnsupportedError(
         "_IntegerImplementation can only be allocated by the VM");
@@ skipping 276 matching lines @@
     0x36, 0x38, 0x36, 0x39, 0x37, 0x30, 0x37, 0x31,
     0x37, 0x32, 0x37, 0x33, 0x37, 0x34, 0x37, 0x35,
     0x37, 0x36, 0x37, 0x37, 0x37, 0x38, 0x37, 0x39,
     0x38, 0x30, 0x38, 0x31, 0x38, 0x32, 0x38, 0x33,
     0x38, 0x34, 0x38, 0x35, 0x38, 0x36, 0x38, 0x37,
     0x38, 0x38, 0x38, 0x39, 0x39, 0x30, 0x39, 0x31,
     0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35,
     0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39
   ];
 
-  // Powers of 10 above 1000000 are indistinguishable.
+  // Powers of 10 above 1000000 are indistinguishable by eye.
   static const int _POW_10_7  = 10000000;
   static const int _POW_10_8  = 100000000;
   static const int _POW_10_9  = 1000000000;
-  static const int _POW_10_10 = 10000000000;
 
   // Find the number of decimal digits in a positive smi.
+  // Never called with numbers < 100. These are handled before calling.
   static int _positiveBase10Length(var smi) {
     // A positive smi has length <= 19 if 63-bit,  <=10 if 31-bit.
     // Avoid comparing a 31-bit smi to a non-smi.
     if (smi < 1000) return 3;
     if (smi < 10000) return 4;
     if (smi < _POW_10_7) {
       if (smi < 100000) return 5;
       if (smi < 1000000) return 6;
       return 7;
     }
-    if (smi < _POW_10_10) {
-      if (smi < _POW_10_8) return 8;
-      if (smi < _POW_10_9) return 9;
-      return 10;
-    }
-    smi = smi ~/ _POW_10_10;
-    if (smi < 10) return 11;
-    if (smi < 100) return 12;
-    return 10 + _positiveBase10Length(smi);
+    if (smi < _POW_10_8) return 8;
+    if (smi < _POW_10_9) return 9;
+    smi = smi ~/ _POW_10_9;
+    // Handle numbers < 100 before calling recursively.
+    if (smi < 10) return 10;
+    if (smi < 100) return 11;
+    return 9 + _positiveBase10Length(smi);
   }
 
   String toString() {
     if (this < 0) return _negativeToString(this);
     // Inspired by Andrei Alexandrescu: "Three Optimization Tips for C++"
     // Avoid expensive remainder operation by doing it on more than
     // one digit at a time.
     const int DIGIT_ZERO = 0x30;
     if (this < 10) {
       return _OneByteString._allocate(1).._setAt(0, DIGIT_ZERO + this);
@@ skipping 23 matching lines @@
     } else {
       // No remainder for this case.
       int digitIndex = smi * 2;
       result._setAt(index, _digitTable[digitIndex + 1]);
       result._setAt(index - 1, _digitTable[digitIndex]);
     }
     return result;
   }
 
   // Find the number of decimal digits in a negative smi.
+  // Never called with numbers > -100. These are handled before calling.
   static int _negativeBase10Length(var negSmi) {
     // A negative smi has length <= 19 if 63-bit, <=10 if 31-bit.
     // Avoid comparing a 31-bit smi to a non-smi.
     if (negSmi > -1000) return 3;
     if (negSmi > -10000) return 4;
     if (negSmi > -_POW_10_7) {
       if (negSmi > -100000) return 5;
       if (negSmi > -1000000) return 6;
       return 7;
     }
-    if (negSmi > -_POW_10_10) {
-      if (negSmi > -_POW_10_8) return 8;
-      if (negSmi > -_POW_10_9) return 9;
-      return 10;
-    }
-    negSmi = negSmi ~/ _POW_10_10;
-    if (negSmi > -10) return 11;
-    if (negSmi > -100) return 12;
-    return 10 + _negativeBase10Length(negSmi);
+    if (negSmi > -_POW_10_8) return 8;
+    if (negSmi > -_POW_10_9) return 9;
+    negSmi = negSmi ~/ _POW_10_9;
+    // Handle numbers > -100 before calling recursively.
+    if (negSmi > -10) return 10;
+    if (negSmi > -100) return 11;
+    return 9 + _negativeBase10Length(negSmi);
   }
 
   // Convert a negative smi to a string.
   // Doesn't negate the smi to avoid negating the most negative smi, which
   // would become a non-smi.
   static String _negativeToString(int negSmi) {
     // Character code for '-'
     const int MINUS_SIGN = 0x2d;
     // Character code for '0'.
     const int DIGIT_ZERO = 0x30;
@@ skipping 76 matching lines @@
     } else {
       return 0;
     }
   }
   int _shlFromInt(int other) native "Bigint_shlFromInt";
 
   int pow(int exponent) {
     throw "Bigint.pow not implemented";
   }
 }