mlogjs · JeanJPNM · Jan 5, 2024 · Jan 11, 2024 · Jan 12, 2024 · Jan 12, 2024
diff --git a/compiler/src/BlockCursor.ts b/compiler/src/BlockCursor.ts
@@ -0,0 +1,95 @@
+import { CompilerError } from "./CompilerError";
+import {
+  Block,
+  BreakInstruction,
+  InstructionNode,
+  TBlockEndInstruction,
+  TBlockInstruction,
+} from "./flow";
+import { Location, es } from "./types";
+
+export interface IBlockCursor {
+  currentBlock: Block;
+  position: InstructionNode | undefined;
+
+  /**
+   * Adds an instruction after the instruction currently pointed at by the
+   * cursor
+   */
+  addInstruction(instruction: TBlockInstruction): void;
+  /** Removes the instruction currently pointed at by the cursor */
+  removeInstruction(): void;
+
+  /** Attempts to connect a block to the current block pointed at by this cursor. */
+  connectBlock(block: Block, node: es.Node): void;
+
+  setEndInstruction(instruction: TBlockEndInstruction): void;
+
+  discardFollowing(): void;
+}
+
+export type CursorMode = "create" | "edit";
+
+export class BlockCursor implements IBlockCursor {
+  private _currentBlock: Block;
+  position: InstructionNode | undefined;
+
+  constructor(
+    public mode: CursorMode,
+    currentBlock: Block,
+  ) {
+    this._currentBlock = currentBlock;
+  }
+
+  get currentBlock(): Block {
+    return this._currentBlock;
+  }
+
+  set currentBlock(block: Block) {
+    this._currentBlock = block;
+    this.position = undefined;
+  }
+
+  addInstruction(instruction: TBlockInstruction) {
+    if (this.mode === "create" && this.currentBlock.endInstruction) return;
+
+    if (this.position === undefined) {
+      this.currentBlock.instructions.add(instruction);
+      return;
+    }
+
+    this.currentBlock.instructions.insertAfter(this.position, instruction);
+    this.position = this.position.next;
+  }
+
+  removeInstruction() {
+    if (this.position === undefined) {
+      this.currentBlock.instructions.removeLast();
+      return;
+    }
+
+    const { previous } = this.position;
+    this.currentBlock.instructions.remove(this.position);
+    this.position = previous;
+  }
+
+  connectBlock(block: Block, loc: Location) {
+    if (block === this.currentBlock) return;
+    this.setEndInstruction(new BreakInstruction(block, loc));
+    this.currentBlock = block;
+  }
+
+  setEndInstruction(instruction: TBlockEndInstruction) {
+    if (this.mode === "create" && this.currentBlock.endInstruction) return;
+    this.currentBlock.endInstruction = instruction;
+  }
+
+  discardFollowing(): void {
+    if (!this.position)
+      throw new CompilerError(
+        "Attempted to discard instructions without a position",
+      );
+
+    this.currentBlock.instructions.removeAllAfter(this.position);
+  }
+}
diff --git a/compiler/src/Compiler.ts b/compiler/src/Compiler.ts
@@ -2,19 +2,13 @@ import { parse } from "@babel/parser";
 import { CompilerError } from "./CompilerError";
 import * as handlers from "./handlers";
 import { createGlobalScope } from "./modules";
