caml_int64.js

'use strict';

var Caml_int32 = require("./caml_int32.js");
var Caml_utils = require("./caml_utils.js");
var Caml_primitive = require("./caml_primitive.js");
var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");

var min_int = {
  hi: -2147483648,
  lo: 0
};

var max_int = {
  hi: 2147483647,
  lo: 1
};

var one = {
  hi: 0,
  lo: 1
};

var zero = {
  hi: 0,
  lo: 0
};

var neg_one = {
  hi: -1,
  lo: 4294967295
};

function neg_signed(x) {
  return (x & 2147483648) !== 0;
}

function add(param, param$1) {
  var other_low_ = param$1.lo;
  var this_low_ = param.lo;
  var lo = this_low_ + other_low_ & 4294967295;
  var overflow = neg_signed(this_low_) && (neg_signed(other_low_) || !neg_signed(lo)) || neg_signed(other_low_) && !neg_signed(lo) ? 1 : 0;
  var hi = param.hi + param$1.hi + overflow & 4294967295;
  return {
          hi: hi,
          lo: (lo >>> 0)
        };
}

function not(param) {
  var hi = param.hi ^ -1;
  var lo = param.lo ^ -1;
  return {
          hi: hi,
          lo: (lo >>> 0)
        };
}

function eq(x, y) {
  if (x.hi === y.hi) {
    return x.lo === y.lo;
  } else {
    return false;
  }
}

function equal_null(x, y) {
  if (y !== null) {
    return eq(x, y);
  } else {
    return false;
  }
}

function equal_undefined(x, y) {
  if (y !== undefined) {
    return eq(x, y);
  } else {
    return false;
  }
}

function equal_nullable(x, y) {
  if (y == null) {
    return false;
  } else {
    return eq(x, y);
  }
}

function neg(x) {
  if (eq(x, min_int)) {
    return min_int;
  } else {
    return add(not(x), one);
  }
}

function sub(x, y) {
  return add(x, neg(y));
}

function lsl_(x, numBits) {
  if (numBits === 0) {
    return x;
  } else {
    var lo = x.lo;
    if (numBits >= 32) {
      return {
              hi: (lo << (numBits - 32 | 0)),
              lo: 0
            };
    } else {
      var hi = (lo >>> (32 - numBits | 0)) | (x.hi << numBits);
      return {
              hi: hi,
              lo: ((lo << numBits) >>> 0)
            };
    }
  }
}

function lsr_(x, numBits) {
  if (numBits === 0) {
    return x;
  } else {
    var hi = x.hi;
    var offset = numBits - 32 | 0;
    if (offset === 0) {
      return {
              hi: 0,
              lo: (hi >>> 0)
            };
    } else if (offset > 0) {
      var lo = (hi >>> offset);
      return {
              hi: 0,
              lo: (lo >>> 0)
            };
    } else {
      var hi$1 = (hi >>> numBits);
      var lo$1 = (hi << (-offset | 0)) | (x.lo >>> numBits);
      return {
              hi: hi$1,
              lo: (lo$1 >>> 0)
            };
    }
  }
}

function asr_(x, numBits) {
  if (numBits === 0) {
    return x;
  } else {
    var hi = x.hi;
    if (numBits < 32) {
      var hi$1 = (hi >> numBits);
      var lo = (hi << (32 - numBits | 0)) | (x.lo >>> numBits);
      return {
              hi: hi$1,
              lo: (lo >>> 0)
            };
    } else {
      var lo$1 = (hi >> (numBits - 32 | 0));
      return {
              hi: hi >= 0 ? 0 : -1,
              lo: (lo$1 >>> 0)
            };
    }
  }
}

function is_zero(param) {
  if (param.hi !== 0 || param.lo !== 0) {
    return false;
  } else {
    return true;
  }
}

