json-as
Version:
The only JSON library you'll need for AssemblyScript. SIMD enabled
785 lines (784 loc) • 73.3 kB
JavaScript
import { Node } from "assemblyscript/dist/assemblyscript.js";
import { Transform } from "assemblyscript/dist/transform.js";
import { Visitor } from "./visitor.js";
import { isStdlib, removeExtension, SimpleParser, toString } from "./util.js";
import * as path from "path";
import { fileURLToPath } from "url";
import { Property, PropertyFlags, Schema, SourceSet } from "./types.js";
import { readFileSync, writeFileSync } from "fs";
import { CustomTransform } from "./linkers/custom.js";
let indent = " ";
let id = 0;
const WRITE = process.env["JSON_WRITE"]?.trim();
const rawValue = process.env["JSON_DEBUG"]?.trim();
const DEBUG = rawValue === "true" ? 1 : rawValue === "false" || rawValue === "" ? 0 : isNaN(Number(rawValue)) ? 0 : Number(rawValue);
const STRICT = process.env["JSON_STRICT"] && process.env["JSON_STRICT"] == "true";
export class JSONTransform extends Visitor {
static SN = new JSONTransform();
program;
baseCWD;
parser;
schemas = new Map();
schema;
sources = new SourceSet();
imports = [];
simdStatements = [];
visitedClasses = new Set();
visitClassDeclarationRef(node) {
if (!node.decorators?.length ||
!node.decorators.some((decorator) => {
const name = decorator.name.text;
return name === "json" || name === "serializable";
}))
throw new Error("Class " + node.name.text + " is missing an @json or @serializable decorator in " + node.range.source.internalPath);
this.visitClassDeclaration(node);
}
visitClassDeclaration(node) {
if (!node.decorators?.length)
return;
if (!node.decorators.some((decorator) => {
const name = decorator.name.text;
return name === "json" || name === "serializable";
}))
return;
const source = this.sources.get(node.range.source);
const fullClassPath = source.getFullPath(node);
if (this.visitedClasses.has(fullClassPath))
return;
if (!this.schemas.has(source.internalPath))
this.schemas.set(source.internalPath, []);
const members = [...node.members.filter((v) => v.kind === 54 && v.flags !== 32 && v.flags !== 512 && v.flags !== 1024 && !v.decorators?.some((decorator) => decorator.name.text === "omit"))];
const serializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "serializer"))];
const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer"))];
const schema = new Schema();
schema.node = node;
schema.name = source.getQualifiedName(node);
if (node.extendsType) {
const extendsName = source.resolveExtendsName(node);
if (!schema.parent) {
const depSearch = schema.deps.find((v) => v.name == extendsName);
if (depSearch) {
if (DEBUG > 0)
console.log("Found " + extendsName + " in dependencies of " + source.internalPath);
if (!schema.deps.some((v) => v.name == depSearch.name))
schema.deps.push(depSearch);
schema.parent = depSearch;
}
else {
const internalSearch = source.getClass(extendsName);
if (internalSearch) {
if (DEBUG > 0)
console.log("Found " + extendsName + " internally from " + source.internalPath);
if (!this.visitedClasses.has(source.getFullPath(internalSearch))) {
this.visitClassDeclarationRef(internalSearch);
this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
this.visitClassDeclaration(node);
return;
}
const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == extendsName);
if (!schem)
throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
schema.deps.push(schem);
schema.parent = schem;
}
else {
const externalSearch = source.getImportedClass(extendsName, this.parser);
if (externalSearch) {
if (DEBUG > 0)
console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
const externalSource = this.sources.get(externalSearch.range.source);
if (!this.visitedClasses.has(externalSource.getFullPath(externalSearch))) {
this.visitClassDeclarationRef(externalSearch);
this.schemas.get(externalSource.internalPath).push(this.schema);
this.visitClassDeclaration(node);
return;
}
const schem = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == extendsName);
if (!schem)
throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
schema.deps.push(schem);
schema.parent = schem;
}
}
}
}
if (schema.parent?.members) {
for (let i = schema.parent.members.length - 1; i >= 0; i--) {
const replace = schema.members.find((v) => v.name == schema.parent?.members[i]?.name);
if (!replace) {
members.unshift(schema.parent?.members[i].node);
}
}
}
}
const getUnknownTypes = (type, types = []) => {
type = stripNull(type);
type = source.aliases.find((v) => stripNull(v.name) == type)?.getBaseType() || type;
if (type.startsWith("Array<")) {
return getUnknownTypes(type.slice(6, -1));
}
else if (type.startsWith("Map<")) {
const parts = type.slice(4, -1).split(",");
return getUnknownTypes(parts[0]) || getUnknownTypes(parts[1]);
}
else if (isString(type) || isPrimitive(type)) {
return types;
}
else if (["JSON.Box", "JSON.Obj", "JSON.Value", "JSON.Raw"].includes(type)) {
return types;
}
else if (node.isGeneric && node.typeParameters.some((p) => p.name.text == type)) {
return types;
}
else if (type == node.name.text) {
return types;
}
types.push(type);
return types;
};
for (const member of members) {
const type = toString(member.type);
const unknown = getUnknownTypes(type);
for (const unknownType of unknown) {
const depSearch = schema.deps.find((v) => v.name == unknownType);
if (depSearch) {
if (DEBUG > 0)
console.log("Found " + unknownType + " in dependencies of " + source.internalPath);
if (!schema.deps.some((v) => v.name == depSearch.name)) {
schema.deps.push(depSearch);
}
}
else {
const internalSearch = source.getClass(unknownType);
if (internalSearch) {
if (DEBUG > 0)
console.log("Found " + unknownType + " internally from " + source.internalPath);
if (!this.visitedClasses.has(source.getFullPath(internalSearch))) {
this.visitClassDeclarationRef(internalSearch);
const internalSchema = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == unknownType);
schema.deps.push(internalSchema);
this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
this.visitClassDeclaration(node);
return;
}
const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == unknownType);
if (!schem)
throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
schema.deps.push(schem);
}
else {
const externalSearch = source.getImportedClass(unknownType, this.parser);
if (externalSearch) {
if (DEBUG > 0)
console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
const externalSource = this.sources.get(externalSearch.range.source);
if (!this.visitedClasses.has(externalSource.getFullPath(externalSearch))) {
this.visitClassDeclarationRef(externalSearch);
const externalSchema = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == unknownType);
schema.deps.push(externalSchema);
this.schemas.get(externalSource.internalPath).push(this.schema);
this.visitClassDeclaration(node);
return;
}
const schem = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == unknownType);
if (!schem)
throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
schema.deps.push(schem);
}
}
}
}
}
this.schemas.get(source.internalPath).push(schema);
this.schema = schema;
this.visitedClasses.add(fullClassPath);
let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
let INITIALIZE = "@inline __INITIALIZE(): this {\n";
let DESERIALIZE = "__DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
let DESERIALIZE_CUSTOM = "";
let SERIALIZE_CUSTOM = "";
if (DEBUG > 0)
console.log("Created schema: " + this.schema.name + " in file " + source.normalizedPath + (this.schema.deps.length ? " with dependencies:\n " + this.schema.deps.map((v) => v.name).join("\n ") : ""));
if (serializers.length > 1)
throwError("Multiple serializers detected for class " + node.name.text + " but schemas can only have one serializer!", serializers[1].range);
if (deserializers.length > 1)
throwError("Multiple deserializers detected for class " + node.name.text + " but schemas can only have one deserializer!", deserializers[1].range);
if (serializers.length) {
this.schema.custom = true;
const serializer = serializers[0];
const hasCall = CustomTransform.hasCall(serializer);
CustomTransform.visit(serializer);
if (serializer.signature.parameters.length > 1)
throwError("Found too many parameters in custom serializer for " + this.schema.name + ", but serializers can only accept one parameter of type '" + this.schema.name + "'!", serializer.signature.parameters[1].range);
if (serializer.signature.parameters.length > 0 && serializer.signature.parameters[0].type.name.identifier.text != node.name.text && serializer.signature.parameters[0].type.name.identifier.text != "this")
throwError("Type of parameter for custom serializer does not match! It should be 'string'either be 'this' or '" + this.schema.name + "'", serializer.signature.parameters[0].type.range);
if (!serializer.signature.returnType || !serializer.signature.returnType.name.identifier.text.includes("string"))
throwError("Could not find valid return type for serializer in " + this.schema.name + "!. Set the return type to type 'string' and try again", serializer.signature.returnType.range);
if (!serializer.decorators.some((v) => v.name.text == "inline")) {
serializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", serializer.range), null, serializer.range));
}
SERIALIZE_CUSTOM += " __SERIALIZE(ptr: usize): void {\n";
SERIALIZE_CUSTOM += " const data = this." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "this" : "") + ");\n";
if (hasCall)
SERIALIZE_CUSTOM += " bs.resetState();\n";
SERIALIZE_CUSTOM += " const dataSize = data.length << 1;\n";
SERIALIZE_CUSTOM += " memory.copy(bs.offset, changetype<usize>(data), dataSize);\n";
SERIALIZE_CUSTOM += " bs.offset += dataSize;\n";
SERIALIZE_CUSTOM += " }\n";
}
if (deserializers.length) {
this.schema.custom = true;
const deserializer = deserializers[0];
if (!deserializer.signature.parameters.length)
throwError("Could not find any parameters in custom deserializer for " + this.schema.name + ". Deserializers must have one parameter like 'deserializer(data: string): " + this.schema.name + " {}'", deserializer.range);
if (deserializer.signature.parameters.length > 1)
throwError("Found too many parameters in custom deserializer for " + this.schema.name + ", but deserializers can only accept one parameter of type 'string'!", deserializer.signature.parameters[1].range);
if (deserializer.signature.parameters[0].type.name.identifier.text != "string")
throwError("Type of parameter for custom deserializer does not match! It must be 'string'", deserializer.signature.parameters[0].type.range);
if (!deserializer.signature.returnType || !(deserializer.signature.returnType.name.identifier.text.includes(this.schema.name) || deserializer.signature.returnType.name.identifier.text.includes("this")))
throwError("Could not find valid return type for deserializer in " + this.schema.name + "!. Set the return type to type '" + this.schema.name + "' or 'this' and try again", deserializer.signature.returnType.range);
if (!deserializer.decorators.some((v) => v.name.text == "inline")) {
deserializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", deserializer.range), null, deserializer.range));
}
DESERIALIZE_CUSTOM += " __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
DESERIALIZE_CUSTOM += " return inline.always(this." + deserializer.name.text + "(JSON.Util.ptrToStr(srcStart, srcEnd)));\n";
DESERIALIZE_CUSTOM += " }\n";
}
if (!members.length && !deserializers.length && !serializers.length) {
this.generateEmptyMethods(node);
return;
}
for (const member of members) {
if (!member.type)
throwError("Fields must be strongly typed", node.range);
let type = toString(member.type);
type = source.aliases.find((v) => stripNull(v.name) == stripNull(type))?.getBaseType() || type;
const name = member.name;
const value = member.initializer ? toString(member.initializer) : null;
if (type.startsWith("(") && type.includes("=>"))
continue;
const mem = new Property();
mem.parent = this.schema;
mem.name = name.text;
mem.type = type;
mem.value = value;
mem.node = member;
mem.byteSize = sizeof(mem.type);
this.schema.byteSize += mem.byteSize;
if (member.decorators) {
for (const decorator of member.decorators) {
const decoratorName = decorator.name.text.toLowerCase().trim();
switch (decoratorName) {
case "alias": {
const arg = decorator.args[0];
if (!arg || arg.kind != 16)
throwError("@alias must have an argument of type string or number", member.range);
mem.alias = arg.value.toString();
break;
}
case "omitif": {
let arg = decorator.args[0];
if (!decorator.args?.length)
throwError("@omitif must have an argument or callback that resolves to type bool", member.range);
mem.flags.set(PropertyFlags.OmitIf, arg);
this.schema.static = false;
break;
}
case "omitnull": {
if (isPrimitive(type)) {
throwError("@omitnull cannot be used on primitive types!", member.range);
}
else if (!member.type.isNullable) {
throwError("@omitnull cannot be used on non-nullable types!", member.range);
}
mem.flags.set(PropertyFlags.OmitNull, null);
this.schema.static = false;
break;
}
}
}
}
this.schema.members.push(mem);
}
if (!this.schema.static)
this.schema.members = sortMembers(this.schema.members);
indent = " ";
if (this.schema.static == false) {
if (this.schema.members.some((v) => v.flags.has(PropertyFlags.OmitNull))) {
SERIALIZE += indent + "let block: usize = 0;\n";
}
this.schema.byteSize += 2;
SERIALIZE += indent + "store<u16>(bs.offset, 123, 0); // {\n";
SERIALIZE += indent + "bs.offset += 2;\n";
}
let isPure = this.schema.static;
let isRegular = isPure;
let isFirst = true;
for (let i = 0; i < this.schema.members.length; i++) {
const member = this.schema.members[i];
const aliasName = JSON.stringify(member.alias || member.name);
const realName = member.name;
const isLast = i == this.schema.members.length - 1;
if (member.value) {
if (member.value != "null" && member.value != "0" && member.value != "0.0" && member.value != "false") {
INITIALIZE += ` store<${member.type}>(changetype<usize>(this), ${member.value}, offsetof<this>(${JSON.stringify(member.name)}));\n`;
}
}
else if (member.generic) {
INITIALIZE += ` if (isManaged<nonnull<${member.type}>>() || isReference<nonnull<${member.type}>>()) {\n`;
INITIALIZE += ` store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())), offsetof<this>(${JSON.stringify(member.name)}));\n`;
INITIALIZE += ` if (isDefined(this.${member.name}.__INITIALIZE)) changetype<nonnull<${member.type}>>(this.${member.name}).__INITIALIZE();\n`;
INITIALIZE += ` }\n`;
}
else if (!member.node.type.isNullable) {
if (this.getSchema(member.type)) {
INITIALIZE += ` store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
}
else if (member.type.startsWith("Array<") || member.type.startsWith("Map<")) {
INITIALIZE += ` store<${member.type}>(changetype<usize>(this), [], offsetof<this>(${JSON.stringify(member.name)}));\n`;
}
else if (member.type == "string" || member.type == "String") {
INITIALIZE += ` store<${member.type}>(changetype<usize>(this), "", offsetof<this>(${JSON.stringify(member.name)}));\n`;
}
}
const SIMD_ENABLED = this.program.options.hasFeature(16);
if (!isRegular && !member.flags.has(PropertyFlags.OmitIf) && !member.flags.has(PropertyFlags.OmitNull))
isRegular = true;
if (isRegular && isPure) {
const keyPart = (isFirst ? "{" : ",") + aliasName + ":";
this.schema.byteSize += keyPart.length << 1;
SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
.map((v) => indent + v + "\n")
.join("");
SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
if (isFirst)
isFirst = false;
}
else if (isRegular && !isPure) {
const keyPart = (isFirst ? "" : ",") + aliasName + ":";
this.schema.byteSize += keyPart.length << 1;
SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
.map((v) => indent + v + "\n")
.join("");
SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
if (isFirst)
isFirst = false;
}
else {
if (member.flags.has(PropertyFlags.OmitNull)) {
SERIALIZE += indent + `if ((block = load<usize>(ptr, offsetof<this>(${JSON.stringify(realName)}))) !== 0) {\n`;
indentInc();
const keyPart = aliasName + ":";
this.schema.byteSize += keyPart.length << 1;
SERIALIZE += this.getStores(keyPart, SIMD_ENABLED)
.map((v) => indent + v + "\n")
.join("");
SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
if (!isLast) {
this.schema.byteSize += 2;
SERIALIZE += indent + `store<u16>(bs.offset, 44, 0); // ,\n`;
SERIALIZE += indent + `bs.offset += 2;\n`;
}
indentDec();
this.schema.byteSize += 2;
SERIALIZE += indent + `}\n`;
}
else if (member.flags.has(PropertyFlags.OmitIf)) {
if (member.flags.get(PropertyFlags.OmitIf).kind == 14) {
const arg = member.flags.get(PropertyFlags.OmitIf);
arg.declaration.signature.parameters[0].type = Node.createNamedType(Node.createSimpleTypeName("this", node.range), null, false, node.range);
arg.declaration.signature.returnType.name = Node.createSimpleTypeName("boolean", arg.declaration.signature.returnType.name.range);
SERIALIZE += indent + `if (!(${toString(member.flags.get(PropertyFlags.OmitIf))})(this)) {\n`;
}
else {
SERIALIZE += indent + `if (${toString(member.flags.get(PropertyFlags.OmitIf))}) {\n`;
}
indentInc();
SERIALIZE += this.getStores(aliasName + ":", SIMD_ENABLED)
.map((v) => indent + v + "\n")
.join("");
SERIALIZE += indent + `JSON.__serialize<${member.type}>(load<${member.type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
if (!isLast) {
this.schema.byteSize += 2;
SERIALIZE += indent + `store<u16>(bs.offset, 44, 0); // ,\n`;
SERIALIZE += indent + `bs.offset += 2;\n`;
}
indentDec();
SERIALIZE += indent + `}\n`;
}
}
}
const sortedMembers = {
string: [],
number: [],
boolean: [],
null: [],
array: [],
object: [],
};
for (const member of this.schema.members) {
const type = stripNull(member.type);
if (member.custom || member.generic) {
sortedMembers.string.push(member);
sortedMembers.number.push(member);
sortedMembers.object.push(member);
sortedMembers.array.push(member);
sortedMembers.boolean.push(member);
sortedMembers.null.push(member);
}
else {
if (member.node.type.isNullable)
sortedMembers.null.push(member);
if (isString(type) || type == "JSON.Raw")
sortedMembers.string.push(member);
else if (isBoolean(type) || type.startsWith("JSON.Box<bool"))
sortedMembers.boolean.push(member);
else if (isPrimitive(type) || type.startsWith("JSON.Box<") || isEnum(type, this.sources.get(this.schema.node.range.source), this.parser))
sortedMembers.number.push(member);
else if (isArray(type))
sortedMembers.array.push(member);
sortedMembers.object.push(member);
}
}
indent = "";
DESERIALIZE += indent + " let keyStart: usize = 0;\n";
DESERIALIZE += indent + " let keyEnd: usize = 0;\n";
DESERIALIZE += indent + " let isKey = false;\n";
if (!STRICT || sortedMembers.object.length || sortedMembers.array.length)
DESERIALIZE += indent + " let depth: i32 = 0;\n";
DESERIALIZE += indent + " let lastIndex: usize = 0;\n\n";
DESERIALIZE += indent + " while (srcStart < srcEnd && JSON.Util.isSpace(load<u16>(srcStart))) srcStart += 2;\n";
DESERIALIZE += indent + " while (srcEnd > srcStart && JSON.Util.isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;\n";
DESERIALIZE += indent + ' if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");\n';
DESERIALIZE += indent + " if (load<u16>(srcStart) != 123) throw new Error(\"Expected '{' at start of object at position \" + (srcEnd - srcStart).toString());\n";
DESERIALIZE += indent + " if (load<u16>(srcEnd - 2) != 125) throw new Error(\"Expected '}' at end of object at position \" + (srcEnd - srcStart).toString());\n";
DESERIALIZE += indent + " srcStart += 2;\n\n";
DESERIALIZE += indent + " while (srcStart < srcEnd) {\n";
DESERIALIZE += indent + " let code = load<u16>(srcStart);\n";
DESERIALIZE += indent + " while (JSON.Util.isSpace(code)) code = load<u16>(srcStart += 2);\n";
DESERIALIZE += indent + " if (keyStart == 0) {\n";
DESERIALIZE += indent + " if (code == 34 && load<u16>(srcStart - 2) !== 92) {\n";
DESERIALIZE += indent + " if (isKey) {\n";
DESERIALIZE += indent + " keyStart = lastIndex;\n";
DESERIALIZE += indent + " keyEnd = srcStart;\n";
if (DEBUG > 1)
DESERIALIZE += indent + ' console.log("Key: " + JSON.Util.ptrToStr(keyStart, keyEnd));\n';
DESERIALIZE += indent + " while (JSON.Util.isSpace((code = load<u16>((srcStart += 2))))) {}\n";
DESERIALIZE += indent + " if (code !== 58) throw new Error(\"Expected ':' after key at position \" + (srcEnd - srcStart).toString());\n";
DESERIALIZE += indent + " isKey = false;\n";
DESERIALIZE += indent + " } else {\n";
DESERIALIZE += indent + " isKey = true;\n";
DESERIALIZE += indent + " lastIndex = srcStart + 2;\n";
DESERIALIZE += indent + " }\n";
DESERIALIZE += indent + " }\n";
DESERIALIZE += indent + " srcStart += 2;\n";
DESERIALIZE += indent + " } else {\n";
const groupMembers = (members) => {
const groups = new Map();
for (const member of members) {
const name = member.alias || member.name;
const length = name.length;
if (!groups.has(length)) {
groups.set(length, []);
}
groups.get(length).push(member);
}
return [...groups.values()]
.map((group) => group.sort((a, b) => {
const aLen = (a.alias || a.name).length;
const bLen = (b.alias || b.name).length;
return aLen - bLen;
}))
.sort((a, b) => b.length - a.length);
};
const generateGroups = (members, cb, type) => {
if (!members.length) {
if (STRICT) {
DESERIALIZE += indent + ' throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
}
else {
if (type == "string") {
DESERIALIZE += indent + " srcStart += 4;\n";
}
else if (type == "boolean" || type == "null" || type == "number") {
DESERIALIZE += indent + " srcStart += 2;\n";
}
DESERIALIZE += indent + " keyStart = 0;\n";
if (type == "string" || type == "object" || type == "array" || type == "number")
DESERIALIZE += indent + " break;\n";
}
}
else {
const groups = groupMembers(members);
DESERIALIZE += " switch (<u32>keyEnd - <u32>keyStart) {\n";
for (const group of groups) {
const groupLen = (group[0].alias || group[0].name).length << 1;
DESERIALIZE += " case " + groupLen + ": {\n";
cb(group);
DESERIALIZE += "\n }\n";
}
DESERIALIZE += " default: {\n";
if (STRICT) {
DESERIALIZE += indent + ' throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
}
else {
if (type == "string") {
DESERIALIZE += indent + " srcStart += 4;\n";
}
else if (type == "boolean" || type == "null" || type == "number") {
DESERIALIZE += indent + " srcStart += 2;\n";
}
DESERIALIZE += indent + " keyStart = 0;\n";
if (type == "string" || type == "object" || type == "array" || type == "number")
DESERIALIZE += indent + " break;\n";
}
DESERIALIZE += " }\n";
DESERIALIZE += " }\n";
if (type != "null" && type != "boolean")
DESERIALIZE += " break;\n";
}
};
const generateConsts = (members) => {
if (members.some((m) => (m.alias || m.name).length << 1 == 2)) {
DESERIALIZE += " const code16 = load<u16>(keyStart);\n";
}
if (members.some((m) => (m.alias || m.name).length << 1 == 4)) {
DESERIALIZE += " const code32 = load<u32>(keyStart);\n";
}
if (members.some((m) => (m.alias || m.name).length << 1 == 6)) {
DESERIALIZE += " const code48 = load<u64>(keyStart) & 0x0000FFFFFFFFFFFF;\n";
}
if (members.some((m) => (m.alias || m.name).length << 1 == 8)) {
DESERIALIZE += " const code64 = load<u64>(keyStart);\n";
}
if (members.some((m) => (m.alias || m.name).length << 1 > 8)) {
DESERIALIZE += toMemCDecl(Math.max(...members.map((m) => (m.alias || m.name).length << 1)), " ");
}
};
let mbElse = " ";
if (!STRICT || sortedMembers.string.length) {
DESERIALIZE += mbElse + "if (code == 34) {\n";
DESERIALIZE += " lastIndex = srcStart;\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " while (srcStart < srcEnd) {\n";
DESERIALIZE += " const code = load<u16>(srcStart);\n";
DESERIALIZE += " if (code == 34 && load<u16>(srcStart - 2) !== 92) {\n";
if (DEBUG > 1)
DESERIALIZE += ' console.log("Value (string, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart + 2));';
generateGroups(sortedMembers.string, (group) => {
generateConsts(group);
const first = group[0];
const fName = first.alias || first.name;
DESERIALIZE += indent + " if (" + (first.generic ? "isString<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
DESERIALIZE += indent + " store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
DESERIALIZE += indent + " srcStart += 4;\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
for (let i = 1; i < group.length; i++) {
const mem = group[i];
const memName = mem.alias || mem.name;
DESERIALIZE += indent + " else if (" + (mem.generic ? "isString<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
DESERIALIZE += indent + " store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
DESERIALIZE += indent + " srcStart += 4;\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
}
if (STRICT) {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + ' throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
DESERIALIZE += indent + " }\n";
}
else {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + " srcStart += 4;\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }\n";
}
}, "string");
DESERIALIZE += " }\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " }\n";
DESERIALIZE += " }\n";
mbElse = " else ";
}
if (!STRICT || sortedMembers.number.length) {
DESERIALIZE += mbElse + "if (code - 48 <= 9 || code == 45) {\n";
DESERIALIZE += " lastIndex = srcStart;\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " while (srcStart < srcEnd) {\n";
DESERIALIZE += " const code = load<u16>(srcStart);\n";
DESERIALIZE += " if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {\n";
if (DEBUG > 1)
DESERIALIZE += ' console.log("Value (number, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart));';
generateGroups(sortedMembers.number, (group) => {
generateConsts(group);
const first = group[0];
const fName = first.alias || first.name;
DESERIALIZE += indent + " if (" + (first.generic ? "(isInteger<" + first.type + ">() || isFloat<" + first.type + ">()) && " : "") + getComparision(fName) + ") { // " + fName + "\n";
DESERIALIZE += indent + " store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
DESERIALIZE += indent + " srcStart += 2;\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
for (let i = 1; i < group.length; i++) {
const mem = group[i];
const memName = mem.alias || mem.name;
DESERIALIZE += indent + " else if (" + (mem.generic ? "(isInteger<" + mem.type + ">() || isFloat<" + mem.type + ">()) && " : "") + getComparision(memName) + ") { // " + memName + "\n";
DESERIALIZE += indent + " store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
DESERIALIZE += indent + " srcStart += 2;\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
}
if (STRICT) {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + ' throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
DESERIALIZE += indent + " }\n";
}
else {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + " srcStart += 2;\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }\n";
}
}, "number");
DESERIALIZE += " }\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " }\n";
DESERIALIZE += " }";
mbElse = " else ";
}
if (!STRICT || sortedMembers.object.length) {
DESERIALIZE += mbElse + "if (code == 123) {\n";
DESERIALIZE += " lastIndex = srcStart;\n";
DESERIALIZE += " depth++;\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " while (srcStart < srcEnd) {\n";
DESERIALIZE += " const code = load<u16>(srcStart);\n";
DESERIALIZE += " if (code == 34) {\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;\n";
DESERIALIZE += " } else if (code == 125) {\n";
DESERIALIZE += " if (--depth == 0) {\n";
DESERIALIZE += " srcStart += 2;\n";
if (DEBUG > 1)
DESERIALIZE += ' console.log("Value (object, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart));';
indent = " ";
generateGroups(sortedMembers.object, (group) => {
generateConsts(group);
const first = group[0];
const fName = first.alias || first.name;
DESERIALIZE += indent + " if (" + (first.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(fName) + ") { // " + fName + "\n";
DESERIALIZE += indent + " store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
for (let i = 1; i < group.length; i++) {
const mem = group[i];
const memName = mem.alias || mem.name;
DESERIALIZE += indent + " else if (" + (mem.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(memName) + ") { // " + memName + "\n";
DESERIALIZE += indent + " store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
}
if (STRICT) {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + ' throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
DESERIALIZE += indent + " }\n";
}
else {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }\n";
}
}, "object");
indent = "";
DESERIALIZE += " }\n";
DESERIALIZE += " } else if (code == 123) depth++;\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " }\n";
DESERIALIZE += " }";
mbElse = " else ";
}
if (!STRICT || sortedMembers.array.length) {
DESERIALIZE += mbElse + "if (code == 91) {\n";
DESERIALIZE += " lastIndex = srcStart;\n";
DESERIALIZE += " depth++;\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " while (srcStart < srcEnd) {\n";
DESERIALIZE += " const code = load<u16>(srcStart);\n";
DESERIALIZE += " if (code == 34) {\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;\n";
DESERIALIZE += " } else if (code == 93) {\n";
DESERIALIZE += " if (--depth == 0) {\n";
DESERIALIZE += " srcStart += 2;\n";
if (DEBUG > 1)
DESERIALIZE += ' console.log("Value (object, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart));';
indent = " ";
generateGroups(sortedMembers.array, (group) => {
generateConsts(group);
const first = group[0];
const fName = first.alias || first.name;
DESERIALIZE += indent + " if (" + (first.generic ? "isArray<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
DESERIALIZE += indent + " store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
for (let i = 1; i < group.length; i++) {
const mem = group[i];
const memName = mem.alias || mem.name;
DESERIALIZE += indent + " else if (" + (mem.generic ? "isArray" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
DESERIALIZE += indent + " store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
}
if (STRICT) {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + ' throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
DESERIALIZE += indent + " }\n";
}
else {
DESERIALIZE += " else {\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }\n";
}
}, "array");
indent = "";
DESERIALIZE += " }\n";
DESERIALIZE += " } else if (code == 91) depth++;\n";
DESERIALIZE += " srcStart += 2;\n";
DESERIALIZE += " }\n";
DESERIALIZE += " }";
mbElse = " else ";
}
if (!STRICT || sortedMembers.boolean.length) {
DESERIALIZE += mbElse + "if (code == 116) {\n";
DESERIALIZE += " if (load<u64>(srcStart) == 28429475166421108) {\n";
DESERIALIZE += " srcStart += 8;\n";
if (DEBUG > 1)
DESERIALIZE += ' console.log("Value (bool, ' + ++id + '): " + JSON.Util.ptrToStr(lastIndex, srcStart - 8));';
generateGroups(sortedMembers.boolean, (group) => {
generateConsts(group);
const first = group[0];
const fName = first.alias || first.name;
DESERIALIZE += indent + " if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
DESERIALIZE += indent + " store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
DESERIALIZE += indent + " srcStart += 2;\n";
DESERIALIZE += indent + " keyStart = 0;\n";
DESERIALIZE += indent + " break;\n";
DESERIALIZE += indent + " }";
for (let i = 1; i < group.length; i++) {
const mem = group[i];
const memName = mem.alias || mem.name;
DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
DESERIALIZE += indent + " store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
DESERIALIZE += indent + " srcStart += 2;\n";