@bablr/bablr-vm 0.23.8 → 0.23.10

package/lib/evaluate.js

@@ -3,7 +3,7 @@ import { Coroutine } from '@bablr/coroutine';
 import {
   buildAttributeDefinition,
   buildCloseNodeTag,
-  buildTypedSpan,
+  buildSpan,
   deepFreeze,
 } from '@bablr/agast-helpers/builders';
 import { getStreamIterator, printType, StreamIterable, wait } from '@bablr/agast-helpers/stream';
@@ -18,15 +18,36 @@ import {
   ShiftTag,
   AttributeDefinition,
 } from '@bablr/agast-helpers/symbols';
-import { getRoot, treeFromStreamSync } from '@bablr/agast-helpers/tree';
+import { treeFromStreamSync } from '@bablr/agast-helpers/tree';
 import * as Tags from '@bablr/agast-helpers/tags';
-import { getEmbeddedTag } from '@bablr/agast-vm-helpers/deembed';
+import { getEmbeddedRegex, getEmbeddedTag } from '@bablr/agast-vm-helpers/deembed';
 import { Match } from './match.js';
-import { buildWriteEffect } from '@bablr/agast-vm-helpers/builders';
-import { has } from '@bablr/agast-helpers/object';
+import { buildEmbeddedRegex, buildWriteEffect } from '@bablr/agast-vm-helpers/builders';
+import { has, isString } from '@bablr/agast-helpers/object';
 import { reifyBablrOptions } from '@bablr/agast-vm-helpers';
-import { buildNode, getTags } from '@bablr/agast-helpers/path';
+import { buildNode, getTags, list } from '@bablr/agast-helpers/path';
 import * as Spans from '@bablr/agast-helpers/spans';
