occam-languages 3.0.4 → 3.0.8

package/src/pass/continuationZip.js

@@ -5,94 +5,69 @@ import { nonTerminalNodeQuery, areChildNodesCongruent } from "../utilities/pass"
 
 export default class ContinuationZipPass {
   run(generalNode, specificNode, ...remainingArguments) {
-    const continuation = remainingArguments.pop();
+    const forward = remainingArguments.pop(),
+          back = remainingArguments.pop();
 
-    return this.visitNode(generalNode, specificNode, ...remainingArguments, continuation);
+    return this.visitNode(generalNode, specificNode, ...remainingArguments, back, forward);
   }
 
   descend(generalChildNodes, specificChildNodes, ...remainingArguments) {
-    const continuation = remainingArguments.pop(),
+    const forward = remainingArguments.pop(),
+          back = remainingArguments.pop(),
           childNodesCongruent = areChildNodesCongruent(generalChildNodes, specificChildNodes);
 
     if (!childNodesCongruent) {
-      const descended = false;
-
-      return continuation(descended, ...remainingArguments);
+      return back();
     }
 
     return match(generalChildNodes, specificChildNodes, (generalChildNode, specificChildNode, ...remainingArguments) => {
-      const continuation = remainingArguments.pop(),
+      const forward = remainingArguments.pop(),
+            back = remainingArguments.pop(),
             generalNode = generalChildNode, ///
             specificNode = specificChildNode; ///
 
-      return this.visitNode(generalNode, specificNode, ...remainingArguments, continuation);
-    }, ...remainingArguments, continuation);
+      return this.visitNode(generalNode, specificNode, ...remainingArguments, back, forward);
+    }, ...remainingArguments, back, forward);
   }
 
   visitNode(generalNode, specificNode, ...remainingArguments) {
-    const continuation = remainingArguments.pop(),
+    const forward = remainingArguments.pop(),
+          back = remainingArguments.pop(),
           generalNodeTerminalNode = generalNode.isTerminalNode(),
           specificNodeTerminalNode = specificNode.isTerminalNode(),
           generalNodeNonTerminalNode = generalNode.isNonTerminalNode(),
           specificNodeNonTerminalNode = specificNode.isNonTerminalNode();
-    
+
     if (generalNodeTerminalNode && specificNodeTerminalNode) {
       const generalTerminalNode = generalNode,  ///
             specificTerminalNode = specificNode;  ///
 
-      return this.visitTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments, continuation);
+      return this.visitTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments, back, forward);
     }
 
     if (generalNodeNonTerminalNode && specificNodeNonTerminalNode) {
       const generalNonTerminalNode = generalNode,  ///
-            specificNonTerminalNode = specificNode; ///
+        specificNonTerminalNode = specificNode; ///
 
-      return this.visitNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments, continuation);
+      return this.visitNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments, back, forward);
     }
 
-    const visited = false;
-
-    return continuation(visited, ...remainingArguments);
+    return back();
   }
 
   visitTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments) { ///
-    const visited = true,
-          continuation = remainingArguments.pop();
+    const forward = remainingArguments.pop(),
+          back = remainingArguments.pop();
 
-    return continuation(visited, ...remainingArguments);
+    return forward(...remainingArguments);
   }
 
   visitNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) {
-    const continuation = remainingArguments.pop();
+    const forward = remainingArguments.pop(),
+          back = remainingArguments.pop();
 
     let { maps } = this.constructor;
 
-    maps = [ ///
-      ...maps,
-      {
-        generalNodeQuery: nonTerminalNodeQuery,
-        specificNodeQuery: nonTerminalNodeQuery,
-        run: (generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) => {
-          const continuation = remainingArguments.pop(),
-                generalNonTerminalNodeRuleName = generalNonTerminalNode.getRuleName(), ///
-                specificNonTerminalNodeRuleName = specificNonTerminalNode.getRuleName(); ///
-
-          if (generalNonTerminalNodeRuleName !== specificNonTerminalNodeRuleName) {
-            const visited = false;
-
-            return continuation(visited, ...remainingArguments);
-          }
-
-          const generalNonTerminalNodeChildNodes = generalNonTerminalNode.getChildNodes(),
-                specificNonTerminalNodeChildNodes = specificNonTerminalNode.getChildNodes(),
-                generalChildNodes = generalNonTerminalNodeChildNodes, ///
-                specificChildNodes = specificNonTerminalNodeChildNodes; ///
-
-          return this.descend(generalChildNodes, specificChildNodes, ...remainingArguments, continuation);
-        }
-      }
-    ];
-
     let generalNode,
         specificNode;
 
@@ -107,14 +82,32 @@ export default class ContinuationZipPass {
       }
     }) || null;
 
-    if (map === null) {
-      const visited = false;
+    if (map !== null) {
+      const { run } = map;
+
+      return run(generalNode, specificNode, ...remainingArguments, back, forward);
+    }
+
+    generalNode = generalNonTerminalNode; ///
+    specificNode = specificNonTerminalNode; ///
+
+    generalNonTerminalNode = nonTerminalNodeQuery(generalNode);
+    specificNonTerminalNode = nonTerminalNodeQuery(specificNode);
+
+    if ((generalNonTerminalNode === null) || (specificNonTerminalNode === null)) {
+      return back();
+    }
+
+    const generalNonTerminalNodeRuleName = generalNonTerminalNode.getRuleName(), ///
+          specificNonTerminalNodeRuleName = specificNonTerminalNode.getRuleName(); ///
 
-      return continuation(visited, ...remainingArguments);
+    if (generalNonTerminalNodeRuleName !== specificNonTerminalNodeRuleName) {
+      return back();
     }
 
-    const { run } = map;
+    const generalChildNodes = generalNonTerminalNode.getChildNodes(), ///
+          specificChildNodes = specificNonTerminalNode.getChildNodes(); ///
 
-    return run(generalNode, specificNode, ...remainingArguments, continuation);
+    return this.descend(generalChildNodes, specificChildNodes, ...remainingArguments, back, forward);
   }
-}
+}

package/src/utilities/breakPoint.js

@@ -4,12 +4,13 @@ import BreakPoint from "../breakPoint";
 
 export function breakable(innerFunction) {
   return function(...remainingArguments) {
-    const continuation = remainingArguments.pop(),
+    const forward = remainingArguments.pop(),
+          back = remainingArguments.pop(),
           context = remainingArguments.pop();
 
-    return this.break(context, () => {
+    return this.break(context, back, () => {
       setImmediate(() => {
-        return innerFunction.call(this, ...remainingArguments, context, continuation);
+        return innerFunction.call(this, ...remainingArguments, context, back, forward);
       });
     });
   };