function mul(_this, _other) {
  while(true) {
    var other = _other;
    var $$this = _this;
    var lo;
    var this_hi = $$this.hi;
    var exit = 0;
    var exit$1 = 0;
    var exit$2 = 0;
    if (this_hi !== 0 || $$this.lo !== 0) {
      exit$2 = 4;
    } else {
      return zero;
    }
    if (exit$2 === 4) {
      if (other.hi !== 0 || other.lo !== 0) {
        exit$1 = 3;
      } else {
        return zero;
      }
    }
    if (exit$1 === 3) {
      if (this_hi !== -2147483648 || $$this.lo !== 0) {
        exit = 2;
      } else {
        lo = other.lo;
      }
    }
    if (exit === 2) {
      var other_hi = other.hi;
      var lo$1 = $$this.lo;
      var exit$3 = 0;
      if (other_hi !== -2147483648 || other.lo !== 0) {
        exit$3 = 3;
      } else {
        lo = lo$1;
      }
      if (exit$3 === 3) {
        var other_lo = other.lo;
        if (this_hi < 0) {
          if (other_hi < 0) {
            _other = neg(other);
            _this = neg($$this);
            continue ;
          } else {
            return neg(mul(neg($$this), other));
          }
        } else if (other_hi < 0) {
          return neg(mul($$this, neg(other)));
        } else {
          var a48 = (this_hi >>> 16);
          var a32 = this_hi & 65535;
          var a16 = (lo$1 >>> 16);
          var a00 = lo$1 & 65535;
          var b48 = (other_hi >>> 16);
          var b32 = other_hi & 65535;
          var b16 = (other_lo >>> 16);
          var b00 = other_lo & 65535;
          var c48 = 0;
          var c32 = 0;
          var c16 = 0;
          var c00 = a00 * b00;
          c16 = (c00 >>> 16) + a16 * b00;
          c32 = (c16 >>> 16);
          c16 = (c16 & 65535) + a00 * b16;
          c32 = c32 + (c16 >>> 16) + a32 * b00;
          c48 = (c32 >>> 16);
          c32 = (c32 & 65535) + a16 * b16;
          c48 = c48 + (c32 >>> 16);
          c32 = (c32 & 65535) + a00 * b32;
          c48 = c48 + (c32 >>> 16);
          c32 = c32 & 65535;
          c48 = c48 + (a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48) & 65535;
          var hi = c32 | (c48 << 16);
          var lo$2 = c00 & 65535 | ((c16 & 65535) << 16);
          return {
                  hi: hi,
                  lo: (lo$2 >>> 0)
                };
        }
      }
      
    }
    if ((lo & 1) === 0) {
      return zero;
    } else {
      return min_int;
    }
  };
}

function swap(param) {
  var hi = Caml_int32.caml_int32_bswap(param.lo);
  var lo = Caml_int32.caml_int32_bswap(param.hi);
  return {
          hi: hi,
          lo: (lo >>> 0)
        };
}

function xor(param, param$1) {
  return {
          hi: param.hi ^ param$1.hi,
          lo: ((param.lo ^ param$1.lo) >>> 0)
        };
}

function or_(param, param$1) {
  return {
          hi: param.hi | param$1.hi,
          lo: ((param.lo | param$1.lo) >>> 0)
        };
}

function and_(param, param$1) {
  return {
          hi: param.hi & param$1.hi,
          lo: ((param.lo & param$1.lo) >>> 0)
        };
}

function ge(param, param$1) {
  var other_hi = param$1.hi;
  var hi = param.hi;
  if (hi > other_hi) {
    return true;
  } else if (hi < other_hi) {
    return false;
  } else {
    return param.lo >= param$1.lo;
  }
}

function neq(x, y) {
  return !eq(x, y);
}

function lt(x, y) {
  return !ge(x, y);
}

function gt(x, y) {
  if (x.hi > y.hi) {
    return true;
  } else if (x.hi < y.hi) {
    return false;
  } else {
    return x.lo > y.lo;
  }
}

function le(x, y) {
  return !gt(x, y);
}

function min(x, y) {
  if (ge(x, y)) {
    return y;
  } else {
    return x;
  }
}

function max(x, y) {
  if (gt(x, y)) {
    return x;
  } else {
    return y;
  }
}

function to_float(param) {
  return param.hi * 0x100000000 + param.lo;
}

function of_float(x) {
  if (isNaN(x) || !isFinite(x)) {
    return zero;
  } else if (x <= -9.22337203685477581e+18) {
    return min_int;
  } else if (x + 1 >= 9.22337203685477581e+18) {
    return max_int;
  } else if (x < 0) {
    return neg(of_float(-x));
  } else {
    var hi = x / 4294967296 | 0;
    var lo = x % 4294967296 | 0;
    return {
            hi: hi,
            lo: (lo >>> 0)
          };
  }
}

function div(_self, _other) {
  while(true) {
    var other = _other;
    var self = _self;
    var self_hi = self.hi;
    var exit = 0;
    var exit$1 = 0;
    if (other.hi !== 0 || other.lo !== 0) {
      exit$1 = 2;
    } else {
      throw Caml_builtin_exceptions.division_by_zero;
    }
    if (exit$1 === 2) {
      if (self_hi !== -2147483648) {
        if (self_hi !== 0 || self.lo !== 0) {
          exit = 1;
        } else {
          return zero;
        }
      } else if (self.lo !== 0) {
        exit = 1;
      } else if (eq(other, one) || eq(other, neg_one)) {
        return self;
      } else if (eq(other, min_int)) {
        return one;
      } else {
        var other_hi = other.hi;
        var half_this = asr_(self, 1);
        var approx = lsl_(div(half_this, other), 1);
        if (approx.hi === 0 && approx.lo === 0) {
          if (other_hi < 0) {
            return one;
          } else {
            return neg(one);
          }
        }
        var y = mul(other, approx);
        var rem = add(self, neg(y));
        return add(approx, div(rem, other));
      }
    }
    if (exit === 1) {
      var other_hi$1 = other.hi;
      if (other_hi$1 === -2147483648 && other.lo === 0) {
        return zero;
      }
      if (self_hi < 0) {
        if (other_hi$1 < 0) {
          _other = neg(other);
          _self = neg(self);
          continue ;
        } else {
          return neg(div(neg(self), other));
        }
      } else if (other_hi$1 < 0) {
        return neg(div(self, neg(other)));
      } else {
        var res = zero;
        var rem$1 = self;
        while(ge(rem$1, other)) {
          var approx$1 = Caml_primitive.caml_float_max(1, Math.floor(to_float(rem$1) / to_float(other)));
          var log2 = Math.ceil(Math.log(approx$1) / Math.LN2);
          var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
          var approxRes = of_float(approx$1);
          var approxRem = mul(approxRes, other);
          while(approxRem.hi < 0 || gt(approxRem, rem$1)) {
            approx$1 = approx$1 - delta;
            approxRes = of_float(approx$1);
            approxRem = mul(approxRes, other);
          };
          if (is_zero(approxRes)) {
            approxRes = one;
          }
          res = add(res, approxRes);
          rem$1 = add(rem$1, neg(approxRem));
        };
        return res;
      }
    }
    
  };
}

