@bablr/bablr-vm 0.18.1 → 0.19.0

package/lib/state.js

@@ -1,11 +1,30 @@
 import emptyStack from '@iter-tools/imm-stack';
 import { WeakStackFrame } from '@bablr/weak-stack';
 import { getCooked } from '@bablr/agast-helpers/stream';
+import { reifyExpression } from '@bablr/agast-vm-helpers';
+import {
+  EmbeddedMatcher,
+  EmbeddedNode,
+  EmbeddedRegex,
+  GapTag,
+  ReferenceTag,
+  ShiftTag,
+} from '@bablr/agast-helpers/symbols';
+import * as btree from '@bablr/agast-helpers/btree';
+import {
+  buildCall,
+  buildEmbeddedRegex,
+  buildEmbeddedTag,
+  buildGapTag,
+  buildReferenceTag,
+  buildStubNode,
+} from '@bablr/agast-helpers/tree';
+import { get, Path, PathResolver, TagPath, updatePath } from '@bablr/agast-helpers/path';
 import { match, guardWithPattern } from './utils/pattern.js';
 import { facades, actuals } from './facades.js';
-import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { EmbeddedNode, GapTag } from '@bablr/agast-helpers/symbols';
-import { NodeFacade } from './node.js';
+import { buildInternalState, FragmentFacade, internalStates } from './node.js';
+
+export const nodeStates = new WeakMap();
 
 export const StateFacade = class BABLRStateFacade {
   constructor(state) {
@@ -24,8 +43,16 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).span.name;
   }
 
-  get result() {
-    return actuals.get(this).result;
+  get resultPath() {
+    return actuals.get(this).resultPath;
+  }
+
+  get reference() {
+    return actuals.get(this).reference;
+  }
+
+  get referencePath() {
+    return actuals.get(this).referencePath;
   }
 
   get holding() {
@@ -36,12 +63,17 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).path;
   }
 
+  get depths() {
+    const { path, result } = actuals.get(this).depths;
+    return { path, result };
+  }
+
   get node() {
-    return NodeFacade.wrap(actuals.get(this).node, this.ctx);
+    return FragmentFacade.wrap(actuals.get(this).node, this.ctx);
   }
 
   get parentNode() {
-    return NodeFacade.wrap(actuals.get(this).parentNode, this.ctx);
+    return FragmentFacade.wrap(actuals.get(this).parentNode, this.ctx);
   }
 
   get source() {
@@ -56,44 +88,57 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).status;
   }
 
