json-as 0.5.26 → 0.5.28

package/README.md

@@ -79,13 +79,13 @@ Performance is nearly equal to the JavaScript JSON implementation which is in C+
 
 ## Performance
 
-**Serialize Object (Vec2):** ~7.20m ops/s
+**Serialize Object (Vec3):** ~11.1m ops/s
 
-**Deserialize Object (Vec2):** ~2.2m ops/s
+**Deserialize Object (Vec3):** ~3.2m ops/s
 
-**Serialize Array (int[4]):** ~1.4m ops/s
+**Serialize Array (int[]):** ~1.4m ops/s
 
-**Deserialize Array (int[4]):** ~2.8m ops/s
+**Deserialize Array (int[]):** ~2.8m ops/s
 
 **Serialize String (5):** ~5.2m ops/sw
 

package/asconfig.json

@@ -12,9 +12,6 @@
   "options": {
     "transform": [
       "./transform"
-    ],
-    "bindings": "esm",
-    "exportStart": "_start"
-  },
-  "extends": "./node_modules/@assemblyscript/wasi-shim/asconfig.json"
+    ]
+  }
 }

package/assembly/__benches__/as-json.ts

@@ -1,28 +1,33 @@
 import { JSON } from "..";
 
 @json
-class Vec2 {
-  x: f32;
-  y: f32;
+class Vec3 {
+  x: i32;
+  y: i32;
+  z: i32;
 }
 
-const vec: Vec2 = blackbox<Vec2>({
-  x: 0.0,
-  y: 0.0,
+const vec: Vec3 = blackbox<Vec3>({
+  x: 0,
+  y: 0,
+  z: 0
 });
 
-bench("Stringify Object (Vec2)", () => {
+bench("Stringify Object (Vec3)", () => {
   blackbox(JSON.stringify(vec));
 });
 
-bench("Parse Object (Vec2)", () => {
-  blackbox(JSON.parse<Vec2>(blackbox('{"x":0.0,"y":0.0}')));
-});
+bench("Parse Object (Vec3)", () => {
+  blackbox(JSON.parse<Vec3>(blackbox('{"x":0,"y":0,"z":0}')));
+});/*
 
 bench("Stringify Array", () => {
   blackbox(JSON.stringify(blackbox([1, 2, 3, 4, 5])));
 });
-
+bench("Stringify String Array", () => {
+  blackbox(JSON.stringify(blackbox(["a", "b", "c", "d", "e"])));
+});
+/*
 bench("Parse Array", () => {
   blackbox(JSON.parse<i32[]>(blackbox("[1,2,3,4]")));
 });
@@ -40,13 +45,13 @@ bench("Stringify Nested Array", () => {
 bench("Parse Nested Array", () => {
   blackbox(JSON.parse<string[][]>(blackbox('[["a","b","c"]]')));
 });
-
+*/
 bench("Stringify String", () => {
-  blackbox(JSON.stringify(blackbox("Hello")));
+  blackbox(JSON.stringify(blackbox("Hello \"World!")));
 });
 
 bench("Parse String", () => {
-  blackbox(JSON.parse<string>(blackbox('"Hello"')));
+  blackbox(JSON.parse<string>(blackbox('"Hello \"World!"')));
 });
 /*
 bench("Stringify Boolean", () => {

package/assembly/src/json.ts

@@ -40,54 +40,7 @@ export namespace JSON {
     export function stringify<T>(data: T): string {
         // String
         if (isString<T>() && data != null) {
-            // @ts-ignore
-            if (data.length === 0) return "\"\""; 
-            let result = new StringSink("\"");
-            // @ts-ignore
-            for (let i = 0; i < data.length; i++) {
-                // @ts-ignore
-                switch (unsafeCharCodeAt(data, i)) {
-                    case 0x22: {
-                        result.write("\\\"");
-                        break;
-                    }
-                    case 0x5C: {
-                        result.write("\\\\");
-                        break;
-                    }
-                    case 0x08: {
-                        result.write("\\b");
-                        break;
-                    }
-                    case 0x0A: {
-                        result.write("\\n");
-                        break;
-                    }
-                    case 0x0D: {
-                        result.write("\\r");
-                        break;
-                    }
-                    case 0x09: {
-                        result.write("\\t");
-                        break;
-                    }
-                    case 0x0C: {
-                        result.write("\\f");
-                        break;
-                    }
-                    case 0x0B: {
-                        result.write("\\u000b");
-                        break;
-                    }
-                    default: {
-                        // @ts-ignore
-                        result.write(data.charAt(i));
-                        break;
-                    }
-                }
-            }
-            result.write("\"");
-            return result.toString();
+            return serializeString(data);
         }
         // Boolean
         else if (isBoolean<T>()) {
@@ -113,19 +66,44 @@ export namespace JSON {
         }
         // ArrayLike
         else if (isArrayLike<T>()) {
-            let result = new StringSink(leftBracketWord);
-            // @ts-ignore
-            if (data.length == 0) return emptyArrayWord;
             // @ts-ignore
-            for (let i = 0; i < data.length - 1; i++) {
+            if (data.length == 0) {
+                return emptyArrayWord;
+            } else if (isString<valueof<T>>()) {
+                let result = "[";
+                for (let i = 0; i < data.length - 1; i++) {
+                    // @ts-ignore
+                    result += serializeString(unchecked(data[i]));
+                    result += commaWord;
+                }
+                result += serializeString(unchecked(data[data.length - 1]));
+                result += rightBracketWord;
+                return result;
+            } else if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
+                let result = new StringSink(leftBracketWord);
+                // @ts-ignore
+                for (let i = 0; i < data.length - 1; i++) {
+                    // @ts-ignore
+                    result.write(JSON.stringify(unchecked(data[i])));
+                    result.write(commaWord);
+                }
+                // @ts-ignore
+                result.write(JSON.stringify(unchecked(data[data.length - 1])));
+                result.write(rightBracketWord);
+                return result.toString();
+            } else {
+                let result = new StringSink(leftBracketWord);
+                // @ts-ignore
+                for (let i = 0; i < data.length - 1; i++) {
+                    // @ts-ignore
+                    result.write(JSON.stringify(unchecked(data[i])));
+                    result.write(commaWord);
+                }
                 // @ts-ignore
-                result.write(JSON.stringify(unchecked(data[i])));
-                result.write(commaWord);
+                result.write(JSON.stringify(unchecked(data[data.length - 1])));
+                result.write(rightBracketWord);
+                return result.toString();
             }
-            // @ts-ignore
-            result.write(JSON.stringify(unchecked(data[data.length - 1])));
-            result.write(rightBracketWord);
-            return result.toString();
         } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
             // @ts-ignore
             return data.toString();
@@ -201,30 +179,158 @@ export namespace JSON {
     }
 }
 
+// @ts-ignore
+@inline
+// @ts-ignore
+function serializeString(data: string): string {
+    // @ts-ignore
+    if (data.length === 0) return "\"\"";
+    // Fast path for Vectors (3)
+    let char: i32 = 0;
+    if (data.length === 1) {
+        char === unsafeCharCodeAt(data, 0);
+        if (char === 34) {
+            return "\\\"";
+        } else if (char === 92) {
+            return "\\n";
+        } else if (char <= 13 && char >= 8) {
+            switch (char) {
+                case 0x5C: {
+                    return "\\\\";
+                }
+                case 0x08: {
+                    return "\\b";
+                }
+                case 0x0D: {
+                    return "\\r";
+                }
+                case 0x09: {
+                    return "\\t";
+                }
+                case 0x0C: {
+                    return "\\f";
+                }
+                case 0x0B: {
+                    return "\\u000b";
+                }
+            }
+        } else {
+            return data;
+        }
+    }
+
+    let result = "\"";
+
+    let last: i32 = 0;
+    let found: boolean = false;
+    // @ts-ignore
+    for (let i = 0; i < data.length; i++) {
+        char = unsafeCharCodeAt(<string>data, i);
+        if (char === 34 || char === 92) {
+            result += (<string>data).slice(last, i) + "\\";
+            last = i;
+            found = true;
+            i++;
+        } else if (char <= 13 && char >= 8) {
+            result += (<string>data).slice(last, i);
+            last = ++i;
+            found = true;
+            switch (char) {
+                case 0x5C: {
+                    result += "\\\\";
+                    break;
+                }
+                case 0x08: {
+                    result += "\\b";
+                    break;
+                }
+                case 0x0D: {
+                    result += "\\r";
+                    break;
+                }
+                case 0x09: {
+                    result += "\\t";
+                    break;
+                }
+                case 0x0C: {
+                    result += "\\f";
+                    break;
+                }
+                case 0x0B: {
+                    result += "\\u000b";
+                    break;
+                }
+            }
+        }
+    }// 8 10 13 9 12
+    if (!found) return "\"" + data + "\"";
+    else result += (<string>data).slice(last);
+    return result + "\"";
+}
 // @ts-ignore
 @inline
 // @ts-ignore
 function parseBigNum<T>(data: string): T {
     // @ts-ignore
     if (idof<T>() == idof<u128>()) return u128.fromString(data);
-        // @ts-ignore
+    // @ts-ignore
     if (idof<T>() == idof<u128Safe>()) return u128Safe.fromString(data);
-        // @ts-ignore
+    // @ts-ignore
     if (idof<T>() == idof<u256>()) return u128Safe.fromString(data);
-        // @ts-ignore
+    // @ts-ignore
     if (idof<T>() == idof<u256Safe>()) return u256Safe.fromString(data);
-        // @ts-ignore
+    // @ts-ignore
     if (idof<T>() == idof<i128>()) return i128.fromString(data);
-        // @ts-ignore
+    // @ts-ignore
     if (idof<T>() == idof<i128Safe>()) return i128Safe.fromString(data);
-        // @ts-ignore
+    // @ts-ignore
     //if (idof<T>() == idof<i256Safe>()) return data.
 }
 
 // @ts-ignore
 @inline
 function parseString(data: string): string {
-    return data.slice(1, data.length - 1).replaceAll('\\"', '"');
+    let result = "";
+    let last = 1;
+    let char = 0;
+    for (let i = 1; i < data.length - 1; i++) {
+        // \\"
+        if (unsafeCharCodeAt(data, i) === backSlashCode) {
+            char = unsafeCharCodeAt(data, ++i);
+            result += data.slice(last, i - 1)
+            if (char === 34) {
+                result += "\"";
+                last = ++i;
+            } else if (char === 110) {
+                result += "\n";
+                last = ++i;
+                // 92 98 114 116 102 117
+            } else if (char >= 92 && char <= 117) {
+                if (char === 92) {
+                    result += "\\";
+                    last = ++i;
+                } else if (char === 98) {
+                    result += "\b";
+                    last = ++i;
+                } else if (char === 102) {
+                    result += "\f";
+                    last = ++i;
+                } else if (char === 114) {
+                    result += "\r";
+                    last = ++i;
+                } else if (char === 116) {
+                    result += "\t";
+                    last = ++i;
+                } else if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
+                    result += "\u000b";
+                    i += 4;
+                    last = ++i;
+                }
+            }
+        }
+    }
+    result += data.slice(last, data.length - 1);
+    return result;
 }
 
 // @ts-ignore
@@ -396,7 +502,7 @@ function parseArray<T extends unknown[]>(data: string): T {
         return parseArrayArray<T>(data);
         // @ts-ignore
     } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
-        const type = changetype<nonnull<valueof<T>>>(__new(offsetof<nonnull<valueof<T>>>(), idof <nonnull<valueof<T>>>()));
+        const type = changetype<nonnull<valueof<T>>>(__new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()));
         // @ts-ignore
         if (isDefined(type.__JSON_Set_Key)) {
             // @ts-ignore

package/assembly/test.ts

@@ -2,16 +2,85 @@ import { u128 } from "as-bignum/assembly";
 import {
   JSON
 } from ".";
+import { unsafeCharCodeAt } from "./src/util";
+import { backSlashCode, quoteCode } from "./src/chars";
 
 const exp = `["abcdefg","st\\"ring\\" w\\"\\"ith quotes\\"","string \\t\\r\\"with ran\\tdom spa\\nces and \\nnewlines\\n\\n\\n","string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\""]`;
 
-console.log(exp);
-console.log(JSON.stringify([
+/*console.log(JSON.stringify([
   "abcdefg",
   'st"ring" w""ith quotes"',
   'string \t\r"with ran\tdom spa\nces and \nnewlines\n\n\n',
   'string with colon : comma , brace [ ] bracket { } and quote " and other quote "',
-]))
+]));*/
+
+const str = "\\\""
+
+function parseString(data: string): string {
+  let result = "";
+  let last = 1;
+  let char = 0;
+  for (let i = 1; i < data.length - 1; i++) {
+    // \\"
+    if (unsafeCharCodeAt(data, i) === backSlashCode) {
+      char = unsafeCharCodeAt(data, ++i);
+      result += data.slice(last, i - 1)
+      if (char === 34) {
+        result += "\"";
+        last = ++i;
+      } else if (char === 110) {
+        result += "\n";
+        last = ++i;
+        // 92 98 114 116 102 117
+      } else if (char >= 92 && char <= 117) {
+        if (char === 92) {
+          result += "\\";
+          last = ++i;
+        } else if (char === 98) {
+          result += "\b";
+          last = ++i;
+        } else if (char === 102) {
+          result += "\f";
+          last = ++i;
+        } else if (char === 114) {
+          result += "\r";
+          last = ++i;
+        } else if (char === 116) {
+          result += "\t";
+          last = ++i;
+        } else if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
+          result += "\u000b";
+          i += 4;
+          last = ++i;
+        }
+      }
+    }
+  }
+  result += data.slice(last, data.length - 1);
+  return result;
+}
+
+console.log(parseString("\"Hello W\\\"orld!\""));
+console.log(parseString("\"Hello New \\nWorld!\""));
+console.log(parseString("\"\\t TAB Hello World!\""));
+console.log(JSON.stringify(parseString("\"U000B \\u000b Hello World!\"")));
+console.log(load<u32>(changetype<usize>(str)).toString());
+console.log(load<u8>(changetype<usize>(str)).toString());
+console.log(load<u8>(changetype<usize>(str) + <usize>2).toString());
+
+console.log("abcdefg");
+console.log('st"ring" w""ith quotes"');
+console.log('string \t\r"with ran\tdom spa\nces and \nnewlines\n\n\n');
+console.log('string with colon : comma , brace [ ] bracket { } and quote " and other quote "');
+
+console.log(JSON.stringify("abcdefg"));
+console.log(JSON.stringify('st"ring" w""ith quotes"'));
+console.log(JSON.stringify('string \t\r"with ran\tdom spa\nces and \nnewlines\n\n\n'));
+console.log(JSON.stringify('string with colon : comma , brace [ ] bracket { } and quote " and other quote "'));
+
+console.log(JSON.stringify("Hello W\"orld!"));
+
+console.log("U000B: \u000b")
 // @ts-ignore
 @JSON
 class Vec3 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.26",
+  "version": "0.5.28",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",

package/transform/lib/index.js

@@ -31,13 +31,18 @@ class AsJSONTransform extends BaseVisitor {
         }
         let type = getName(node.type);
         // @ts-ignore
-        this.currentClass.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
+        if (["u8", "i8", "u16", "i16", "u32", "i32", "f32", "u64", "i64", "f64"].includes(type.toLowerCase())) {
+            this.currentClass.encodeStmts.push(`"${name}":\${this.${name}.toString()},`);
+        }
+        else {
+            this.currentClass.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
+        }
         // @ts-ignore
         //this.decodeStmts.push(
         //   `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
         //);
         // @ts-ignore
-        this.currentClass.setDataStmts.push(`if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+        this.currentClass.setDataStmts.push(`if (key == "${name}") {
         this.${name} = JSON.parseObjectValue<${type}>(value);
         return;
       }
@@ -93,6 +98,7 @@ class AsJSONTransform extends BaseVisitor {
             const stmt = this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1];
             this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] = stmt.slice(0, stmt.length - 1);
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }
@@ -100,12 +106,14 @@ class AsJSONTransform extends BaseVisitor {
         }
         else {
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
         }
         const setKeyFunc = `
+      @inline
       __JSON_Set_Key(key: string, value: string): void {
         ${
         // @ts-ignore
@@ -117,6 +125,8 @@ class AsJSONTransform extends BaseVisitor {
         const setDataMethod = SimpleParser.parseClassMember(setKeyFunc, node);
         node.members.push(setDataMethod);
         this.schemasList.push(this.currentClass);
+        console.log(serializeFunc);
+        console.log(setKeyFunc);
     }
     visitSource(node) {
         super.visitSource(node);

package/transform/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@json-as/transform",
-    "version": "0.5.26",
+    "version": "0.5.28",
     "description": "JSON encoder/decoder for AssemblyScript",
     "main": "./lib/index.js",
     "author": "Jairus Tanaka",

package/transform/src/index.ts

@@ -35,9 +35,15 @@ class AsJSONTransform extends BaseVisitor {
 
     let type = getName(node.type);
     // @ts-ignore
-    this.currentClass.encodeStmts.push(
-      `"${name}":\${JSON.stringify<${type}>(this.${name})},`
-    );
+    if (["u8", "i8", "u16", "i16", "u32", "i32", "f32", "u64", "i64", "f64"].includes(type.toLowerCase())) {
+      this.currentClass.encodeStmts.push(
+        `"${name}":\${this.${name}.toString()},`
+      );
+    } else {
+      this.currentClass.encodeStmts.push(
+        `"${name}":\${JSON.stringify<${type}>(this.${name})},`
+      );
+    }
 
     // @ts-ignore
     //this.decodeStmts.push(
@@ -46,7 +52,7 @@ class AsJSONTransform extends BaseVisitor {
 
     // @ts-ignore
     this.currentClass.setDataStmts.push(
-      `if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+      `if (key == "${name}") {
         this.${name} = JSON.parseObjectValue<${type}>(value);
         return;
       }
@@ -107,12 +113,14 @@ class AsJSONTransform extends BaseVisitor {
         stmt.length - 1
       );
       serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }
       `;
     } else {
       serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
@@ -120,6 +128,7 @@ class AsJSONTransform extends BaseVisitor {
     }
 
     const setKeyFunc = `
+      @inline
       __JSON_Set_Key(key: string, value: string): void {
         ${
       // @ts-ignore
@@ -138,6 +147,9 @@ class AsJSONTransform extends BaseVisitor {
     node.members.push(setDataMethod);
 
     this.schemasList.push(this.currentClass);
+
+    console.log(serializeFunc);
+    console.log(setKeyFunc);
   }
   visitSource(node: Source): void {
     super.visitSource(node);