cbor/lib/utils.js

Encode and parse CBOR documents.

(function() {
  var SHIFT32, bignumber, parseHalf,
    __slice = [].slice;

  bignumber = require('bignumber.js');

  SHIFT32 = Math.pow(2, 32);

  exports.parseInt = function(ai, buf) {
    var f, g;
    switch (ai) {
      case 24:
        return buf.readUInt8(0, true);
      case 25:
        return buf.readUInt16BE(0, true);
      case 26:
        return buf.readUInt32BE(0, true);
      case 27:
        f = buf.readUInt32BE(0);
        g = buf.readUInt32BE(4);
        return (f * SHIFT32) + g;
      default:
        throw new Error("Invalid additional info for int: " + ai);
    }
  };

  exports.parseHalf = parseHalf = function(buf) {
    var exp, mant, sign;
    sign = buf[0] & 0x80 ? -1 : 1;
    exp = (buf[0] & 0x7C) >> 2;
    mant = ((buf[0] & 0x03) << 8) | buf[1];
    if (!exp) {
      return sign * 5.9604644775390625e-8 * mant;
    } else if (exp === 0x1f) {
      return sign * (mant ? NaN : Infinity);
    } else {
      return sign * Math.pow(2, exp - 25) * (1024 + mant);
    }
  };

  exports.parseFloat = function(ai, buf) {
    switch (ai) {
      case 25:
        return parseHalf(buf);
      case 26:
        return buf.readFloatBE(0, true);
      case 27:
        return buf.readDoubleBE(0, true);
      default:
        throw new Error("Invalid additional info for float: " + ai);
    }
  };

  exports.hex = function(s) {
    return new Buffer(s.replace(/^0x/, ''), 'hex');
  };

  exports.bin = function(s) {
    var chunks, end, start;
    s = s.replace(/\s/g, '');
    start = 0;
    end = s.length % 8 || 8;
    chunks = [];
    while (end <= s.length) {
      chunks.push(parseInt(s.slice(start, end), 2));
      start = end;
      end += 8;
    }
    return new Buffer(chunks);
  };

  exports.extend = function() {
    var a, adds, k, old, v, _i, _len;
    old = arguments[0], adds = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
    if (old == null) {
      old = {};
    }
    for (_i = 0, _len = adds.length; _i < _len; _i++) {
      a = adds[_i];
      for (k in a) {
        v = a[k];
        old[k] = v;
      }
    }
    return old;
  };

  exports.arrayEqual = function(a, b) {
    if ((a == null) && (b == null)) {
      return true;
    }
    if ((a == null) || (b == null)) {
      return false;
    }
    return (a.length === b.length) && a.every(function(elem, i) {
      return elem === b[i];
    });
  };

  exports.bufferEqual = function(a, b) {
    var byte, i, ret, _i, _len;
    if ((a == null) && (b == null)) {
      return true;
    }
    if ((a == null) || (b == null)) {
      return false;
    }
    if (!(Buffer.isBuffer(a) && Buffer.isBuffer(b) && (a.length === b.length))) {
      return false;
    }
    ret = true;
    for (i = _i = 0, _len = a.length; _i < _len; i = ++_i) {
      byte = a[i];
      ret &= b[i] === byte;
    }
    return !!ret;
  };

  exports.bufferToBignumber = function(buf) {
    return new bignumber(buf.toString('hex'), 16);
  };

}).call(this);