Read/write strings from/to binary

Author: mdingena

src/utils/createBinaryReader.ts

@@ -9,9 +9,12 @@ export type BinaryReader = {
   binary: (bits: number) => string;
   boolean: () => boolean;
   uInt: () => number;
+  uShort: () => number;
   uLong: () => number;
   float: () => number;
   int: () => number;
+  char: () => string;
+  string: () => string;
 };
 
 export const createBinaryReader = (binary: string): BinaryReader => {
@@ -39,6 +42,12 @@ export const createBinaryReader = (binary: string): BinaryReader => {
       return binaryToNumber(bits);
     },
 
+    uShort: function () {
+      const bits = this.binary(16);
+
+      return binaryToNumber(bits);
+    },
+
     uLong: function () {
       const bits = this.binary(64);
 
@@ -55,6 +64,55 @@ export const createBinaryReader = (binary: string): BinaryReader => {
       const bits = this.binary(32);
 
       return binaryToInt(bits);
+    },
+
+    char: function () {
+      const bits = this.binary(8);
+      const charCode = binaryToNumber(bits);
+
+      return String.fromCharCode(charCode);
+    },
+
+    string: function () {
+      const length = this.uShort();
+
+      if (length === 0) return '';
+
+      /* Align bits. */
+      const offset = index.current % 8 === 0 ? 0 : 8 - (index.current % 8);
+
+      if (offset > 0) this.binary(offset);
+
+      let currentByte = (index.current % 32) / 8;
+
+      /* Read garbled text from binary. */
+      let textBuffer = '';
+
+      while (textBuffer.length < length) {
+        textBuffer += this.char();
+      }
+
+      /* Untangle garbled text. */
+      let text = '';
+      let bufferIndex = 0;
+
+      while (currentByte < 4 && bufferIndex < length) {
+        text += textBuffer[bufferIndex++];
+        currentByte++;
+      }
+
+      while (bufferIndex + 4 <= length) {
+        const chars = textBuffer.substr(bufferIndex, 4);
+
+        text += chars.split('').reverse().join('');
+        bufferIndex += 4;
+      }
+
+      while (bufferIndex < length) {
+        text += textBuffer[bufferIndex++];
+      }
+
+      return text;
     }
   };
 };

src/utils/createBinaryWriter.ts

@@ -1,15 +1,20 @@
 import { floatToBinary } from './floatToBinary';
+import { uShortToBinary } from './uShortToBinary';
 import { uLongToBinary } from './uLongToBinary';
 import { intToBinary } from './intToBinary';
 import { uIntToBinary } from './uIntToBinary';
+import { numberToBinary } from './numberToBinary';
 
 export type BinaryWriter = {
   binary: (bits: string) => void;
   boolean: (bit: boolean) => void;
   uInt: (number: number) => void;
+  uShort: (number: number) => void;
   uLong: (number: number) => void;
   float: (number: number) => void;
   int: (number: number) => void;
+  char: (char: string) => void;
+  string: (text: string) => void;
   flush: () => string;
 };
 
@@ -29,6 +34,10 @@ export const createBinaryWriter = (): BinaryWriter => {
       binary += uIntToBinary(number);
     },
 
+    uShort: function (number: number) {
+      binary += uShortToBinary(number);
+    },
+
     uLong: function (number: number) {
       binary += uLongToBinary(number);
     },
@@ -41,6 +50,55 @@ export const createBinaryWriter = (): BinaryWriter => {
       binary += intToBinary(number);
     },
 
+    char: function (char: string) {
+      const charCode = char.charCodeAt(0);
+      const bits = numberToBinary(charCode).padStart(8, '0');
+
+      binary += bits;
+    },
+
+    string: function (textBuffer: string) {
+      this.uShort(textBuffer.length);
+
+      if (textBuffer.length === 0) return;
+
+      /* Align bits. */
+      const index = binary.length;
+      const offset = index % 8 === 0 ? 0 : 8 - (index % 8);
+
+      if (offset > 0) {
+        const align = '0'.repeat(offset);
+
+        this.binary(align);
+      }
+
+      let currentByte = (binary.length % 32) / 8;
+
+      /* Garble text, ATT style. */
+      let text = '';
+      let bufferIndex = 0;
+
+      while (currentByte < 4 && bufferIndex < textBuffer.length) {
+        text += textBuffer[bufferIndex++];
+        currentByte++;
+      }
+
+      while (bufferIndex + 4 <= textBuffer.length) {
+        const chars = textBuffer.substr(bufferIndex, 4);
+
+        text += chars.split('').reverse().join('');
+        bufferIndex += 4;
+      }
+
+      while (bufferIndex < textBuffer.length) {
+        text += textBuffer[bufferIndex++];
+      }
+
+      for (const letter of text) {
+        this.char(letter);
+      }
+    },
+
     flush: function () {
       const result = binary;
       binary = '';