typespeed 2.0.13 → 2.0.16

package/test/node_modules/@acuminous/bitsyntax/lib/constructor.js

@@ -0,0 +1,142 @@
+// -*- js-indent-level: 2 -*-
+
+// Constructors given patterns
+
+'use strict';
+
+var ints = require('buffer-more-ints');
+var Buffer = require('safe-buffer').Buffer;
+
+// Interpret the pattern, writing values into a buffer
+function write(buf, offset, pattern, bindings) {
+  for (var i=0, len = pattern.length; i < len; i++) {
+    var segment = pattern[i];
+    switch (segment.type) {
+    case 'string':
+      offset += buf.write(segment.value, offset, 'utf8');
+      break;
+    case 'binary':
+      offset += writeBinary(segment, buf, offset, bindings);
+      break;
+    case 'integer':
+      offset += writeInteger(segment, buf, offset, bindings);
+      break;
+    case 'float':
+      offset += writeFloat(segment, buf, offset, bindings);
+      break;
+    }
+  }
+  return offset;
+}
+
+function build(pattern, bindings) {
+  var bufsize = size_of(pattern, bindings);
+  var buf = Buffer.alloc(bufsize);
+  write(buf, 0, pattern, bindings);
+  return buf;
+}
+
+// In bytes
+function size_of_segment(segment, bindings) {
+  // size refers to a variable
+  if (typeof segment.size === 'string') {
+    return (bindings[segment.size] * segment.unit) / 8;
+  }
+  if (segment.type === 'string') {
+    return Buffer.byteLength(segment.value, 'utf8');
+  }
+  if (segment.type === 'binary' && segment.size === true) {
+    var val = bindings[segment.name];
+    return val.length;
+  }
+  return (segment.size * segment.unit) / 8;
+}
+
+// size of the to-be-constructed binary, in bytes
+function size_of(segments, bindings) {
+  var size = 0;
+  for (var i=0, len = segments.length; i < len; i++) {
+    size += size_of_segment(segments[i], bindings);
+  }
+  return size;
+}
+
+function writeBinary(segment, buf, offset, bindings) {
+  var bin = bindings[segment.name];
+  var size = size_of_segment(segment, bindings);
+  bin.copy(buf, offset, 0, size);
+  return size;
+}
+
+// TODO in ff might use the noAssert argument to Buffer.write*() but
+// need to check that it does the right thing wrt little-endian
+
+function writeInteger(segment, buf, offset, bindings) {
+  var value = (segment.name) ? bindings[segment.name] : segment.value;
+  var size = size_of_segment(segment, bindings);
+  return write_int(buf, value, offset, size, segment.bigendian);
+}
+
+function write_int(buf, value, offset, size, bigendian) {
+  switch (size) {
+  case 1:
+    buf.writeUInt8(value, offset);
+    break;
+  case 2:
+    (bigendian) ?
+      buf.writeUInt16BE(value, offset) :
+      buf.writeUInt16LE(value, offset);
+    break;
+  case 4:
+    (bigendian) ?
+      buf.writeUInt32BE(value, offset) :
+      buf.writeUInt32LE(value, offset);
+    break;
+  case 8:
+    (bigendian) ?
+      ints.writeUInt64BE(buf, value, offset) :
+      ints.writeUInt64LE(buf, value, offset);
+    break;
+  default:
+    throw new Error("integer size * unit must be 8, 16, 32 or 64");
+  }
+  return size;
+}
+
+function writeFloat(segment, buf, offset, bindings) {
+  var value = (segment.name) ? bindings[segment.name] : segment.value;
+  var size = size_of_segment(segment, bindings);
+  return write_float(buf, value, offset, size, segment.bigendian);
+}
+
+function write_float(buf, value, offset, size, bigendian) {
+  if (size === 4) {
+    (bigendian) ?
+      buf.writeFloatBE(value, offset) :
+      buf.writeFloatLE(value, offset);
+  }
+  else if (size === 8) {
+    (bigendian) ?
+      buf.writeDoubleBE(value, offset) :
+      buf.writeDoubleLE(value, offset);
+  }
+  else {
+    throw new Error("float size * unit must be 32 or 64");
+  }
+  return size;
+}
+
+var parse = require('./parse').parse;
+
+module.exports.write = write;
+module.exports.build = build;
+module.exports.write_int = write_int;
+module.exports.write_float = write_float;
+
+module.exports.builder = function(pstr) {
+  pstr = (arguments.length > 1) ? [].join.call(arguments, ',') : pstr;
+  var pattern = parse(pstr);
+  return function(vars) {
+    return build(pattern, vars);
+  };
+};

package/test/node_modules/@acuminous/bitsyntax/lib/grammar.pegjs

