@bablr/bablr-vm 0.22.1 → 0.23.1

package/lib/state.js

@@ -1,141 +1,27 @@
-import { agast as createAgast, TagPathFacade as TagPath } from '@bablr/agast-vm';
 import emptyStack from '@iter-tools/imm-stack';
 import { WeakStackFrame } from '@bablr/weak-stack';
 import { getCooked, maybeWait } from '@bablr/agast-helpers/stream';
-import * as Tags from '@bablr/agast-helpers/tags';
+import * as BTree from '@bablr/agast-helpers/btree';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
-import {
-  Matcher,
-  Node,
-  Regex,
-  GapTag,
-  InitializerTag,
-  OpenNodeTag,
-  ReferenceTag,
-  ShiftTag,
-  Property,
-  BindingTag,
-  PropertyWrapper,
-} from '@bablr/agast-vm-helpers/symbols';
-import {
-  buildBindingTag,
-  buildChild,
-  buildInitializerTag,
-  buildNullNode,
-  buildProperty,
-  buildPropertyWrapper,
-  buildReferenceTag,
-  getOr,
-  multiFragmentFlags,
-} from '@bablr/agast-helpers/tree';
+import { Matcher, Node, Regex, ShiftTag } from '@bablr/agast-vm-helpers/symbols';
 import { match, guardWithPattern } from './utils/pattern.js';
-import { facades, actuals } from './facades.js';
-import { FragmentFacade } from './node.js';
-import { wrapperIsFull } from '@bablr/agast-helpers/path';
-
-const { freeze } = Object;
+import { getOpenTag } from '@bablr/agast-helpers/path';
 
 export const nodeStates = new WeakMap();
 
