[fix] decode base64

jtenner · jtenner · commit 64f296e3b2b2 · 2019-08-22T17:16:44.000-04:00
diff --git a/assembly/buffer/index.ts b/assembly/buffer/index.ts
@@ -378,10 +378,12 @@ export namespace Buffer {
   }
 
   export namespace BASE64 {
-
+    // @ts-ignore: Decorators!
+    @inline
     function charCodeFromByte(value: i32): u64 {
       if (i32(value >= 0) & i32(value < 26)) return value + 0x41;
-      else if (i32(value >= 26) & i32(value < 51)) return value + 0x61;
+      else if (i32(value >= 26) & i32(value < 52)) return value + 0x47;
+      else if (i32(value >= 52) & i32(value < 62)) return value - 0x4;
       else return select(0x2B, 0x2F, value == 62);
     }
 
@@ -401,20 +403,20 @@ export namespace Buffer {
       return decodeUnsafe(changetype<usize>(buffer), buffer.byteLength);
     }
 
-    export function decodeUnsafe(pointer: usize, length: i32): string {
+    export function decodeUnsafe(sourcePointer: usize, length: i32): string {
       if (length == 0) return "";
       let iterations = <i32>Math.floor(length / 3);
       let leftoverBytes = length % 3;
-      let stringLength = (iterations << 2) + select(4, 0, leftoverBytes);
+      let stringLength = (iterations << 2) + select(4, 0, leftoverBytes != 0);
       let output = __alloc(stringLength << 1, idof<String>());
 
       for (let i = 0; i < iterations; i++) {
-        let bytes = bswap<u32>(load<u32>(pointer + <usize>i * 3)) >>> 8;
+        let bytes = bswap<u32>(load<u32>(sourcePointer + <usize>i * 3)) >>> 8;
+
         let value1 = (bytes & 0b111111000000000000000000) >> 18; // first 6 bits
         let value2 = (bytes &       0b111111000000000000) >> 12; // second 6 bits
         let value3 = (bytes &             0b111111000000) >> 6 ; // third 6 bits
         let value4 = (bytes &                   0b111111)      ; // fourth 6 bits
-
         let chars: u64 = charCodeFromByte(value1)
           | (charCodeFromByte(value2) << 16)
           | (charCodeFromByte(value3) << 32)
@@ -425,7 +427,7 @@ export namespace Buffer {
       // A is 0x61
       // = is 0x3D
       if (leftoverBytes == 2) {
-        let bytes = <u32>bswap<u16>(load<u16>(pointer + <usize>(iterations * 3))) << 2;
+        let bytes = <u32>bswap<u16>(load<u16>(sourcePointer + <usize>(iterations * 3))) << 2;
         let value1 = (bytes &       0b111111000000000000) >> 12; // first 6 bits
         let value2 = (bytes &             0b111111000000) >> 6 ; // second 6 bits
         let value3 = (bytes &                   0b111111) >> 0 ; // third 6 bits
@@ -435,9 +437,14 @@ export namespace Buffer {
           | <u64>0x3D000000000000;
         store<u64>(output + (<usize>iterations << alignof<u64>()), chars);
       } else if (leftoverBytes == 1) {
-        let bytes = <i32>load<u8>(pointer + <usize>(iterations * 3)) >> 2;
-        let chars: u64 = charCodeFromByte(bytes & 0b111111)
-           | <u64>0x3D003D00410000;
+        let bytes = <i32>load<u8>(sourcePointer + <usize>(iterations * 3));
+        trace("bytes", 1, bytes);
+        let value1 = (bytes & 0b11111100) >> 2;
+        let value2 = (bytes & 0b11) << 4;
+        let chars: u64 = charCodeFromByte(value1)
+           | <u64>(charCodeFromByte(value2) << 16)
+           | <u64>0x3D003D00000000;
+
         store<u64>(output + (<usize>iterations << alignof<u64>()), chars);
       }
 
diff --git a/assembly/node.d.ts b/assembly/node.d.ts
@@ -94,4 +94,9 @@ declare namespace Buffer {
     /** Decodes a chunk of memory to a utf16le encoded string in hex format. */
     export function decodeUnsafe(ptr: usize, byteLength: i32): string;
   }
+
+  export namespace BASE64 {
+    /** Creates a string from a given ArrayBuffer that is decoded into base64 format. */
+    export function decode(buffer: ArrayBuffer): string;
+  }
 }
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -12,7 +12,7 @@
     "url": "https://github.com/AssemblyScript/node/issues"
   },
   "devDependencies": {
-    "@as-pect/core": "^2.3.1",
+    "@as-pect/core": "^2.4.0",
     "assemblyscript": "github:assemblyscript/assemblyscript",
     "glob": "^7.1.4",
     "wasi": "github:devsnek/node-wasi"
diff --git a/tests/buffer.spec.ts b/tests/buffer.spec.ts
@@ -592,7 +592,6 @@ describe("buffer", () => {
     expect<string>(decoded).toStrictEqual("AQIDBA==");
     decoded = Buffer.BASE64.decode(create<Buffer>([1, 2, 3, 4, 5]).buffer);
     expect<string>(decoded).toBe("AQIDBAU=", "target");
-
     decoded = Buffer.BASE64.decode(create<Buffer>([
       150, 144,  40,  36,  82,   6, 240,  81, 182,  94,  22,
       137,  32, 212,  14,   6, 176, 169, 104,  91, 243, 241,
@@ -615,5 +614,11 @@ describe("buffer", () => {
       106
     ]).buffer);
     expect<string>(decoded).toBe("vSQJHj1Wusb3lhfgbLIj35vyjKujgq1+PEZT03EGiYymYl5eBG6SAuIze+LrBCwfcUWpZGGq77l3anBroizTpljhjSZ6UuWZcxdsdyYR5Mw0DhtoO0DFbevO88SrswY+ag==");
+
+    decoded = Buffer.BASE64.decode(create<Buffer>([
+      141, 192, 94, 172,
+      180, 140,  2,  59
+    ]).buffer);
+    expect<string>(decoded).toBe("jcBerLSMAjs=");
   });
 });

Original file line number	Diff line number	Diff line change
`@@ -94,4 +94,9 @@ declare namespace Buffer {`
`94`	`94`	`/** Decodes a chunk of memory to a utf16le encoded string in hex format. */`
`95`	`95`	`export function decodeUnsafe(ptr: usize, byteLength: i32): string;`
`96`	`96`	`}`
	`97`	`+`
	`98`	`+ export namespace BASE64 {`
	`99`	`+ /** Creates a string from a given ArrayBuffer that is decoded into base64 format. */`
	`100`	`+ export function decode(buffer: ArrayBuffer): string;`
	`101`	`+ }`
`97`	`102`	`}`