-  nodeForPath(path) {
-    return NodeFacade.wrap(actuals.get(this).nodeForPath(path), this.ctx);
-  }
-
-  pathForTag(tag) {
-    return actuals.get(this).pathForTag(tag);
+  get parent() {
+    return facades.get(actuals.get(this).parent);
   }
 
-  nodeForTag(tag) {
-    return NodeFacade.wrap(actuals.get(this).nodeForTag(tag), this.ctx);
+  nodeForPath(path) {
+    return actuals.get(this).nodeForPath(path);
   }
 };
 
 export const State = class BABLRState extends WeakStackFrame {
   constructor(
+    parent,
     source,
-    agast,
     context,
+    expressions = emptyStack,
     balanced = emptyStack,
     spans = emptyStack.push({ name: 'Bare' }),
+    referencePath = null,
+    resultPath = null,
+    depths = { path: -1, result: -1, emitted: -1 },
+    held = null,
+    node = null,
   ) {
-    super();
+    super(parent);
 
-    if (!source || !agast) throw new Error('invalid args to State');
+    if (!source) throw new Error('invalid args to State');
 
     this.source = source;
-    this.agast = agast;
     this.context = context;
+    this.expressions = expressions;
     this.balanced = balanced;
     this.spans = spans;
+    this.referencePath = referencePath;
+    this.resultPath = resultPath;
+    this.depths = depths;
+    this.held = held;
+    this.node = node;
 
     this.status = 'active';
 
+    this.emitted = null;
+
     new StateFacade(this);
   }
 
-  static from(source, agast, context) {
-    return State.create(source, agast, context);
+  static from(source, context, expressions = []) {
+    return State.create(source, context, emptyStack.push(...expressions));
+  }
+
+  get unboundAttributes() {
+    return nodeStates.get(this.node).unboundAttributes;
   }
 
   get guardedSource() {
@@ -108,23 +153,19 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   get path() {
-    return this.agast.path;
-  }
-
-  get node() {
-    return this.agast.node;
+    throw new Error('not implemented');
   }
 
   get parentNode() {
-    return this.agast.parentNode;
+    throw new Error('not implemented');
   }
 
   get holding() {
-    return this.agast.holding;
+    return !!this.held;
   }
 
-  get result() {
-    return this.agast.result;
+  get reference() {
+    return this.referencePath?.tag;
   }
 
   get isGap() {
@@ -135,50 +176,224 @@ export const State = class BABLRState extends WeakStackFrame {
     return !!this.parent;
   }
 
-  nodeForPath(path) {
-    return this.agast.nodeForPath(path);
-  }
+  advance(tag) {
+    const { path, instructionsPump, expressionsPump, agast } = internalStates.get(this.node);
 
-  pathForTag(tag) {
-    return this.agast.pathForTag(tag);
-  }
+    if (tag.type === GapTag) {
+      expressionsPump.queue(
+        this.expressions.size ? this.expressions.value : buildStubNode(buildGapTag()),
+      );
+      this.expressions = this.expressions.pop();
+    }
+    instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
+    agast.next();
 
-  nodeForTag(tag) {
-    return this.agast.nodeForTag(tag);
+    this.resultPath = TagPath.from(path, -1);
   }
 
   guardedMatch(pattern) {
-    let { span, spans, source, node } = this;
+    let { span, source } = this;
     let { guard } = span;
 
-    if (pattern.type === EmbeddedNode) {
-      pattern = reifyExpression(pattern.value);
+    let pattern_ = pattern;
+    if (pattern.type === EmbeddedMatcher) {
+      pattern_ = reifyExpression(pattern.value).nodeMatcher;
+    } else if (pattern.type === EmbeddedRegex) {
+      pattern_ = pattern.value;
+    } else if (typeof pattern !== 'string') {
+      throw new Error();
     }
 
     if (
       span.type === 'Lexical' &&
-      (node.flags.token
-        ? node.attributes.balancer || node.attributes.balanced
-        : pattern.attributes?.balancer)
+      pattern.type === EmbeddedMatcher &&
+      (pattern_.flags.token
+        ? pattern_.attributes.balancer || pattern_.attributes.balanced
+        : pattern_.attributes?.balancer)
     ) {
       // also check that the open node starts a lexical span?
       guard = null;
     }
 
-    if (pattern?.intrinsicValue) {
+    if (pattern_?.intrinsicValue) {
       // if (pattern.type === OpenNodeTag) {
 
       //   // TODO differntiate better between self-closing tags and matchers
       //   pattern = pattern.value;
       // }
 
-      pattern = pattern.intrinsicValue || getCooked(pattern.children);
+      pattern_ = pattern_.intrinsicValue || getCooked(pattern_.children);
+
+      if (pattern_.type === Symbol.for('String')) {
+        pattern_ = reifyExpression(pattern_);
+      }
+    }
+
+    return match(pattern_, guard ? guardWithPattern(guard, source) : source);
+  }
+
+  match(pattern) {
+    return match(pattern, this.source);
+  }
 
-      if (pattern.type === 'String') {
-        pattern = reifyExpression(pattern);
+  branch() {
+    const baseState = this;
+    let {
+      source,
+      context,
+      balanced,
+      spans,
+      resultPath,
+      depths,
+      referencePath,
+      held,
+      node,
+      expressions,
+    } = baseState;
+
+    let resolver = new PathResolver();
+
+    const internalState = buildInternalState();
+
+    for (let tag of btree.traverse(node.children)) {
+      if (tag.type === GapTag) {
+        let { name, isArray, flags } = resolver.reference.value;
+        const resolvedPath = buildReferenceTag(
+          name,
+          isArray,
+          flags,
+          Number.isFinite(resolver.counters[name]) ? resolver.counters[name] : null,
+        );
+        const expr = get(resolvedPath, node);
+        internalState.expressionsPump.queue(expr);
+      } else if (tag.type === EmbeddedNode) {
+        internalState.expressionsPump.queue(tag.value);
+        tag = buildGapTag();
       }
+
+      resolver.advance(tag);
+
+      internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
+      internalState.agast.next();
+    }
+
+    const newNode = internalState.agastState.node;
+    const nodeState = nodeStates.get(node);
+    let newResultPath;
+
+    if (resultPath.path.node === node) {
+      newResultPath = TagPath.from(Path.from(newNode), resultPath.childrenIndex);
+    } else {
+      newResultPath = resultPath;
     }
 
-    return match(pattern, guard ? guardWithPattern(guard, source) : source);
+    nodeStates.set(newNode, { ...nodeState });
+    internalStates.set(newNode, internalState);
+
+    const child = this.push(
+      source.branch(),
+      context,
+      expressions,
+      balanced,
+      spans,
+      referencePath,
+      newResultPath,
+      depths,
+      held,
+      newNode,
+    );
+
+    return child;
+  }
+
+  accept() {
+    const accepted = this;
+
+    this.status = 'accepted';
+
+    const { parent } = this;
+
+    if (!parent) {
+      throw new Error('accepted the root state');
+    }
+
+    parent.spans = accepted.spans;
+    parent.balanced = accepted.balanced;
+    parent.referencePath = accepted.referencePath;
+    parent.held = accepted.held;
+    parent.depths = accepted.depths;
+    parent.expressions = accepted.expressions;
+    // do I need this condition?
+    if (parent.depths.path === accepted.depths.path) {
+      const parentChildren = parent.node.children;
+      parent.node.children = parentChildren;
+
+      const internalState = internalStates.get(parent.node);
+      const { path: parentPath } = internalState;
+      // FIXME
+      // some `properties` are not copied
+      for (let i = btree.getSum(parentChildren); i < btree.getSum(accepted.node.children); i++) {
+        let tag = btree.getAt(i, accepted.node.children);
+
+        if (tag.type === GapTag) {
+          let referenceIdx = i;
+          let reference;
+          let isShift = btree.getAt(i - 1, accepted.node.children).type === ShiftTag;
+
+          while (
+            (reference = btree.getAt(--referenceIdx, accepted.node.children)).type !== ReferenceTag
+          );
+
+          let { name, isArray, flags } = reference.value;
+          const resolvedPath = buildReferenceTag(
+            name,
+            isArray,
+            flags,
+            isArray ? btree.getSum(parentPath.node.properties[name]) - (isShift ? 1 : 0) : null,
+          );
+          const expr = get(resolvedPath, accepted.node);
+          internalState.expressionsPump.queue(expr);
+        } else if (tag.type === EmbeddedNode) {
+          internalState.expressionsPump.queue(tag.value);
+          tag = buildGapTag();
+        }
+
+        internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
+        internalState.agast.next();
+
+        updatePath(parentPath, tag);
+      }
+    }
+
+    if (parent.depths.result === accepted.depths.result + 1) {
+      parent.resultPath = new TagPath(parent.resultPath.path, accepted.resultPath.childrenIndex);
+    } else {
+      parent.resultPath = accepted.resultPath;
+    }
+
+    nodeStates.set(parent.node, nodeStates.get(accepted.node));
+
+    parent.source.accept(accepted.source);
+
+    return parent;
+  }
+
+  reject() {
+    const rejectedState = this;
+    const { parent } = rejectedState;
+
+    if (this.status === 'rejected') {
+      return parent;
+    }
+
+    if (this.status !== 'active') throw new Error();
+
+    this.status = 'rejected';
+
+    if (!parent) throw new Error('rejected root state');
+
+    rejectedState.source.reject();
+
+    return parent;
   }
 };

package/lib/utils/pattern.js

@@ -1,9 +1,16 @@
 import isString from 'iter-tools-es/methods/is-string';
 import isEmpty from 'iter-tools-es/methods/is-empty';
 import { generateMatches } from '@bablr/regex-vm';
-import { getStreamIterator, maybeWait } from '@bablr/agast-helpers/stream';
-import * as t from '@bablr/agast-helpers/shorthand';
+import { getStreamIterator, maybeWait, printType } from '@bablr/agast-helpers/stream';
 import * as l from '@bablr/agast-vm-helpers/languages';
+import {
+  buildAlternative,
+  buildAlternatives,
+  buildElements,
+  buildPattern,
+  buildToken,
+} from '@bablr/helpers/builders';
+import { buildEmbeddedRegex } from '@bablr/agast-helpers/builders';
 
 export const assertValidRegex = (expr) => {
   const { flags } = expr;
@@ -16,25 +23,21 @@ export const assertValidRegex = (expr) => {
 };
 
 const buildStringRegex = (str) => {
-  return t.node(l.Regex, 'Pattern', [t.ref`open`, t.ref`alternatives[]`, t.ref`close`], {
-    open: t.s_node(l.Regex, 'Punctuator', '/'),
-    alternatives: [
-      t.node(l.Regex, 'Alternative', [t.ref`elements[]`], {
-        elements: [...str].map((chr) => t.s_node(l.Regex, 'Character', chr)),
-      }),
-    ],
-    close: t.s_node(l.Regex, 'Punctuator', '/'),
-  });
+  return buildPattern(
+    buildAlternatives([
+      buildAlternative(buildElements([...str].map((chr) => buildToken(l.Regex, 'Character', chr)))),
+    ]),
+  );
 };
 
 export const match = (pattern, source) => {
   const pattern_ = isString(pattern) ? buildStringRegex(pattern) : pattern;
 
-  if (pattern_.type !== 'Pattern') throw new Error();
+  if (printType(pattern_.type) !== 'Pattern') throw new Error();
 
   assertValidRegex(pattern_);
 
-  const iter = getStreamIterator(generateMatches(pattern_, source));
+  const iter = getStreamIterator(generateMatches(buildEmbeddedRegex(pattern_), source));
 
   const step = iter.next();
 

package/lib/utils/pump.js

@@ -0,0 +1,20 @@
+export class Pump {
+  constructor() {
+    this.held = [];
+  }
+
+  queue(value) {
+    this.held.push(value);
+  }
+
+  next() {
+    const held = this.held[0];
+    if (!held) throw new Error();
+    this.held.shift();
+    return { done: false, value: held };
+  }
+
+  [Symbol.iterator]() {
+    return this;
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,14 +12,15 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "^0.5.0",
-    "@bablr/agast-vm-helpers": "^0.5.0",
+    "@bablr/agast-helpers": "0.6.0",
+    "@bablr/agast-vm": "0.7.0",
+    "@bablr/agast-vm-helpers": "0.6.0",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "^0.20.0",
-    "@bablr/regex-vm": "^0.9.0",
+    "@bablr/helpers": "0.21.1",
+    "@bablr/regex-vm": "0.10.0",
     "@bablr/weak-stack": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0",
-    "iter-tools-es": "^7.5.3"
+    "iter-tools-es": "7.5.3"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#d834ccc52795d6c3b96ecc6c419960fceed221a6",