+import {
+  buildAlternative,
+  buildAlternatives,
+  buildLiteralElements,
+  buildPattern,
+} from '@bablr/helpers/builders';
+
+let mergePatterns = (a, b) => {
+  if (a == null && b == null) return null;
+  if (a == null) return b;
+  if (b == null) return a;
+
+  let a_ = isString(a) ? [buildAlternative(buildLiteralElements(a))] : list('alternatives', a);
+  let b_ = isString(b) ? [buildAlternative(buildLiteralElements(b))] : list('alternatives', b);
+
+  return buildEmbeddedRegex(buildPattern(buildAlternatives([...a_, ...b_])));
+};
+
+let unwrapPattern = (pattern) => {
+  return isString(pattern) ? pattern : getEmbeddedRegex(pattern);
+};
 
 const getSourceLength = (tags) => {
   let i = 0;
@@ -67,7 +88,7 @@ function* __bablr(ctx, rootSource, rootLanguage, strategy, options, registerNode
     throw new Error('holdUndefinedAttributes not implemented');
   }
 
-  let co = new Coroutine(getStreamIterator(strategy(ctx.getPublic(), rootLanguage, getState)));
+  let co = new Coroutine(getStreamIterator(strategy(ctx.getPublic(), getState)));
 
   co.advance();
 
@@ -333,12 +354,23 @@ function* __bablr(ctx, rootSource, rootLanguage, strategy, options, registerNode
       case 'startSpan': {
         let { arguments: { 0: name, 1: guard = null, 2: { value: props } } = [] } = instr;
         deepFreeze(props);
-        s.spans = Spans.push(s.spans, buildTypedSpan('Instruction', name, guard, props));
+        s.spans = Spans.push(s.spans, buildSpan(name, guard, props));
+        break;
+      }
+
+      case 'startSubspan': {
+        let { arguments: { 0: name, 1: guard = null, 2: { value: props } } = [] } = instr;
+        deepFreeze(props);
+
+        let name_ = name == null ? s.span.name : `${s.span.name}:${name}`;
+        let guard_ = mergePatterns(unwrapPattern(guard), unwrapPattern(s.span.guard));
+        let props_ = deepFreeze({ ...s.span.props, ...props });
+
+        s.spans = Spans.push(s.spans, buildSpan(name_, guard_, props_));
         break;
       }
 
       case 'endSpan': {
-        if (s.span.type !== 'Instruction') throw new Error();
         s.spans = Spans.pop(s.spans);
         break;
       }

package/lib/facades.js

@@ -2,13 +2,15 @@ import * as Tags from '@bablr/agast-helpers/tags';
 import { buildGapTag, buildPropertyTag } from '@bablr/agast-helpers/builders';
 import { buildFacadeLayer } from '@bablr/agast-vm-helpers/facades';
 import { buildNode, getTags, isStubNode } from '@bablr/agast-helpers/path';
-import { Property } from '@bablr/agast-helpers/symbols';
+import { GapNode, Property } from '@bablr/agast-helpers/symbols';
 
 export const { facades, actuals } = buildFacadeLayer();
 
 let gapNodes = new WeakMap();
 
-export const getGapNode = (gap) => gapNodes.get(gap);
+export const getGapNode = (node) => {
+  return node.type === GapNode ? gapNodes.get(node) || node : node;
+};
 
 export const buildFacadeNode = (node) => {
   if (!node) return null;

package/lib/match.js

@@ -37,7 +37,6 @@ import {
   Path,
   TagPath,
 } from '@bablr/agast-helpers/path';
-import { updateSpans } from './spans.js';
 
 let facades = new WeakMap();
 
@@ -84,8 +83,6 @@ export class Match {
       ? parentMatch.startFrame(s, matcher, effects, isShift ? finishedMatch : null, options)
       : Match.from(ctx, s, matcher, null, options);
 
-    updateSpans(m, 'open');
-
     if (m.name && !getProduction(m.grammar, m.name))
       throw new Error(`Production {type: ${printType(m.name)}} does not exist`);
 
@@ -134,7 +131,7 @@ export class Match {
       normalizeBindingPath(matcher.bindingMatchers).length || !parent ? this : parent.languageMatch;
     this.agast = null;
     this.cover =
-      !parent?.isNode && parent?.cover && matcher.refMatcher?.type !== '#'
+      !shiftMatch && !parent?.isNode && parent?.cover && matcher.refMatcher?.type !== '#'
         ? parent.cover
         : isCover && parent
         ? this
@@ -376,8 +373,6 @@ export class Match {
 
     if (!m) return m;
 
-    updateSpans(finishedMatch, 'close');
-
     if (shouldBranch(finishedMatch.effects)) {
       if (finishedMatch.effects.success !== 'none') {
         s = s.accept();

package/lib/state.js

@@ -6,11 +6,14 @@ import { reifyExpression } from '@bablr/agast-vm-helpers';
 import { Matcher, Node, Regex } from '@bablr/agast-vm-helpers/symbols';
 import { match, guardWithPattern } from './utils/pattern.js';
 import { getOpenTag } from '@bablr/agast-helpers/path';
+import { buildSpan } from '@bablr/agast-helpers/builders';
+
+let { freeze } = Object;
 
 export const nodeStates = new WeakMap();
 
 export const State = class BABLRState {
-  static from(source, context, language, spans = Spans.fromValues([])) {
+  static from(source, context, language, spans = Spans.fromValues([buildSpan('Bare')])) {
     return new State(null, source, context, BTree.fromValues([language]), spans);
   }
 
@@ -88,19 +91,22 @@ export const State = class BABLRState {
   getPublic() {
     let { languages, spans, depths, held, node, source, result, resultPath, status } = this;
 
-    return Object.freeze({
+    return freeze({
       languages,
       span: Spans.getAt(-1, spans),
       spans: spans,
-      depths: Object.freeze({ ...depths }),
+      depths: freeze({ ...depths }),
       holding: !!held,
       held,
       node,
       atGap: source.atGap,
       done: source.done,
-      sourceIndex: source.index,
+      source: freeze({
+        index: source.index,
+        done: source.done,
+      }),
       result,
-      resultPath: resultPath?.frames || null,
+      resultPath: resultPath?.asPrimitive() || null,
       status,
     });
   }

package/lib/utils/pattern.js

@@ -131,11 +131,13 @@ function* __stringEqual(str, iterable) {
     let strStep = strIter.next();
     step = iter.next();
 
-    while (!strStep.done) {
+    while (true) {
       if (step instanceof Promise) {
         step = yield wait(step);
       }
 
+      if (strStep.done) break;
+
       if (step.value !== strStep.value) {
         step = iter.return();
         if (step instanceof Promise) {
@@ -166,9 +168,11 @@ export const match = (pattern, source) => {
       ? [buildOpenNodeTag(tokenFlags), buildLiteralTag(pattern), buildCloseNodeTag()]
       : null;
   } else if (typeof pattern === 'string') {
-    return stringEqual(pattern, source)
-      ? [buildOpenNodeTag(tokenFlags), buildLiteralTag(pattern), buildCloseNodeTag()]
-      : null;
+    return maybeWait(stringEqual(pattern, source), (equal) => {
+      return equal
+        ? [buildOpenNodeTag(tokenFlags), buildLiteralTag(pattern), buildCloseNodeTag()]
+        : null;
+    });
   }
 
   const pattern_ =
@@ -197,7 +201,7 @@ export const match = (pattern, source) => {
 
 class GuardedIterator {
   constructor(pattern, source) {
-    this.pattern = pattern;
+    this.pattern = typeof pattern === 'string' ? pattern : pattern.value;
     this.source = source.branch();
     this.done = false;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.23.8",
+  "version": "0.23.10",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,11 +12,11 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.10.4",
-    "@bablr/agast-vm": "0.11.4",
-    "@bablr/agast-vm-helpers": "0.10.4",
+    "@bablr/agast-helpers": "0.10.10",
+    "@bablr/agast-vm": "0.11.5",
+    "@bablr/agast-vm-helpers": "0.10.5",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "0.25.4",
+    "@bablr/helpers": "0.25.5",
     "@bablr/regex-vm": "0.14.2",
     "@bablr/stream-iterator": "2.0.0",
     "@iter-tools/imm-stack": "1.2.0",

package/lib/spans.js

@@ -1,38 +0,0 @@
-import { ReferenceTag } from '@bablr/agast-helpers/symbols';
-import * as Spans from '@bablr/agast-helpers/spans';
-import { buildTypedSpan } from '@bablr/agast-helpers/builders';
-
-const popSpan = (s) => {
-  s.spans = Spans.pop(s.spans);
-};
-
-const pushSpan = (s, type, name, guard) => {
-  s.spans = Spans.push(s.spans, buildTypedSpan(type, name, guard));
-};
-
-export function updateSpans(m, phase) {
-  const { state: s } = m;
-  const refPath = m.reference;
-
-  if (refPath && refPath.tag.type !== ReferenceTag) throw new Error();
-
-  switch (phase) {
-    case 'open': {
-      if (m.language !== m.parent?.language) {
-        pushSpan(s, 'Explicit', 'Bare', null);
-      }
-
-      break;
-    }
-
-    case 'close': {
-      if (m.language !== m.parent?.language) {
-        popSpan(s);
-      }
-
-      break;
-    }
-    default:
-      throw new Error();
-  }
-}