-export const StateFacade = class BABLRStateFacade {
-  constructor(state) {
-    facades.set(state, this);
-    freeze(this);
-  }
-
-  static from(source) {
-    return State.from(actuals.get(source));
-  }
-
-  get ctx() {
-    return actuals.get(this).context;
-  }
-
-  get span() {
-    return actuals.get(this).span.name;
-  }
-
-  get resultPath() {
-    return actuals.get(this).resultPath;
-  }
-
-  get result() {
-    return actuals.get(this).result;
-  }
-
-  get referenceTag() {
-    return actuals.get(this).referenceTag;
-  }
-
-  get referenceTagPath() {
-    return actuals.get(this).referenceTagPath;
-  }
-
-  get referencePath() {
-    return actuals.get(this).referencePath;
-  }
-
-  get holding() {
-    return actuals.get(this).holding;
-  }
-
-  get language() {
-    return actuals.get(this).language;
-  }
-
-  get depths() {
-    const { path, result, shift, nodeShift } = actuals.get(this).depths;
-    return { path, result, shift, nodeShift };
-  }
-
-  get held() {
-    const { held } = actuals.get(this);
-    return held && FragmentFacade.wrapNode(held.node, this.ctx);
-  }
-
-  get node() {
-    return FragmentFacade.wrapNode(actuals.get(this).node, this.ctx);
-  }
-
-  get parentNode() {
-    return FragmentFacade.wrapNode(actuals.get(this).parentNode, this.ctx);
-  }
-
-  get source() {
-    return facades.get(actuals.get(this).source);
-  }
-
-  get depth() {
-    return actuals.get(this).depth;
-  }
-
-  get status() {
-    return actuals.get(this).status;
-  }
-
-  get parent() {
-    return facades.get(actuals.get(this).parent);
-  }
-
-  nodeForPath(path) {
-    return actuals.get(this).nodeForPath(path);
-  }
-};
-
 export const State = class BABLRState extends WeakStackFrame {
   constructor(
     parent,
     source,
     context,
-    language,
+    languages,
     expressions = emptyStack,
     balanced = emptyStack,
-    spans = emptyStack.push({ name: 'Bare' }),
-    referenceTagPath = null,
+    spans = emptyStack,
     resultPath = null,
     depths = { path: -1, result: -1, emitted: -1, shift: 0, nodeShift: 0 },
     held = null,
-    agast = null,
+    node = null,
   ) {
     super(parent);
 
@@ -143,51 +29,29 @@ export const State = class BABLRState extends WeakStackFrame {
 
     this.source = source;
     this.context = context;
-    this.language = language;
+    this.languages = languages;
     this.expressions = expressions;
     this.balanced = balanced;
     this.spans = spans;
-    this.referenceTagPath = referenceTagPath;
     this.resultPath = resultPath;
     this.depths = depths;
     this.held = held;
-    this.agast = agast;
+    this.node = node;
 
     this.status = 'active';
-
-    this.emitted = null;
-
-    new StateFacade(this);
   }
 
   static from(source, context, language, expressions = []) {
     return State.create(
       source,
       context,
-      language,
+      BTree.fromValues([language]),
       emptyStack.push(...emptyStack.push(...expressions).valuesReverse()),
     );
   }
 
-  get node() {
-    return this.agast?.state.node;
-  }
-
-  get referencePath() {
-    let refPath = this.referenceTagPath;
-
-    if (!refPath) return null;
-
-    let { previousSibling } = refPath;
-    let isShift = previousSibling.tag.type === ShiftTag;
-
-    let referenceTagPath = previousSibling;
-
-    if (isShift) {
-      let refIndex = previousSibling.tagsIndex - 1 - previousSibling.tag.value.index * 3;
-      referenceTagPath = previousSibling.siblingAt(refIndex);
-    }
-    return referenceTagPath;
+  get language() {
+    return BTree.getAt(-1, this.languages);
   }
 
   get guardedSource() {
@@ -201,67 +65,70 @@ export const State = class BABLRState extends WeakStackFrame {
     return this.spans.value;
   }
 
-  get path() {
-    return this.agast?.state.path;
-  }
-
   get result() {
-    return this.resultPath.tag;
-  }
-
-  get parentNode() {
-    throw new Error('not implemented');
+    return this.resultPath?.tag;
   }
 
   get holding() {
     return !!this.held;
   }
 
-  get referenceTag() {
-    return this.referenceTagPath?.tag;
-  }
-
-  get isGap() {
-    return this.tag.type === GapTag;
-  }
-
   get speculative() {
     return !!this.parent;
   }
 
-  guardedMatch(pattern, attributes = {}) {
+  getPublic() {
+    let { languages, spans, depths, held, node, source, result, resultPath, status } = this;
+    return {
+      languages,
+      span: spans.value?.name,
+      depths: { ...depths },
+      holding: !!held,
+      held,
+      node,
+      atGap: source.atGap,
+      done: source.done,
+      sourceIndex: source.index,
+      result,
+      resultPath,
+      status,
+    };
+  }
+
+  guardedMatch(pattern) {
     let { span, source } = this;
     let { guard } = span;
 
+    let branchedSource = false;
     let pattern_ = pattern;
     if (pattern.type === Matcher) {
-      pattern_ = reifyExpression(pattern.value).nodeMatcher;
-    } else if (pattern.type === Regex || pattern.type === Node) {
-      pattern_ = pattern.value;
-    } else if (typeof pattern !== 'string') {
-      throw new Error();
-    }
-
-    if (span.type === 'Lexical' && attributes.balancer) {
-      // also check that the open node starts a lexical span?
-      guard = null;
-    }
-
-    if (pattern_?.literalValue) {
-      pattern_ = pattern_.literalValue || getCooked(pattern_.tags);
+      let { nodeMatcher } = reifyExpression(pattern.value);
 
-      if (pattern_.type === Symbol.for('String')) {
-        pattern_ = reifyExpression(pattern_);
+      if (nodeMatcher?.literalValue) {
+        pattern_ = nodeMatcher.literalValue; // || getCooked(pattern_.value.tags);
+      } else {
+        throw new Error();
       }
+    } else if (pattern.type === Node) {
+      if (!getOpenTag(pattern.value).value.flags.token) throw new Error();
+
+      pattern_ = reifyExpression(pattern.value);
+    } else if (pattern.type === Regex) {
+      pattern_ = pattern.value;
+    } else if (pattern.type !== Matcher && typeof pattern !== 'string') {
+      throw new Error();
     }
 
-    let guardedSource = guard && guardWithPattern(guard, source);
+    let guardedSource = guard ? guardWithPattern(guard, source) : source;
 
-    let result = match(pattern_, guardedSource || source);
+    let result = match(pattern_, guardedSource);
 
     return maybeWait(result, (result) => {
-      if (guardedSource && !guardedSource.done) {
-        guardedSource.return();
+      if (branchedSource) {
+        source.release();
+      }
+      if (guard && !guardedSource.done) {
+        return maybeWait(guardedSource.return(), () => result);
       }
       return result;
     });
@@ -274,63 +141,29 @@ export const State = class BABLRState extends WeakStackFrame {
   branch() {
     let baseState = this;
     let {
-      agast,
       source,
       context,
       balanced,
       spans,
       resultPath,
       depths,
-      referenceTagPath,
       held,
       node,
-      language,
+      languages,
       expressions,
     } = baseState;
 
-    let newAgast = createAgast(agast.options);
-
-    let fragRefTag = buildReferenceTag('_', null, false, multiFragmentFlags);
-
-    if (node.tags.openTag) newAgast.vm.next(node.tags.openTag);
-    if (node.tags.childrenNode) {
-      let property = buildProperty(fragRefTag.value, null, node.tags.childrenNode);
-      newAgast.vm.next(
-        buildChild(
-          PropertyWrapper,
-          buildPropertyWrapper(
-            [fragRefTag, buildBindingTag(), buildChild(Property, property)],
-            property,
-          ),
-        ),
-      );
-    }
-    if (node.tags.closeTag) newAgast.vm.next(node.tags.closeTag);
-
-    let newNode = newAgast.state.node;
-    let nodeState = nodeStates.get(node);
-    let newResultPath;
-
-    if (resultPath.path.node === node) {
-      newResultPath = TagPath.fromNode(newNode, resultPath.tagsIndex);
-    } else {
-      newResultPath = resultPath;
-    }
-
-    nodeStates.set(newNode, { ...nodeState });
-
     let child = this.push(
       source.branch(),
       context,
-      language,
+      languages,
       expressions,
       balanced,
       spans,
-      referenceTagPath,
-      newResultPath,
+      resultPath,
       { ...depths },
       held,
-      newAgast,
+      node,
     );
 
     return child;
@@ -347,40 +180,11 @@ export const State = class BABLRState extends WeakStackFrame {
       throw new Error('accepted the root state');
     }
 
-    if (parent.depths.path === accepted.depths.path) {
-      let parentChildren = parent.node.tags;
-
-      if (parent.node.type !== accepted.node.type) throw new Error();
-
-      let lastParentProp = parentChildren.at(-1);
-
-      let partialOffset =
-        lastParentProp.type === PropertyWrapper && !wrapperIsFull(lastParentProp) ? -1 : 0;
-
-      for (let i = parentChildren.size + partialOffset; i < accepted.node.tags.size; i++) {
-        let acceptedTag = accepted.node.tags.at(i);
-        let tag = parentChildren.at(i);
-
-        // let wrapperTag =
-
-        for (
-          let i = tag ? Tags.getSize(tag.value.tags) : 0;
-          i < Tags.getSize(acceptedTag.value.tags);
-          i++
-        ) {
-          let tag = Tags.getAt(i, acceptedTag.value.tags);
-
-          parent.agast.vm.next(tag);
-        }
-      }
-    }
-
     parent.spans = accepted.spans;
     parent.balanced = accepted.balanced;
-    parent.referenceTagPath = accepted.referenceTagPath;
     parent.held = accepted.held;
     parent.depths = accepted.depths;
-    parent.language = accepted.language;
+    parent.languages = accepted.languages;
     parent.expressions = accepted.expressions;
 
     if (parent.depths.result + 1 === accepted.depths.result) {
@@ -397,97 +201,15 @@ export const State = class BABLRState extends WeakStackFrame {
     return parent;
   }
 
-  reject(finishedMatch, options) {
-    let { bind = false } = options;
+  reject(finishedMatch) {
     let rejectedState = this;
 
-    let didBranch = finishedMatch.s !== finishedMatch.parent.state;
-    let abandon =
-      (!finishedMatch.isNode && !didBranch) ||
-      finishedMatch.cover ||
-      finishedMatch.effects.success === 'none';
     let shallower =
       finishedMatch.coveredBoundary.didShift &&
       finishedMatch.coveredBoundary.shiftMatch.state.depth === this.depth - 2
         ? finishedMatch.coveredBoundary.shiftMatch.state
         : this.parent;
 
-    if (!abandon && shallower) {
-      let parentChildren = shallower.node.tags;
-      let ourChildren = finishedMatch.fragmentNode.tags;
-      let refTag;
-
-      if (shallower.node.type) {
-        if (shallower.node.type !== rejectedState.node.type) throw new Error();
-
-        for (let i = parentChildren.size; i < ourChildren.size; i++) {
-          let tag = ourChildren.at(i);
-
-          if (tag.type === PropertyWrapper) {
-            for (let wrappedTag of tag.value.tags) {
-              if (wrappedTag.type === ReferenceTag) {
-                refTag = wrappedTag;
-              }
-
-              if ([InitializerTag, GapTag].includes(wrappedTag.type)) {
-                let previousSibling = ourChildren.at(i, 0);
-                let isShift = previousSibling.type === ShiftTag;
-
-                let referenceTag = previousSibling;
-
-                if (isShift) {
-                  let refIndex = i - 1 - previousSibling.value.index;
-                  referenceTag = ourChildren.at(refIndex, 0);
-                }
-
-                if (
-                  !['#', '@'].includes(referenceTag.value.type) &&
-                  !referenceTag.value.isArray &&
-                  getOr(0, referenceTag.value.name, shallower.node) === 0 &&
-                  refTag !== ShiftTag
-                ) {
-                  if (refTag !== ReferenceTag) {
-                    shallower.agast.vm.next(refTag);
-                  }
-
-                  if (bind || wrappedTag.type === GapTag) {
-                    shallower.agast.vm.next(
-                      buildChild(Property, buildProperty(refTag.value, null, buildNullNode())),
-                    );
-                  } else {
-                    shallower.agast.vm.next(wrappedTag);
-                  }
-                }
-                refTag = null;
-              }
-            }
-          }
-        }
-
-        if (refTag?.type === ReferenceTag) {
-          if (
-            refTag.value.name &&
-            !refTag.value.isArray &&
-            !shallower.node.properties.has(refTag.value.name)
-          ) {
-            if (bind) {
-              shallower.agast.vm.next(refTag);
-              shallower.agast.vm.next(
-                buildChild(Property, buildProperty(refTag.value, [], buildNullNode())),
-              );
-            } else {
-              if (!refTag.value.flags.expression) {
-                shallower.agast.vm.next(refTag);
-                shallower.agast.vm.next(buildInitializerTag(refTag.value.isArray));
-              }
-            }
-          }
-          shallower.referenceTagPath = null;
-          shallower.resultPath = TagPath.fromNode(shallower.node, -1);
-        }
-      }
-    }
-
     if (this.status === 'rejected') {
       return shallower;
     }

package/lib/utils/pattern.js

@@ -4,7 +4,7 @@ import { generateMatches } from '@bablr/regex-vm';
 import {
   getStreamIterator,
   maybeWait,
-  printType,
+  printName,
   StreamIterable,
 } from '@bablr/agast-helpers/stream';
 import * as Tags from '@bablr/agast-helpers/tags';
@@ -24,7 +24,7 @@ import {
   buildOpenNodeTag,
   tokenFlags,
 } from '@bablr/agast-helpers/builders';
-import { streamIteratorSymbol } from '@bablr/stream-iterator';
+import { streamIteratorSymbol, wait } from '@bablr/stream-iterator';
 
 function* __wrapSource(source) {
   let source_ = source.source || source;
@@ -36,16 +36,31 @@ function* __wrapSource(source) {
     yield '';
   }
   let iter = getStreamIterator(source);
-
-  let step = iter.next();
-  while (!step.done) {
-    yield step.value;
+  let step;
+  try {
     step = iter.next();
-  }
 
-  iter.return();
+    if (step instanceof Promise) {
+      step = yield wait(step);
+    }
+
+    while (!step.done) {
+      yield step.value;
+      step = iter.next();
+
+      if (step instanceof Promise) {
+        step = yield wait(step);
+      }
+    }
+
+    yield Symbol.for('EOS');
+  } finally {
+    step = iter.return();
 
-  yield Symbol.for('EOS');
+    if (step instanceof Promise) {
+      step = yield wait(step);
+    }
+  }
 }
 
 export const wrapSource = (source) => {
@@ -73,7 +88,7 @@ const buildFragmentRegex = (frag) => {
     buildAlternatives([
       buildAlternative(
         buildElements(
-          [...Tags.traverse(frag.tags)].flatMap((tag) => {
+          [...Tags.traverse(frag.value.tags)].flatMap((tag) => {
             if (tag.type === LiteralTag) {
               let str = tag.value;
               return [...str].map((chr) => buildToken('Character', chr));
@@ -110,25 +125,34 @@ const promiseCo = (gen) => {
 function* __stringEqual(str, iterable) {
   let strIter = str[Symbol.iterator]();
   let iter = getStreamIterator(iterable);
+  let step;
 
-  let strStep = strIter.next();
-  let step = iter.next();
+  try {
+    let strStep = strIter.next();
+    step = iter.next();
 
-  while (!strStep.done) {
-    if (step instanceof Promise) {
-      step = yield step;
-    }
+    while (!strStep.done) {
+      if (step instanceof Promise) {
+        step = yield wait(step);
+      }
 
-    if (step.value !== strStep.value) {
-      iter.return();
-      return false;
-    }
+      if (step.value !== strStep.value) {
+        step = iter.return();
+        if (step instanceof Promise) {
+          step = yield wait(step);
+        }
+        return false;
+      }
 
-    strStep = strIter.next();
-    step = iter.next();
+      strStep = strIter.next();
+      step = iter.next();
+    }
+  } finally {
+    step = iter.return();
+    if (step instanceof Promise) {
+      step = yield wait(step);
+    }
   }
-
-  iter.return();
   return true;
 }
 
@@ -148,13 +172,13 @@ export const match = (pattern, source) => {
   }
 
   const pattern_ =
-    pattern.type === null && pattern.flags.token
+    pattern.type === null && pattern.value.flags.token
       ? buildFragmentRegex(pattern)
       : isString(pattern)
       ? buildStringRegex(pattern)
       : pattern;
 
-  if (printType(pattern_.type) !== 'Pattern') throw new Error();
+  if (printName(pattern_.value.name) !== 'Pattern') throw new Error();
 
   assertValidRegex(pattern_);
 
@@ -163,9 +187,11 @@ export const match = (pattern, source) => {
   const step = iter.next();
 
   return maybeWait(step, (step) => {
+    if (!step.done && step.value.length > 1) throw new Error('capturing group');
     const result = step.done ? null : step.value[0];
-    iter.return();
-    return isEmpty(result) ? null : result;
+    return maybeWait(iter.return(), () => {
+      return isEmpty(result) ? null : result;
+    });
   });
 };
 
@@ -201,6 +227,10 @@ class GuardedIterator {
     this.source.release();
   }
 
+  release() {
+    this.source.release();
+  }
+
   [streamIteratorSymbol]() {
     return this;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,13 +12,13 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.9.0",
-    "@bablr/agast-vm": "0.10.0",
-    "@bablr/agast-vm-helpers": "0.9.0",
+    "@bablr/agast-helpers": "0.10.0",
+    "@bablr/agast-vm": "0.11.0",
+    "@bablr/agast-vm-helpers": "0.10.0",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "0.24.0",
-    "@bablr/regex-vm": "0.13.1",
-    "@bablr/stream-iterator": "1.0.0",
+    "@bablr/helpers": "0.25.0",
+    "@bablr/regex-vm": "0.14.0",
+    "@bablr/stream-iterator": "2.0.0",
     "@bablr/weak-stack": "1.0.1",
     "@iter-tools/imm-stack": "1.2.0",
     "iter-tools-es": "7.5.3"
@@ -32,7 +32,10 @@
     "iter-tools-es": "^7.3.1",
     "prettier": "^2.6.2"
   },
-  "repository": "github:bablr-lang/bablr-vm",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bablr-lang/bablr-vm.git"
+  },
   "homepage": "https://github.com/bablr-lang/bablr-vm",
   "license": "MIT"
 }