function mod_(self, other) {
  var y = mul(div(self, other), other);
  return add(self, neg(y));
}

function div_mod(self, other) {
  var quotient = div(self, other);
  var y = mul(quotient, other);
  return /* tuple */[
          quotient,
          add(self, neg(y))
        ];
}

function compare(self, other) {
  var v = Caml_primitive.caml_nativeint_compare(self.hi, other.hi);
  if (v === 0) {
    return Caml_primitive.caml_nativeint_compare(self.lo, other.lo);
  } else {
    return v;
  }
}

function of_int32(lo) {
  return {
          hi: lo < 0 ? -1 : 0,
          lo: (lo >>> 0)
        };
}

function to_int32(x) {
  return x.lo | 0;
}

function to_hex(x) {
  var x_lo = x.lo;
  var x_hi = x.hi;
  var aux = function (v) {
    return (v >>> 0).toString(16);
  };
  if (x_hi === 0 && x_lo === 0) {
    return "0";
  }
  if (x_lo !== 0) {
    if (x_hi !== 0) {
      var lo = aux(x_lo);
      var pad = 8 - lo.length | 0;
      if (pad <= 0) {
        return aux(x_hi) + lo;
      } else {
        return aux(x_hi) + (Caml_utils.repeat(pad, "0") + lo);
      }
    } else {
      return aux(x_lo);
    }
  } else {
    return aux(x_hi) + "00000000";
  }
}

function discard_sign(x) {
  return {
          hi: 2147483647 & x.hi,
          lo: x.lo
        };
}

function float_of_bits(x) {
  return (function(lo,hi){ return (new Float64Array(new Int32Array([lo,hi]).buffer))[0]})(x.lo, x.hi);
}

function bits_of_float(x) {
  var buf = (function(x){return new Int32Array(new Float64Array([x]).buffer)})(x);
  return {
          hi: buf[1],
          lo: (buf[0] >>> 0)
        };
}

function get64(s, i) {
  var hi = (s.charCodeAt(i + 4 | 0) << 32) | (s.charCodeAt(i + 5 | 0) << 40) | (s.charCodeAt(i + 6 | 0) << 48) | (s.charCodeAt(i + 7 | 0) << 56);
  var lo = s.charCodeAt(i) | (s.charCodeAt(i + 1 | 0) << 8) | (s.charCodeAt(i + 2 | 0) << 16) | (s.charCodeAt(i + 3 | 0) << 24);
  return {
          hi: hi,
          lo: (lo >>> 0)
        };
}

exports.min_int = min_int;
exports.max_int = max_int;
exports.one = one;
exports.zero = zero;
exports.not = not;
exports.of_int32 = of_int32;
exports.to_int32 = to_int32;
exports.add = add;
exports.neg = neg;
exports.sub = sub;
exports.lsl_ = lsl_;
exports.lsr_ = lsr_;
exports.asr_ = asr_;
exports.is_zero = is_zero;
exports.mul = mul;
exports.xor = xor;
exports.or_ = or_;
exports.and_ = and_;
exports.swap = swap;
exports.ge = ge;
exports.eq = eq;
exports.neq = neq;
exports.lt = lt;
exports.gt = gt;
exports.le = le;
exports.equal_null = equal_null;
exports.equal_undefined = equal_undefined;
exports.equal_nullable = equal_nullable;
exports.min = min;
exports.max = max;
exports.to_float = to_float;
exports.of_float = of_float;
exports.div = div;
exports.mod_ = mod_;
exports.compare = compare;
exports.float_of_bits = float_of_bits;
exports.bits_of_float = bits_of_float;
exports.get64 = get64;
exports.div_mod = div_mod;
exports.to_hex = to_hex;
exports.discard_sign = discard_sign;
/* Caml_int32 Not a pure module */