typespeed 2.0.21 → 2.0.23

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

@@ -1,142 +0,0 @@
-// -*- 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

@@ -1,67 +0,0 @@
-
-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

@@ -1,232 +0,0 @@
-// -*- 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

@@ -1,32 +0,0 @@
-// 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);
-};