Additional checks to determine if next field is a bit field or not

Author: nick-hunter

lib/binary_parser.ts

@@ -286,7 +286,7 @@ export class Parser {
   alias?: string;
   useContextVariables = false;
 
-  constructor() {}
+  constructor() { }
 
   static start() {
     return new Parser();
@@ -1038,6 +1038,36 @@ export class Parser {
     return ctx;
   }
 
+  private nextNotBit() {
+    // Used to test if next type is a bitN or not
+    if (this.next) {
+      if (this.next.type === "nest") {
+        // For now consider a nest as a bit
+        if (this.next.options && this.next.options.type instanceof Parser) {
+          // Something in the nest
+          if (this.next.options.type.next) {
+            if (this.next.options.type.next.type === "bit") {
+              // Next is a bit field
+              return false;
+            } else {
+              // Next is something elses
+              return true;
+            }
+          }
+          return false;
+        } else {
+          // Nest is empty. For now assume this means bit is not next. However what if something comes after the nest?
+          return true;
+        }
+      } else {
+        return this.next.type !== "bit";
+      }
+    } else {
+      // Nothing else so next can't be bits
+      return true;
+    }
+  }
+
   private generateBit(ctx: Context) {
     // TODO find better method to handle nested bit fields
     const parser = JSON.parse(JSON.stringify(this));
@@ -1049,7 +1079,7 @@ export class Parser {
 
     if (
       !this.next ||
-      (this.next && ["bit", "nest"].indexOf(this.next.type) < 0)
+      this.nextNotBit()
     ) {
       const val = ctx.generateTmpVariable();
 
@@ -1097,8 +1127,7 @@ export class Parser {
           if (rem) {
             const mask = -1 >>> (32 - rem);
             ctx.pushCode(
-              `${parser.varName} = (${val} & 0x${mask.toString(16)}) << ${
-                length - rem
+              `${parser.varName} = (${val} & 0x${mask.toString(16)}) << ${length - rem
               };`
             );
             length -= rem;
@@ -1110,8 +1139,7 @@ export class Parser {
         const mask = -1 >>> (32 - length);
 
         ctx.pushCode(
-          `${parser.varName} ${
-            length < (parser.options.length as number) ? "|=" : "="
+          `${parser.varName} ${length < (parser.options.length as number) ? "|=" : "="
           } ${val} >> ${offset} & 0x${mask.toString(16)};`
         );
 

test/composite_parser.ts

@@ -982,6 +982,35 @@ function compositeParserTests(
           },
         });
       });
+
+      it("bit before nest should work", () => {
+        const parser = Parser.start()
+          .useContextVars()
+          .bit8("items")
+          .nest("data", {
+            type: Parser.start()
+              .uint8("length")
+              .string("message", { length: "length" })
+              .array("value", {
+                type: "uint8",
+                length: "$parent.items",
+              }),
+          });
+
+        const buffer = factory([
+          0x2, 0xc, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x77, 0x6f, 0x72,
+          0x6c, 0x64, 0x01, 0x02, 0x02, 0x02,
+        ]);
+        deepStrictEqual(parser.parse(buffer), {
+          items: 2,
+          data: {
+            length: 12,
+            message: "hello, world",
+            value: [0x01, 0x02],
+          },
+        });
+      });
+
     });
 
     describe("Constructors", () => {
@@ -1044,7 +1073,7 @@ function compositeParserTests(
         });
       });
 
-      it("should pass variable context to child parser", () => {});
+      it("should pass variable context to child parser", () => { });
       const parser = Parser.start()
         .uint16be("len")
         .pointer("child", {