frontend: export resumptionTargets

Author: indutny

src/frontend.ts

@@ -70,6 +70,7 @@ export class Frontend {
   private readonly map: Map<source.node.Node, WrappedNode> = new Map();
   private readonly spanMap: Map<source.Span, SpanField> = new Map();
   private readonly codeCache: Map<string, WrappedCode> = new Map();
+  private readonly resumptionTargets: Set<WrappedNode> = new Set();
 
   constructor(private readonly prefix: string,
               private readonly implementation: IImplementation,
@@ -112,15 +113,28 @@ export class Frontend {
 
     debug('enumerating');
     const enumerator = new Enumerator();
-    const nodes = enumerator.getAllNodes(out);
+    let nodes = enumerator.getAllNodes(out);
 
     debug('peephole optimization');
     const peephole = new Peephole();
     out = peephole.optimize(out, nodes);
 
+    debug('re-enumerating');
+    nodes = enumerator.getAllNodes(out);
+
+    debug('registering resumption targets');
+    this.resumptionTargets.add(out);
+    for (const node of nodes) {
+      this.registerNode(node);
+    }
+
     return { prefix: this.prefix, properties, spans, root: out };
   }
 
+  public getResumptionTargets(): ReadonlySet<WrappedNode> {
+    return this.resumptionTargets;
+  }
+
   private translate(node: source.node.Node): WrappedNode {
     if (this.map.has(node)) {
       return this.map.get(node)!;
@@ -188,7 +202,7 @@ export class Frontend {
       assert(result.length >= 1);
       return result[0];
     } else {
-      const single = result as WrappedNode;
+      const single: WrappedNode = result as WrappedNode;
       assert(single.ref instanceof frontend.node.Node);
 
       // Break loops
@@ -215,6 +229,25 @@ export class Frontend {
     }
   }
 
+  private registerNode(node: any): void {
+    const nodeImpl = this.implementation.node;
+
+    // Nodes with prologue check (start_pos != end_pos)
+    if (node instanceof nodeImpl.Consume ||
+        node instanceof nodeImpl.Empty ||
+        node instanceof nodeImpl.Sequence ||
+        node instanceof nodeImpl.Single ||
+        node instanceof nodeImpl.SpanStart ||
+        node instanceof nodeImpl.TableLookup) {
+      this.resumptionTargets.add(node);
+
+    // Nodes that can interrupt the execution to be resumed at different node
+    } else if (node instanceof nodeImpl.Pause ||
+               node instanceof nodeImpl.SpanEnd) {
+      this.resumptionTargets.add(node.ref.otherwise!.node);
+    }
+  }
+
   private translateMatch(node: source.node.Match): MatchResult {
     const trie = new Trie(node.name);
 

test/fixtures/implementation/node/sequence.ts

@@ -3,6 +3,9 @@ import { Node } from './base';
 
 export class Sequence extends Node<node.Sequence> {
   protected doBuild(out: string[]): void {
-    out.push(this.format(`select="${this.ref.select.toString('hex')}"`));
+    out.push(this.format(`select="${this.ref.select.toString('hex')}" ` +
+        `edge="${this.ref.edge!.node.ref.id.name}"`));
+    const edgeNode = this.ref.edge!.node as Node<node.Node>;
+    edgeNode.build(out);
   }
 }

test/frontend-test.ts

@@ -1,16 +1,34 @@
 import * as assert from 'assert';
 
-import { Builder } from 'llparse-builder';
+import * as source from 'llparse-builder';
 
 import { Frontend, node } from '../src/frontend';
 import implementation from './fixtures/implementation';
 import { Node } from './fixtures/implementation/node/base';
 
+function checkNodes(f: Frontend, root: source.node.Node,
+                    expected: ReadonlyArray<string>) {
+  const fRoot = f.compile(root, []).root as Node<node.Node>;
+
+  const out: string[] = [];
+  fRoot.build(out);
+
+  assert.deepStrictEqual(out, expected);
+}
+
+function checkResumptionTargets(f: Frontend, expected: ReadonlyArray<string>) {
+  const targets = Array.from(f.getResumptionTargets()).map((t) => {
+    return t.ref.id.name;
+  });
+
+  assert.deepStrictEqual(targets, expected);
+}
+
 describe('llparse-frontend', () => {
-  let b: Builder;
+  let b: source.Builder;
   let f: Frontend;
   beforeEach(() => {
-    b = new Builder();
+    b = new source.Builder();
     f = new Frontend('llparse', implementation);
   });
 
@@ -22,12 +40,7 @@ describe('llparse-frontend', () => {
     root.match('efg', root);
     root.otherwise(b.error(123, 'hello'));
 
-    const fRoot = f.compile(root, []).root as Node<node.Node>;
-
-    const out: string[] = [];
-    fRoot.build(out);
-
-    assert.deepStrictEqual(out, [
+    checkNodes(f, root, [
       '<Single name=llparse__n_root k97=llparse__n_root_1 ' +
         'k101=llparse__n_root_3 otherwise-no_adv=llparse__n_error/>',
       '<Single name=llparse__n_root_1 k98=llparse__n_root ' +
@@ -36,8 +49,16 @@ describe('llparse-frontend', () => {
         'otherwise-no_adv=llparse__n_error/>',
       '<ErrorNode name=llparse__n_error code=123 reason="hello"/>',
       '<Sequence name=llparse__n_root_3 select="6667" ' +
+        'edge=\"llparse__n_root\" ' +
         'otherwise-no_adv=llparse__n_error/>',
     ]);
+
+    checkResumptionTargets(f, [
+      'llparse__n_root',
+      'llparse__n_root_1',
+      'llparse__n_root_3',
+      'llparse__n_root_2',
+    ]);
   });
 
   it('should do peephole optimization', () => {
@@ -53,13 +74,56 @@ describe('llparse-frontend', () => {
     node1.otherwise(node2);
     node2.otherwise(root);
 
-    const fRoot = f.compile(root, []).root as Node<node.Node>;
+    checkNodes(f, root, [
+      '<Empty name=llparse__n_b  otherwise=llparse__n_b/>',
+    ]);
 
-    const out: string[] = [];
-    fRoot.build(out);
+    checkResumptionTargets(f, [
+      'llparse__n_b',
+    ]);
+  });
 
-    assert.deepStrictEqual(out, [
-      '<Empty name=llparse__n_b  otherwise=llparse__n_b/>',
+  it('should generate proper resumption targets', () => {
+    b.property('i64', 'counter');
+
+    const root = b.node('root');
+    const end = b.node('end');
+    const store = b.invoke(b.code.store('counter'));
+
+    root.select({ a: 1, b: 2 }, store);
+    root.otherwise(b.error(1, 'okay'));
+
+    store.otherwise(end);
+
+    end.match('ohai', root);
+    end.match('paus', b.pause(1, 'paused').otherwise(
+        b.pause(2, 'paused').otherwise(root)));
+    end.otherwise(b.error(2, 'ohai'));
+
+    checkNodes(f, root, [
+      '<Single name=llparse__n_root k97=llparse__n_invoke_store_counter ' +
+          'k98=llparse__n_invoke_store_counter ' +
+          'otherwise-no_adv=llparse__n_error_1/>',
+      '<Invoke name=llparse__n_invoke_store_counter  ' +
+          'otherwise-no_adv=llparse__n_end/>',
+      '<Single name=llparse__n_end k111=llparse__n_end_1 ' +
+          'k112=llparse__n_end_2 otherwise-no_adv=llparse__n_error/>',
+      '<Sequence name=llparse__n_end_1 select="686169" ' +
+          'edge="llparse__n_root" otherwise-no_adv=llparse__n_error/>',
+      '<ErrorNode name=llparse__n_error code=2 reason="ohai"/>',
+      '<Sequence name=llparse__n_end_2 select="617573" ' +
+          'edge="llparse__n_pause" otherwise-no_adv=llparse__n_error/>',
+      '<Pause name=llparse__n_pause  otherwise-no_adv=llparse__n_pause_1/>',
+      '<Pause name=llparse__n_pause_1  otherwise-no_adv=llparse__n_root/>',
+      '<ErrorNode name=llparse__n_error_1 code=1 reason="okay"/>',
+    ]);
+
+    checkResumptionTargets(f, [
+      'llparse__n_root',
+      'llparse__n_end',
+      'llparse__n_end_1',
+      'llparse__n_end_2',
+      'llparse__n_pause_1',
     ]);
   });
 });