mirror of
https://github.com/fluencelabs/assemblyscript-json
synced 2025-03-16 03:30:48 +00:00
334 lines
9.7 KiB
TypeScript
334 lines
9.7 KiB
TypeScript
declare function logStr(str: string): void;
|
|
declare function logF64(val: f64): void;
|
|
|
|
/**
|
|
* Extend from this class to handle events from parser.
|
|
* Default implementation traverses whole object tree and does nothing.
|
|
*/
|
|
export abstract class JSONHandler {
|
|
setString(name: string, value: string): void {
|
|
}
|
|
|
|
setBoolean(name: string, value: bool): void {
|
|
}
|
|
|
|
setNull(name: string): void {
|
|
}
|
|
|
|
setInteger(name: string, value: i32): void {
|
|
}
|
|
|
|
pushArray(name: string): bool {
|
|
return true;
|
|
}
|
|
|
|
popArray(): void {
|
|
}
|
|
|
|
pushObject(name: string): bool {
|
|
return true;
|
|
}
|
|
|
|
popObject(): void {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extend from this class to handle events from parser.
|
|
* This implementation crashes on every unimplemented set/push method
|
|
* to allow easier validation of input.
|
|
*/
|
|
export class ThrowingJSONHandler extends JSONHandler {
|
|
setString(name: string, value: string): void {
|
|
assert(false, 'Unexpected string field ' + name + ' : "' + value + '"');
|
|
}
|
|
|
|
setBoolean(name: string, value: bool): void {
|
|
assert(false, 'Unexpected bool field ' + name + ' : ' + (value ? 'true' : 'false'));
|
|
}
|
|
|
|
setNull(name: string): void {
|
|
assert(false, 'Unexpected null field ' + name);
|
|
}
|
|
|
|
setInteger(name: string, value: i32): void {
|
|
let arr: Array<i32> = [value];
|
|
assert(false, 'Unexpected integer field ' + name + ' : ' + arr.toString());
|
|
}
|
|
|
|
pushArray(name: string): bool {
|
|
assert(false, 'Unexpected array field ' + name);
|
|
return true;
|
|
}
|
|
|
|
pushObject(name: string): bool {
|
|
assert(false, 'Unexpected object field ' + name);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
const TRUE_STR = "true";
|
|
const FALSE_STR = "false";
|
|
const NULL_STR = "null";
|
|
let CHAR_0 = "0".charCodeAt(0);
|
|
let CHAR_9 = "9".charCodeAt(0);
|
|
let CHAR_A = "A".charCodeAt(0);
|
|
let CHAR_A_LOWER = "a".charCodeAt(0);
|
|
|
|
export class DecoderState {
|
|
readIndex: i32 = 0;
|
|
buffer: Uint8Array = null;
|
|
lastKey: string = null;
|
|
}
|
|
|
|
export class JSONDecoder<JSONHandlerT extends JSONHandler> {
|
|
|
|
handler: JSONHandlerT;
|
|
state: DecoderState;
|
|
|
|
constructor(handler: JSONHandlerT) {
|
|
this.handler = handler;
|
|
}
|
|
|
|
deserialize(buffer: Uint8Array, decoderState: DecoderState = null): void {
|
|
if (decoderState) {
|
|
this.state = decoderState;
|
|
} else {
|
|
this.state = new DecoderState();
|
|
this.state.readIndex = 0;
|
|
this.state.buffer = buffer;
|
|
this.state.lastKey = null;
|
|
}
|
|
|
|
assert(this.parseValue(), "Cannot parse JSON");
|
|
// TODO: Error if input left
|
|
}
|
|
|
|
private peekChar(): i32 {
|
|
if (this.state.readIndex >= this.state.buffer.length) {
|
|
return -1;
|
|
}
|
|
return this.state.buffer[this.state.readIndex];
|
|
}
|
|
|
|
private readChar(): i32 {
|
|
assert(this.state.readIndex < this.state.buffer.length, "Unexpected input end");
|
|
return this.state.buffer[this.state.readIndex++];
|
|
}
|
|
|
|
private parseValue(): bool {
|
|
this.skipWhitespace();
|
|
let result = this.parseObject()
|
|
|| this.parseArray()
|
|
|| this.parseString()
|
|
|| this.parseBoolean()
|
|
|| this.parseNumber()
|
|
|| this.parseNull()
|
|
this.skipWhitespace();
|
|
return result;
|
|
}
|
|
|
|
private parseObject(): bool {
|
|
if (this.peekChar() != "{".charCodeAt(0)) {
|
|
return false;
|
|
}
|
|
let key = this.state.lastKey;
|
|
this.state.lastKey = null;
|
|
if (this.handler.pushObject(key)) {
|
|
this.readChar();
|
|
this.skipWhitespace();
|
|
|
|
let firstItem = true;
|
|
while (this.peekChar() != "}".charCodeAt(0)) {
|
|
if (!firstItem) {
|
|
assert(this.readChar() == ",".charCodeAt(0), "Expected ','");
|
|
} else {
|
|
firstItem = false;
|
|
}
|
|
this.parseKey();
|
|
this.parseValue();
|
|
}
|
|
assert(this.readChar() == "}".charCodeAt(0), "Unexpected end of object");
|
|
}
|
|
this.handler.popObject();
|
|
return true;
|
|
}
|
|
|
|
private parseKey(): void {
|
|
this.skipWhitespace();
|
|
this.state.lastKey = this.readString();
|
|
this.skipWhitespace();
|
|
assert(this.readChar() == ":".charCodeAt(0), "Expected ':'");
|
|
}
|
|
|
|
private parseArray(): bool {
|
|
if (this.peekChar() != "[".charCodeAt(0)) {
|
|
return false;
|
|
}
|
|
let key = this.state.lastKey;
|
|
this.state.lastKey = null;
|
|
if (this.handler.pushArray(key)) {
|
|
this.readChar();
|
|
this.skipWhitespace();
|
|
|
|
let firstItem = true;
|
|
while (this.peekChar() != "]".charCodeAt(0)) {
|
|
if (!firstItem) {
|
|
assert(this.readChar() == ",".charCodeAt(0), "Expected ','");
|
|
} else {
|
|
firstItem = false;
|
|
}
|
|
this.parseValue();
|
|
}
|
|
assert(this.readChar() == "]".charCodeAt(0), "Unexpected end of array");
|
|
}
|
|
this.handler.popArray();
|
|
return true;;
|
|
}
|
|
|
|
private parseString(): bool {
|
|
if (this.peekChar() != '"'.charCodeAt(0)) {
|
|
return false;
|
|
}
|
|
this.handler.setString(this.state.lastKey, this.readString());
|
|
return true;
|
|
}
|
|
|
|
private readString(): string {
|
|
assert(this.readChar() == '"'.charCodeAt(0), "Expected double-quoted string");
|
|
let savedIndex = this.state.readIndex;
|
|
let stringParts: Array<string> = new Array<string>();
|
|
for (;;) {
|
|
let byte = this.readChar();
|
|
assert(byte >= 0x20, "Unexpected control character");
|
|
if (byte == '"'.charCodeAt(0)) {
|
|
stringParts.push(
|
|
String.fromUTF8(this.state.buffer.buffer.data + savedIndex, this.state.readIndex - savedIndex - 1));
|
|
return stringParts.join("");
|
|
}
|
|
if (byte == "\\".charCodeAt(0)) {
|
|
if (this.state.readIndex > savedIndex + 1) {
|
|
stringParts.push(
|
|
String.fromUTF8(this.state.buffer.buffer.data + savedIndex, this.state.readIndex - savedIndex - 1));
|
|
}
|
|
stringParts.push(this.readEscapedChar());
|
|
savedIndex = this.state.readIndex;
|
|
}
|
|
}
|
|
// Should never happen
|
|
return "";
|
|
}
|
|
|
|
private readEscapedChar(): string {
|
|
let byte = this.readChar();
|
|
// TODO: Use lookup table for anything except \u
|
|
if (byte == '"'.charCodeAt(0)) {
|
|
return '"';
|
|
}
|
|
if (byte == "\\".charCodeAt(0)) {
|
|
return "\\";
|
|
}
|
|
if (byte == "/".charCodeAt(0)) {
|
|
return "/";
|
|
}
|
|
if (byte == "b".charCodeAt(0)) {
|
|
return "\b";
|
|
}
|
|
if (byte == "n".charCodeAt(0)) {
|
|
return "\n";
|
|
}
|
|
if (byte == "r".charCodeAt(0)) {
|
|
return "\r";
|
|
}
|
|
if (byte == "t".charCodeAt(0)) {
|
|
return "\t";
|
|
}
|
|
if (byte == "u".charCodeAt(0)) {
|
|
let d1 = this.readHexDigit();
|
|
let d2 = this.readHexDigit();
|
|
let d3 = this.readHexDigit();
|
|
let d4 = this.readHexDigit();
|
|
let charCode = d1 * 0x1000 + d2 * 0x100 + d3 * 0x10 + d4;
|
|
return String.fromCodePoint(charCode);
|
|
}
|
|
assert(false, "Unexpected escaped character: " + String.fromCharCode(byte));
|
|
return "";
|
|
}
|
|
|
|
private readHexDigit(): i32 {
|
|
let byte = this.readChar();
|
|
let digit = byte - CHAR_0;
|
|
if (digit > 9) {
|
|
digit = byte - CHAR_A + 10;
|
|
if (digit < 10 || digit > 15) {
|
|
digit = byte - CHAR_A_LOWER + 10;
|
|
}
|
|
}
|
|
let arr: Array<i32> = [byte, digit];
|
|
assert(digit >= 0 && digit < 16, "Unexpected \\u digit");
|
|
return digit;
|
|
}
|
|
|
|
private parseNumber(): bool {
|
|
// TODO: Parse floats
|
|
let number: i32 = 0;
|
|
let sign: i32 = 1;
|
|
if (this.peekChar() == "-".charCodeAt(0)) {
|
|
sign = -1;
|
|
this.readChar();
|
|
}
|
|
let digits = 0;
|
|
while (CHAR_0 <= this.peekChar() && this.peekChar() <= CHAR_9 ) {
|
|
let byte = this.readChar();
|
|
number *= 10;
|
|
number += byte - CHAR_0;
|
|
digits++;
|
|
}
|
|
if (digits > 0) {
|
|
this.handler.setInteger(this.state.lastKey, number * sign);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private parseBoolean(): bool {
|
|
if (this.peekChar() == FALSE_STR.charCodeAt(0)) {
|
|
this.readAndAssert(FALSE_STR);
|
|
this.handler.setBoolean(this.state.lastKey, false);
|
|
return true;
|
|
}
|
|
if (this.peekChar() == TRUE_STR.charCodeAt(0)) {
|
|
this.readAndAssert(TRUE_STR);
|
|
this.handler.setBoolean(this.state.lastKey, true);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private parseNull(): bool {
|
|
if (this.peekChar() == NULL_STR.charCodeAt(0)) {
|
|
this.readAndAssert(NULL_STR);
|
|
this.handler.setNull(this.state.lastKey);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private readAndAssert(str: string): void {
|
|
for (let i = 0; i < str.length; i++) {
|
|
assert(str.charCodeAt(i) == this.readChar(), "Expected '" + str + "'");
|
|
}
|
|
}
|
|
|
|
private skipWhitespace(): void {
|
|
while (this.isWhitespace(this.peekChar())) {
|
|
this.readChar();
|
|
}
|
|
}
|
|
|
|
private isWhitespace(charCode: i32): bool {
|
|
return charCode == 0x9 || charCode == 0xa || charCode == 0xd || charCode == 0x20;
|
|
}
|
|
}
|