@bablr/bablr-vm 0.19.1 → 0.20.0

package/lib/state.js

@@ -3,26 +3,32 @@ import { WeakStackFrame } from '@bablr/weak-stack';
 import { getCooked } from '@bablr/agast-helpers/stream';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
 import {
+  CloseNodeTag,
   EmbeddedMatcher,
   EmbeddedNode,
   EmbeddedRegex,
   GapTag,
+  InitializerTag,
+  OpenNodeTag,
   ReferenceTag,
   ShiftTag,
-} from '@bablr/agast-helpers/symbols';
+} from '@bablr/agast-vm-helpers/symbols';
 import * as btree from '@bablr/agast-helpers/btree';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
 import {
-  buildCall,
-  buildEmbeddedRegex,
-  buildEmbeddedTag,
   buildGapTag,
+  buildInitializerTag,
+  buildNullNode,
   buildReferenceTag,
   buildStubNode,
 } from '@bablr/agast-helpers/tree';
-import { get, Path, PathResolver, TagPath, updatePath } from '@bablr/agast-helpers/path';
+import { getShifted, TagPath } from '@bablr/agast-helpers/path';
 import { match, guardWithPattern } from './utils/pattern.js';
 import { facades, actuals } from './facades.js';
 import { buildInternalState, FragmentFacade, internalStates } from './node.js';
+import { buildCall, buildEmbeddedTag } from '@bablr/agast-vm-helpers/builders';
+
+const { hasOwn } = Object;
 
 export const nodeStates = new WeakMap();
 
@@ -47,6 +53,10 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).resultPath;
   }
 
+  get result() {
+    return actuals.get(this).result;
+  }
+
   get reference() {
     return actuals.get(this).reference;
   }
@@ -55,6 +65,10 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).referencePath;
   }
 
+  get unshiftedReferencePath() {
+    return actuals.get(this).unshiftedReferencePath;
+  }
+
   get holding() {
     return actuals.get(this).holding;
   }
@@ -63,17 +77,26 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).path;
   }
 
+  get language() {
+    return actuals.get(this).language;
+  }
+
   get depths() {
     const { path, result } = actuals.get(this).depths;
     return { path, result };
   }
 
