Issue keichi#19 Little endianess incorrect

Author: Ericbla

README.md

@@ -338,6 +338,21 @@ var parser = new Parser()
   .int32("c");
 ```
 
+### setEncoderOptions(opts)
+Set specific options for encoding.
+Current supported `opts` object may contain:
+  - bitEndianess: true|false (default false) When true, tell the encoder to respect endianess BITs order, so that
+    encoding is exactly the reverse of the parsing process for bits fields.
+
+```javascript
+var parser = new Parser()
+  .endianess("little")
+  .setEncoderOpts({bitEndianess: true}) // Use BITs endianess for bits fields
+  .bit4("a")
+  .bit4("b")
+  .uint16("c");
+```
+
 ### namely(alias)
 Set an alias to this parser, so there will be an opportunity to refer to it by
 name in methods like `.array`, `.nest` and `.choice`, instead of requirement

lib/binary_parser.js

@@ -76,6 +76,9 @@ var Parser = function(opts) {
     opts && typeof opts === "object" && opts.smartBufferSize
       ? opts.smartBufferSize
       : 256;
+  this.encoderOpts = {
+    bitEndianess: false
+  };
 };
 
 //----------------------------------------------------------------------------------------
@@ -247,6 +250,11 @@ Parser.prototype.endianess = function(endianess) {
   return this;
 };
 
+Parser.prototype.encoderSetOptions = function(opts) {
+  Object.assign(this.encoderOpts, opts);
+  return this;
+};
+
 Parser.prototype.create = function(constructorFn) {
   if (!(constructorFn instanceof Function)) {
     throw new Error("Constructor must be a Function object.");
@@ -466,6 +474,7 @@ Parser.prototype.setNextParser = function(type, varName, options) {
   parser.varName = varName;
   parser.options = options || parser.options;
   parser.endian = this.endian;
+  parser.encoderOpts = this.encoderOpts;
 
   if (this.head) {
     this.head.next = parser;
@@ -668,15 +677,25 @@ Parser.prototype.generate_encodeBit = function(ctx) {
       );
     }
 
+    var isBitLittleEndian =
+      this.endian === "le" && this.encoderOpts.bitEndianess;
     var tmpVal = ctx.generateTmpVariable();
+    var boundVal = ctx.generateTmpVariable();
     ctx.pushCode("var {0} = 0;", tmpVal);
+    ctx.pushCode("var {0} = 0;", boundVal);
     var bitOffset = 0;
     ctx.bitFields.forEach(function(parser) {
+      ctx.pushCode(
+        "{0} = ({1} & {2});",
+        boundVal,
+        parser.varName,
+        (1 << parser.options.length) - 1
+      );
       ctx.pushCode(
         "{0} |= ({1} << {2});",
         tmpVal,
-        parser.varName,
-        sum - parser.options.length - bitOffset
+        boundVal,
+        isBitLittleEndian ? bitOffset : sum - bitOffset - parser.options.length
       );
       ctx.pushCode("{0} = {0} >>> 0;", tmpVal);
       bitOffset += parser.options.length;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "binary-parser-encoder",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "Blazing-fast binary parser builder",
   "main": "lib/binary_parser.js",
   "devDependencies": {

test/zz_encoder_bugs.js

@@ -219,4 +219,134 @@ describe("Specific bugs testing", function() {
       });
     });
   });
+
+  describe("Issue #19 Little endianess incorrect", function() {
+    let binaryLiteral = function(s) {
+      var i;
+      var bytes = [];
+
+      s = s.replace(/\s/g, "");
+      for (i = 0; i < s.length; i += 8) {
+        bytes.push(parseInt(s.slice(i, i + 8), 2));
+      }
+
+      return Buffer.from(bytes);
+    };
+    it("should parse 4-byte-length bit field sequence wit little endian", function() {
+      let buf = binaryLiteral("0000000000001111 1010000110100010"); // 000F A1A2
+
+      // Parsed as two uint16 with little-endian (BYTES order)
+      let parser1 = new Parser().uint16le("a").uint16le("b");
+
+      // Parsed as two 16 bits fields with little-endian
+      let parser2 = new Parser()
+        .endianess("little")
+        .bit16("a")
+        .bit16("b");
+
+      let parsed1 = parser1.parse(buf);
+      let parsed2 = parser2.parse(buf);
+
+      assert.deepEqual(parsed1, {
+        a: 0x0f00, // 000F
+        b: 0xa2a1 // A1A2
+      });
+
+      assert.deepEqual(parsed2, {
+        a: 0xa1a2, // last 16 bits (but value coded as BE)
+        b: 0x000f // first 16 bits  (but value coded as BE)
+      });
+
+      /* This is a little confusing. The endianess with bits fields affect the order of fields */
+    });
+    it("should encode bit ranges with little endian correctly", function() {
+      let bigParser = Parser.start()
+        .endianess("big")
+        .bit4("a")
+        .bit1("b")
+        .bit1("c")
+        .bit1("d")
+        .bit1("e")
+        .uint16("f")
+        .array("g", { type: "uint8", readUntil: "eof" });
+      let littleParser = Parser.start()
+        .endianess("little")
+        .bit4("a")
+        .bit1("b")
+        .bit1("c")
+        .bit1("d")
+        .bit1("e")
+        .uint16("f")
+        .array("g", { type: "uint8", readUntil: "eof" });
+      // Parser definition for a symetric encoding/decoding of little-endian bit fields
+      let little2Parser = Parser.start()
+        .endianess("little")
+        .encoderSetOptions({ bitEndianess: true })
+        .bit4("a")
+        .bit1("b")
+        .bit1("c")
+        .bit1("d")
+        .bit1("e")
+        .uint16("f")
+        .array("g", { type: "uint8", readUntil: "eof" });
+
+      let data = binaryLiteral(
+        "0011 0 1 0 1 0000000011111111 00000001 00000010 00000011"
+      ); // 35 00FF 01 02 03
+      // in big endian:            3 0 1 0 1             00FF        1        2        3
+      // in little endian:         3 0 1 0 1             FF00        1        2        3
+      // LE with encoderBitEndianess option:
+      //                           5 1 1 0 0             FF00        1        2        3
+
+      //let bigDecoded = bigParser.parse(data);
+      //let littleDecoded = littleParser.parse(data);
+      let little2Decoded = little2Parser.parse(data);
+
+      //console.log(bigDecoded);
+      //console.log(littleDecoded);
+      //console.log(little2Decoded);
+
+      let big = {
+        a: 3,
+        b: 0,
+        c: 1,
+        d: 0,
+        e: 1,
+        f: 0x00ff,
+        g: [1, 2, 3]
+      };
+      let little = {
+        a: 3,
+        b: 0,
+        c: 1,
+        d: 0,
+        e: 1,
+        f: 0xff00,
+        g: [1, 2, 3]
+      };
+      let little2 = {
+        a: 5,
+        b: 1,
+        c: 1,
+        d: 0,
+        e: 0,
+        f: 0xff00,
+        g: [1, 2, 3]
+      };
+
+      assert.deepEqual(little2Decoded, little2);
+
+      let bigEncoded = bigParser.encode(big);
+      let littleEncoded = littleParser.encode(little);
+      let little2Encoded = little2Parser.encode(little2);
+
+      //console.log(bigEncoded);
+      //console.log(littleEncoded);
+      //console.log(little2Encoded);
+
+      assert.deepEqual(bigEncoded, data);
+      assert.deepEqual(littleEncoded, data);
+      assert.deepEqual(little2Encoded, data);
+    });
+  });
 });