| // 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. |
| // Dart core library. |
| |
| // VM implementation of int. |
| |
| import 'dart:_internal' as internal; |
| |
| patch class int { |
| |
| /* patch */ const factory int.fromEnvironment(String name, |
| {int defaultValue}) |
| native "Integer_fromEnvironment"; |
| |
| |
| static int _tryParseSmi(String str, int first, int last) { |
| assert(first <= last); |
| var ix = first; |
| var sign = 1; |
| var c = str.codeUnitAt(ix); |
| // Check for leading '+' or '-'. |
| if ((c == 0x2b) || (c == 0x2d)) { |
| ix++; |
| sign = 0x2c - c; // -1 for '-', +1 for '+'. |
| if (ix > last) { |
| return null; // Empty. |
| } |
| } |
| var smiLimit = internal.is64Bit ? 18 : 9; |
| if ((last - ix) >= smiLimit) { |
| return null; // May not fit into a Smi. |
| } |
| var result = 0; |
| for (int i = ix; i <= last; i++) { |
| var c = 0x30 ^ str.codeUnitAt(i); |
| if (9 < c) { |
| return null; |
| } |
| result = 10 * result + c; |
| } |
| return sign * result; |
| } |
| |
| /* patch */ static int parse(String source, |
| { int radix, |
| int onError(String str) }) { |
| if (source == null) throw new ArgumentError("The source must not be null"); |
| if (source.isEmpty) return _throwFormatException(onError, source, 0, radix); |
| if (radix == null || radix == 10) { |
| // Try parsing immediately, without trimming whitespace. |
| int result = _tryParseSmi(source, 0, source.length - 1); |
| if (result != null) return result; |
| } else if (radix < 2 || radix > 36) { |
| throw new RangeError("Radix $radix not in range 2..36"); |
| } |
| // Split here so improve odds of parse being inlined and the checks omitted. |
| return _parse(source, radix, onError); |
| } |
| |
| static int _parse(String source, int radix, onError) { |
| int end = source._lastNonWhitespace() + 1; |
| if (end == 0) { |
| return _throwFormatException(onError, source, source.length, radix); |
| } |
| int start = source._firstNonWhitespace(); |
| |
| int first = source.codeUnitAt(start); |
| int sign = 1; |
| if (first == 0x2b /* + */ || first == 0x2d /* - */) { |
| sign = 0x2c - first; // -1 if '-', +1 if '+'. |
| start++; |
| if (start == end) { |
| return _throwFormatException(onError, source, end, radix); |
| } |
| first = source.codeUnitAt(start); |
| } |
| if (radix == null) { |
| // check for 0x prefix. |
| int index = start; |
| if (first == 0x30 /* 0 */) { |
| index++; |
| if (index == end) return 0; |
| first = source.codeUnitAt(index); |
| if ((first | 0x20) == 0x78 /* x */) { |
| index++; |
| if (index == end) { |
| return _throwFormatException(onError, source, index, null); |
| } |
| int result = _parseRadix(source, 16, index, end, sign); |
| if (result == null) { |
| return _throwFormatException(onError, source, null, null); |
| } |
| return result; |
| } |
| } |
| radix = 10; |
| } |
| int result = _parseRadix(source, radix, start, end, sign); |
| if (result == null) { |
| return _throwFormatException(onError, source, null, radix); |
| } |
| return result; |
| } |
| |
| static int _throwFormatException(onError, source, index, radix) { |
| if (onError != null) return onError(source); |
| if (radix == null) { |
| throw new FormatException("Invalid number", source, index); |
| } |
| throw new FormatException("Invalid radix-$radix number", source, index); |
| } |
| |
| static int _parseRadix(String source, int radix, |
| int start, int end, int sign) { |
| int tableIndex = (radix - 2) * 4 + (internal.is64Bit ? 2 : 0); |
| int blockSize = _PARSE_LIMITS[tableIndex]; |
| int length = end - start; |
| if (length <= blockSize) { |
| _Smi smi = _parseBlock(source, radix, start, end); |
| if (smi != null) return sign * smi; |
| return null; |
| } |
| |
| // Often cheaper than: int smallBlockSize = length % blockSize; |
| // because digit count generally tends towards smaller. rather |
| // than larger. |
| int smallBlockSize = length; |
| while (smallBlockSize >= blockSize) smallBlockSize -= blockSize; |
| int result = 0; |
| if (smallBlockSize > 0) { |
| int blockEnd = start + smallBlockSize; |
| _Smi smi = _parseBlock(source, radix, start, blockEnd); |
| if (smi == null) return null; |
| result = sign * smi; |
| start = blockEnd; |
| } |
| int multiplier = _PARSE_LIMITS[tableIndex + 1]; |
| int blockEnd = start + blockSize; |
| do { |
| _Smi smi = _parseBlock(source, radix, start, blockEnd); |
| if (smi == null) return null; |
| result = (result * multiplier) + (sign * smi); |
| start = blockEnd; |
| blockEnd = start + blockSize; |
| } while (blockEnd <= end); |
| return result; |
| } |
| |
| // Parse block of digits into a Smi. |
| static _Smi _parseBlock(String source, int radix, int start, int end) { |
| _Smi result = 0; |
| if (radix <= 10) { |
| for (int i = start; i < end; i++) { |
| int digit = source.codeUnitAt(i) ^ 0x30; |
| if (digit >= radix) return null; |
| result = radix * result + digit; |
| } |
| } else { |
| for (int i = start; i < end; i++) { |
| int char = source.codeUnitAt(i); |
| int digit = char ^ 0x30; |
| if (digit > 9) { |
| digit = (char | 0x20) - (0x61 - 10); |
| if (digit < 10 || digit >= radix) return null; |
| } |
| result = radix * result + digit; |
| } |
| } |
| return result; |
| } |
| |
| // For each radix, 2-36, how many digits are guaranteed to fit in a smi, |
| // and magnitude of such a block (radix ** digit-count). |
| // 32-bit limit/multiplier at (radix - 2)*4, 64-bit limit at (radix-2)*4+2 |
| static const _PARSE_LIMITS = const [ |
| 30, 1073741824, 62, 4611686018427387904, /* radix: 2 */ |
| 18, 387420489, 39, 4052555153018976267, |
| 15, 1073741824, 30, 1152921504606846976, |
| 12, 244140625, 26, 1490116119384765625, /* radix: 5 */ |
| 11, 362797056, 23, 789730223053602816, |
| 10, 282475249, 22, 3909821048582988049, |
| 10, 1073741824, 20, 1152921504606846976, |
| 9, 387420489, 19, 1350851717672992089, |
| 9, 1000000000, 18, 1000000000000000000, /* radix: 10 */ |
| 8, 214358881, 17, 505447028499293771, |
| 8, 429981696, 17, 2218611106740436992, |
| 8, 815730721, 16, 665416609183179841, |
| 7, 105413504, 16, 2177953337809371136, |
| 7, 170859375, 15, 437893890380859375, /* radix: 15 */ |
| 7, 268435456, 15, 1152921504606846976, |
| 7, 410338673, 15, 2862423051509815793, |
| 7, 612220032, 14, 374813367582081024, |
| 7, 893871739, 14, 799006685782884121, |
| 6, 64000000, 14, 1638400000000000000, /* radix: 20 */ |
| 6, 85766121, 14, 3243919932521508681, |
| 6, 113379904, 13, 282810057883082752, |
| 6, 148035889, 13, 504036361936467383, |
| 6, 191102976, 13, 876488338465357824, |
| 6, 244140625, 13, 1490116119384765625, /* radix: 25 */ |
| 6, 308915776, 13, 2481152873203736576, |
| 6, 387420489, 13, 4052555153018976267, |
| 6, 481890304, 12, 232218265089212416, |
| 6, 594823321, 12, 353814783205469041, |
| 6, 729000000, 12, 531441000000000000, /* radix: 30 */ |
| 6, 887503681, 12, 787662783788549761, |
| 6, 1073741824, 12, 1152921504606846976, |
| 5, 39135393, 12, 1667889514952984961, |
| 5, 45435424, 12, 2386420683693101056, |
| 5, 52521875, 12, 3379220508056640625, /* radix: 35 */ |
| 5, 60466176, 11, 131621703842267136, |
| ]; |
| } |