+  get held() {
+    const { held } = actuals.get(this);
+    return held && FragmentFacade.wrapNode(held, this.ctx);
+  }
+
   get node() {
-    return FragmentFacade.wrap(actuals.get(this).node, this.ctx);
+    return FragmentFacade.wrapNode(actuals.get(this).node, this.ctx);
   }
 
   get parentNode() {
-    return FragmentFacade.wrap(actuals.get(this).parentNode, this.ctx);
+    return FragmentFacade.wrapNode(actuals.get(this).parentNode, this.ctx);
   }
 
   get source() {
@@ -102,6 +125,7 @@ export const State = class BABLRState extends WeakStackFrame {
     parent,
     source,
     context,
+    language,
     expressions = emptyStack,
     balanced = emptyStack,
     spans = emptyStack.push({ name: 'Bare' }),
@@ -117,6 +141,7 @@ export const State = class BABLRState extends WeakStackFrame {
 
     this.source = source;
     this.context = context;
+    this.language = language;
     this.expressions = expressions;
     this.balanced = balanced;
     this.spans = spans;
@@ -133,12 +158,29 @@ export const State = class BABLRState extends WeakStackFrame {
     new StateFacade(this);
   }
 
-  static from(source, context, expressions = []) {
-    return State.create(source, context, emptyStack.push(...expressions));
+  static from(source, context, language, expressions = []) {
+    return State.create(source, context, language, emptyStack.push(...expressions));
   }
 
-  get unboundAttributes() {
-    return nodeStates.get(this.node).unboundAttributes;
+  get unshiftedReferencePath() {
+    let refPath = this.referencePath;
+
+    if (!refPath) return null;
+
+    let { previousSibling } = refPath;
+    let isShift = previousSibling.tag.type === ShiftTag;
+
+    let referencePath = previousSibling;
+
+    if (isShift) {
+      let refIndex = previousSibling.childrenIndex - 1 - previousSibling.tag.value.index * 2;
+      referencePath = previousSibling.siblingAt(refIndex);
+    }
+    return referencePath;
+  }
+
+  get undefinedAttributes() {
+    return nodeStates.get(this.node).undefinedAttributes;
   }
 
   get guardedSource() {
@@ -156,6 +198,10 @@ export const State = class BABLRState extends WeakStackFrame {
     throw new Error('not implemented');
   }
 
+  get result() {
+    return this.resultPath.tag;
+  }
+
   get parentNode() {
     throw new Error('not implemented');
   }
@@ -188,6 +234,9 @@ export const State = class BABLRState extends WeakStackFrame {
     instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
     agast.next();
 
+    if (tag.type === OpenNodeTag) this.depths.result++;
+    if (tag.type === CloseNodeTag) this.depths.result--;
+
     this.resultPath = TagPath.from(path, -1);
   }
 
@@ -198,30 +247,31 @@ export const State = class BABLRState extends WeakStackFrame {
     let pattern_ = pattern;
     if (pattern.type === EmbeddedMatcher) {
       pattern_ = reifyExpression(pattern.value).nodeMatcher;
-    } else if (pattern.type === EmbeddedRegex) {
+    } else if (pattern.type === EmbeddedRegex || pattern.type === EmbeddedNode) {
       pattern_ = pattern.value;
     } else if (typeof pattern !== 'string') {
       throw new Error();
     }
 
+    let openNode =
+      this.resultPath.tag.type === OpenNodeTag && this.resultPath.tag.value.flags.token
+        ? this.resultPath.node
+        : typeof pattern_ === 'string'
+        ? null
+        : pattern_;
+
     if (
       span.type === 'Lexical' &&
-      pattern.type === EmbeddedMatcher &&
-      (pattern_.flags.token
-        ? pattern_.attributes.balancer || pattern_.attributes.balanced
-        : pattern_.attributes?.balancer)
+      openNode &&
+      (openNode.flags.token
+        ? openNode.attributes.balancer || openNode.attributes.balanced
+        : openNode.attributes?.balancer)
     ) {
       // also check that the open node starts a lexical span?
       guard = null;
     }
 
     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);
 
       if (pattern_.type === Symbol.for('String')) {
@@ -248,31 +298,35 @@ export const State = class BABLRState extends WeakStackFrame {
       referencePath,
       held,
       node,
+      language,
       expressions,
     } = baseState;
 
-    let resolver = new PathResolver();
-
     const internalState = buildInternalState();
 
-    for (let tag of btree.traverse(node.children)) {
+    for (let tagPath = TagPath.fromNode(node, 0); tagPath; tagPath = tagPath.nextSibling) {
+      let { tag } = tagPath;
+
       if (tag.type === GapTag) {
-        let { name, isArray, flags } = resolver.reference.value;
+        let ref = tagPath.previousSibling.tag;
+        let firstRef =
+          ref.type === ShiftTag
+            ? tagPath.siblingAt(tagPath.childrenIndex - ref.value.index * 2 - 1)
+            : ref;
+        let { name, isArray, flags } = firstRef.value;
         const resolvedPath = buildReferenceTag(
           name,
           isArray,
           flags,
-          Number.isFinite(resolver.counters[name]) ? resolver.counters[name] : null,
+          isArray ? btree.getSize(internalState.path.node.properties[name]) : null,
         );
-        const expr = get(resolvedPath, node);
+        const expr = getShifted(ref.value.index || 0, 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();
     }
@@ -282,7 +336,7 @@ export const State = class BABLRState extends WeakStackFrame {
     let newResultPath;
 
     if (resultPath.path.node === node) {
-      newResultPath = TagPath.from(Path.from(newNode), resultPath.childrenIndex);
+      newResultPath = TagPath.fromNode(newNode, resultPath.childrenIndex);
     } else {
       newResultPath = resultPath;
     }
@@ -293,12 +347,13 @@ export const State = class BABLRState extends WeakStackFrame {
     const child = this.push(
       source.branch(),
       context,
+      language,
       expressions,
       balanced,
       spans,
       referencePath,
       newResultPath,
-      depths,
+      { ...depths },
       held,
       newNode,
     );
@@ -317,41 +372,45 @@ export const State = class BABLRState extends WeakStackFrame {
       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 (parent.node.type !== accepted.node.type) throw new Error();
+
+      for (
+        let i = sumtree.getSize(parentChildren);
+        i < sumtree.getSize(accepted.node.children);
+        i++
+      ) {
+        let tag = sumtree.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;
+          let previousSibling = sumtree.getAt(i - 1, accepted.node.children);
+          let isShift = previousSibling.type === ShiftTag;
+          let reference = previousSibling;
 
-          while (
-            (reference = btree.getAt(--referenceIdx, accepted.node.children)).type !== ReferenceTag
-          );
+          if (isShift) {
+            reference = sumtree.getAt(
+              i - 1 - previousSibling.value.index * 2,
+              accepted.node.children,
+            );
+          }
 
           let { name, isArray, flags } = reference.value;
           const resolvedPath = buildReferenceTag(
             name,
             isArray,
             flags,
-            isArray ? btree.getSum(parentPath.node.properties[name]) - (isShift ? 1 : 0) : null,
+            isArray ? btree.getSize(parentPath.node.properties[name]) - (isShift ? 1 : 0) : null,
+          );
+          const expr = getShifted(
+            isShift ? previousSibling.value.index : null,
+            resolvedPath,
+            accepted.node,
           );
-          const expr = get(resolvedPath, accepted.node);
           internalState.expressionsPump.queue(expr);
         } else if (tag.type === EmbeddedNode) {
           internalState.expressionsPump.queue(tag.value);
@@ -360,16 +419,23 @@ export const State = class BABLRState extends WeakStackFrame {
 
         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);
+    parent.spans = accepted.spans;
+    parent.balanced = accepted.balanced;
+    parent.referencePath = accepted.referencePath;
+    parent.held = accepted.held;
+    parent.depths = accepted.depths;
+    parent.language = accepted.language;
+    parent.expressions = accepted.expressions;
+
+    if (parent.depths.result + 1 === accepted.depths.result) {
+      parent.resultPath = parent.resultPath.siblingAt(accepted.resultPath.childrenIndex);
     } else {
       parent.resultPath = accepted.resultPath;
     }
+    if (!parent.resultPath) throw new Error();
 
     nodeStates.set(parent.node, nodeStates.get(accepted.node));
 
@@ -378,22 +444,101 @@ export const State = class BABLRState extends WeakStackFrame {
     return parent;
   }
 
-  reject() {
-    const rejectedState = this;
-    const { parent } = rejectedState;
+  reject(finishedMatch, options) {
+    let { bind = false } = options;
+    let rejectedState = this;
+
+    let didBranch = finishedMatch.s !== finishedMatch.parent.state;
+    let abandon =
+      (!finishedMatch.isNode && !didBranch) ||
+      finishedMatch.cover ||
+      finishedMatch.effects.success === 'none';
+    let shallower = finishedMatch.didShift ? finishedMatch.shiftMatch.state : this.parent;
+
+    if (shallower) {
+      let parentChildren = shallower.node.children;
+      let ourChildren = finishedMatch.fragmentNode.children;
+      let internalState = internalStates.get(shallower.node);
+
+      if (!abandon && shallower.node.type) {
+        if (shallower.node.type !== rejectedState.node.type) throw new Error();
+
+        for (let i = sumtree.getSize(parentChildren); i < sumtree.getSize(ourChildren); i++) {
+          let tag = sumtree.getAt(i, ourChildren);
+
+          if ([InitializerTag, GapTag].includes(tag.type)) {
+            let previousSibling = sumtree.getAt(i - 1, ourChildren);
+            let isShift = previousSibling.type === ShiftTag;
+
+            let reference = previousSibling;
+
+            if (isShift) {
+              let refIndex = i - 1 - previousSibling.value.index * 2;
+              reference = sumtree.getAt(refIndex, ourChildren);
+            }
+
+            let lastParentTag = TagPath.from(internalState.path, -1).tag.type;
+
+            if (
+              !['#', '@'].includes(reference.value.name) &&
+              !reference.value.isArray &&
+              !hasOwn(shallower.node.properties, reference.value.name) &&
+              lastParentTag !== ShiftTag
+            ) {
+              if (lastParentTag !== ReferenceTag) {
+                internalState.instructionsPump.queue(
+                  buildCall('advance', buildEmbeddedTag(reference)),
+                );
+                internalState.agast.next();
+              }
+              if (bind || tag.type === GapTag) {
+                internalState.expressionsPump.queue(buildNullNode());
+                internalState.instructionsPump.queue(
+                  buildCall('advance', buildEmbeddedTag(buildGapTag())),
+                );
+              } else {
+                internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
+              }
+              internalState.agast.next();
+            }
+          }
+        }
+
+        let lastParentTagPath = TagPath.fromNode(shallower.node, -1);
+        if (lastParentTagPath?.tag.type === ReferenceTag) {
+          let ref = lastParentTagPath?.tag;
+          if (bind) {
+            internalState.expressionsPump.queue(buildNullNode());
+            internalState.instructionsPump.queue(
+              buildCall('advance', buildEmbeddedTag(buildGapTag())),
+            );
+            internalState.agast.next();
+          } else {
+            if (!ref.value.flags.expression) {
+              internalState.instructionsPump.queue(
+                buildCall('advance', buildEmbeddedTag(buildInitializerTag(ref.value.isArray))),
+              );
+              internalState.agast.next();
+            }
+          }
+          shallower.referencePath = null;
+          shallower.resultPath = TagPath.fromNode(shallower.node, -1);
+        }
+      }
+    }
 
     if (this.status === 'rejected') {
-      return parent;
+      return shallower;
     }
 
     if (this.status !== 'active') throw new Error();
 
     this.status = 'rejected';
 
-    if (!parent) throw new Error('rejected root state');
+    if (!shallower) throw new Error('rejected root state');
 
     rejectedState.source.reject();
 
-    return parent;
+    return shallower;
   }
 };

package/lib/utils/pattern.js

@@ -2,15 +2,18 @@ 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, printType } from '@bablr/agast-helpers/stream';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
 import * as l from '@bablr/agast-vm-helpers/languages';
 import {
   buildAlternative,
   buildAlternatives,
   buildElements,
   buildPattern,
+  buildRegexGap,
   buildToken,
 } from '@bablr/helpers/builders';
-import { buildEmbeddedRegex } from '@bablr/agast-helpers/builders';
+import { buildEmbeddedRegex } from '@bablr/agast-vm-helpers/builders';
+import { GapTag, LiteralTag } from '@bablr/agast-helpers/symbols';
 
 export const assertValidRegex = (expr) => {
   const { flags } = expr;
@@ -30,8 +33,34 @@ const buildStringRegex = (str) => {
   );
 };
 
+const buildFragmentRegex = (frag) => {
+  return buildPattern(
+    buildAlternatives([
+      buildAlternative(
+        buildElements(
+          [...sumtree.traverse(frag.children)].flatMap((tag) => {
+            if (tag.type === LiteralTag) {
+              let str = tag.value;
+              return [...str].map((chr) => buildToken(l.Regex, 'Character', chr));
+            } else if (tag.type === GapTag) {
+              return [buildRegexGap()];
+            } else {
+              return [];
+            }
+          }),
+        ),
+      ),
+    ]),
+  );
+};
+
 export const match = (pattern, source) => {
-  const pattern_ = isString(pattern) ? buildStringRegex(pattern) : pattern;
+  const pattern_ =
+    pattern.type === null && pattern.flags.token
+      ? buildFragmentRegex(pattern)
+      : isString(pattern)
+      ? buildStringRegex(pattern)
+      : pattern;
 
   if (printType(pattern_.type) !== 'Pattern') throw new Error();
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,12 +12,12 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.6.1",
-    "@bablr/agast-vm": "0.7.1",
-    "@bablr/agast-vm-helpers": "0.6.1",
+    "@bablr/agast-helpers": "0.7.0",
+    "@bablr/agast-vm": "0.8.0",
+    "@bablr/agast-vm-helpers": "0.7.0",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "0.21.4",
-    "@bablr/regex-vm": "0.10.1",
+    "@bablr/helpers": "0.22.0",
+    "@bablr/regex-vm": "0.11.0",
     "@bablr/weak-stack": "1.0.0",
     "@iter-tools/imm-stack": "1.1.0",
     "iter-tools-es": "7.5.3"