-import { AddressResolver, EndInstruction } from "./instructions";
-import {
-  es,
-  IInstruction,
-  IScope,
-  IValue,
-  TEOutput,
-  THandler,
-  TValueInstructions,
-} from "./types";
-import { appendSourceLocations, hideRedundantJumps, pipeInsts } from "./utils";
-
-type THandlerMap = { [k in es.Node["type"]]?: THandler<IValue | null> };
+import { es, IInstruction, THandler } from "./types";
+import { hideRedundantJumps } from "./utils";
+import { CompilerContext } from "./CompilerContext";
+import { BlockCursor } from "./BlockCursor";
+import { Block, EndInstruction, Graph } from "./flow";
+
+type THandlerMap = { [k in es.Node["type"]]?: THandler };
 
 export interface CompilerOptions {
   /** Wether the compiler should preserve or compact variable and function names */
@@ -44,23 +38,34 @@ export class Compiler {
     let sourcemaps: es.SourceLocation[] | undefined;
 
     try {
+      const c = new CompilerContext(this);
       const program = this.parse(script);
-      const globalScope = createGlobalScope();
+      const globalScope = createGlobalScope(c);
       // this allows the user to shadow global variables inside
       // the script, since it is treated as a module
       const scope = globalScope.createScope();
 
-      const valueInst = this.handle(scope, program);
-      if (needsEndInstruction(valueInst[1], scope)) {
-        valueInst[1].push(new EndInstruction());
-      }
-      valueInst[1].push(...scope.inst);
+      const entryBlock = new Block();
+      const exitBlock = new Block(new EndInstruction());
+      const cursor = new BlockCursor("create", entryBlock);
+
+      c.handle(scope, cursor, program);
+
+      const rootGraph = Graph.from(entryBlock, exitBlock);
 
-      hideRedundantJumps(valueInst[1]);
-      this.resolve(valueInst);
-      output = this.serialize(valueInst) + "\n";
+      const inst = rootGraph.toMlog(c);
+
+      // const valueInst = this.handle(scope, program);
+      // if (needsEndInstruction(valueInst[1], scope)) {
+      //   valueInst[1].push(new EndInstruction());
+      // }
+      // valueInst[1].push(...scope.inst);
+
+      hideRedundantJumps(inst);
+      this.resolve(inst);
+      output = this.serialize(inst) + "\n";
       if (this.sourcemap) {
-        sourcemaps = this.mapSources(valueInst);
+        sourcemaps = this.mapSources(inst);
       }
     } catch (error) {
       const err =
@@ -70,16 +75,15 @@ export class Compiler {
     return [output, null, sourcemaps];
   }
 
-  protected resolve(valueInst: TValueInstructions<IValue | null>) {
+  protected resolve(instructions: IInstruction[]) {
     let i = 0;
-    for (const inst of valueInst[1]) {
+    for (const inst of instructions) {
       inst.resolve(i);
       if (!inst.hidden) i++;
     }
   }
 
-  protected serialize(resLines: TValueInstructions<IValue | null>) {
-    const [, inst] = resLines;
+  protected serialize(inst: IInstruction[]) {
     return inst.filter(l => !l.hidden).join("\n");
   }
 
@@ -91,111 +95,13 @@ export class Compiler {
     });
   }
 
-  protected mapSources(
-    valueInst: TValueInstructions<IValue | null>,
-  ): es.SourceLocation[] {
+  protected mapSources(insts: IInstruction[]): es.SourceLocation[] {
     const result: es.SourceLocation[] = [];
 
-    for (const inst of valueInst[1]) {
+    for (const inst of insts) {
       if (!inst.hidden) result.push(inst.source as es.SourceLocation);
     }
 
     return result;
   }
-
-  handle(
-    scope: IScope,
-    node: es.Node,
-    handler = this.handlers[node.type],
-    out?: TEOutput,
-    arg?: unknown,
-  ): TValueInstructions<IValue | null> {
-    try {
-      if (!handler) throw new CompilerError("Missing handler for " + node.type);
-      const result = handler(this, scope, node, out, arg);
-      if (this.sourcemap) return appendSourceLocations(result, node);
-      return result;
-    } catch (error) {
-      if (error instanceof CompilerError) {
-        error.loc ??= node.loc as es.SourceLocation;
-      }
-      throw error;
-    }
-  }
-
-  /** Handles the node and asserts that it resolves to a value. */
-  handleValue(
-    scope: IScope,
-    node: es.Node,
-    handler = this.handlers[node.type],
-    out?: TEOutput,
-    arg?: unknown,
-  ): TValueInstructions {
-    const result = this.handle(scope, node, handler, out, arg);
-    if (!result[0])
-      throw new CompilerError(
-        `This node (${node.type}) did not return a value`,
-        node,
-      );
-    return result as TValueInstructions;
-  }
-
-  handleEval(
-    scope: IScope,
-    node: es.Node,
-    out?: TEOutput,
-    arg?: unknown,
-  ): TValueInstructions {
-    const [res, inst] = this.handleValue(scope, node, undefined, out, arg);
-    const [evaluated, evaluatedInst] = res.eval(scope, out);
-    const result: TValueInstructions = [evaluated, [...inst, ...evaluatedInst]];
-
-    if (this.sourcemap) return appendSourceLocations(result, node);
-    return result;
-  }
-
-  /**
-   * Handles many nodes in order.
-   *
-   * The usage of this method over a regular loop over an array of nodes is only
-   * required if the code inside the loop generates instructions that are not
-   * tracked by the compiler handler methods ({@link handle}, {@link handleEval}
-   * and {@link handleMany})
-   */
-  handleMany<T extends es.Node>(
-    scope: IScope,
-    nodes: T[],
-    handler?: (node: T) => TValueInstructions<IValue | null>,
-  ): TValueInstructions<null> {
-    const lines: IInstruction[] = [];
-    for (const node of hoistedFunctionNodes(nodes)) {
-      pipeInsts(
-        this.handle(scope, node, handler && (() => handler(node))),
-        lines,
-      );
-    }
-    return [null, lines];
-  }
-}
-
-function* hoistedFunctionNodes<T extends es.Node>(nodes: T[]) {
-  // sorting is O(n long n) while this is just O(n)
-  // besides, it's better not to modify the node array
-  for (const node of nodes) {
-    if (node.type === "FunctionDeclaration") {
-      yield node;
-    }
-  }
-
-  for (const node of nodes) {
-    if (node.type !== "FunctionDeclaration") {
-      yield node;
-    }
-  }
-}
-
-function needsEndInstruction(inst: IInstruction[], scope: IScope) {
-  const last = inst[inst.length - 1];
-  if (last instanceof AddressResolver) return true;
-  return scope.inst.length > 0;
 }