Replaces static Buffer with smart-buffer for internal encoding

Author: Ericbla

README.md

@@ -95,7 +95,7 @@ console.log(ipHeader.encode(anIpHeader).toString("hex"));
 Constructs a Parser object. Returned object represents a parser which parses
 nothing. `options` is an optional object to pass options to this declarative
 parser.
-  - `bufferSize` The size of the encoding buffer (when encoding is used) (default is 256 bytes).
+  - `smartBufferSize` The chunk size of the encoding (smart)buffer (when encoding is used) (default is 256 bytes).
 
 ### parse(buffer)
 Parse a `Buffer` object `buffer` with this parser and return the resulting
@@ -155,9 +155,10 @@ the following keys:
   `"utf8"`, `"ascii"`, `"hex"` and else are valid. See
   [`Buffer.toString`](http://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end)
   for more info.
-- `length ` - (Optional) Length of the string. Can be a number, string or a
+- `length ` - (Optional) (Bytes)Length of the string. Can be a number, string or a
   function. Use number for statically sized arrays, string to reference
   another variable and function to do some calculation.
+  Note: when encoding the string is padded with spaces (0x20) at end to fit the length requirement.
 - `zeroTerminated` - (Optional, defaults to `false`) If true, then this parser
   reads until it reaches zero.
 - `greedy` - (Optional, defaults to `false`) If true, then this parser reads

lib/binary_parser.js

@@ -2,6 +2,8 @@
 // Globals
 //========================================================================================
 var vm = require("vm");
+const SmartBuffer = require("smart-buffer").SmartBuffer;
+global.SmartBuffer = SmartBuffer;
 
 var Context = require("./context").Context;
 
@@ -70,8 +72,10 @@ var Parser = function(opts) {
   this.endian = "be";
   this.constructorFn = null;
   this.alias = null;
-  this.bufferSize =
-    opts && typeof opts === "object" && opts.bufferSize ? opts.bufferSize : 256;
+  this.smartBufferSize =
+    opts && typeof opts === "object" && opts.smartBufferSize
+      ? opts.smartBufferSize
+      : 256;
 };
 
 //----------------------------------------------------------------------------------------
@@ -310,14 +314,16 @@ Parser.prototype.addRawCode = function(ctx) {
 
 Parser.prototype.addRawCodeEncode = function(ctx) {
   ctx.pushCode("var vars = obj;");
-  ctx.pushCode("var offset = 0, maxOffset = {0};", this.bufferSize);
-  ctx.pushCode("var buffer = Buffer.alloc(maxOffset);"); //TODO See how to dynamically alloc encode buffer
+  ctx.pushCode(
+    "var smartBuffer = SmartBuffer.fromOptions({size: {0}, encoding: 'utf8'});",
+    this.smartBufferSize
+  );
 
   this.generateEncode(ctx);
 
   this.resolveReferences(ctx, "encode");
 
-  ctx.pushCode("return buffer.slice(0, offset);");
+  ctx.pushCode("return smartBuffer.toBuffer();");
 };
 
 Parser.prototype.addAliasedCode = function(ctx) {
@@ -344,15 +350,17 @@ Parser.prototype.addAliasedCodeEncode = function(ctx) {
   ctx.pushCode("function {0}(obj) {", FUNCTION_ENCODE_PREFIX + this.alias);
 
   ctx.pushCode("var vars = obj;");
-  ctx.pushCode("var offset = 0, maxOffset = {0};", this.bufferSize);
-  ctx.pushCode("var buffer = Buffer.alloc(maxOffset);"); //TODO See how to dynamically alloc encode buffer
+  ctx.pushCode(
+    "var smartBuffer = SmartBuffer.fromOptions({size: {0}, encoding: 'utf8'});",
+    this.smartBufferSize
+  );
 
   this.generateEncode(ctx);
 
   ctx.markResolved(this.alias);
   this.resolveReferences(ctx, "encode");
 
-  ctx.pushCode("return buffer.slice(0, offset);");
+  ctx.pushCode("return smartBuffer.toBuffer();");
   ctx.pushCode("}");
 
   return ctx;
@@ -377,7 +385,7 @@ Parser.prototype.compile = function() {
 };
 
 Parser.prototype.compileEncode = function() {
-  var src = "(function(obj, buffer) { " + this.getCodeEncode() + " })";
+  var src = "(function(obj) { " + this.getCodeEncode() + " })";
   this.compiledEncode = vm.runInThisContext(src);
 };
 
@@ -439,12 +447,12 @@ Parser.prototype.parse = function(buffer) {
 };
 
 // Follow the parser chain till the root and start encoding from there
-Parser.prototype.encode = function(obj, buffer) {
+Parser.prototype.encode = function(obj) {
   if (!this.compiledEncode) {
     this.compileEncode();
   }
 
-  return this.compiledEncode(obj, buffer);
+  return this.compiledEncode(obj);
 };
 
 //----------------------------------------------------------------------------------------
@@ -557,8 +565,7 @@ Object.keys(PRIMITIVE_TYPES).forEach(function(type) {
   };
   Parser.prototype["generate_encode" + type] = function(ctx) {
     ctx.pushCode(
-      "if (offset + {0} <= maxOffset) offset = buffer.write{1}({2}, offset);",
-      PRIMITIVE_TYPES[type],
+      "smartBuffer.write{0}({1});",
       type,
       ctx.generateVariable(this.varName)
     );
@@ -664,11 +671,20 @@ Parser.prototype.generate_encodeBit = function(ctx) {
       ctx.pushCode("{0} = {0} >>> 0;", tmpVal);
       bitOffset += parser.options.length;
     });
-    ctx.pushCode(
-      "if (offset + {1} <= maxOffset) offset = buffer.writeUIntBE({0}, offset, {1});",
-      tmpVal,
-      sum / 8
-    );
+    if (sum == 8) {
+      ctx.pushCode("smartBuffer.writeUInt8({0});", tmpVal);
+    } else if (sum == 16) {
+      ctx.pushCode("smartBuffer.writeUInt16BE({0});", tmpVal);
+    } else if (sum == 24) {
+      var val1 = ctx.generateTmpVariable();
+      var val2 = ctx.generateTmpVariable();
+      ctx.pushCode("var {0} = ({1} >>> 8);", val1, tmpVal);
+      ctx.pushCode("var {0} = ({1} & 0x0ff);", val2, tmpVal);
+      ctx.pushCode("smartBuffer.writeUInt16BE({0});", val1);
+      ctx.pushCode("smartBuffer.writeUInt8({0});", val2);
+    } else if (sum == 32) {
+      ctx.pushCode("smartBuffer.writeUInt32BE({0});", tmpVal);
+    }
 
     ctx.bitFields = [];
   }
@@ -681,7 +697,8 @@ Parser.prototype.generateSkip = function(ctx) {
 
 Parser.prototype.generate_encodeSkip = function(ctx) {
   var length = ctx.generateOption(this.options.length);
-  ctx.pushCode("offset += {0};", length);
+  ctx.pushCode("smartBuffer._ensureWriteable({0});", length);
+  ctx.pushCode("smartBuffer.writeOffset += {0};", length);
 };
 
 Parser.prototype.generateString = function(ctx) {
@@ -740,21 +757,36 @@ Parser.prototype.generate_encodeString = function(ctx) {
 
   // Get the length of string to encode
   if (this.options.length) {
+    var optLength = ctx.generateOption(this.options.length);
+    // Encode the string to a temporary buffer
+    var tmpBuf = ctx.generateTmpVariable();
     ctx.pushCode(
-      "offset += buffer.write({0}, offset, {1}, '{2}');",
+      "var {0} = Buffer.from({1}, '{2}');",
+      tmpBuf,
       name,
-      ctx.generateOption(this.options.length),
       this.options.encoding
     );
+    // Truncate the buffer to specified (Bytes) length
+    ctx.pushCode("{0} = {0}.slice(0, {1});", tmpBuf, optLength);
+    // Compute padding length
+    var padLen = ctx.generateTmpVariable();
+    ctx.pushCode("{0} = {1} - {2}.length;", padLen, optLength, tmpBuf);
+    // Copy the temporary string buffer to current smartBuffer
+    ctx.pushCode("smartBuffer.writeBuffer({0});", tmpBuf);
+    // Add padding spaces
+    ctx.pushCode(
+      "if ({0} > 0) {smartBuffer.writeString(' '.repeat({0}));}",
+      padLen
+    );
   } else {
     ctx.pushCode(
-      "offset += buffer.write({0}, offset, '{1}');",
+      "smartBuffer.writeString({0}, '{1}');",
       name,
       this.options.encoding
     );
   }
   if (this.options.zeroTerminated) {
-    ctx.pushCode("offset = buffer.writeUInt8(0x00, offset);");
+    ctx.pushCode("smartBuffer.writeUInt8(0x00);");
   }
 };
 
@@ -780,7 +812,7 @@ Parser.prototype.generateBuffer = function(ctx) {
 
 Parser.prototype.generate_encodeBuffer = function(ctx) {
   ctx.pushCode(
-    "offset += {0}.copy(buffer, offset);",
+    "smartBuffer.writeBuffer({0});",
     ctx.generateVariable(this.varName)
   );
 };
@@ -864,11 +896,7 @@ Parser.prototype.generate_encodeArray = function(ctx) {
     ctx.generateError('"Encoding associative array not supported"');
   }
 
-  if (lengthInBytes !== undefined) {
-    ctx.pushCode("var {0} = offset + {1};", maxOffset, lengthInBytes);
-  } else {
-    ctx.pushCode("var {0} = Number.MAX_SAFE_INTEGER;", maxOffset);
-  }
+  // Compute the desired count of array items to encode (min of array size and length option)
   if (length !== undefined) {
     var tmpLength = ctx.generateTmpVariable();
     ctx.pushCode("var {0} = {1};", tmpLength, length);
@@ -882,8 +910,15 @@ Parser.prototype.generate_encodeArray = function(ctx) {
     ctx.pushCode("var {0} = {1}.length;", maxItems, name);
   }
 
-  ctx.pushCode("var {0} = 0;", itemCounter);
+  // Save current encoding smartBuffer and allocate a new one
+  var savSmartBuffer = ctx.generateTmpVariable();
+  ctx.pushCode(
+    "var {0} = smartBuffer; smartBuffer = SmartBuffer.fromOptions({size: {1}, encoding: 'utf8'});",
+    savSmartBuffer,
+    this.smartBufferSize
+  );
 
+  ctx.pushCode("var {0} = 0;", itemCounter);
   if (typeof this.options.readUntil === "function") {
     ctx.pushCode("do {");
   } else {
@@ -895,74 +930,44 @@ Parser.prototype.generate_encodeArray = function(ctx) {
 
   if (typeof type === "string") {
     if (!aliasRegistry[type]) {
-      ctx.pushCode(
-        "if (offset + {0} > {1} || offset + {0} > maxOffset) break;",
-        PRIMITIVE_TYPES[NAME_MAP[type]],
-        maxOffset
-      );
-      ctx.pushCode(
-        "offset = buffer.write{0}({1}, offset);",
-        NAME_MAP[type],
-        item
-      );
+      ctx.pushCode("smartBuffer.write{0}({1});", NAME_MAP[type], item);
     } else {
-      var tempVar = ctx.generateTmpVariable();
       ctx.pushCode(
-        "var {0} = {1}({2});",
-        tempVar,
+        "smartBuffer.writeBuffer({0}({1}));",
         FUNCTION_ENCODE_PREFIX + type,
         item
       );
-      ctx.pushCode(
-        "if (offset + {0}.length > {1} || offset + {0}.length > maxOffset) break;",
-        tempVar,
-        maxOffset
-      );
-      ctx.pushCode("offset += {0}.copy(buffer, offset);", tempVar);
-      if (type !== this.alias) ctx.addReference(type);
+      if (type !== this.alias) {
+        ctx.addReference(type);
+      }
     }
   } else if (type instanceof Parser) {
-    var savMaxOffset = ctx.generateTmpVariable();
-    var savBuffer = ctx.generateTmpVariable();
-    var savOffset = ctx.generateTmpVariable();
-    ctx.pushCode(
-      "var {0} = maxOffset; maxOffset = {1};",
-      savMaxOffset,
-      maxOffset
-    );
-    ctx.pushCode(
-      "var {0} = buffer; buffer = Buffer.alloc({1});",
-      savBuffer,
-      this.bufferSize
-    );
-    ctx.pushCode("var {0} = offset; offset = 0;", savOffset);
     ctx.pushScope(item);
     type.generateEncode(ctx);
     ctx.popScope();
-    ctx.pushCode(
-      "if ({1} + offset <= {0}) {1} += buffer.copy({2}, {3}, 0, offset);",
-      maxOffset,
-      savOffset,
-      savBuffer,
-      savOffset
-    );
-    ctx.pushCode(
-      "maxOffset = {0}; buffer = {1}; offset = {2};",
-      savMaxOffset,
-      savBuffer,
-      savOffset
-    );
   }
 
   ctx.pushCode("}"); // End of 'do {'  or 'for(...) {'
 
   if (typeof this.options.readUntil === "function") {
     ctx.pushCode(
-      " while (!({0}).call(this, {1}, buffer.slice(offset)));",
+      " while (!({0}).call(this, {1}, {2}.toBuffer()));",
       this.options.readUntil,
-      item
+      item,
+      savSmartBuffer
     );
   }
+
+  var tmpBuffer = ctx.generateTmpVariable();
+  ctx.pushCode("var {0} = smartBuffer.toBuffer()", tmpBuffer);
+  if (lengthInBytes !== undefined) {
+    // Truncate the tmpBuffer so that it will respect the lengthInBytes option
+    ctx.pushCode("{0} = {0}.slice(0, {1});", tmpBuffer, lengthInBytes);
+  }
+  // Copy tmp Buffer to saved smartBuffer
+  ctx.pushCode("{0}.writeBuffer({1});", savSmartBuffer, tmpBuffer);
+  // Restore current smartBuffer
+  ctx.pushCode("smartBuffer = {0};", savSmartBuffer);
 };
 
 Parser.prototype.generateChoiceCase = function(ctx, varName, type) {
@@ -995,7 +1000,7 @@ Parser.prototype.generate_encodeChoiceCase = function(ctx, varName, type) {
   if (typeof type === "string") {
     if (!aliasRegistry[type]) {
       ctx.pushCode(
-        "offset = buffer.write{0}({1}, offset);",
+        "smartBuffer.write{0}({1});",
         NAME_MAP[type],
         ctx.generateVariable(this.varName)
       );
@@ -1007,7 +1012,7 @@ Parser.prototype.generate_encodeChoiceCase = function(ctx, varName, type) {
         FUNCTION_ENCODE_PREFIX + type,
         ctx.generateVariable(this.varName)
       );
-      ctx.pushCode("offset += {0}.copy(buffer, offset);", tempVar);
+      ctx.pushCode("smartBuffer.writeBuffer({0});", tempVar);
       if (type !== this.alias) ctx.addReference(type);
     }
   } else if (type instanceof Parser) {
@@ -1099,7 +1104,7 @@ Parser.prototype.generate_encodeNest = function(ctx) {
       FUNCTION_ENCODE_PREFIX + this.options.type,
       nestVar
     );
-    ctx.pushCode("offset += {0}.copy(buffer, offset);", tempVar);
+    ctx.pushCode("smartBuffer.writeBuffer({0});", tempVar);
     if (this.options.type !== this.alias) ctx.addReference(this.options.type);
   }
 };

package-lock.json

@@ -34,8 +34,10 @@
     "url": "http://github.com/keichi/binary-parser.git"
   },
   "bugs": "http://github.com/keichi/binary-parser/issues",
-  "dependencies": {},
+  "dependencies": {
+    "smart-buffer": "^4.0.1"
+  },
   "engines": {
-      "node": ">=5.10.0"
+    "node": ">=5.10.0"
   }
 }