occam-parsers 22.0.62 → 22.0.64

package/src/node/nonTerminal.js

@@ -5,7 +5,7 @@ import { specialSymbols } from "occam-lexers";
 
 import NonTerminalNodeParseTree from "../parseTree/nonTerminalNode";
 
-const { first, match, forwardsSome, backwardsSome } = arrayUtilities,
+const { first, match, backwardsSome, forwardsSome } = arrayUtilities,
       { opaque : opaqueSpecialSymbol , semiOpaque: semiOpaqueSpecialSymbol } = specialSymbols;
 
 export default class NonTerminalNode {
@@ -118,6 +118,38 @@ export default class NonTerminalNode {
     return lowerPrecedence;
   }
 
+  getFirstSignificantTokenIndex(tokens) {
+    let firstSignificantTokenIndex;
+
+    forwardsSome(this.childNodes, (childNode) => {
+      const node = childNode;
+
+      firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens);
+
+      if (firstSignificantTokenIndex !== -1) {
+        return true;
+      }
+    });
+
+    return firstSignificantTokenIndex;
+  }
+
+  getLastSignificantTokenIndex(tokens) {
+    let lastSignificantTokenIndex;
+
+    backwardsSome(this.childNodes, (childNode) => {
+      const node = childNode;
+
+      lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens);
+
+      if (lastSignificantTokenIndex !== -1) {
+        return true;
+      }
+    });
+
+    return lastSignificantTokenIndex;
+  }
+
   isUnprecedented() {
     let unprecedented = false;
 

package/src/node/terminal/epsilon.js

@@ -8,12 +8,6 @@ import EpsilonNodeParseTree from "../../parseTree/epsilonNode";
 const { epsilon } = specialSymbols;
 
 export default class EpsilonNode extends TerminalNode {
-  isEpsilonNode() {
-    const epsilonNode = true;
-
-    return epsilonNode;
-  }
-
   getType() {
     const type = null;  ///
 
@@ -26,6 +20,12 @@ export default class EpsilonNode extends TerminalNode {
     return content;
   }
 
+  isEpsilonNode() {
+    const epsilonNode = true;
+
+    return epsilonNode;
+  }
+
   asParseTree(tokens) {
     const epsilonNodeParseTree = EpsilonNodeParseTree.fromNothing(),
           parseTree = epsilonNodeParseTree;  ///

package/src/node/terminal.js

@@ -69,6 +69,30 @@ export default class TerminalNode {
     return lowerPrecedence;
   }
 
+  getFirstSignificantTokenIndex(tokens) {
+    const significantTokenIndex = this.getSignificantTokenIndex(tokens),
+          firstSignificantTokenIndex = significantTokenIndex; ///
+
+    return firstSignificantTokenIndex;
+  }
+
+  getLastSignificantTokenIndex(tokens) {
+    const significantTokenIndex = this.getSignificantTokenIndex(tokens),
+          lastSignificantTokenIndex = significantTokenIndex; ///
+
+    return lastSignificantTokenIndex;
+  }
+
+  getSignificantTokenIndex(tokens) {
+    let significantTokenIndex = null;
+
+    if (this.significantToken !== null) {
+      significantTokenIndex = tokens.indexOf(this.significantToken);
+    }
+
+    return significantTokenIndex;
+  }
+
   isIncludedIn(node) {
     let includedIn = false;
 

package/src/parseTree/ruleName.js

@@ -4,7 +4,8 @@ import { characters} from "necessary";
 
 import VerticalBranchParseTree from "./verticalBranch";
 
-import { tokenLineIndexFromTokenAndTokens } from "../utilities/tokens";
+import { EMPTY_STRING } from "../constants";
+import { lineIndexFromTokenIndexAndTokens } from "../utilities/tokens";
 
 const { SPACE_CHARACTER } = characters;
 
@@ -12,13 +13,32 @@ export default class RuleNameParseTree extends VerticalBranchParseTree {
   static fromNonTerminalNodeAndTokens(nonTerminalNode, tokens) {
     const ruleName = nonTerminalNode.getRuleName(),
           opacity = nonTerminalNode.getOpacity(),
-          firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
-          lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
-          firstSignificantTokenLineIndex = tokenLineIndexFromTokenAndTokens(firstSignificantToken, tokens),
-          lastSignificantTokenLineIndex = tokenLineIndexFromTokenAndTokens(lastSignificantToken, tokens),
-          tokenLineIndexes = (firstSignificantTokenLineIndex !== lastSignificantTokenLineIndex) ?
-                              `${firstSignificantTokenLineIndex}-${lastSignificantTokenLineIndex}` :
-                                `${firstSignificantTokenLineIndex}`;
+          firstSignificantTokenIndex = nonTerminalNode.getFirstSignificantTokenIndex(tokens),
+          lastSignificantTokenIndex = nonTerminalNode.getLastSignificantTokenIndex(tokens),
+          firstLineIndex = lineIndexFromTokenIndexAndTokens(firstSignificantTokenIndex, tokens),
+          lastLineIndex = lineIndexFromTokenIndexAndTokens(lastSignificantTokenIndex, tokens);
+
+    let lineIndexes;
+
+    if (firstLineIndex === lastLineIndex) {
+      const lineIndex = firstLineIndex; ///
+
+      if (lineIndex === null) {
+        lineIndexes = EMPTY_STRING;
+      } else {
+        lineIndexes = ` [${lineIndex}]`;
+      }
+    } else {
+      if (false) {
+        ///
+      } else if (firstLineIndex === null) {
+        lineIndexes = ` [${lastLineIndex}]`;
+      } else if (lastLineIndex === null) {
+        lineIndexes = ` [${firstLineIndex}]`;
+      } else {
+        lineIndexes = ` [${firstLineIndex}-${lastLineIndex}]`
+      }
+    }
 
     let string = `${ruleName}`;
 
@@ -26,7 +46,7 @@ export default class RuleNameParseTree extends VerticalBranchParseTree {
       string = `${string}${opacity}`;
     }
 
-    string = `${string} [${tokenLineIndexes}]`;
+    string = `${string}${lineIndexes}`;
 
     let precedence = nonTerminalNode.getPrecedence();
 

package/src/parseTree/terminalNode.js

@@ -2,15 +2,25 @@
 
 import VerticalBranchParseTree from "./verticalBranch";
 
-import { tokenLineIndexFromTokenAndTokens } from "../utilities/tokens";
+import { EMPTY_STRING } from "../constants";
+import { lineIndexFromTokenIndexAndTokens } from "../utilities/tokens";
 
 export default class TerminalNodeParseTree extends VerticalBranchParseTree {
   static fromTerminalNodeAndTokens(terminalNode, tokens) {
-    const significantToken = terminalNode.getSignificantToken(),
+    const type = terminalNode.getType(),
           content = terminalNode.getContent(),
-          type = significantToken.getType(),
-          significantTokenLineIndex = tokenLineIndexFromTokenAndTokens(significantToken, tokens),
-          string = `"${content}"[${type}] [${significantTokenLineIndex}]`,
+          significantTokenIndex = terminalNode.getSignificantTokenIndex(tokens),
+          lineIndex = lineIndexFromTokenIndexAndTokens(significantTokenIndex, tokens);
+
+    let lineIndexes;
+
+    if (lineIndex === null) {
+      lineIndexes = EMPTY_STRING;
+    } else {
+      lineIndexes = ` [${lineIndex}]`;
+    }
+
+    const string = `"${content}"[${type}]${lineIndexes}`,
           stringLength = string.length,
           verticalBranchParseTreeWidth = stringLength, ///
           verticalBranchParseTree = VerticalBranchParseTree.fromWidth(verticalBranchParseTreeWidth),

package/src/state.js

@@ -119,7 +119,7 @@ export default class State {
 
       tokens = Class; ///
 
-      Class = State;
+      Class = State;  ///
     }
 
     const index = 0,

package/src/utilities/tokens.js

@@ -1,21 +1,24 @@
 "use strict";
 
-export function tokenLineIndexFromTokenAndTokens(token, tokens) {
-  let tokenLineIndex = 0;
+export function lineIndexFromTokenIndexAndTokens(tokenIndex, tokens) {
+  let lineIndex = null;
 
-  const tokenIndex = tokens.indexOf(token),
-        start = 0,
-        end = tokenIndex;
+  if (tokenIndex !== null) {
+    lineIndex = 0;
 
-  tokens = tokens.slice(start, end);  ///
+    const start = 0,
+          end = tokenIndex;
 
-  tokens.forEach((token) => {
-    const tokenEndOfLineToken = token.isEndOfLineToken();
+    tokens = tokens.slice(start, end);  ///
 
-    if (tokenEndOfLineToken) {
-      tokenLineIndex++;
-    }
-  });
+    tokens.forEach((token) => {
+      const tokenEndOfLineToken = token.isEndOfLineToken();
 
-  return tokenLineIndex;
+      if (tokenEndOfLineToken) {
+        lineIndex++;
+      }
+    });
+  }
+
+  return lineIndex;
 }