Merge pull request #115 from keichi/buffer-readuntil

Implement readUntil option for buffer

Author: keichi

README.md

@@ -151,14 +151,16 @@ the following keys:
 - `clone` - (Optional, defaults to `false`) By default,
   `buffer(name [,options])` returns a new buffer which references the same
   memory as the parser input, but offset and cropped by a certain range. If
-  this option is true, input buffer will be cloned and a new buffer referncing
-  another memory is returned.
+  this option is true, input buffer will be cloned and a new buffer
+  referencing a new memory region is returned.
 - `length ` - (either `length` or `readUntil` is required) Length of the
   buffer. Can be a number, string or a function. Use number for statically
   sized buffers, string to reference another variable and function to do some
   calculation.
 - `readUntil` - (either `length` or `readUntil` is required) If `"eof"`, then
-  this parser will read till it reaches end of the `Buffer` object.
+  this parser will read till it reaches end of the `Buffer` object. If it is a
+  function, this parser will read the buffer is read until the function
+  returns true.
 
 ### array(name, options)
 Parse bytes as an array. `options` is an object which can have the following

lib/binary_parser.ts

@@ -911,7 +911,22 @@ export class Parser {
   private generateBuffer(ctx: Context) {
     const varName = ctx.generateVariable(this.varName);
 
-    if (this.options.readUntil === 'eof') {
+    if (typeof this.options.readUntil === 'function') {
+      const pred = this.options.readUntil;
+      const start = ctx.generateTmpVariable();
+      const cur = ctx.generateTmpVariable();
+
+      ctx.pushCode(`var ${start} = offset;`);
+      ctx.pushCode(`var ${cur} = 0;`);
+      ctx.pushCode(`while (offset < buffer.length) {`);
+      ctx.pushCode(`${cur} = buffer.readUInt8(offset);`);
+      ctx.pushCode(
+        `if (${pred}.call(this, ${cur}, buffer.slice(offset))) break;`
+      );
+      ctx.pushCode(`offset += 1;`);
+      ctx.pushCode(`}`);
+      ctx.pushCode(`${varName} = buffer.slice(${start}, offset);`);
+    } else if (this.options.readUntil === 'eof') {
       ctx.pushCode(`${varName} = buffer.slice(offset);`);
     } else {
       const len = ctx.generateOption(this.options.length);

test/composite_parser.js

@@ -906,22 +906,6 @@ describe('Composite parser', function() {
     });
   });
 
-  describe('Buffer parser', function() {
-    //this is a test for testing a fix of a bug, that removed the last byte of the
-    //buffer parser
-    it('should return a buffer with same size', function() {
-      var bufferParser = new Parser().buffer('buf', {
-        readUntil: 'eof',
-        formatter: function(buffer) {
-          return buffer;
-        },
-      });
-
-      var buffer = Buffer.from('John\0Doe\0');
-      assert.deepEqual(bufferParser.parse(buffer), { buf: buffer });
-    });
-  });
-
   describe('Constructors', function() {
     it('should create a custom object type', function() {
       function Person() {

test/primitive_parser.js

@@ -424,5 +424,45 @@ describe('Primitive parser', function() {
       result.raw[0] = 0xff;
       assert.notDeepEqual(result.raw, buf);
     });
+
+    it('should parse until function returns true when readUntil is function', function() {
+      var parser = new Parser()
+        .endianess('big')
+        .uint8('cmd')
+        .buffer('data', {
+          readUntil: function(item) {
+            return item === 2;
+          },
+        });
+
+      var result = parser.parse(Buffer.from('aa', 'hex'));
+      assert.deepEqual(result, { cmd: 0xaa, data: Buffer.from([]) });
+
+      var result = parser.parse(Buffer.from('aabbcc', 'hex'));
+      assert.deepEqual(result, { cmd: 0xaa, data: Buffer.from('bbcc', 'hex') });
+
+      var result = parser.parse(Buffer.from('aa02bbcc', 'hex'));
+      assert.deepEqual(result, { cmd: 0xaa, data: Buffer.from([]) });
+
+      var result = parser.parse(Buffer.from('aabbcc02', 'hex'));
+      assert.deepEqual(result, { cmd: 0xaa, data: Buffer.from('bbcc', 'hex') });
+
+      var result = parser.parse(Buffer.from('aabbcc02dd', 'hex'));
+      assert.deepEqual(result, { cmd: 0xaa, data: Buffer.from('bbcc', 'hex') });
+    });
+
+    // this is a test for testing a fix of a bug, that removed the last byte
+    // of the buffer parser
+    it('should return a buffer with same size', function() {
+      var bufferParser = new Parser().buffer('buf', {
+        readUntil: 'eof',
+        formatter: function(buffer) {
+          return buffer;
+        },
+      });
+
+      var buffer = Buffer.from('John\0Doe\0');
+      assert.deepEqual(bufferParser.parse(buffer), { buf: buffer });
+    });
   });
 });