@@ -0,0 +1,67 @@
+
+start
+    = ws head:segment tail:segmentTail* { tail.unshift(head); return tail; }
+
+segmentTail
+    = ws ',' ws seg:segment { return seg; }
+
+segment
+    = str:string { return {string: str}; }
+    / v:identifier size:size ? specs:specifierList ?
+      { return {name: v, size: size, specifiers: specs}; }
+    / v:number size:size ? specs:specifierList ?
+      { return {value: v, size: size, specifiers: specs}; }
+
+string
+  = '"' '"'             { return "";    }
+  / '"' chars:chars '"' { return chars; }
+
+/* From JSON example
+https://github.com/dmajda/pegjs/blob/master/examples/json.pegjs */
+
+chars
+  = chars:char+ { return chars.join(""); }
+
+char
+  = [^"\\\0-\x1F\x7f]
+  / '\\"'  { return '"';  }
+  / "\\\\" { return "\\"; }
+  / "\\/"  { return "/";  }
+  / "\\b"  { return "\b"; }
+  / "\\f"  { return "\f"; }
+  / "\\n"  { return "\n"; }
+  / "\\r"  { return "\r"; }
+  / "\\t"  { return "\t"; }
+  / "\\u" h1:hexDigit h2:hexDigit h3:hexDigit h4:hexDigit {
+      return String.fromCharCode(parseInt("0x" + h1 + h2 + h3 + h4));
+    }
+
+hexDigit
+  = [0-9a-fA-F]
+
+identifier
+    = (head:[_a-zA-Z] tail:[_a-zA-Z0-9]*) { return head + tail.join(''); }
+
+number
+    = '0' { return 0; }
+    / head:[1-9] tail:[0-9]* { return parseInt(head + tail.join('')); }
+
+size
+    = ':' num:number { return num; }
+    / ':' id:identifier { return id; }
+
+specifierList
+    = '/' head:specifier tail:specifierTail* { tail.unshift(head); return tail; }
+
+specifierTail
+    = '-' spec:specifier { return spec; }
+
+specifier
+    = 'little' / 'big' / 'signed' / 'unsigned'
+    / 'integer' / 'binary' / 'float'
+    / unit
+
+unit
+    = 'unit:' num:number { return 'unit:' + num; }
+
+ws = [ \t\n]*

package/test/node_modules/@acuminous/bitsyntax/lib/interp.js

@@ -0,0 +1,232 @@
+// -*- js-indent: 2 -*-
+// Interpreter for bit syntax AST.
+// Grammar:
+//
+// pattern   := segment ("," segment)*
+// segment   := (value | var) (":" size)? ("/" specifier ("-" specifier)*)? | string
+// var       := "_" | identifier
+// size      := integer | var
+// specifier := "little" | "big" | "signed" | "unsigned" | "unit" ":" 0..256 | type
+// type      := "integer" | "binary" | "float"
+//
+// where integer has the obvious meaning, and identifier is anything
+// other than "_" that fits the JavaScript identifier specification.
+//
+
+// We'll use an object to represent each segment, and an array of
+// segments for a pattern. We won't try to optimise for groups of
+// patterns; we'll just step through each to see if it works. We rely
+// a hypothetical prior step to check that it's a valid pattern.
+
+// ? compile to intermediate instructions ?
+
+// A segment looks like
+// {
+//    type: string, // 'string' is special case
+//    size: integer | true, // true means 'all remaining'
+//    name: string | null, // (may be '_')
+//    value: value | null, // either name OR value
+//    unit: integer,
+//    signed: boolean,
+//    bigendian: boolean
+// }
+
+'use strict';
+
+var ints    = require('buffer-more-ints'),
+    debug   = require('debug')('bitsyntax-Interpreter');
+
+function parse_int(bin, off, sizeInBytes, bigendian, signed) {
+  switch (sizeInBytes) {
+  case 1:
+    return (signed) ? bin.readInt8(off) : bin.readUInt8(off);
+  case 2:
+    return (bigendian) ?
+      (signed) ? bin.readInt16BE(off) : bin.readUInt16BE(off) :
+      (signed) ? bin.readInt16LE(off) : bin.readUInt16LE(off);
+  case 4:
+    return (bigendian) ?
+      (signed) ? bin.readInt32BE(off) : bin.readUInt32BE(off) :
+      (signed) ? bin.readInt32LE(off) : bin.readUInt32LE(off);
+  case 8:
+    return (bigendian) ?
+      ((signed) ? ints.readInt64BE : ints.readUInt64BE)(bin, off) :
+      ((signed) ? ints.readInt64LE : ints.readUInt64LE)(bin, off);
+  default:
+    throw "Integers must be 8-, 16-, 32- or 64-bit";
+  }
+}
+
+function parse_float(bin, off, sizeInBytes, bigendian) {
+  switch (sizeInBytes) {
+  case 4:
+    return (bigendian) ? bin.readFloatBE(off) : bin.readFloatLE(off);
+  case 8:
+    return (bigendian) ? bin.readDoubleBE(off) : bin.readDoubleLE(off);
+  default:
+    throw "Floats must be 32- or 64-bit";
+  }
+}
+
+function size_of(segment, bound) {
+  var size = segment.size;
+  if (typeof size === 'string') {
+    return bound[size];
+  }
+  else {
+    return size;
+  }
+}
+
+function new_scope(env) {
+  function scope() {};
+  scope.prototype = env;
+  return new scope();
+}
+
+function bindings(scope) {
+  var s = {};
+  for (var k in scope) {
+    if (scope.hasOwnProperty(k)) {
+      s[k] = scope[k];
+    }
+  }
+  return s;
+}
+
+function match(pattern, binary, boundvars) {
+  var offset = 0, vars = new_scope(boundvars);
+  var binsize = binary.length * 8;
+
+  function skip_bits(segment) {
+    debug("skip bits"); debug(segment);
+    var size = size_of(segment, vars);
+    if (size === true) {
+      if (offset % 8 === 0) {
+        offset = binsize;
+        return true;
+      }
+      else {
+        return false;
+      }
+    }
+
+    var bits = segment.unit * size;
+    if (offset + bits > binsize) {
+      return false;
+    }
+    else {
+      offset += bits;
+    }
+  }
+
+  function get_integer(segment) {
+    debug("get_integer"); debug(segment);
+    // let's do only multiples of eight bits for now
+    var unit = segment.unit, size = size_of(segment, vars);
+    var bitsize = size * unit;
+    var byteoffset = offset / 8; // NB assumes aligned
+    offset += bitsize;
+    if (bitsize % 8 > 0 || (offset > binsize)) {
+      return false;
+    }
+    else {
+      return parse_int(binary, byteoffset, bitsize / 8,
+                       segment.bigendian, segment.signed);
+    }
+  }
+
+  function get_float(segment) {
+    debug("get_float"); debug(segment);
+    var unit = segment.unit; var size = size_of(segment, vars);
+    var bitsize = size * unit;
+    var byteoffset = offset / 8; // assume aligned
+    offset += bitsize;
+    if (offset > binsize) {
+      return false;
+    }
+    else {
+      return parse_float(binary, byteoffset,
+                         bitsize / 8, segment.bigendian);
+    }
+  }
+
+  function get_binary(segment) {
+    debug("get_binary"); debug(segment);
+    var unit = segment.unit, size = size_of(segment, vars);
+    var byteoffset = offset / 8; // NB alignment
+
+    if (size === true) {
+      offset = binsize;
+      return binary.slice(byteoffset);
+    }
+    else {
+      var bitsize = size * unit;
+      if (bitsize % 8 > 0 || (offset + bitsize) > binsize) {
+        return false;
+      }
+      else {
+        offset += bitsize;
+        return binary.slice(byteoffset, byteoffset + bitsize / 8);
+      }
+    }
+  }
+
+  function get_string(segment) {
+    debug("get_string"); debug(segment);
+    var len = segment.value.length;
+    var byteoffset = offset / 8;
+
+    offset += len * 8;
+    if (offset > binsize) {
+      return false;
+    }
+    // FIXME bytes vs UTF8 characters
+    return binary.slice(byteoffset, byteoffset + len).toString('utf8');
+  }
+
+  var patternlen = pattern.length;
+  for (var i = 0;  i < patternlen; i++) {
+    var segment = pattern[i];
+    var result = false;
+    if (segment.name === '_') {
+      result = skip_bits(segment);
+    }
+    else {
+      switch (segment.type) {
+      case 'string':
+        result = get_string(segment);
+        break;
+      case 'integer':
+        result = get_integer(segment);
+        break;
+      case 'float':
+        result = get_float(segment);
+        break;
+      case 'binary':
+        result = get_binary(segment);
+        break;
+      }
+
+      if (result === false) {
+        return false;
+      }
+      else if (segment.name) {
+        vars[segment.name] = result;
+      }
+      else if (segment.value != result) {
+        return false;
+      }
+    }
+  }
+  if (offset == binsize) {
+    return bindings(vars);
+  }
+  else {
+    return false;
+  }
+}
+
+module.exports.match = match;
+module.exports.parse_int = parse_int;
+module.exports.parse_float = parse_float;

package/test/node_modules/@acuminous/bitsyntax/lib/parse.js

@@ -0,0 +1,32 @@
+// Parse patterns in string form into the form we use for interpreting
+// (and later, for compiling).
+
+'use strict';
+
+var ast = require('./pattern');
+var parser = require('./parser');
+
+function parse_pattern(string) {
+  var segments = parser.parse(string);
+  for (var i=0, len = segments.length; i < len; i++) {
+    var s = segments[i];
+    if (s.string != undefined) {
+      segments[i] = ast.string(s.string);
+    }
+    else if (s.value != undefined) {
+      segments[i] = ast.value(s.value, s.size, s.specifiers);
+    }
+    else if (s.name != undefined) {
+      segments[i] = ast.variable(s.name, s.size, s.specifiers);
+    }
+    else {
+      throw "Unknown segment " + s;
+    }
+  }
+  return segments;
+}
+
+module.exports.parse = function() {
+  var str = [].join.call(arguments, ',');
+  return parse_pattern(str);
+};