Native-specific implementation.
diff --git a/lib/src/int64.dart b/lib/src/int64.dart
index b0485a1..e54654a 100644
--- a/lib/src/int64.dart
+++ b/lib/src/int64.dart
@@ -2,1128 +2,7 @@
// 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.
-// ignore_for_file: constant_identifier_names
+export 'int64_native.dart' if (dart.library.js) 'int64_web.dart';
-// Many locals are declared as `int` or `double`. We keep local variable types
-// because the types are critical to the efficiency of many operations.
-//
-// ignore_for_file: omit_local_variable_types
-
-import 'int32.dart';
-import 'intx.dart';
-import 'utilities.dart' as u;
-
-/// An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
-/// Arithmetic operations may overflow in order to maintain this range.
-class Int64 implements IntX {
- // A 64-bit integer is represented internally as three non-negative
- // integers, storing the 22 low, 22 middle, and 20 high bits of the
- // 64-bit value. _l (low) and _m (middle) are in the range
- // [0, 2^22 - 1] and _h (high) is in the range [0, 2^20 - 1].
- //
- // The values being assigned to _l, _m and _h in initialization are masked to
- // force them into the above ranges. Sometimes we know that the value is a
- // small non-negative integer but the dart2js compiler can't infer that, so a
- // few of the masking operations are not needed for correctness but are
- // helpful for dart2js code quality.
-
- final int _l, _m, _h;
-
- // Note: several functions require _BITS == 22 -- do not change this value.
- static const int _BITS = 22;
- static const int _BITS01 = 44; // 2 * _BITS
- static const int _BITS2 = 20; // 64 - _BITS01
- static const int _MASK = 4194303; // (1 << _BITS) - 1
- static const int _MASK2 = 1048575; // (1 << _BITS2) - 1
- static const int _SIGN_BIT = 19; // _BITS2 - 1
- static const int _SIGN_BIT_MASK = 1 << _SIGN_BIT;
-
- /// The maximum positive value attainable by an [Int64], namely
- /// 9,223,372,036,854,775,807.
- static const Int64 MAX_VALUE = Int64._bits(_MASK, _MASK, _MASK2 >> 1);
-
- /// The minimum positive value attainable by an [Int64], namely
- /// -9,223,372,036,854,775,808.
- static const Int64 MIN_VALUE = Int64._bits(0, 0, _SIGN_BIT_MASK);
-
- /// An [Int64] constant equal to 0.
- static const Int64 ZERO = Int64._bits(0, 0, 0);
-
- /// An [Int64] constant equal to 1.
- static const Int64 ONE = Int64._bits(1, 0, 0);
-
- /// An [Int64] constant equal to 2.
- static const Int64 TWO = Int64._bits(2, 0, 0);
-
- /// Constructs an [Int64] with a given bitwise representation. No validation
- /// is performed.
- const Int64._bits(this._l, this._m, this._h);
-
- /// Parses [source] in a given [radix] between 2 and 36.
- ///
- /// Returns an [Int64] with the numerical value of [source].
- /// If the numerical value of [source] does not fit
- /// in a signed 64 bit integer,
- /// the numerical value is truncated to the lowest 64 bits
- /// of the value's binary representation,
- /// interpreted as a 64-bit two's complement integer.
- ///
- /// The [source] string must contain a sequence of base-[radix]
- /// digits (using letters from `a` to `z` as digits with values 10 through
- /// 25 for radixes above 10), possibly prefixed by a `-` sign.
- ///
- /// Throws a [FormatException] if the input is not recognized as a valid
- /// integer numeral.
- static Int64 parseRadix(String source, int radix) =>
- _parseRadix(source, u.validateRadix(radix), true)!;
-
- /// Parses [source] in a given [radix] between 2 and 36.
- ///
- /// Returns an [Int64] with the numerical value of [source].
- /// If the numerical value of [source] does not fit
- /// in a signed 64 bit integer,
- /// the numerical value is truncated to the lowest 64 bits
- /// of the value's binary representation,
- /// interpreted as a 64-bit two's complement integer.
- ///
- /// The [source] string must contain a sequence of base-[radix]
- /// digits (using letters from `a` to `z` as digits with values 10 through
- /// 25 for radixes above 10), possibly prefixed by a `-` sign.
- ///
- /// Returns `null` if the input is not recognized as a valid
- /// integer numeral.
- static Int64? tryParseRadix(String source, int radix) =>
- _parseRadix(source, u.validateRadix(radix), false);
-
- static Int64? _parseRadix(String s, int radix, bool throwOnError) {
- int i = 0;
- bool negative = false;
- if (s.startsWith('-')) {
- negative = true;
- i++;
- }
-
- if (i >= s.length) {
- if (!throwOnError) return null;
- throw FormatException('No digits', s, i);
- }
-
- int d0 = 0, d1 = 0, d2 = 0; // low, middle, high components.
- for (; i < s.length; i++) {
- int c = s.codeUnitAt(i);
- int digit = u.decodeDigit(c);
- if (digit < radix) {
- // [radix] and [digit] are at most 6 bits, component is 22, so we can
- // multiply and add within 30 bit temporary values.
- d0 = d0 * radix + digit;
- int carry = d0 >> _BITS;
- d0 = _MASK & d0;
-
- d1 = d1 * radix + carry;
- carry = d1 >> _BITS;
- d1 = _MASK & d1;
-
- d2 = d2 * radix + carry;
- d2 = _MASK2 & d2;
- } else {
- if (!throwOnError) return null;
- throw FormatException('Not radix digit', s, i);
- }
- }
-
- if (negative) return _negate(d0, d1, d2);
-
- return Int64._masked(d0, d1, d2);
- }
-
- /// Parses [source] as a decimal numeral.
- ///
- /// Returns an [Int64] with the numerical value of [source].
- /// If the numerical value of [source] does not fit
- /// in a signed 64 bit integer,
- /// the numerical value is truncated to the lowest 64 bits
- /// of the value's binary representation,
- /// interpreted as a 64-bit two's complement integer.
- ///
- /// The [source] string must contain a sequence of digits (`0`-`9`),
- /// possibly prefixed by a `-` sign.
- ///
- /// Throws a [FormatException] if the input is not a valid
- /// decimal integer numeral.
- static Int64 parseInt(String source) => _parseRadix(source, 10, true)!;
-
- /// Parses [source] as a decimal numeral.
- ///
- /// Returns an [Int64] with the numerical value of [source].
- /// If the numerical value of [source] does not fit
- /// in a signed 64 bit integer,
- /// the numerical value is truncated to the lowest 64 bits
- /// of the value's binary representation,
- /// interpreted as a 64-bit two's complement integer.
- ///
- /// The [source] string must contain a sequence of digits (`0`-`9`),
- /// possibly prefixed by a `-` sign.
- ///
- /// Returns `null` if the input is not a valid
- /// decimal integer numeral.
- static Int64? tryParseInt(String source) => _parseRadix(source, 10, false);
-
- /// Parses [source] as a hexadecimal numeral.
- ///
- /// Returns an [Int64] with the numerical value of [source].
- /// If the numerical value of [source] does not fit
- /// in a signed 64 bit integer,
- /// the numerical value is truncated to the lowest 64 bits
- /// of the value's binary representation,
- /// interpreted as a 64-bit two's complement integer.
- ///
- /// The [source] string must contain a sequence of hexadecimal
- /// digits (`0`-`9`, `a`-`f` or `A`-`F`), possibly prefixed by a `-` sign.
- ///
- /// Throws a [FormatException] if the input is not a valid
- /// hexadecimal integer numeral.
- static Int64 parseHex(String source) => _parseRadix(source, 16, true)!;
-
- /// Parses [source] as a hexadecimal numeral.
- ///
- /// Returns an [Int64] with the numerical value of [source].
- /// If the numerical value of [source] does not fit
- /// in a signed 64 bit integer,
- /// the numerical value is truncated to the lowest 64 bits
- /// of the value's binary representation,
- /// interpreted as a 64-bit two's complement integer.
- ///
- /// The [source] string must contain a sequence of hexadecimal
- /// digits (`0`-`9`, `a`-`f` or `A`-`F`), possibly prefixed by a `-` sign.
- ///
- /// Returns `null` if the input is not a valid
- /// hexadecimal integer numeral.
- static Int64? tryParseHex(String source) => _parseRadix(source, 16, false);
-
- //
- // Public constructors
- //
-
- /// Constructs an [Int64] with a given [int] value; zero by default.
- factory Int64([int value = 0]) {
- int v0 = 0, v1 = 0, v2 = 0;
- bool negative = false;
- if (value < 0) {
- negative = true;
- value = -value;
- }
- // Avoid using bitwise operations that in JavaScript coerce their input to
- // 32 bits.
- v2 = value ~/ 17592186044416; // 2^44
- value -= v2 * 17592186044416;
- v1 = value ~/ 4194304; // 2^22
- value -= v1 * 4194304;
- v0 = value;
-
- return negative
- ? Int64._negate(_MASK & v0, _MASK & v1, _MASK2 & v2)
- : Int64._masked(v0, v1, v2);
- }
-
- factory Int64.fromBytes(List<int> bytes) {
- // 20 bits into top, 22 into middle and bottom.
- var split1 = bytes[5] & 0xFF;
- var high =
- ((bytes[7] & 0xFF) << 12) | ((bytes[6] & 0xFF) << 4) | (split1 >> 4);
- var split2 = bytes[2] & 0xFF;
- var middle = (split1 << 18) |
- ((bytes[4] & 0xFF) << 10) |
- ((bytes[3] & 0xFF) << 2) |
- (split2 >> 6);
- var low = (split2 << 16) | ((bytes[1] & 0xFF) << 8) | (bytes[0] & 0xFF);
- // Top bits from above will be masked off here.
- return Int64._masked(low, middle, high);
- }
-
- factory Int64.fromBytesBigEndian(List<int> bytes) {
- var split1 = bytes[2] & 0xFF;
- var high =
- ((bytes[0] & 0xFF) << 12) | ((bytes[1] & 0xFF) << 4) | (split1 >> 4);
- var split2 = bytes[5] & 0xFF;
- var middle = (split1 << 18) |
- ((bytes[3] & 0xFF) << 10) |
- ((bytes[4] & 0xFF) << 2) |
- (split2 >> 6);
- var low = (split2 << 16) | ((bytes[6] & 0xFF) << 8) | (bytes[7] & 0xFF);
- // Top bits from above will be masked off here.
- return Int64._masked(low, middle, high);
- }
-
- /// Constructs an [Int64] from a pair of 32-bit integers having the value
- /// [:((top & 0xffffffff) << 32) | (bottom & 0xffffffff):].
- factory Int64.fromInts(int top, int bottom) {
- top &= 0xffffffff;
- bottom &= 0xffffffff;
- int d0 = _MASK & bottom;
- int d1 = ((0xfff & top) << 10) | (0x3ff & (bottom >> _BITS));
- int d2 = _MASK2 & (top >> 12);
- return Int64._masked(d0, d1, d2);
- }
-
- // Returns the [Int64] representation of the specified value. Throws
- // [ArgumentError] for non-integer arguments.
- static Int64 _promote(value) {
- if (value is Int64) {
- return value;
- } else if (value is int) {
- return Int64(value);
- } else if (value is Int32) {
- return value.toInt64();
- }
- throw ArgumentError.value(value, 'other', 'not an int, Int32 or Int64');
- }
-
- @override
- Int64 operator +(Object other) {
- Int64 o = _promote(other);
- int sum0 = _l + o._l;
- int sum1 = _m + o._m + (sum0 >> _BITS);
- int sum2 = _h + o._h + (sum1 >> _BITS);
- return Int64._masked(sum0, sum1, sum2);
- }
-
- @override
- Int64 operator -(Object other) {
- Int64 o = _promote(other);
- return _sub(_l, _m, _h, o._l, o._m, o._h);
- }
-
- @override
- Int64 operator -() => _negate(_l, _m, _h);
-
- @override
- Int64 operator *(Object other) {
- Int64 o = _promote(other);
-
- // Grab 13-bit chunks.
- int a0 = _l & 0x1fff;
- int a1 = (_l >> 13) | ((_m & 0xf) << 9);
- int a2 = (_m >> 4) & 0x1fff;
- int a3 = (_m >> 17) | ((_h & 0xff) << 5);
- int a4 = (_h & 0xfff00) >> 8;
-
- int b0 = o._l & 0x1fff;
- int b1 = (o._l >> 13) | ((o._m & 0xf) << 9);
- int b2 = (o._m >> 4) & 0x1fff;
- int b3 = (o._m >> 17) | ((o._h & 0xff) << 5);
- int b4 = (o._h & 0xfff00) >> 8;
-
- // Compute partial products.
- // Optimization: if b is small, avoid multiplying by parts that are 0.
- int p0 = a0 * b0; // << 0
- int p1 = a1 * b0; // << 13
- int p2 = a2 * b0; // << 26
- int p3 = a3 * b0; // << 39
- int p4 = a4 * b0; // << 52
-
- if (b1 != 0) {
- p1 += a0 * b1;
- p2 += a1 * b1;
- p3 += a2 * b1;
- p4 += a3 * b1;
- }
- if (b2 != 0) {
- p2 += a0 * b2;
- p3 += a1 * b2;
- p4 += a2 * b2;
- }
- if (b3 != 0) {
- p3 += a0 * b3;
- p4 += a1 * b3;
- }
- if (b4 != 0) {
- p4 += a0 * b4;
- }
-
- // Accumulate into 22-bit chunks:
- // .........................................c10|...................c00|
- // |....................|..................xxxx|xxxxxxxxxxxxxxxxxxxxxx| p0
- // |....................|......................|......................|
- // |....................|...................c11|......c01.............|
- // |....................|....xxxxxxxxxxxxxxxxxx|xxxxxxxxx.............| p1
- // |....................|......................|......................|
- // |.................c22|...............c12....|......................|
- // |..........xxxxxxxxxx|xxxxxxxxxxxxxxxxxx....|......................| p2
- // |....................|......................|......................|
- // |.................c23|..c13.................|......................|
- // |xxxxxxxxxxxxxxxxxxxx|xxxxx.................|......................| p3
- // |....................|......................|......................|
- // |.........c24........|......................|......................|
- // |xxxxxxxxxxxx........|......................|......................| p4
-
- int c00 = p0 & 0x3fffff;
- int c01 = (p1 & 0x1ff) << 13;
- int c0 = c00 + c01;
-
- int c10 = p0 >> 22;
- int c11 = p1 >> 9;
- int c12 = (p2 & 0x3ffff) << 4;
- int c13 = (p3 & 0x1f) << 17;
- int c1 = c10 + c11 + c12 + c13;
-
- int c22 = p2 >> 18;
- int c23 = p3 >> 5;
- int c24 = (p4 & 0xfff) << 8;
- int c2 = c22 + c23 + c24;
-
- // Propagate high bits from c0 -> c1, c1 -> c2.
- c1 += c0 >> _BITS;
- c2 += c1 >> _BITS;
-
- return Int64._masked(c0, c1, c2);
- }
-
- @override
- Int64 operator %(Object other) => _divide(this, other, _RETURN_MOD);
-
- @override
- Int64 operator ~/(Object other) => _divide(this, other, _RETURN_DIV);
-
- @override
- Int64 remainder(Object other) => _divide(this, other, _RETURN_REM);
-
- @override
- Int64 operator &(Object other) {
- Int64 o = _promote(other);
- int a0 = _l & o._l;
- int a1 = _m & o._m;
- int a2 = _h & o._h;
- return Int64._masked(a0, a1, a2);
- }
-
- @override
- Int64 operator |(Object other) {
- Int64 o = _promote(other);
- int a0 = _l | o._l;
- int a1 = _m | o._m;
- int a2 = _h | o._h;
- return Int64._masked(a0, a1, a2);
- }
-
- @override
- Int64 operator ^(Object other) {
- Int64 o = _promote(other);
- int a0 = _l ^ o._l;
- int a1 = _m ^ o._m;
- int a2 = _h ^ o._h;
- return Int64._masked(a0, a1, a2);
- }
-
- @override
- Int64 operator ~() => Int64._masked(~_l, ~_m, ~_h);
-
- @override
- Int64 operator <<(int n) {
- if (n < 0) {
- throw ArgumentError.value(n);
- }
- if (n >= 64) {
- return ZERO;
- }
-
- int res0, res1, res2;
- if (n < _BITS) {
- res0 = _l << n;
- res1 = (_m << n) | (_l >> (_BITS - n));
- res2 = (_h << n) | (_m >> (_BITS - n));
- } else if (n < _BITS01) {
- res0 = 0;
- res1 = _l << (n - _BITS);
- res2 = (_m << (n - _BITS)) | (_l >> (_BITS01 - n));
- } else {
- res0 = 0;
- res1 = 0;
- res2 = _l << (n - _BITS01);
- }
-
- return Int64._masked(res0, res1, res2);
- }
-
- @override
- Int64 operator >>(int n) {
- if (n < 0) {
- throw ArgumentError.value(n);
- }
- if (n >= 64) {
- return isNegative ? const Int64._bits(_MASK, _MASK, _MASK2) : ZERO;
- }
-
- int res0, res1, res2;
-
- // Sign extend h(a).
- int a2 = _h;
- bool negative = (a2 & _SIGN_BIT_MASK) != 0;
- if (negative && _MASK > _MASK2) {
- // Add extra one bits on the left so the sign gets shifted into the wider
- // lower words.
- a2 += _MASK - _MASK2;
- }
-
- if (n < _BITS) {
- res2 = _shiftRight(a2, n);
- if (negative) {
- res2 |= _MASK2 & ~(_MASK2 >> n);
- }
- res1 = _shiftRight(_m, n) | (a2 << (_BITS - n));
- res0 = _shiftRight(_l, n) | (_m << (_BITS - n));
- } else if (n < _BITS01) {
- res2 = negative ? _MASK2 : 0;
- res1 = _shiftRight(a2, n - _BITS);
- if (negative) {
- res1 |= _MASK & ~(_MASK >> (n - _BITS));
- }
- res0 = _shiftRight(_m, n - _BITS) | (a2 << (_BITS01 - n));
- } else {
- res2 = negative ? _MASK2 : 0;
- res1 = negative ? _MASK : 0;
- res0 = _shiftRight(a2, n - _BITS01);
- if (negative) {
- res0 |= _MASK & ~(_MASK >> (n - _BITS01));
- }
- }
-
- return Int64._masked(res0, res1, res2);
- }
-
- @override
- Int64 shiftRightUnsigned(int n) {
- if (n < 0) {
- throw ArgumentError.value(n);
- }
- if (n >= 64) {
- return ZERO;
- }
-
- int res0, res1, res2;
- int a2 = _MASK2 & _h; // Ensure a2 is positive.
- if (n < _BITS) {
- res2 = a2 >> n;
- res1 = (_m >> n) | (a2 << (_BITS - n));
- res0 = (_l >> n) | (_m << (_BITS - n));
- } else if (n < _BITS01) {
- res2 = 0;
- res1 = a2 >> (n - _BITS);
- res0 = (_m >> (n - _BITS)) | (_h << (_BITS01 - n));
- } else {
- res2 = 0;
- res1 = 0;
- res0 = a2 >> (n - _BITS01);
- }
-
- return Int64._masked(res0, res1, res2);
- }
-
- /// Returns [:true:] if this [Int64] has the same numeric value as the
- /// given object. The argument may be an [int] or an [IntX].
- @override
- bool operator ==(Object other) {
- Int64? o;
- if (other is Int64) {
- o = other;
- } else if (other is int) {
- if (_h == 0 && _m == 0) return _l == other;
- // Since we know one of [_h] or [_m] is non-zero, if [other] fits in the
- // low word then it can't be numerically equal.
- if ((_MASK & other) == other) return false;
- o = Int64(other);
- } else if (other is Int32) {
- o = other.toInt64();
- }
- if (o != null) {
- return _l == o._l && _m == o._m && _h == o._h;
- }
- return false;
- }
-
- @override
- int compareTo(Object other) => _compareTo(other);
-
- int _compareTo(Object other) {
- Int64 o = _promote(other);
- int signa = _h >> (_BITS2 - 1);
- int signb = o._h >> (_BITS2 - 1);
- if (signa != signb) {
- return signa == 0 ? 1 : -1;
- }
- if (_h > o._h) {
- return 1;
- } else if (_h < o._h) {
- return -1;
- }
- if (_m > o._m) {
- return 1;
- } else if (_m < o._m) {
- return -1;
- }
- if (_l > o._l) {
- return 1;
- } else if (_l < o._l) {
- return -1;
- }
- return 0;
- }
-
- @override
- bool operator <(Object other) => _compareTo(other) < 0;
-
- @override
- bool operator <=(Object other) => _compareTo(other) <= 0;
-
- @override
- bool operator >(Object other) => _compareTo(other) > 0;
-
- @override
- bool operator >=(Object other) => _compareTo(other) >= 0;
-
- @override
- bool get isEven => (_l & 0x1) == 0;
-
- @override
- bool get isMaxValue => (_h == _MASK2 >> 1) && _m == _MASK && _l == _MASK;
-
- @override
- bool get isMinValue => _h == _SIGN_BIT_MASK && _m == 0 && _l == 0;
-
- @override
- bool get isNegative => (_h & _SIGN_BIT_MASK) != 0;
-
- @override
- bool get isOdd => (_l & 0x1) == 1;
-
- @override
- bool get isZero => _h == 0 && _m == 0 && _l == 0;
-
- @override
- int get bitLength {
- if (isZero) return 0;
- int a0 = _l, a1 = _m, a2 = _h;
- if (isNegative) {
- a0 = _MASK & ~a0;
- a1 = _MASK & ~a1;
- a2 = _MASK2 & ~a2;
- }
- if (a2 != 0) return _BITS01 + a2.bitLength;
- if (a1 != 0) return _BITS + a1.bitLength;
- return a0.bitLength;
- }
-
- /// Returns a hash code based on all the bits of this [Int64].
- @override
- int get hashCode {
- // TODO(sra): Should we ensure that hashCode values match corresponding int?
- // i.e. should `new Int64(x).hashCode == x.hashCode`?
- int bottom = ((_m & 0x3ff) << _BITS) | _l;
- int top = (_h << 12) | ((_m >> 10) & 0xfff);
- return bottom ^ top;
- }
-
- @override
- Int64 abs() => isNegative ? -this : this;
-
- @override
- Int64 clamp(Object lowerLimit, Object upperLimit) {
- Int64 lower = _promote(lowerLimit);
- Int64 upper = _promote(upperLimit);
- if (this < lower) return lower;
- if (this > upper) return upper;
- return this;
- }
-
- /// Returns the number of leading zeros in this [Int64] as an [int]
- /// between 0 and 64.
- @override
- int numberOfLeadingZeros() {
- int b2 = u.numberOfLeadingZeros(_h);
- if (b2 == 32) {
- int b1 = u.numberOfLeadingZeros(_m);
- if (b1 == 32) {
- return u.numberOfLeadingZeros(_l) + 32;
- } else {
- return b1 + _BITS2 - (32 - _BITS);
- }
- } else {
- return b2 - (32 - _BITS2);
- }
- }
-
- /// Returns the number of trailing zeros in this [Int64] as an [int]
- /// between 0 and 64.
- @override
- int numberOfTrailingZeros() {
- int zeros = u.numberOfTrailingZeros(_l);
- if (zeros < 32) {
- return zeros;
- }
-
- zeros = u.numberOfTrailingZeros(_m);
- if (zeros < 32) {
- return _BITS + zeros;
- }
-
- zeros = u.numberOfTrailingZeros(_h);
- if (zeros < 32) {
- return _BITS01 + zeros;
- }
- // All zeros
- return 64;
- }
-
- @override
- Int64 toSigned(int width) {
- if (width < 1 || width > 64) throw RangeError.range(width, 1, 64);
- if (width > _BITS01) {
- return Int64._masked(_l, _m, _h.toSigned(width - _BITS01));
- } else if (width > _BITS) {
- int m = _m.toSigned(width - _BITS);
- return m.isNegative
- ? Int64._masked(_l, m, _MASK2)
- : Int64._masked(_l, m, 0); // Masking for type inferrer.
- } else {
- int l = _l.toSigned(width);
- return l.isNegative
- ? Int64._masked(l, _MASK, _MASK2)
- : Int64._masked(l, 0, 0); // Masking for type inferrer.
- }
- }
-
- @override
- Int64 toUnsigned(int width) {
- if (width < 0 || width > 64) throw RangeError.range(width, 0, 64);
- if (width > _BITS01) {
- int h = _h.toUnsigned(width - _BITS01);
- return Int64._masked(_l, _m, h);
- } else if (width > _BITS) {
- int m = _m.toUnsigned(width - _BITS);
- return Int64._masked(_l, m, 0);
- } else {
- int l = _l.toUnsigned(width);
- return Int64._masked(l, 0, 0);
- }
- }
-
- @override
- List<int> toBytes() {
- var result = List<int>.filled(8, 0);
- result[0] = _l & 0xff;
- result[1] = (_l >> 8) & 0xff;
- result[2] = ((_m << 6) & 0xfc) | ((_l >> 16) & 0x3f);
- result[3] = (_m >> 2) & 0xff;
- result[4] = (_m >> 10) & 0xff;
- result[5] = ((_h << 4) & 0xf0) | ((_m >> 18) & 0xf);
- result[6] = (_h >> 4) & 0xff;
- result[7] = (_h >> 12) & 0xff;
- return result;
- }
-
- @override
- double toDouble() => toInt().toDouble();
-
- @override
- int toInt() {
- int l = _l;
- int m = _m;
- int h = _h;
- // In the sum we add least significant to most significant so that in
- // JavaScript double arithmetic rounding occurs on only the last addition.
- if ((_h & _SIGN_BIT_MASK) != 0) {
- l = _MASK & ~_l;
- m = _MASK & ~_m;
- h = _MASK2 & ~_h;
- return -((1 + l) + (4194304 * m) + (17592186044416 * h));
- } else {
- return l + (4194304 * m) + (17592186044416 * h);
- }
- }
-
- /// Returns an [Int32] containing the low 32 bits of this [Int64].
- @override
- Int32 toInt32() => Int32(((_m & 0x3ff) << _BITS) | _l);
-
- /// Returns `this`.
- @override
- Int64 toInt64() => this;
-
- /// Returns the value of this [Int64] as a decimal [String].
- @override
- String toString() => _toRadixString(10);
-
- @override
- String toHexString() {
- if (isZero) return '0';
- Int64 x = this;
- String hexStr = '';
- while (!x.isZero) {
- int digit = x._l & 0xf;
- hexStr = '${_hexDigit(digit)}$hexStr';
- x = x.shiftRightUnsigned(4);
- }
- return hexStr;
- }
-
- /// Returns the digits of `this` when interpreted as an unsigned 64-bit value.
- @pragma('dart2js:noInline')
- String toStringUnsigned() => _toRadixStringUnsigned(10, _l, _m, _h, '');
-
- @pragma('dart2js:noInline')
- String toRadixStringUnsigned(int radix) =>
- _toRadixStringUnsigned(u.validateRadix(radix), _l, _m, _h, '');
-
- @override
- String toRadixString(int radix) => _toRadixString(u.validateRadix(radix));
-
- String _toRadixString(int radix) {
- int d0 = _l;
- int d1 = _m;
- int d2 = _h;
-
- String sign = '';
- if ((d2 & _SIGN_BIT_MASK) != 0) {
- sign = '-';
-
- // Negate in-place.
- d0 = 0 - d0;
- int borrow = (d0 >> _BITS) & 1;
- d0 &= _MASK;
- d1 = 0 - d1 - borrow;
- borrow = (d1 >> _BITS) & 1;
- d1 &= _MASK;
- d2 = 0 - d2 - borrow;
- d2 &= _MASK2;
- // d2, d1, d0 now are an unsigned 64 bit integer for MIN_VALUE and an
- // unsigned 63 bit integer for other values.
- }
- return _toRadixStringUnsigned(radix, d0, d1, d2, sign);
- }
-
- static String _toRadixStringUnsigned(
- int radix, int d0, int d1, int d2, String sign) {
- if (d0 == 0 && d1 == 0 && d2 == 0) return '0';
-
- // Rearrange components into five components where all but the most
- // significant are 10 bits wide.
- //
- // d4, d3, d4, d1, d0: 24 + 10 + 10 + 10 + 10 bits
- //
- // The choice of 10 bits allows a remainder of 20 bits to be scaled by 10
- // bits and added during division while keeping all intermediate values
- // within 30 bits (unsigned small integer range for 32 bit implementations
- // of Dart VM and V8).
- //
- // 6 6 5 4 3 2 1
- // 3210987654321098765432109876543210987654321098765432109876543210
- // [--------d2--------][---------d1---------][---------d0---------]
- // -->
- // [----------d4----------][---d3---][---d2---][---d1---][---d0---]
-
- int d4 = (d2 << 4) | (d1 >> 18);
- int d3 = (d1 >> 8) & 0x3ff;
- d2 = ((d1 << 2) | (d0 >> 20)) & 0x3ff;
- d1 = (d0 >> 10) & 0x3ff;
- d0 = d0 & 0x3ff;
-
- int fatRadix = _fatRadixTable[radix];
-
- // Generate chunks of digits. In radix 10, generate 6 digits per chunk.
- //
- // This loop generates at most 3 chunks, so we store the chunks in locals
- // rather than a list. We are trying to generate digits 20 bits at a time
- // until we have only 30 bits left. 20 + 20 + 30 > 64 would imply that we
- // need only two chunks, but radix values 17-19 and 33-36 generate only 15
- // or 16 bits per iteration, so sometimes the third chunk is needed.
-
- String chunk1 = '', chunk2 = '', chunk3 = '';
-
- while (!(d4 == 0 && d3 == 0)) {
- int q = d4 ~/ fatRadix;
- int r = d4 - q * fatRadix;
- d4 = q;
- d3 += r << 10;
-
- q = d3 ~/ fatRadix;
- r = d3 - q * fatRadix;
- d3 = q;
- d2 += r << 10;
-
- q = d2 ~/ fatRadix;
- r = d2 - q * fatRadix;
- d2 = q;
- d1 += r << 10;
-
- q = d1 ~/ fatRadix;
- r = d1 - q * fatRadix;
- d1 = q;
- d0 += r << 10;
-
- q = d0 ~/ fatRadix;
- r = d0 - q * fatRadix;
- d0 = q;
-
- assert(chunk3 == '');
- chunk3 = chunk2;
- chunk2 = chunk1;
- // Adding [fatRadix] Forces an extra digit which we discard to get a fixed
- // width. E.g. (1000000 + 123) -> "1000123" -> "000123". An alternative
- // would be to pad to the left with zeroes.
- chunk1 = (fatRadix + r).toRadixString(radix).substring(1);
- }
- int residue = (d2 << 20) + (d1 << 10) + d0;
- String leadingDigits = residue == 0 ? '' : residue.toRadixString(radix);
- return '$sign$leadingDigits$chunk1$chunk2$chunk3';
- }
-
- // Table of 'fat' radix values. Each entry for index `i` is the largest power
- // of `i` whose remainder fits in 20 bits.
- static const _fatRadixTable = <int>[
- 0,
- 0,
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2 *
- 2,
- 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
- 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4,
- 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
- 6 * 6 * 6 * 6 * 6 * 6 * 6,
- 7 * 7 * 7 * 7 * 7 * 7 * 7,
- 8 * 8 * 8 * 8 * 8 * 8,
- 9 * 9 * 9 * 9 * 9 * 9,
- 10 * 10 * 10 * 10 * 10 * 10,
- 11 * 11 * 11 * 11 * 11,
- 12 * 12 * 12 * 12 * 12,
- 13 * 13 * 13 * 13 * 13,
- 14 * 14 * 14 * 14 * 14,
- 15 * 15 * 15 * 15 * 15,
- 16 * 16 * 16 * 16 * 16,
- 17 * 17 * 17 * 17,
- 18 * 18 * 18 * 18,
- 19 * 19 * 19 * 19,
- 20 * 20 * 20 * 20,
- 21 * 21 * 21 * 21,
- 22 * 22 * 22 * 22,
- 23 * 23 * 23 * 23,
- 24 * 24 * 24 * 24,
- 25 * 25 * 25 * 25,
- 26 * 26 * 26 * 26,
- 27 * 27 * 27 * 27,
- 28 * 28 * 28 * 28,
- 29 * 29 * 29 * 29,
- 30 * 30 * 30 * 30,
- 31 * 31 * 31 * 31,
- 32 * 32 * 32 * 32,
- 33 * 33 * 33,
- 34 * 34 * 34,
- 35 * 35 * 35,
- 36 * 36 * 36
- ];
-
- String toDebugString() => 'Int64[_l=$_l, _m=$_m, _h=$_h]';
-
- static Int64 _masked(int low, int medium, int high) =>
- Int64._bits(_MASK & low, _MASK & medium, _MASK2 & high);
-
- static Int64 _sub(int a0, int a1, int a2, int b0, int b1, int b2) {
- int diff0 = a0 - b0;
- int diff1 = a1 - b1 - ((diff0 >> _BITS) & 1);
- int diff2 = a2 - b2 - ((diff1 >> _BITS) & 1);
- return _masked(diff0, diff1, diff2);
- }
-
- static Int64 _negate(int b0, int b1, int b2) => _sub(0, 0, 0, b0, b1, b2);
-
- String _hexDigit(int digit) => '0123456789ABCDEF'[digit];
-
- // Work around dart2js bugs with negative arguments to '>>' operator.
- static int _shiftRight(int x, int n) {
- if (x >= 0) {
- return x >> n;
- } else {
- int shifted = x >> n;
- if (shifted >= 0x80000000) {
- shifted -= 4294967296;
- }
- return shifted;
- }
- }
-
- // Implementation of '~/', '%' and 'remainder'.
-
- static Int64 _divide(Int64 a, other, int what) {
- Int64 b = _promote(other);
- if (b.isZero) {
- // ignore: deprecated_member_use
- throw const IntegerDivisionByZeroException();
- }
- if (a.isZero) return ZERO;
-
- bool aNeg = a.isNegative;
- bool bNeg = b.isNegative;
- a = a.abs();
- b = b.abs();
-
- int a0 = a._l;
- int a1 = a._m;
- int a2 = a._h;
-
- int b0 = b._l;
- int b1 = b._m;
- int b2 = b._h;
- return _divideHelper(a0, a1, a2, aNeg, b0, b1, b2, bNeg, what);
- }
-
- static const _RETURN_DIV = 1;
- static const _RETURN_REM = 2;
- static const _RETURN_MOD = 3;
-
- static Int64 _divideHelper(
- // up to 64 bits unsigned in a2/a1/a0 and b2/b1/b0
- int a0,
- int a1,
- int a2,
- bool aNeg, // input A.
- int b0,
- int b1,
- int b2,
- bool bNeg, // input B.
- int what) {
- int q0 = 0, q1 = 0, q2 = 0; // result Q.
- int r0 = 0, r1 = 0, r2 = 0; // result R.
-
- if (b2 == 0 && b1 == 0 && b0 < (1 << (30 - _BITS))) {
- // Small divisor can be handled by single-digit division within Smi range.
- //
- // Handling small divisors here helps the estimate version below by
- // handling cases where the estimate is off by more than a small amount.
-
- q2 = a2 ~/ b0;
- int carry = a2 - q2 * b0;
- int d1 = a1 + (carry << _BITS);
- q1 = d1 ~/ b0;
- carry = d1 - q1 * b0;
- int d0 = a0 + (carry << _BITS);
- q0 = d0 ~/ b0;
- r0 = d0 - q0 * b0;
- } else {
- // Approximate Q = A ~/ B and R = A - Q * B using doubles.
-
- // The floating point approximation is very close to the correct value
- // when floor(A/B) fits in fewer that 53 bits.
-
- // We use double arithmetic for intermediate values. Double arithmetic on
- // non-negative values is exact under the following conditions:
- //
- // - The values are integer values that fit in 53 bits.
- // - Dividing by powers of two (adjusts exponent only).
- // - Floor (zeroes bits with fractional weight).
-
- const double K2 = 17592186044416.0; // 2^44
- const double K1 = 4194304.0; // 2^22
-
- // Approximate double values for [a] and [b].
- double ad = a0 + K1 * a1 + K2 * a2;
- double bd = b0 + K1 * b1 + K2 * b2;
- // Approximate quotient.
- double qd = (ad / bd).floorToDouble();
-
- // Extract components of [qd] using double arithmetic.
- double q2d = (qd / K2).floorToDouble();
- qd = qd - K2 * q2d;
- double q1d = (qd / K1).floorToDouble();
- double q0d = qd - K1 * q1d;
- q2 = q2d.toInt();
- q1 = q1d.toInt();
- q0 = q0d.toInt();
-
- assert(q0 + K1 * q1 + K2 * q2 == (ad / bd).floorToDouble());
- assert(q2 == 0 || b2 == 0); // Q and B can't both be big since Q*B <= A.
-
- // P = Q * B, using doubles to hold intermediates.
- // We don't need all partial sums since Q*B <= A.
- double p0d = q0d * b0;
- double p0carry = (p0d / K1).floorToDouble();
- p0d = p0d - p0carry * K1;
- double p1d = q1d * b0 + q0d * b1 + p0carry;
- double p1carry = (p1d / K1).floorToDouble();
- p1d = p1d - p1carry * K1;
- double p2d = q2d * b0 + q1d * b1 + q0d * b2 + p1carry;
- assert(p2d <= _MASK2); // No partial sum overflow.
-
- // R = A - P
- int diff0 = a0 - p0d.toInt();
- int diff1 = a1 - p1d.toInt() - ((diff0 >> _BITS) & 1);
- int diff2 = a2 - p2d.toInt() - ((diff1 >> _BITS) & 1);
- r0 = _MASK & diff0;
- r1 = _MASK & diff1;
- r2 = _MASK2 & diff2;
-
- // while (R < 0 || R >= B)
- // adjust R towards [0, B)
- while (r2 >= _SIGN_BIT_MASK ||
- r2 > b2 ||
- (r2 == b2 && (r1 > b1 || (r1 == b1 && r0 >= b0)))) {
- // Direction multiplier for adjustment.
- int m = (r2 & _SIGN_BIT_MASK) == 0 ? 1 : -1;
- // R = R - B or R = R + B
- int d0 = r0 - m * b0;
- int d1 = r1 - m * (b1 + ((d0 >> _BITS) & 1));
- int d2 = r2 - m * (b2 + ((d1 >> _BITS) & 1));
- r0 = _MASK & d0;
- r1 = _MASK & d1;
- r2 = _MASK2 & d2;
-
- // Q = Q + 1 or Q = Q - 1
- d0 = q0 + m;
- d1 = q1 + m * ((d0 >> _BITS) & 1);
- d2 = q2 + m * ((d1 >> _BITS) & 1);
- q0 = _MASK & d0;
- q1 = _MASK & d1;
- q2 = _MASK2 & d2;
- }
- }
-
- // 0 <= R < B
- assert(Int64.ZERO <= Int64._bits(r0, r1, r2));
- assert(r2 < b2 || // Handles case where B = -(MIN_VALUE)
- Int64._bits(r0, r1, r2) < Int64._bits(b0, b1, b2));
-
- assert(what == _RETURN_DIV || what == _RETURN_MOD || what == _RETURN_REM);
- if (what == _RETURN_DIV) {
- if (aNeg != bNeg) return _negate(q0, q1, q2);
- return Int64._masked(q0, q1, q2); // Masking for type inferrer.
- }
-
- if (!aNeg) {
- return Int64._masked(r0, r1, r2); // Masking for type inferrer.
- }
-
- if (what == _RETURN_MOD) {
- if (r0 == 0 && r1 == 0 && r2 == 0) {
- return ZERO;
- } else {
- return _sub(b0, b1, b2, r0, r1, r2);
- }
- } else {
- return _negate(r0, r1, r2);
- }
- }
-}
+// Use export below instead while working on the web implementation.
+// export 'int64_web.dart' if (dart.library.io) 'int64_native.dart';
diff --git a/lib/src/int64_native.dart b/lib/src/int64_native.dart
new file mode 100644
index 0000000..5ff622a
--- /dev/null
+++ b/lib/src/int64_native.dart
@@ -0,0 +1,561 @@
+// 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.
+
+// ignore_for_file: constant_identifier_names
+
+// Many locals are declared as `int` or `double`. We keep local variable types
+// because the types are critical to the efficiency of many operations.
+//
+// ignore_for_file: omit_local_variable_types
+
+import 'dart:typed_data';
+
+import 'int32.dart';
+import 'intx.dart';
+import 'utilities.dart' as u;
+
+/// An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
+///
+/// Arithmetic operations may overflow in order to maintain this range.
+class Int64 implements IntX {
+ /// The 64-bit value.
+ final int _value;
+
+ // Minimal 64-bit value, -2^63.
+ static const int _minValue = -9223372036854775808;
+ // Maximal 64-bit value, 2^63 - 1.
+ static const int _maxValue = 9223372036854775807;
+
+ /// The maximum positive value attainable by an [Int64], namely
+ /// 9,223,372,036,854,775,807.
+ static const Int64 MAX_VALUE = Int64._(_maxValue);
+
+ /// The minimum positive value attainable by an [Int64], namely
+ /// -9,223,372,036,854,775,808.
+ static const Int64 MIN_VALUE = Int64._(_minValue);
+
+ /// An [Int64] constant equal to 0.
+ static const Int64 ZERO = Int64._(0);
+
+ /// An [Int64] constant equal to 1.
+ static const Int64 ONE = Int64._(1);
+
+ /// An [Int64] constant equal to 2.
+ static const Int64 TWO = Int64._(2);
+
+ /// Constructs an [Int64] with a given value.
+ const Int64._(this._value);
+
+ /// Parses [source] in a given [radix] between 2 and 36.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of base-[radix]
+ /// digits (using letters from `a` to `z` as digits with values 10 through
+ /// 25 for radixes above 10), possibly prefixed by a `-` sign.
+ ///
+ /// Throws a [FormatException] if the input is not recognized as a valid
+ /// integer numeral.
+ static Int64 parseRadix(String source, int radix) =>
+ Int64._(_parse(source, u.validateRadix(radix), true)!);
+
+ /// Parses [source] in a given [radix] between 2 and 36.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of base-[radix]
+ /// digits (using letters from `a` to `z` as digits with values 10 through
+ /// 25 for radixes above 10), possibly prefixed by a `-` sign.
+ ///
+ /// Returns `null` if the input is not recognized as a valid
+ /// integer numeral.
+ static Int64? tryParseRadix(String source, int radix) {
+ var value = _parse(source, u.validateRadix(radix), false);
+ return value == null ? null : Int64._(value);
+ }
+
+ /// Parses [source] as a decimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of digits (`0`-`9`),
+ /// possibly prefixed by a `-` sign.
+ ///
+ /// Throws a [FormatException] if the input is not a valid
+ /// decimal integer numeral.
+ static Int64 parseInt(String source) => Int64._(_parse(source, 10, true)!);
+
+ /// Parses [source] as a decimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of digits (`0`-`9`),
+ /// possibly prefixed by a `-` sign.
+ ///
+ /// Returns `null` if the input is not a valid
+ /// decimal integer numeral.
+ static Int64? tryParseInt(String source) {
+ var value = _parse(source, 10, false);
+ return value == null ? null : Int64._(value);
+ }
+
+ /// Parses [source] as a hexadecimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of hexadecimal
+ /// digits (`0`-`9`, `a`-`f` or `A`-`F`), possibly prefixed by a `-` sign.
+ ///
+ /// Throws a [FormatException] if the input is not a valid
+ /// hexadecimal integer numeral.
+ static Int64 parseHex(String source) => Int64._(_parse(source, 16, true)!);
+
+ /// Parses [source] as a hexadecimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of hexadecimal
+ /// digits (`0`-`9`, `a`-`f` or `A`-`F`), possibly prefixed by a `-` sign.
+ ///
+ /// Returns `null` if the input is not a valid
+ /// hexadecimal integer numeral.
+ static Int64? tryParseHex(String source) {
+ var value = _parse(source, 16, false);
+ return value == null ? null : Int64._(value);
+ }
+
+ /// Parses [source] as a base [radix] number.
+ ///
+ /// Unlike `int.parse`, it allows over-long numerals, and truncates
+ /// the result.
+ static int? _parse(String source, int radix, bool throwOnError) {
+ // Try using `int.parse` first. If it works, we're set.
+ var fastResult = int.tryParse(source, radix: radix);
+ if (fastResult != null) return fastResult;
+ // If not, the input is either invalid, or too long for `int.parse`,
+ // and we need to truncate the value.
+ var negative = false;
+ var index = 0;
+ if (source.startsWith('-')) {
+ negative = true;
+ index = 1;
+ }
+ if (index == source.length) {
+ if (throwOnError) {
+ throw FormatException("No digits", source, index);
+ }
+ return null;
+ }
+ var result = 0;
+ while (index < source.length) {
+ var char = source.codeUnitAt(index);
+ var digit = u.decodeDigit(char);
+ if (digit < radix) {
+ result = result * radix + digit;
+ index++;
+ } else {
+ if (throwOnError) {
+ throw FormatException("Not a radix $radix digit", source, index);
+ }
+ return null;
+ }
+ }
+ return negative ? -result : result;
+ }
+
+ //
+ // Public constructors
+ //
+
+ /// Constructs an [Int64] with a given [int] value; zero by default.
+ factory Int64([int value = 0]) => Int64._(value);
+
+ factory Int64.fromBytes(List<int> bytes) {
+ var result = 0;
+ for (var i = 7; i >= 0; i--) {
+ result = (result << 8) | (bytes[i] & 0xFF);
+ }
+ return Int64._(result);
+ }
+
+ factory Int64.fromBytesBigEndian(List<int> bytes) {
+ var result = 0;
+ for (var i = 0; i < 8; i++) {
+ result = (result << 8) | (bytes[i] & 0xFF);
+ }
+ return Int64._(result);
+ }
+
+ /// Constructs an [Int64] from a pair of 32-bit integers having the value
+ /// [:((top & 0xffffffff) << 32) | (bottom & 0xffffffff):].
+ factory Int64.fromInts(int top, int bottom) => Int64._(top << 32 | bottom);
+
+ // Returns the [Int64] representation of the specified value. Throws
+ // [ArgumentError] for non-integer arguments.
+ static int _promote(value) {
+ if (value is Int64) {
+ return value._value;
+ } else if (value is int) {
+ return value;
+ } else if (value is Int32) {
+ return value.toInt();
+ }
+ throw ArgumentError.value(value, 'other', 'not an int, Int32 or Int64');
+ }
+
+ @override
+ Int64 operator +(Object other) {
+ int o = _promote(other);
+ return Int64._(_value + o);
+ }
+
+ @override
+ Int64 operator -(Object other) {
+ int o = _promote(other);
+ return Int64._(_value - o);
+ }
+
+ @override
+ Int64 operator -() => Int64._(-_value);
+
+ @override
+ Int64 operator *(Object other) {
+ int o = _promote(other);
+ return Int64._(_value * o);
+ }
+
+ @override
+ Int64 operator %(Object other) {
+ int o = _promote(other);
+ return Int64._(_value % o);
+ }
+
+ @override
+ Int64 operator ~/(Object other) {
+ int o = _promote(other);
+ return Int64._(_value ~/ o);
+ }
+
+ @override
+ Int64 remainder(Object other) {
+ int o = _promote(other);
+ return Int64._(_value.remainder(o));
+ }
+
+ @override
+ Int64 operator &(Object other) {
+ int o = _promote(other);
+ return Int64._(_value & o);
+ }
+
+ @override
+ Int64 operator |(Object other) {
+ int o = _promote(other);
+ return Int64._(_value | o);
+ }
+
+ @override
+ Int64 operator ^(Object other) {
+ int o = _promote(other);
+ return Int64._(_value ^ o);
+ }
+
+ @override
+ Int64 operator ~() => Int64._(~_value);
+
+ @override
+ Int64 operator <<(int n) => Int64._(_value << n);
+
+ @override
+ Int64 operator >>(int n) => Int64._(_value >> n);
+
+ @override
+ Int64 shiftRightUnsigned(int n) => Int64._(_value >>> n);
+
+ /// Returns [:true:] if this [Int64] has the same numeric value as the
+ /// given object. The argument may be an [int] or an [IntX].
+ @override
+ bool operator ==(Object other) {
+ if (other is Int64) {
+ return _value == other._value;
+ } else if (other is int) {
+ return _value == other;
+ } else if (other is Int32) {
+ return _value == other.toInt();
+ }
+ return false;
+ }
+
+ @override
+ int compareTo(Object other) => _value.compareTo(_promote(other));
+
+ @override
+ bool operator <(Object other) => _value < _promote(other);
+
+ @override
+ bool operator <=(Object other) => _value <= _promote(other);
+
+ @override
+ bool operator >(Object other) => _value > _promote(other);
+
+ @override
+ bool operator >=(Object other) => _value >= _promote(other);
+
+ @override
+ bool get isEven => _value.isEven;
+
+ @override
+ bool get isMaxValue => _value == _maxValue;
+
+ @override
+ bool get isMinValue => _value == _minValue;
+
+ @override
+ bool get isNegative => _value < 0;
+
+ @override
+ bool get isOdd => _value.isOdd;
+
+ @override
+ bool get isZero => _value == 0;
+
+ @override
+ int get bitLength => _value.bitLength;
+
+ /// Returns a hash code based on all the bits of this [Int64].
+ @override
+ int get hashCode => _value.hashCode;
+
+ @override
+ Int64 abs() => _value < 0 ? Int64._(-_value) : this;
+
+ @override
+ Int64 clamp(Object lowerLimit, Object upperLimit) {
+ if (lowerLimit is Int64) {
+ if (_value < lowerLimit._value) return lowerLimit;
+ } else {
+ int lower = _promote(lowerLimit);
+ if (_value < lower) return Int64._(lower);
+ }
+ if (upperLimit is Int64) {
+ if (_value > upperLimit._value) return upperLimit;
+ } else {
+ int upper = _promote(upperLimit);
+ if (_value > upper) return Int64._(upper);
+ }
+ return this;
+ }
+
+ /// Returns the number of leading zeros in this [Int64] as an [int]
+ /// between 0 and 64.
+ @override
+ int numberOfLeadingZeros() => _value < 0 ? 0 : 64 - _value.bitLength;
+
+ /// Returns the number of trailing zeros in this [Int64] as an [int]
+ /// between 0 and 64.
+ @override
+ int numberOfTrailingZeros() {
+ var value = _value;
+ if (value == 0) return 64;
+ // Set every bit up to and including the lowest set bit, clear the rest.
+ value ^= value - 1;
+ // Count of bits is number of trailing zeros plus one.
+ if (value >= 0 && value < 0x100000000) {
+ // u.bitCount only works up to 32-bit values.
+ return u.bitCount(value) - 1;
+ }
+ return 31 + u.bitCount(value >>> 32);
+ }
+
+ @override
+ Int64 toSigned(int width) {
+ if (width < 1 || width > 64) throw RangeError.range(width, 1, 64);
+ return Int64._(_value.toSigned(width));
+ }
+
+ @override
+ Int64 toUnsigned(int width) {
+ if (width < 0 || width > 64) throw RangeError.range(width, 0, 64);
+ return Int64._(_value.toUnsigned(width));
+ }
+
+ @override
+ List<int> toBytes() {
+ var result = List<int>.filled(8, 0);
+ var value = _value;
+ for (var i = 0; i < 8 && value != 0; i++) {
+ result[i] = value & 0xFF;
+ value >>= 8;
+ }
+ return result;
+ }
+
+ @override
+ double toDouble() => _value.toDouble();
+
+ @override
+ int toInt() => _value;
+
+ /// Returns an [Int32] containing the low 32 bits of this [Int64].
+ @override
+ Int32 toInt32() => Int32(_value & 0xFFFFFFFF);
+
+ /// Returns `this`.
+ @override
+ Int64 toInt64() => this;
+
+ /// Returns the value of this [Int64] as a decimal [String].
+ @override
+ String toString() => _value.toString();
+
+ @override
+ String toHexString() {
+ if (_value >= 0) return _value.toRadixString(16).toUpperCase();
+ return _toRadixStringUnsignedPow2(16, _value);
+ }
+
+ /// Returns the digits of `this` when interpreted as an unsigned 64-bit value.
+ String toStringUnsigned() {
+ if (_value >= 0) return _value.toString();
+ return _toRadixStringUnsigned(10, _value);
+ }
+
+ String toRadixStringUnsigned(int radix) {
+ if (_value >= 0) {
+ var result = _value.toRadixString(radix);
+ if (radix > 10) result = result.toUpperCase();
+ return result;
+ }
+ return _toRadixStringUnsigned(u.validateRadix(radix), _value);
+ }
+
+ @override
+ String toRadixString(int radix) =>
+ _value.toRadixString(u.validateRadix(radix));
+
+ // Reusable buffer.
+ static final Uint8List _buffer = Uint8List(64);
+
+ static String _toRadixStringUnsignedPow2(int radix, int value) {
+ var buffer = _buffer;
+ assert(value < 0);
+ var bits = u.bitCount(radix - 1);
+ var mask = radix - 1;
+ var index = 64;
+ while (value != 0) {
+ buffer[--index] = u.radixDigits.codeUnitAt(value & mask);
+ value >>>= bits;
+ }
+ return String.fromCharCodes(Uint8List.sublistView(buffer, index));
+ }
+
+ static String _toRadixStringUnsigned(int radix, int value) {
+ if (u.isPowerOf2(radix)) {
+ // 16 is likely to be the most common radix for unsigned,
+ // so use a faster approach, which works for all powers of 2.
+ return _toRadixStringUnsignedPow2(radix, value);
+ }
+ // Consider adding a special case for radix 10, if it's commonly used.
+
+ assert(value < 0);
+ // Remove sign bit, since it affects numerical value.
+ // Correct for missing 2^63 after first division.
+ value &= 0x7FFFFFFFFFFFFFFF;
+
+ var buffer = _buffer;
+ var index = 64;
+
+ var digit = value.remainder(radix);
+ value ~/= radix;
+ // Correct for missing 2^63.
+ // Table is (2^63 ~/ radix, 2^63 % radix) pairs, starting from radix 3.
+ value += _toUnsignedTable[radix * 2 - 6];
+ digit += _toUnsignedTable[radix * 2 - 5];
+ if (digit >= radix) {
+ digit -= radix;
+ value += 1;
+ }
+ buffer[--index] = u.radixDigits.codeUnitAt(digit);
+
+ do {
+ var digit = value.remainder(radix);
+ value ~/= radix;
+ buffer[--index] = u.radixDigits.codeUnitAt(digit);
+ } while (value != 0);
+
+ return String.fromCharCodes(Uint8List.sublistView(buffer, index));
+ }
+
+ /// Table of 2^63 ~/ radix and 2^63 % radix for radix 3-36.
+ ///
+ /// Omits powers of two, since they use a simpler algorthm.
+ static const List<int> _toUnsignedTable = [
+ 3074457345618258602, 2, // 3
+ 0, 0, // 4
+ 1844674407370955161, 3, // 5
+ 1537228672809129301, 2, // 6
+ 1317624576693539401, 1, // 7
+ 0, 0, // 8
+ 1024819115206086200, 8, // 9
+ 922337203685477580, 8, // 10
+ 838488366986797800, 8, // 11
+ 768614336404564650, 8, // 12
+ 709490156681136600, 8, // 13
+ 658812288346769700, 8, // 14
+ 614891469123651720, 8, // 15
+ 0, 0, // 16
+ 542551296285575047, 9, // 17
+ 512409557603043100, 8, // 18
+ 485440633518672410, 18, // 19
+ 461168601842738790, 8, // 20
+ 439208192231179800, 8, // 21
+ 419244183493398900, 8, // 22
+ 401016175515425035, 3, // 23
+ 384307168202282325, 8, // 24
+ 368934881474191032, 8, // 25
+ 354745078340568300, 8, // 26
+ 341606371735362066, 26, // 27
+ 329406144173384850, 8, // 28
+ 318047311615681924, 12, // 29
+ 307445734561825860, 8, // 30
+ 297528130221121800, 8, // 31
+ 0, 0, // 32
+ 279496122328932600, 8, // 33
+ 271275648142787523, 26, // 34
+ 263524915338707880, 8, // 35
+ 256204778801521550, 8, // 36
+ ];
+
+ String toDebugString() => 'Int64[$_value]';
+}
diff --git a/lib/src/int64_web.dart b/lib/src/int64_web.dart
new file mode 100644
index 0000000..b0485a1
--- /dev/null
+++ b/lib/src/int64_web.dart
@@ -0,0 +1,1129 @@
+// 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.
+
+// ignore_for_file: constant_identifier_names
+
+// Many locals are declared as `int` or `double`. We keep local variable types
+// because the types are critical to the efficiency of many operations.
+//
+// ignore_for_file: omit_local_variable_types
+
+import 'int32.dart';
+import 'intx.dart';
+import 'utilities.dart' as u;
+
+/// An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
+/// Arithmetic operations may overflow in order to maintain this range.
+class Int64 implements IntX {
+ // A 64-bit integer is represented internally as three non-negative
+ // integers, storing the 22 low, 22 middle, and 20 high bits of the
+ // 64-bit value. _l (low) and _m (middle) are in the range
+ // [0, 2^22 - 1] and _h (high) is in the range [0, 2^20 - 1].
+ //
+ // The values being assigned to _l, _m and _h in initialization are masked to
+ // force them into the above ranges. Sometimes we know that the value is a
+ // small non-negative integer but the dart2js compiler can't infer that, so a
+ // few of the masking operations are not needed for correctness but are
+ // helpful for dart2js code quality.
+
+ final int _l, _m, _h;
+
+ // Note: several functions require _BITS == 22 -- do not change this value.
+ static const int _BITS = 22;
+ static const int _BITS01 = 44; // 2 * _BITS
+ static const int _BITS2 = 20; // 64 - _BITS01
+ static const int _MASK = 4194303; // (1 << _BITS) - 1
+ static const int _MASK2 = 1048575; // (1 << _BITS2) - 1
+ static const int _SIGN_BIT = 19; // _BITS2 - 1
+ static const int _SIGN_BIT_MASK = 1 << _SIGN_BIT;
+
+ /// The maximum positive value attainable by an [Int64], namely
+ /// 9,223,372,036,854,775,807.
+ static const Int64 MAX_VALUE = Int64._bits(_MASK, _MASK, _MASK2 >> 1);
+
+ /// The minimum positive value attainable by an [Int64], namely
+ /// -9,223,372,036,854,775,808.
+ static const Int64 MIN_VALUE = Int64._bits(0, 0, _SIGN_BIT_MASK);
+
+ /// An [Int64] constant equal to 0.
+ static const Int64 ZERO = Int64._bits(0, 0, 0);
+
+ /// An [Int64] constant equal to 1.
+ static const Int64 ONE = Int64._bits(1, 0, 0);
+
+ /// An [Int64] constant equal to 2.
+ static const Int64 TWO = Int64._bits(2, 0, 0);
+
+ /// Constructs an [Int64] with a given bitwise representation. No validation
+ /// is performed.
+ const Int64._bits(this._l, this._m, this._h);
+
+ /// Parses [source] in a given [radix] between 2 and 36.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of base-[radix]
+ /// digits (using letters from `a` to `z` as digits with values 10 through
+ /// 25 for radixes above 10), possibly prefixed by a `-` sign.
+ ///
+ /// Throws a [FormatException] if the input is not recognized as a valid
+ /// integer numeral.
+ static Int64 parseRadix(String source, int radix) =>
+ _parseRadix(source, u.validateRadix(radix), true)!;
+
+ /// Parses [source] in a given [radix] between 2 and 36.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of base-[radix]
+ /// digits (using letters from `a` to `z` as digits with values 10 through
+ /// 25 for radixes above 10), possibly prefixed by a `-` sign.
+ ///
+ /// Returns `null` if the input is not recognized as a valid
+ /// integer numeral.
+ static Int64? tryParseRadix(String source, int radix) =>
+ _parseRadix(source, u.validateRadix(radix), false);
+
+ static Int64? _parseRadix(String s, int radix, bool throwOnError) {
+ int i = 0;
+ bool negative = false;
+ if (s.startsWith('-')) {
+ negative = true;
+ i++;
+ }
+
+ if (i >= s.length) {
+ if (!throwOnError) return null;
+ throw FormatException('No digits', s, i);
+ }
+
+ int d0 = 0, d1 = 0, d2 = 0; // low, middle, high components.
+ for (; i < s.length; i++) {
+ int c = s.codeUnitAt(i);
+ int digit = u.decodeDigit(c);
+ if (digit < radix) {
+ // [radix] and [digit] are at most 6 bits, component is 22, so we can
+ // multiply and add within 30 bit temporary values.
+ d0 = d0 * radix + digit;
+ int carry = d0 >> _BITS;
+ d0 = _MASK & d0;
+
+ d1 = d1 * radix + carry;
+ carry = d1 >> _BITS;
+ d1 = _MASK & d1;
+
+ d2 = d2 * radix + carry;
+ d2 = _MASK2 & d2;
+ } else {
+ if (!throwOnError) return null;
+ throw FormatException('Not radix digit', s, i);
+ }
+ }
+
+ if (negative) return _negate(d0, d1, d2);
+
+ return Int64._masked(d0, d1, d2);
+ }
+
+ /// Parses [source] as a decimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of digits (`0`-`9`),
+ /// possibly prefixed by a `-` sign.
+ ///
+ /// Throws a [FormatException] if the input is not a valid
+ /// decimal integer numeral.
+ static Int64 parseInt(String source) => _parseRadix(source, 10, true)!;
+
+ /// Parses [source] as a decimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of digits (`0`-`9`),
+ /// possibly prefixed by a `-` sign.
+ ///
+ /// Returns `null` if the input is not a valid
+ /// decimal integer numeral.
+ static Int64? tryParseInt(String source) => _parseRadix(source, 10, false);
+
+ /// Parses [source] as a hexadecimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of hexadecimal
+ /// digits (`0`-`9`, `a`-`f` or `A`-`F`), possibly prefixed by a `-` sign.
+ ///
+ /// Throws a [FormatException] if the input is not a valid
+ /// hexadecimal integer numeral.
+ static Int64 parseHex(String source) => _parseRadix(source, 16, true)!;
+
+ /// Parses [source] as a hexadecimal numeral.
+ ///
+ /// Returns an [Int64] with the numerical value of [source].
+ /// If the numerical value of [source] does not fit
+ /// in a signed 64 bit integer,
+ /// the numerical value is truncated to the lowest 64 bits
+ /// of the value's binary representation,
+ /// interpreted as a 64-bit two's complement integer.
+ ///
+ /// The [source] string must contain a sequence of hexadecimal
+ /// digits (`0`-`9`, `a`-`f` or `A`-`F`), possibly prefixed by a `-` sign.
+ ///
+ /// Returns `null` if the input is not a valid
+ /// hexadecimal integer numeral.
+ static Int64? tryParseHex(String source) => _parseRadix(source, 16, false);
+
+ //
+ // Public constructors
+ //
+
+ /// Constructs an [Int64] with a given [int] value; zero by default.
+ factory Int64([int value = 0]) {
+ int v0 = 0, v1 = 0, v2 = 0;
+ bool negative = false;
+ if (value < 0) {
+ negative = true;
+ value = -value;
+ }
+ // Avoid using bitwise operations that in JavaScript coerce their input to
+ // 32 bits.
+ v2 = value ~/ 17592186044416; // 2^44
+ value -= v2 * 17592186044416;
+ v1 = value ~/ 4194304; // 2^22
+ value -= v1 * 4194304;
+ v0 = value;
+
+ return negative
+ ? Int64._negate(_MASK & v0, _MASK & v1, _MASK2 & v2)
+ : Int64._masked(v0, v1, v2);
+ }
+
+ factory Int64.fromBytes(List<int> bytes) {
+ // 20 bits into top, 22 into middle and bottom.
+ var split1 = bytes[5] & 0xFF;
+ var high =
+ ((bytes[7] & 0xFF) << 12) | ((bytes[6] & 0xFF) << 4) | (split1 >> 4);
+ var split2 = bytes[2] & 0xFF;
+ var middle = (split1 << 18) |
+ ((bytes[4] & 0xFF) << 10) |
+ ((bytes[3] & 0xFF) << 2) |
+ (split2 >> 6);
+ var low = (split2 << 16) | ((bytes[1] & 0xFF) << 8) | (bytes[0] & 0xFF);
+ // Top bits from above will be masked off here.
+ return Int64._masked(low, middle, high);
+ }
+
+ factory Int64.fromBytesBigEndian(List<int> bytes) {
+ var split1 = bytes[2] & 0xFF;
+ var high =
+ ((bytes[0] & 0xFF) << 12) | ((bytes[1] & 0xFF) << 4) | (split1 >> 4);
+ var split2 = bytes[5] & 0xFF;
+ var middle = (split1 << 18) |
+ ((bytes[3] & 0xFF) << 10) |
+ ((bytes[4] & 0xFF) << 2) |
+ (split2 >> 6);
+ var low = (split2 << 16) | ((bytes[6] & 0xFF) << 8) | (bytes[7] & 0xFF);
+ // Top bits from above will be masked off here.
+ return Int64._masked(low, middle, high);
+ }
+
+ /// Constructs an [Int64] from a pair of 32-bit integers having the value
+ /// [:((top & 0xffffffff) << 32) | (bottom & 0xffffffff):].
+ factory Int64.fromInts(int top, int bottom) {
+ top &= 0xffffffff;
+ bottom &= 0xffffffff;
+ int d0 = _MASK & bottom;
+ int d1 = ((0xfff & top) << 10) | (0x3ff & (bottom >> _BITS));
+ int d2 = _MASK2 & (top >> 12);
+ return Int64._masked(d0, d1, d2);
+ }
+
+ // Returns the [Int64] representation of the specified value. Throws
+ // [ArgumentError] for non-integer arguments.
+ static Int64 _promote(value) {
+ if (value is Int64) {
+ return value;
+ } else if (value is int) {
+ return Int64(value);
+ } else if (value is Int32) {
+ return value.toInt64();
+ }
+ throw ArgumentError.value(value, 'other', 'not an int, Int32 or Int64');
+ }
+
+ @override
+ Int64 operator +(Object other) {
+ Int64 o = _promote(other);
+ int sum0 = _l + o._l;
+ int sum1 = _m + o._m + (sum0 >> _BITS);
+ int sum2 = _h + o._h + (sum1 >> _BITS);
+ return Int64._masked(sum0, sum1, sum2);
+ }
+
+ @override
+ Int64 operator -(Object other) {
+ Int64 o = _promote(other);
+ return _sub(_l, _m, _h, o._l, o._m, o._h);
+ }
+
+ @override
+ Int64 operator -() => _negate(_l, _m, _h);
+
+ @override
+ Int64 operator *(Object other) {
+ Int64 o = _promote(other);
+
+ // Grab 13-bit chunks.
+ int a0 = _l & 0x1fff;
+ int a1 = (_l >> 13) | ((_m & 0xf) << 9);
+ int a2 = (_m >> 4) & 0x1fff;
+ int a3 = (_m >> 17) | ((_h & 0xff) << 5);
+ int a4 = (_h & 0xfff00) >> 8;
+
+ int b0 = o._l & 0x1fff;
+ int b1 = (o._l >> 13) | ((o._m & 0xf) << 9);
+ int b2 = (o._m >> 4) & 0x1fff;
+ int b3 = (o._m >> 17) | ((o._h & 0xff) << 5);
+ int b4 = (o._h & 0xfff00) >> 8;
+
+ // Compute partial products.
+ // Optimization: if b is small, avoid multiplying by parts that are 0.
+ int p0 = a0 * b0; // << 0
+ int p1 = a1 * b0; // << 13
+ int p2 = a2 * b0; // << 26
+ int p3 = a3 * b0; // << 39
+ int p4 = a4 * b0; // << 52
+
+ if (b1 != 0) {
+ p1 += a0 * b1;
+ p2 += a1 * b1;
+ p3 += a2 * b1;
+ p4 += a3 * b1;
+ }
+ if (b2 != 0) {
+ p2 += a0 * b2;
+ p3 += a1 * b2;
+ p4 += a2 * b2;
+ }
+ if (b3 != 0) {
+ p3 += a0 * b3;
+ p4 += a1 * b3;
+ }
+ if (b4 != 0) {
+ p4 += a0 * b4;
+ }
+
+ // Accumulate into 22-bit chunks:
+ // .........................................c10|...................c00|
+ // |....................|..................xxxx|xxxxxxxxxxxxxxxxxxxxxx| p0
+ // |....................|......................|......................|
+ // |....................|...................c11|......c01.............|
+ // |....................|....xxxxxxxxxxxxxxxxxx|xxxxxxxxx.............| p1
+ // |....................|......................|......................|
+ // |.................c22|...............c12....|......................|
+ // |..........xxxxxxxxxx|xxxxxxxxxxxxxxxxxx....|......................| p2
+ // |....................|......................|......................|
+ // |.................c23|..c13.................|......................|
+ // |xxxxxxxxxxxxxxxxxxxx|xxxxx.................|......................| p3
+ // |....................|......................|......................|
+ // |.........c24........|......................|......................|
+ // |xxxxxxxxxxxx........|......................|......................| p4
+
+ int c00 = p0 & 0x3fffff;
+ int c01 = (p1 & 0x1ff) << 13;
+ int c0 = c00 + c01;
+
+ int c10 = p0 >> 22;
+ int c11 = p1 >> 9;
+ int c12 = (p2 & 0x3ffff) << 4;
+ int c13 = (p3 & 0x1f) << 17;
+ int c1 = c10 + c11 + c12 + c13;
+
+ int c22 = p2 >> 18;
+ int c23 = p3 >> 5;
+ int c24 = (p4 & 0xfff) << 8;
+ int c2 = c22 + c23 + c24;
+
+ // Propagate high bits from c0 -> c1, c1 -> c2.
+ c1 += c0 >> _BITS;
+ c2 += c1 >> _BITS;
+
+ return Int64._masked(c0, c1, c2);
+ }
+
+ @override
+ Int64 operator %(Object other) => _divide(this, other, _RETURN_MOD);
+
+ @override
+ Int64 operator ~/(Object other) => _divide(this, other, _RETURN_DIV);
+
+ @override
+ Int64 remainder(Object other) => _divide(this, other, _RETURN_REM);
+
+ @override
+ Int64 operator &(Object other) {
+ Int64 o = _promote(other);
+ int a0 = _l & o._l;
+ int a1 = _m & o._m;
+ int a2 = _h & o._h;
+ return Int64._masked(a0, a1, a2);
+ }
+
+ @override
+ Int64 operator |(Object other) {
+ Int64 o = _promote(other);
+ int a0 = _l | o._l;
+ int a1 = _m | o._m;
+ int a2 = _h | o._h;
+ return Int64._masked(a0, a1, a2);
+ }
+
+ @override
+ Int64 operator ^(Object other) {
+ Int64 o = _promote(other);
+ int a0 = _l ^ o._l;
+ int a1 = _m ^ o._m;
+ int a2 = _h ^ o._h;
+ return Int64._masked(a0, a1, a2);
+ }
+
+ @override
+ Int64 operator ~() => Int64._masked(~_l, ~_m, ~_h);
+
+ @override
+ Int64 operator <<(int n) {
+ if (n < 0) {
+ throw ArgumentError.value(n);
+ }
+ if (n >= 64) {
+ return ZERO;
+ }
+
+ int res0, res1, res2;
+ if (n < _BITS) {
+ res0 = _l << n;
+ res1 = (_m << n) | (_l >> (_BITS - n));
+ res2 = (_h << n) | (_m >> (_BITS - n));
+ } else if (n < _BITS01) {
+ res0 = 0;
+ res1 = _l << (n - _BITS);
+ res2 = (_m << (n - _BITS)) | (_l >> (_BITS01 - n));
+ } else {
+ res0 = 0;
+ res1 = 0;
+ res2 = _l << (n - _BITS01);
+ }
+
+ return Int64._masked(res0, res1, res2);
+ }
+
+ @override
+ Int64 operator >>(int n) {
+ if (n < 0) {
+ throw ArgumentError.value(n);
+ }
+ if (n >= 64) {
+ return isNegative ? const Int64._bits(_MASK, _MASK, _MASK2) : ZERO;
+ }
+
+ int res0, res1, res2;
+
+ // Sign extend h(a).
+ int a2 = _h;
+ bool negative = (a2 & _SIGN_BIT_MASK) != 0;
+ if (negative && _MASK > _MASK2) {
+ // Add extra one bits on the left so the sign gets shifted into the wider
+ // lower words.
+ a2 += _MASK - _MASK2;
+ }
+
+ if (n < _BITS) {
+ res2 = _shiftRight(a2, n);
+ if (negative) {
+ res2 |= _MASK2 & ~(_MASK2 >> n);
+ }
+ res1 = _shiftRight(_m, n) | (a2 << (_BITS - n));
+ res0 = _shiftRight(_l, n) | (_m << (_BITS - n));
+ } else if (n < _BITS01) {
+ res2 = negative ? _MASK2 : 0;
+ res1 = _shiftRight(a2, n - _BITS);
+ if (negative) {
+ res1 |= _MASK & ~(_MASK >> (n - _BITS));
+ }
+ res0 = _shiftRight(_m, n - _BITS) | (a2 << (_BITS01 - n));
+ } else {
+ res2 = negative ? _MASK2 : 0;
+ res1 = negative ? _MASK : 0;
+ res0 = _shiftRight(a2, n - _BITS01);
+ if (negative) {
+ res0 |= _MASK & ~(_MASK >> (n - _BITS01));
+ }
+ }
+
+ return Int64._masked(res0, res1, res2);
+ }
+
+ @override
+ Int64 shiftRightUnsigned(int n) {
+ if (n < 0) {
+ throw ArgumentError.value(n);
+ }
+ if (n >= 64) {
+ return ZERO;
+ }
+
+ int res0, res1, res2;
+ int a2 = _MASK2 & _h; // Ensure a2 is positive.
+ if (n < _BITS) {
+ res2 = a2 >> n;
+ res1 = (_m >> n) | (a2 << (_BITS - n));
+ res0 = (_l >> n) | (_m << (_BITS - n));
+ } else if (n < _BITS01) {
+ res2 = 0;
+ res1 = a2 >> (n - _BITS);
+ res0 = (_m >> (n - _BITS)) | (_h << (_BITS01 - n));
+ } else {
+ res2 = 0;
+ res1 = 0;
+ res0 = a2 >> (n - _BITS01);
+ }
+
+ return Int64._masked(res0, res1, res2);
+ }
+
+ /// Returns [:true:] if this [Int64] has the same numeric value as the
+ /// given object. The argument may be an [int] or an [IntX].
+ @override
+ bool operator ==(Object other) {
+ Int64? o;
+ if (other is Int64) {
+ o = other;
+ } else if (other is int) {
+ if (_h == 0 && _m == 0) return _l == other;
+ // Since we know one of [_h] or [_m] is non-zero, if [other] fits in the
+ // low word then it can't be numerically equal.
+ if ((_MASK & other) == other) return false;
+ o = Int64(other);
+ } else if (other is Int32) {
+ o = other.toInt64();
+ }
+ if (o != null) {
+ return _l == o._l && _m == o._m && _h == o._h;
+ }
+ return false;
+ }
+
+ @override
+ int compareTo(Object other) => _compareTo(other);
+
+ int _compareTo(Object other) {
+ Int64 o = _promote(other);
+ int signa = _h >> (_BITS2 - 1);
+ int signb = o._h >> (_BITS2 - 1);
+ if (signa != signb) {
+ return signa == 0 ? 1 : -1;
+ }
+ if (_h > o._h) {
+ return 1;
+ } else if (_h < o._h) {
+ return -1;
+ }
+ if (_m > o._m) {
+ return 1;
+ } else if (_m < o._m) {
+ return -1;
+ }
+ if (_l > o._l) {
+ return 1;
+ } else if (_l < o._l) {
+ return -1;
+ }
+ return 0;
+ }
+
+ @override
+ bool operator <(Object other) => _compareTo(other) < 0;
+
+ @override
+ bool operator <=(Object other) => _compareTo(other) <= 0;
+
+ @override
+ bool operator >(Object other) => _compareTo(other) > 0;
+
+ @override
+ bool operator >=(Object other) => _compareTo(other) >= 0;
+
+ @override
+ bool get isEven => (_l & 0x1) == 0;
+
+ @override
+ bool get isMaxValue => (_h == _MASK2 >> 1) && _m == _MASK && _l == _MASK;
+
+ @override
+ bool get isMinValue => _h == _SIGN_BIT_MASK && _m == 0 && _l == 0;
+
+ @override
+ bool get isNegative => (_h & _SIGN_BIT_MASK) != 0;
+
+ @override
+ bool get isOdd => (_l & 0x1) == 1;
+
+ @override
+ bool get isZero => _h == 0 && _m == 0 && _l == 0;
+
+ @override
+ int get bitLength {
+ if (isZero) return 0;
+ int a0 = _l, a1 = _m, a2 = _h;
+ if (isNegative) {
+ a0 = _MASK & ~a0;
+ a1 = _MASK & ~a1;
+ a2 = _MASK2 & ~a2;
+ }
+ if (a2 != 0) return _BITS01 + a2.bitLength;
+ if (a1 != 0) return _BITS + a1.bitLength;
+ return a0.bitLength;
+ }
+
+ /// Returns a hash code based on all the bits of this [Int64].
+ @override
+ int get hashCode {
+ // TODO(sra): Should we ensure that hashCode values match corresponding int?
+ // i.e. should `new Int64(x).hashCode == x.hashCode`?
+ int bottom = ((_m & 0x3ff) << _BITS) | _l;
+ int top = (_h << 12) | ((_m >> 10) & 0xfff);
+ return bottom ^ top;
+ }
+
+ @override
+ Int64 abs() => isNegative ? -this : this;
+
+ @override
+ Int64 clamp(Object lowerLimit, Object upperLimit) {
+ Int64 lower = _promote(lowerLimit);
+ Int64 upper = _promote(upperLimit);
+ if (this < lower) return lower;
+ if (this > upper) return upper;
+ return this;
+ }
+
+ /// Returns the number of leading zeros in this [Int64] as an [int]
+ /// between 0 and 64.
+ @override
+ int numberOfLeadingZeros() {
+ int b2 = u.numberOfLeadingZeros(_h);
+ if (b2 == 32) {
+ int b1 = u.numberOfLeadingZeros(_m);
+ if (b1 == 32) {
+ return u.numberOfLeadingZeros(_l) + 32;
+ } else {
+ return b1 + _BITS2 - (32 - _BITS);
+ }
+ } else {
+ return b2 - (32 - _BITS2);
+ }
+ }
+
+ /// Returns the number of trailing zeros in this [Int64] as an [int]
+ /// between 0 and 64.
+ @override
+ int numberOfTrailingZeros() {
+ int zeros = u.numberOfTrailingZeros(_l);
+ if (zeros < 32) {
+ return zeros;
+ }
+
+ zeros = u.numberOfTrailingZeros(_m);
+ if (zeros < 32) {
+ return _BITS + zeros;
+ }
+
+ zeros = u.numberOfTrailingZeros(_h);
+ if (zeros < 32) {
+ return _BITS01 + zeros;
+ }
+ // All zeros
+ return 64;
+ }
+
+ @override
+ Int64 toSigned(int width) {
+ if (width < 1 || width > 64) throw RangeError.range(width, 1, 64);
+ if (width > _BITS01) {
+ return Int64._masked(_l, _m, _h.toSigned(width - _BITS01));
+ } else if (width > _BITS) {
+ int m = _m.toSigned(width - _BITS);
+ return m.isNegative
+ ? Int64._masked(_l, m, _MASK2)
+ : Int64._masked(_l, m, 0); // Masking for type inferrer.
+ } else {
+ int l = _l.toSigned(width);
+ return l.isNegative
+ ? Int64._masked(l, _MASK, _MASK2)
+ : Int64._masked(l, 0, 0); // Masking for type inferrer.
+ }
+ }
+
+ @override
+ Int64 toUnsigned(int width) {
+ if (width < 0 || width > 64) throw RangeError.range(width, 0, 64);
+ if (width > _BITS01) {
+ int h = _h.toUnsigned(width - _BITS01);
+ return Int64._masked(_l, _m, h);
+ } else if (width > _BITS) {
+ int m = _m.toUnsigned(width - _BITS);
+ return Int64._masked(_l, m, 0);
+ } else {
+ int l = _l.toUnsigned(width);
+ return Int64._masked(l, 0, 0);
+ }
+ }
+
+ @override
+ List<int> toBytes() {
+ var result = List<int>.filled(8, 0);
+ result[0] = _l & 0xff;
+ result[1] = (_l >> 8) & 0xff;
+ result[2] = ((_m << 6) & 0xfc) | ((_l >> 16) & 0x3f);
+ result[3] = (_m >> 2) & 0xff;
+ result[4] = (_m >> 10) & 0xff;
+ result[5] = ((_h << 4) & 0xf0) | ((_m >> 18) & 0xf);
+ result[6] = (_h >> 4) & 0xff;
+ result[7] = (_h >> 12) & 0xff;
+ return result;
+ }
+
+ @override
+ double toDouble() => toInt().toDouble();
+
+ @override
+ int toInt() {
+ int l = _l;
+ int m = _m;
+ int h = _h;
+ // In the sum we add least significant to most significant so that in
+ // JavaScript double arithmetic rounding occurs on only the last addition.
+ if ((_h & _SIGN_BIT_MASK) != 0) {
+ l = _MASK & ~_l;
+ m = _MASK & ~_m;
+ h = _MASK2 & ~_h;
+ return -((1 + l) + (4194304 * m) + (17592186044416 * h));
+ } else {
+ return l + (4194304 * m) + (17592186044416 * h);
+ }
+ }
+
+ /// Returns an [Int32] containing the low 32 bits of this [Int64].
+ @override
+ Int32 toInt32() => Int32(((_m & 0x3ff) << _BITS) | _l);
+
+ /// Returns `this`.
+ @override
+ Int64 toInt64() => this;
+
+ /// Returns the value of this [Int64] as a decimal [String].
+ @override
+ String toString() => _toRadixString(10);
+
+ @override
+ String toHexString() {
+ if (isZero) return '0';
+ Int64 x = this;
+ String hexStr = '';
+ while (!x.isZero) {
+ int digit = x._l & 0xf;
+ hexStr = '${_hexDigit(digit)}$hexStr';
+ x = x.shiftRightUnsigned(4);
+ }
+ return hexStr;
+ }
+
+ /// Returns the digits of `this` when interpreted as an unsigned 64-bit value.
+ @pragma('dart2js:noInline')
+ String toStringUnsigned() => _toRadixStringUnsigned(10, _l, _m, _h, '');
+
+ @pragma('dart2js:noInline')
+ String toRadixStringUnsigned(int radix) =>
+ _toRadixStringUnsigned(u.validateRadix(radix), _l, _m, _h, '');
+
+ @override
+ String toRadixString(int radix) => _toRadixString(u.validateRadix(radix));
+
+ String _toRadixString(int radix) {
+ int d0 = _l;
+ int d1 = _m;
+ int d2 = _h;
+
+ String sign = '';
+ if ((d2 & _SIGN_BIT_MASK) != 0) {
+ sign = '-';
+
+ // Negate in-place.
+ d0 = 0 - d0;
+ int borrow = (d0 >> _BITS) & 1;
+ d0 &= _MASK;
+ d1 = 0 - d1 - borrow;
+ borrow = (d1 >> _BITS) & 1;
+ d1 &= _MASK;
+ d2 = 0 - d2 - borrow;
+ d2 &= _MASK2;
+ // d2, d1, d0 now are an unsigned 64 bit integer for MIN_VALUE and an
+ // unsigned 63 bit integer for other values.
+ }
+ return _toRadixStringUnsigned(radix, d0, d1, d2, sign);
+ }
+
+ static String _toRadixStringUnsigned(
+ int radix, int d0, int d1, int d2, String sign) {
+ if (d0 == 0 && d1 == 0 && d2 == 0) return '0';
+
+ // Rearrange components into five components where all but the most
+ // significant are 10 bits wide.
+ //
+ // d4, d3, d4, d1, d0: 24 + 10 + 10 + 10 + 10 bits
+ //
+ // The choice of 10 bits allows a remainder of 20 bits to be scaled by 10
+ // bits and added during division while keeping all intermediate values
+ // within 30 bits (unsigned small integer range for 32 bit implementations
+ // of Dart VM and V8).
+ //
+ // 6 6 5 4 3 2 1
+ // 3210987654321098765432109876543210987654321098765432109876543210
+ // [--------d2--------][---------d1---------][---------d0---------]
+ // -->
+ // [----------d4----------][---d3---][---d2---][---d1---][---d0---]
+
+ int d4 = (d2 << 4) | (d1 >> 18);
+ int d3 = (d1 >> 8) & 0x3ff;
+ d2 = ((d1 << 2) | (d0 >> 20)) & 0x3ff;
+ d1 = (d0 >> 10) & 0x3ff;
+ d0 = d0 & 0x3ff;
+
+ int fatRadix = _fatRadixTable[radix];
+
+ // Generate chunks of digits. In radix 10, generate 6 digits per chunk.
+ //
+ // This loop generates at most 3 chunks, so we store the chunks in locals
+ // rather than a list. We are trying to generate digits 20 bits at a time
+ // until we have only 30 bits left. 20 + 20 + 30 > 64 would imply that we
+ // need only two chunks, but radix values 17-19 and 33-36 generate only 15
+ // or 16 bits per iteration, so sometimes the third chunk is needed.
+
+ String chunk1 = '', chunk2 = '', chunk3 = '';
+
+ while (!(d4 == 0 && d3 == 0)) {
+ int q = d4 ~/ fatRadix;
+ int r = d4 - q * fatRadix;
+ d4 = q;
+ d3 += r << 10;
+
+ q = d3 ~/ fatRadix;
+ r = d3 - q * fatRadix;
+ d3 = q;
+ d2 += r << 10;
+
+ q = d2 ~/ fatRadix;
+ r = d2 - q * fatRadix;
+ d2 = q;
+ d1 += r << 10;
+
+ q = d1 ~/ fatRadix;
+ r = d1 - q * fatRadix;
+ d1 = q;
+ d0 += r << 10;
+
+ q = d0 ~/ fatRadix;
+ r = d0 - q * fatRadix;
+ d0 = q;
+
+ assert(chunk3 == '');
+ chunk3 = chunk2;
+ chunk2 = chunk1;
+ // Adding [fatRadix] Forces an extra digit which we discard to get a fixed
+ // width. E.g. (1000000 + 123) -> "1000123" -> "000123". An alternative
+ // would be to pad to the left with zeroes.
+ chunk1 = (fatRadix + r).toRadixString(radix).substring(1);
+ }
+ int residue = (d2 << 20) + (d1 << 10) + d0;
+ String leadingDigits = residue == 0 ? '' : residue.toRadixString(radix);
+ return '$sign$leadingDigits$chunk1$chunk2$chunk3';
+ }
+
+ // Table of 'fat' radix values. Each entry for index `i` is the largest power
+ // of `i` whose remainder fits in 20 bits.
+ static const _fatRadixTable = <int>[
+ 0,
+ 0,
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2 *
+ 2,
+ 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
+ 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4,
+ 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+ 6 * 6 * 6 * 6 * 6 * 6 * 6,
+ 7 * 7 * 7 * 7 * 7 * 7 * 7,
+ 8 * 8 * 8 * 8 * 8 * 8,
+ 9 * 9 * 9 * 9 * 9 * 9,
+ 10 * 10 * 10 * 10 * 10 * 10,
+ 11 * 11 * 11 * 11 * 11,
+ 12 * 12 * 12 * 12 * 12,
+ 13 * 13 * 13 * 13 * 13,
+ 14 * 14 * 14 * 14 * 14,
+ 15 * 15 * 15 * 15 * 15,
+ 16 * 16 * 16 * 16 * 16,
+ 17 * 17 * 17 * 17,
+ 18 * 18 * 18 * 18,
+ 19 * 19 * 19 * 19,
+ 20 * 20 * 20 * 20,
+ 21 * 21 * 21 * 21,
+ 22 * 22 * 22 * 22,
+ 23 * 23 * 23 * 23,
+ 24 * 24 * 24 * 24,
+ 25 * 25 * 25 * 25,
+ 26 * 26 * 26 * 26,
+ 27 * 27 * 27 * 27,
+ 28 * 28 * 28 * 28,
+ 29 * 29 * 29 * 29,
+ 30 * 30 * 30 * 30,
+ 31 * 31 * 31 * 31,
+ 32 * 32 * 32 * 32,
+ 33 * 33 * 33,
+ 34 * 34 * 34,
+ 35 * 35 * 35,
+ 36 * 36 * 36
+ ];
+
+ String toDebugString() => 'Int64[_l=$_l, _m=$_m, _h=$_h]';
+
+ static Int64 _masked(int low, int medium, int high) =>
+ Int64._bits(_MASK & low, _MASK & medium, _MASK2 & high);
+
+ static Int64 _sub(int a0, int a1, int a2, int b0, int b1, int b2) {
+ int diff0 = a0 - b0;
+ int diff1 = a1 - b1 - ((diff0 >> _BITS) & 1);
+ int diff2 = a2 - b2 - ((diff1 >> _BITS) & 1);
+ return _masked(diff0, diff1, diff2);
+ }
+
+ static Int64 _negate(int b0, int b1, int b2) => _sub(0, 0, 0, b0, b1, b2);
+
+ String _hexDigit(int digit) => '0123456789ABCDEF'[digit];
+
+ // Work around dart2js bugs with negative arguments to '>>' operator.
+ static int _shiftRight(int x, int n) {
+ if (x >= 0) {
+ return x >> n;
+ } else {
+ int shifted = x >> n;
+ if (shifted >= 0x80000000) {
+ shifted -= 4294967296;
+ }
+ return shifted;
+ }
+ }
+
+ // Implementation of '~/', '%' and 'remainder'.
+
+ static Int64 _divide(Int64 a, other, int what) {
+ Int64 b = _promote(other);
+ if (b.isZero) {
+ // ignore: deprecated_member_use
+ throw const IntegerDivisionByZeroException();
+ }
+ if (a.isZero) return ZERO;
+
+ bool aNeg = a.isNegative;
+ bool bNeg = b.isNegative;
+ a = a.abs();
+ b = b.abs();
+
+ int a0 = a._l;
+ int a1 = a._m;
+ int a2 = a._h;
+
+ int b0 = b._l;
+ int b1 = b._m;
+ int b2 = b._h;
+ return _divideHelper(a0, a1, a2, aNeg, b0, b1, b2, bNeg, what);
+ }
+
+ static const _RETURN_DIV = 1;
+ static const _RETURN_REM = 2;
+ static const _RETURN_MOD = 3;
+
+ static Int64 _divideHelper(
+ // up to 64 bits unsigned in a2/a1/a0 and b2/b1/b0
+ int a0,
+ int a1,
+ int a2,
+ bool aNeg, // input A.
+ int b0,
+ int b1,
+ int b2,
+ bool bNeg, // input B.
+ int what) {
+ int q0 = 0, q1 = 0, q2 = 0; // result Q.
+ int r0 = 0, r1 = 0, r2 = 0; // result R.
+
+ if (b2 == 0 && b1 == 0 && b0 < (1 << (30 - _BITS))) {
+ // Small divisor can be handled by single-digit division within Smi range.
+ //
+ // Handling small divisors here helps the estimate version below by
+ // handling cases where the estimate is off by more than a small amount.
+
+ q2 = a2 ~/ b0;
+ int carry = a2 - q2 * b0;
+ int d1 = a1 + (carry << _BITS);
+ q1 = d1 ~/ b0;
+ carry = d1 - q1 * b0;
+ int d0 = a0 + (carry << _BITS);
+ q0 = d0 ~/ b0;
+ r0 = d0 - q0 * b0;
+ } else {
+ // Approximate Q = A ~/ B and R = A - Q * B using doubles.
+
+ // The floating point approximation is very close to the correct value
+ // when floor(A/B) fits in fewer that 53 bits.
+
+ // We use double arithmetic for intermediate values. Double arithmetic on
+ // non-negative values is exact under the following conditions:
+ //
+ // - The values are integer values that fit in 53 bits.
+ // - Dividing by powers of two (adjusts exponent only).
+ // - Floor (zeroes bits with fractional weight).
+
+ const double K2 = 17592186044416.0; // 2^44
+ const double K1 = 4194304.0; // 2^22
+
+ // Approximate double values for [a] and [b].
+ double ad = a0 + K1 * a1 + K2 * a2;
+ double bd = b0 + K1 * b1 + K2 * b2;
+ // Approximate quotient.
+ double qd = (ad / bd).floorToDouble();
+
+ // Extract components of [qd] using double arithmetic.
+ double q2d = (qd / K2).floorToDouble();
+ qd = qd - K2 * q2d;
+ double q1d = (qd / K1).floorToDouble();
+ double q0d = qd - K1 * q1d;
+ q2 = q2d.toInt();
+ q1 = q1d.toInt();
+ q0 = q0d.toInt();
+
+ assert(q0 + K1 * q1 + K2 * q2 == (ad / bd).floorToDouble());
+ assert(q2 == 0 || b2 == 0); // Q and B can't both be big since Q*B <= A.
+
+ // P = Q * B, using doubles to hold intermediates.
+ // We don't need all partial sums since Q*B <= A.
+ double p0d = q0d * b0;
+ double p0carry = (p0d / K1).floorToDouble();
+ p0d = p0d - p0carry * K1;
+ double p1d = q1d * b0 + q0d * b1 + p0carry;
+ double p1carry = (p1d / K1).floorToDouble();
+ p1d = p1d - p1carry * K1;
+ double p2d = q2d * b0 + q1d * b1 + q0d * b2 + p1carry;
+ assert(p2d <= _MASK2); // No partial sum overflow.
+
+ // R = A - P
+ int diff0 = a0 - p0d.toInt();
+ int diff1 = a1 - p1d.toInt() - ((diff0 >> _BITS) & 1);
+ int diff2 = a2 - p2d.toInt() - ((diff1 >> _BITS) & 1);
+ r0 = _MASK & diff0;
+ r1 = _MASK & diff1;
+ r2 = _MASK2 & diff2;
+
+ // while (R < 0 || R >= B)
+ // adjust R towards [0, B)
+ while (r2 >= _SIGN_BIT_MASK ||
+ r2 > b2 ||
+ (r2 == b2 && (r1 > b1 || (r1 == b1 && r0 >= b0)))) {
+ // Direction multiplier for adjustment.
+ int m = (r2 & _SIGN_BIT_MASK) == 0 ? 1 : -1;
+ // R = R - B or R = R + B
+ int d0 = r0 - m * b0;
+ int d1 = r1 - m * (b1 + ((d0 >> _BITS) & 1));
+ int d2 = r2 - m * (b2 + ((d1 >> _BITS) & 1));
+ r0 = _MASK & d0;
+ r1 = _MASK & d1;
+ r2 = _MASK2 & d2;
+
+ // Q = Q + 1 or Q = Q - 1
+ d0 = q0 + m;
+ d1 = q1 + m * ((d0 >> _BITS) & 1);
+ d2 = q2 + m * ((d1 >> _BITS) & 1);
+ q0 = _MASK & d0;
+ q1 = _MASK & d1;
+ q2 = _MASK2 & d2;
+ }
+ }
+
+ // 0 <= R < B
+ assert(Int64.ZERO <= Int64._bits(r0, r1, r2));
+ assert(r2 < b2 || // Handles case where B = -(MIN_VALUE)
+ Int64._bits(r0, r1, r2) < Int64._bits(b0, b1, b2));
+
+ assert(what == _RETURN_DIV || what == _RETURN_MOD || what == _RETURN_REM);
+ if (what == _RETURN_DIV) {
+ if (aNeg != bNeg) return _negate(q0, q1, q2);
+ return Int64._masked(q0, q1, q2); // Masking for type inferrer.
+ }
+
+ if (!aNeg) {
+ return Int64._masked(r0, r1, r2); // Masking for type inferrer.
+ }
+
+ if (what == _RETURN_MOD) {
+ if (r0 == 0 && r1 == 0 && r2 == 0) {
+ return ZERO;
+ } else {
+ return _sub(b0, b1, b2, r0, r1, r2);
+ }
+ } else {
+ return _negate(r0, r1, r2);
+ }
+ }
+}
diff --git a/lib/src/utilities.dart b/lib/src/utilities.dart
index 45207d7..7e5f48c 100644
--- a/lib/src/utilities.dart
+++ b/lib/src/utilities.dart
@@ -70,3 +70,18 @@
i += i >> 16;
return i & 0x0000003F;
}
+
+bool isPowerOf2(int value) => value != 0 && (value & (value - 1)) == 0;
+
+const String radixDigits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+void reverseList(List<Object?> values) {
+ var half = values.length ~/ 2;
+ var last = values.length - 1;
+ for (var i = 0; i < half; i++) {
+ var tmp = values[i];
+ var fromEnd = last - i;
+ values[i] = values[fromEnd];
+ values[fromEnd] = tmp;
+ }
+}
diff --git a/pubspec.yaml b/pubspec.yaml
index 7609938..9adb91f 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -6,7 +6,7 @@
repository: https://github.com/dart-lang/fixnum
environment:
- sdk: '>=2.12.0 <3.0.0'
+ sdk: '>=2.14.0 <3.0.0'
dev_dependencies:
lints: ^1.0.0
