bufferpack.js

/*!
 *  Copyright 2008 Fair Oaks Labs, Inc.
 *  All rights reserved.
 */

// Utility object:  Encode/Decode C-style binary primitives to/from octet arrays
function BufferPack() {
  // Module-level (private) variables
  var el,  bBE = false, m = this;

  // Raw byte arrays
  m._DeArray = function (a, p, l) {
    return [a.slice(p,p+l)];
  };
  m._EnArray = function (a, p, l, v) {
    for (var i = 0; i < l; a[p+i] = v[i]?v[i]:0, i++);
  };

  // ASCII characters
  m._DeChar = function (a, p) {
    return String.fromCharCode(a[p]);
  };
  m._EnChar = function (a, p, v) {
    a[p] = v.charCodeAt(0);
  };

  // Little-endian (un)signed N-byte integers
  m._DeInt = function (a, p) {
    var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, rv, i, f;
    for (rv = 0, i = lsb, f = 1; i != stop; rv+=(a[p+i]*f), i+=nsb, f*=256);
    if (el.bSigned && (rv & Math.pow(2, el.len*8-1))) {
      rv -= Math.pow(2, el.len*8);
    }
    return rv;
  };
  m._EnInt = function (a, p, v) {
    var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, i;
    v = (v<el.min)?el.min:(v>el.max)?el.max:v;
    for (i = lsb; i != stop; a[p+i]=v&0xff, i+=nsb, v>>=8);
  };

  // ASCII character strings
  m._DeString = function (a, p, l) {
    for (var rv = new Array(l), i = 0; i < l; rv[i] = String.fromCharCode(a[p+i]), i++);
    return rv.join('');
  };
  m._EnString = function (a, p, l, v) {
    for (var t, i = 0; i < l; a[p+i] = (t=v.charCodeAt(i))?t:0, i++);
  };

  // ASCII character strings null terminated
  m._DeNullString = function (a, p, l, v) {
    var str = m._DeString(a, p, l, v);
    return str.substring(0, str.length - 1);
  };

  // Little-endian N-bit IEEE 754 floating point
  m._De754 = function (a, p) {
    var s, e, m, i, d, nBits, mLen, eLen, eBias, eMax;
    mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;

    i = bBE?0:(el.len-1); d = bBE?1:-1; s = a[p+i]; i+=d; nBits = -7;
    for (e = s&((1<<(-nBits))-1), s>>=(-nBits), nBits += eLen; nBits > 0; e=e*256+a[p+i], i+=d, nBits-=8);
    for (m = e&((1<<(-nBits))-1), e>>=(-nBits), nBits += mLen; nBits > 0; m=m*256+a[p+i], i+=d, nBits-=8);

    switch (e) {
    case 0:
      // Zero, or denormalized number
      e = 1-eBias;
      break;
    case eMax:
      // NaN, or +/-Infinity
      return m?NaN:((s?-1:1)*Infinity);
    default:
      // Normalized number
      m = m + Math.pow(2, mLen);
      e = e - eBias;
      break;
    }
    return (s?-1:1) * m * Math.pow(2, e-mLen);
  };
  m._En754 = function (a, p, v) {
    var s, e, m, i, d, c, mLen, eLen, eBias, eMax;
    mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;

    s = v<0?1:0;
    v = Math.abs(v);
    if (isNaN(v) || (v == Infinity)) {
      m = isNaN(v)?1:0;
      e = eMax;
    } else {
      e = Math.floor(Math.log(v)/Math.LN2);			// Calculate log2 of the value

      if (v*(c = Math.pow(2, -e)) < 1) {
        e--; c*=2;						// Math.log() isn't 100% reliable
      }

      // Round by adding 1/2 the significand's LSD
      if (e+eBias >= 1) {
        v += el.rt/c;                                           // Normalized:  mLen significand digits
      } else {
        v += el.rt*Math.pow(2, 1-eBias);                        // Denormalized:  <= mLen significand digits
      }

      if (v*c >= 2) {
        e++; c/=2;						// Rounding can increment the exponent
      }

      if (e+eBias >= eMax) {
        // Overflow
        m = 0;
        e = eMax;
      } else if (e+eBias >= 1) {
        // Normalized - term order matters, as Math.pow(2, 52-e) and v*Math.pow(2, 52) can overflow
        m = (v*c-1)*Math.pow(2, mLen);
        e = e + eBias;
      } else {
        // Denormalized - also catches the '0' case, somewhat by chance
        m = v*Math.pow(2, eBias-1)*Math.pow(2, mLen);
        e = 0;
      }
    }

    for (i = bBE?(el.len-1):0, d=bBE?-1:1; mLen >= 8; a[p+i]=m&0xff, i+=d, m/=256, mLen-=8);
    for (e=(e<<mLen)|m, eLen+=mLen; eLen > 0; a[p+i]=e&0xff, i+=d, e/=256, eLen-=8);
    a[p+i-d] |= s*128;
  };

  // Class data
  m._sPattern = '(\\d+)?([AxcbBhHsSfdiIlL])(\\(([a-zA-Z0-9]+)\\))?';
  m._lenLut = {'A': 1, 'x': 1, 'c': 1, 'b': 1, 'B': 1, 'h': 2, 'H': 2, 's': 1,
               'S': 1, 'f': 4, 'd': 8, 'i': 4, 'I': 4, 'l': 4, 'L': 4};
  m._elLut = {'A': {en: m._EnArray, de: m._DeArray},
              's': {en: m._EnString, de: m._DeString},
              'S': {en: m._EnString, de: m._DeNullString},
              'c': {en: m._EnChar, de: m._DeChar},
              'b': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: true, min: -Math.pow(2, 7), max: Math.pow(2, 7) - 1},
              'B': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: false, min: 0, max: Math.pow(2, 8) - 1},
              'h': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: true, min: -Math.pow(2, 15), max: Math.pow(2, 15) - 1},
              'H': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: false, min: 0, max: Math.pow(2, 16) - 1},
              'i': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
              'I': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
              'l': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
              'L': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
              'f': {en: m._En754, de: m._De754, len: 4, mLen: 23, rt: Math.pow(2, -24) - Math.pow(2, -77)},
              'd': {en: m._En754, de: m._De754, len: 8, mLen: 52, rt: 0}};

  // Unpack a series of n elements of size s from array a at offset p with fxn
  m._UnpackSeries = function (n, s, a, p) {

    for (var fxn = el.de, rv = [], i = 0; i < n; rv.push(fxn(a, p+i*s)), i++);
    return rv;
  };

  // Pack a series of n elements of size s from array v at offset i to array a at offset p with fxn
  m._PackSeries = function (n, s, a, p, v, i) {
    for (var fxn = el.en, o = 0; o < n; fxn(a, p+o*s, v[i+o]), o++);
  };

  m._zip = function (keys, values) {
    var result = {};

    for (var i = 0; i < keys.length; i++) {
      result[keys[i]] = values[i];
    }

    return result;
  }

  // Unpack the octet array a, beginning at offset p, according to the fmt string
  m.unpack = function (fmt, a, p) {
    // Set the private bBE flag based on the format string - assume big-endianness
    bBE = (fmt.charAt(0) != '<');

    p = p?p:0;
    var re = new RegExp(this._sPattern, 'g');
    var m;
    var n;
    var s;
    var rk = [];
    var rv = [];

    while (m = re.exec(fmt)) {
      n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);

      if(m[2] === 'S') { // Null term string support
        n = 0; // Need to deal with empty  null term strings
        while(a[p + n] !== 0) {
          n++;
        }
        n++; // Add one for null byte
      }

      s = this._lenLut[m[2]];

      if ((p + n*s) > a.length) {
        return undefined;
      }

      switch (m[2]) {
      case 'A': case 's': case 'S':
        rv.push(this._elLut[m[2]].de(a, p, n));
        break;
      case 'c': case 'b': case 'B': case 'h': case 'H':
      case 'i': case 'I': case 'l': case 'L': case 'f': case 'd':
        el = this._elLut[m[2]];
        rv.push(this._UnpackSeries(n, s, a, p));
        break;
      }

      rk.push(m[4]); // Push key on to array

      p += n*s;
    }

    rv = Array.prototype.concat.apply([], rv)

    if(rk.indexOf(undefined) !== -1) {
      return rv;
    } else {
      return this._zip(rk, rv);
    }
  };

  // Pack the supplied values into the octet array a, beginning at offset p, according to the fmt string
  m.packTo = function (fmt, a, p, values) {
    // Set the private bBE flag based on the format string - assume big-endianness
    bBE = (fmt.charAt(0) != '<');

    var re = new RegExp(this._sPattern, 'g');
    var m;
    var n;
    var s;
    var i = 0;
    var j;

    while (m = re.exec(fmt)) {
      n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);

      // Null term string support
      if(m[2] === 'S') {
        n = values[i].length + 1; // Add one for null byte
      }

      s = this._lenLut[m[2]];

      if ((p + n*s) > a.length) {
        return false;
      }

      switch (m[2]) {
      case 'A': case 's': case 'S':
        if ((i + 1) > values.length) { return false; }
        this._elLut[m[2]].en(a, p, n, values[i]);
        i += 1;
        break;
      case 'c': case 'b': case 'B': case 'h': case 'H':
      case 'i': case 'I': case 'l': case 'L': case 'f': case 'd':
        el = this._elLut[m[2]];
        if ((i + n) > values.length) { return false; }
        this._PackSeries(n, s, a, p, values, i);
        i += n;
        break;
      case 'x':
        for (j = 0; j < n; j++) { a[p+j] = 0; }
        break;
      }
      p += n*s;
    }

    return a;
  };

  // Pack the supplied values into a new octet array, according to the fmt string
  m.pack = function (fmt, values) {
    return this.packTo(fmt, new Buffer(this.calcLength(fmt, values)), 0, values);
  };

  // Determine the number of bytes represented by the format string
  m.calcLength = function (format, values) {
    var re = new RegExp(this._sPattern, 'g'), m, sum = 0, i = 0;
    while (m = re.exec(format)) {
      var n = (((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1])) * this._lenLut[m[2]];

      if(m[2] === 'S') {
        n = values[i].length + 1; // Add one for null byte
      }

      sum += n;
      if(m[2] !== 'x') {
        i++;
      }
    }
    return sum;
  };
};

//module.exports = new BufferPack();