object-input-stream 0.1.0

package/src/ois-ast.ts

@@ -0,0 +1,147 @@
+import ObjectInputStream, { type OisOptions } from ".";
+import type * as ast from './ast';
+import * as exc from "./exceptions";
+
+
+export class ObjectInputStreamAST extends ObjectInputStream {
+    protected ast: ast.Ast
+    protected nodeStack: ast.Node[];
+
+    constructor(data: Uint8Array, options?: OisOptions) {
+        super(data, options);
+
+        this.ast = {data, root: {
+            type: "root",
+            span: {start: 0, end: this.data.length},
+            children: [
+                {type: "magic",   value: this.STREAM_MAGIC,   span: {start: 0, end: 2}, children: null},
+                {type: "version", value: this.STREAM_VERSION, span: {start: 2, end: 4}, children: null},
+                {type: "contents", span: {start: 4, end: this.data.length}, children:[]},
+            ]
+        }}
+        this.nodeStack = [this.ast.root, this.ast.root.children[2]];
+    }
+
+    protected get curNode() {
+        return this.nodeStack[this.nodeStack.length-1];
+    }
+
+    getAST(): ast.Ast {
+        return this.ast;
+    }
+
+    @primitiveAST("boolean")
+    readBoolean(): boolean { return super.readBoolean(); }
+    @primitiveAST("byte")
+    readByte(): number { return super.readByte(); }
+    @primitiveAST("unsigned-byte")
+    readUnsignedByte(): number { return super.readUnsignedByte(); }
+    @primitiveAST("char")
+    readChar(): string { return super.readChar(); }
+    @primitiveAST("short")
+    readShort(): number { return super.readShort(); }
+    @primitiveAST("unsigned-short")
+    readUnsignedShort(): number { return super.readUnsignedShort(); }
+    @primitiveAST("int")
+    readInt(): number { return super.readInt(); }
+    @primitiveAST("long")
+    readLong(): bigint { return super.readLong(); }
+    @primitiveAST("float")
+    readFloat(): number { return super.readFloat(); }
+    @primitiveAST("double")
+    readDouble(): number { return super.readDouble(); }
+
+    @nodeAST("tc")
+    protected readTC(): number { return super.readTC(); }
+}
+
+function nodeAST<T>(type: string) {return (fun: () => T) => {
+    return function decorated(this: ObjectInputStreamAST) {
+        if (!(this instanceof ObjectInputStreamAST))
+            throw new exc.InternalError();
+
+        const start = this.offset;
+        const result = fun.apply(this);
+        const end = this.offset;
+
+        if (this.nodeStack === undefined)
+            return result;
+
+        const span = {start, end};
+
+        const node: ast.Node = {
+            type: type as any,
+            span: span,
+            children: null,
+        }
+
+        if (this.curNode.children === null)
+            throw new exc.InternalError();
+
+        // @ts-expect-error
+        this.curNode.children.push(node);
+
+        return result;
+    }
+}}
+
+function primitiveAST<T extends number | string | boolean | bigint>(dataType: string) {return (fun: () => T) => {
+    return function decorated(this: ObjectInputStreamAST) {
+        if (!(this instanceof ObjectInputStreamAST))
+            throw new exc.InternalError();
+
+        const start = this.offset;
+        const result = fun.apply(this);
+        const end = this.offset;
+
+        if (this.nodeStack === undefined)
+            return result;
+
+        const span = {start, end};
+
+        const node: ast.PrimitiveNode = {
+            type: "primitive",
+            // @ts-expect-error
+            dataType: dataType,
+            value: result,
+            span: span,
+            children: null,
+        }
+
+        if (this.curNode.type === "blockdata") {
+            const sequence = this.nodeStack[this.nodeStack.length-2];
+            if (sequence.type !== "blockdata-sequence")
+                throw new exc.InternalError();
+            sequence.values.push(node);
+        } else {
+            if (this.curNode.children === null)
+                throw new exc.InternalError();
+            // @ts-expect-error
+            this.curNode.children.push(node);
+        }
+
+        return result;
+    }
+}}
+
+
+const ois_ast = new ObjectInputStreamAST(new Uint8Array([
+      172, 237,   0,  5, 119,  30,  69,  39,  20,
+       78, 206, 109, 85,  58,   3,  21, 127, 242,
+      227,  49,  35,  0,   0, 113,  52, 105,   0,
+        0,   0,   0,  0,   0,   0, 207, 199,   1
+]));
+
+ois_ast.readByte()
+ois_ast.readChar()
+ois_ast.readDouble()
+ois_ast.readFloat()
+ois_ast.readInt()
+ois_ast.readLong()
+ois_ast.readShort()
+ois_ast.readBoolean()
+
+
+const myAst: any = ois_ast.getAST();
+myAst.data = [...myAst.data];
+console.log(JSON.stringify(myAst, (key, value) => typeof value === "bigint" ? ''+value : value, 2));