occam-furtle 2.0.120 → 2.0.122

package/src/dom/assignment/variable.js

@@ -5,10 +5,10 @@ import dom from "../../dom";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class VariableAssignment {
-  constructor(string, variable, value) {
+  constructor(string, variable, expression) {
     this.string = string;
     this.variable = variable;
-    this.value = value;
+    this.expression = expression;
   }
 
   getString() {
@@ -19,24 +19,24 @@ export default domAssigned(class VariableAssignment {
     return this.variable;
   }
 
-  getValue() {
-    return this.value;
+  getExpression() {
+    return this.expression;
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const variableAssignmentString = this.string; ///
 
     context.trace(`Evaluating the '${variableAssignmentString}' variable assignment...`);
 
-    value = this.value.evaluate(context);
+    expression = this.expression.evaluate(context);
 
-    this.variable.assign(value, context);
+    this.variable.assign(expression, context);
 
     context.debug(`...evaluated the '${variableAssignmentString}' variable assignment.`);
 
-    return value;
+    return expression;
   }
 
   static name = "VariableAssignment";
@@ -49,19 +49,19 @@ export default domAssigned(class VariableAssignment {
 });
 
 function variableAssignmentFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
-  const { Variable, Value, VariableAssignment } = dom,
-        value = Value.fromVariableAssignmentNode(variableAssignmentNode, context),
+  const { Variable, Expression, VariableAssignment } = dom,
+        expression = Expression.fromVariableAssignmentNode(variableAssignmentNode, context),
         variable = Variable.fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context),
-        string = stringFromValueAndVariable(value, variable, context),
-        assignment = new VariableAssignment(string, variable, value);
+        string = stringFromExpressionAndVariable(expression, variable, context),
+        assignment = new VariableAssignment(string, variable, expression);
 
   return assignment;
 }
 
-function stringFromValueAndVariable(value, variable, context) {
+function stringFromExpressionAndVariable(expression, variable, context) {
   const variableString = variable.getString(),
-        valueString = value.asString(context),
-        string = `${variableString} = ${valueString};`;
+        expressionString = expression.asString(context),
+        string = `${variableString} = ${expressionString};`;
 
   return string;
 }

package/src/dom/block/return.js

@@ -9,7 +9,7 @@ import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const stepNodesQuery = nodesQuery("/returnBlock/step"),
       nonsenseNodesQuery = nodesQuery("/returnBlock/nonsense"),
-      valueReturnBlockNodeQuery = nodeQuery("/value/returnBlock"),
+      expressionReturnBlockNodeQuery = nodeQuery("/expression/returnBlock"),
       anonymousProcedureReturnBlockNodeQuery = nodeQuery("/anonymousProcedure/returnBlock"),
       procedureDeclarationReturnBlockNodeQuery = nodeQuery("/procedureDeclaration/returnBlock");
 
@@ -59,20 +59,20 @@ export default domAssigned(class ReturnBlock {
       step.evaluate(context);
     });
 
-    const value = this.returnStatement.evaluate(context);
+    const expression = this.returnStatement.evaluate(context);
 
-    return value;
+    return expression;
   }
 
   static name = "ReturnBlock";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let returnBlock = null;
 
-    const valueReturnBlockNode = valueReturnBlockNodeQuery(valueNode);
+    const expressionReturnBlockNode = expressionReturnBlockNodeQuery(expressionNode);
 
-    if (valueReturnBlockNode !== null) {
-      const returnBlockNode = valueReturnBlockNode;  ///
+    if (expressionReturnBlockNode !== null) {
+      const returnBlockNode = expressionReturnBlockNode;  ///
 
       returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
     }

package/src/dom/comparison.js

@@ -8,16 +8,16 @@ import { domAssigned } from "../dom";
 import { EQUAL_TO, NOT_EQUAL_TO } from "../constants";
 
 const terminalNodeQuery = nodeQuery("/comparison/@*"),
-      leftValueNodeQuery = nodeQuery("/comparison/value[0]"),
-      rightValueNodeQuery = nodeQuery("/comparison/value[1]"),
-      valueComparisonNodeQuery = nodeQuery("/value/comparison");
+      leftExpressionNodeQuery = nodeQuery("/comparison/expression[0]"),
+      rightExpressionNodeQuery = nodeQuery("/comparison/expression[1]"),
+      expressionComparisonNodeQuery = nodeQuery("/expression/comparison");
 
 export default domAssigned(class Comparison {
-  constructor(string, negated, leftValue, rightValue) {
+  constructor(string, negated, leftExpression, rightExpression) {
     this.string = string;
     this.negated = negated;
-    this.leftValue = leftValue;
-    this.rightValue = rightValue;
+    this.leftExpression = leftExpression;
+    this.rightExpression = rightExpression;
   }
 
   getString() {
@@ -28,61 +28,61 @@ export default domAssigned(class Comparison {
     return this.negated;
   }
 
-  getLeftValue() {
-    return this.leftValue;
+  getLeftExpression() {
+    return this.leftExpression;
   }
 
-  getRightValue() {
-    return this.rightValue;
+  getRightExpression() {
+    return this.rightExpression;
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const comparisonString = this.string; ///
 
     context.trace(`Evaluating the '${comparisonString}' comparison...`);
 
-    const leftValue = this.leftValue.evaluate(context),
-          rightValue = this.rightValue.evaluate(context),
-          leftValueType = leftValue.getType(),
-          rightValueType = rightValue.getType();
+    const leftExpression = this.leftExpression.evaluate(context),
+          rightExpression = this.rightExpression.evaluate(context),
+          leftExpressionType = leftExpression.getType(),
+          rightExpressionType = rightExpression.getType();
 
-    if (leftValueType !== rightValueType) {
-      const leftValueString = leftValue.asString(context),
-            rightValueString = rightValue.asString(context),
-            message = `The ${leftValueString} left value's type is '${leftValueType}' whereas the ${rightValueString} right value's type is '${rightValueType}'.`,
+    if (leftExpressionType !== rightExpressionType) {
+      const leftExpressionString = leftExpression.asString(context),
+            rightExpressionString = rightExpression.asString(context),
+            message = `The ${leftExpressionString} left expression's type is '${leftExpressionType}' whereas the ${rightExpressionString} right expression's type is '${rightExpressionType}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    const leftValueEqualToRightValue = leftValue.isEqualTo(rightValue);
+    const leftExpressionEqualToRightExpression = leftExpression.isEqualTo(rightExpression);
 
-    let boolean = leftValueEqualToRightValue; ///
+    let boolean = leftExpressionEqualToRightExpression; ///
 
     if (this.negated) {
       boolean = !boolean; ///
     }
 
-    const { Value } = dom;
+    const { Expression } = dom;
 
-    value = Value.fromBoolean(boolean, context);
+    expression = Expression.fromBoolean(boolean, context);
 
     context.debug(`...evaluated the '${comparisonString}' comparison.`);
 
-    return value;
+    return expression;
   }
 
   static name = "Comparison";
 
-  static fromValueNode(valudNode, context) {
+  static fromExpressionNode(valudNode, context) {
     let comparison = null;
 
-    const valueComparisonNode = valueComparisonNodeQuery(valudNode);
+    const expressionComparisonNode = expressionComparisonNodeQuery(valudNode);
 
-    if (valueComparisonNode !== null) {
-      const comparisonNode = valueComparisonNode; ///
+    if (expressionComparisonNode !== null) {
+      const comparisonNode = expressionComparisonNode; ///
 
       comparison = comparisonFromComparisonNode(comparisonNode, context);
     }
@@ -100,25 +100,25 @@ function negatedFromComparisonNode(comparisonNode) {
 }
 
 function comparisonFromComparisonNode(comparisonNode, context) {
-  const { Value, Comparison } = dom,
-        leftValueNode = leftValueNodeQuery(comparisonNode),
-        rightValueNode = rightValueNodeQuery(comparisonNode),
-        rightValue = Value.fromValueNode(rightValueNode, context),
-        leftValue = Value.fromValueNode(leftValueNode, context),
+  const { Expression, Comparison } = dom,
+        leftExpressionNode = leftExpressionNodeQuery(comparisonNode),
+        rightExpressionNode = rightExpressionNodeQuery(comparisonNode),
+        rightExpression = Expression.fromExpressionNode(rightExpressionNode, context),
+        leftExpression = Expression.fromExpressionNode(leftExpressionNode, context),
         negated = negatedFromComparisonNode(comparisonNode, context),
-        string = stringFromNegatedLeftValueAndRightValue(negated, leftValue, rightValue, context),
-        comparison = new Comparison(string, negated, leftValue, rightValue);
+        string = stringFromNegatedLeftExpressionAndRightExpression(negated, leftExpression, rightExpression, context),
+        comparison = new Comparison(string, negated, leftExpression, rightExpression);
 
   return comparison;
 }
 
-function stringFromNegatedLeftValueAndRightValue(negated, leftValue, rightValue, context) {
+function stringFromNegatedLeftExpressionAndRightExpression(negated, leftExpression, rightExpression, context) {
   const operatorString = negated ?
                            EQUAL_TO :
                             NOT_EQUAL_TO,
-        leftValueString = leftValue.asString(context),
-        rightValueString = rightValue.asString(context),
-        string = `${leftValueString} ${operatorString} ${rightValueString}`;
+        leftExpressionString = leftExpression.asString(context),
+        rightExpressionString = rightExpression.asString(context),
+        string = `${leftExpressionString} ${operatorString} ${rightExpressionString}`;
 
   return string;
 }

package/src/dom/every.js

@@ -7,7 +7,7 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { NODES_TYPE, BOOLEAN_TYPE } from "../types";
 
-const valueEveryNodeQuery = nodeQuery("/value/every");
+const expressionEveryNodeQuery = nodeQuery("/expression/every");
 
 export default domAssigned(class Every {
   constructor(string, variable, anonymousProcedure) {
@@ -29,69 +29,69 @@ export default domAssigned(class Every {
   }
 
   evaluate(context) {
-    let value;
+    let expression;
 
     const everyString = this.getString();
 
     context.trace(`Evaluating the '${everyString}' every...`);
 
-    value = this.variable.evaluate(context);
+    expression = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const expressionType = expression.getType();
 
-    if (valueType !== NODES_TYPE) {
-      const valueString = value.asString(context),
-            message = `The ${valueString} value's '${valueType}' type should be '${NODES_TYPE}'.`,
+    if (expressionType !== NODES_TYPE) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} expression's '${expressionType}' type should be '${NODES_TYPE}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    const nodes = value.getNodes(),
+    const nodes = expression.getNodes(),
           boolean = nodes.every((node) => {
-            let value;
+            let expression;
 
-            const { Value, Values } = dom;
+            const { Expression, Expressions } = dom;
 
-            value = Value.fromNode(node, context);
+            expression = Expression.fromNode(node, context);
 
-            const values = Values.fromValue(value, context);
+            const expressions = Expressions.fromExpression(expression, context);
 
-            value = this.anonymousProcedure.call(values, context);
+            expression = this.anonymousProcedure.call(expressions, context);
 
-            const valueType = value.getType();
+            const expressionType = expression.getType();
 
-            if (valueType !== BOOLEAN_TYPE) {
-              const valueString = value.asString(context),
-                    message = `The ${valueString} value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            if (expressionType !== BOOLEAN_TYPE) {
+              const expressionString = expression.asString(context),
+                    message = `The ${expressionString} expression's type is '${expressionType}' when it should be of type '${BOOLEAN_TYPE}'.`,
                     exception = Exception.fromMessage(message);
 
               throw exception;
             }
 
-            const boolean = value.getBoolean();
+            const boolean = expression.getBoolean();
 
             return boolean;
           });
 
-    const { Value } = dom;
+    const { Expression } = dom;
 
-    value = Value.fromBoolean(boolean, context);
+    expression = Expression.fromBoolean(boolean, context);
 
     context.trace(`...evaluated the '${everyString}' every.`);
 
-    return value;
+    return expression;
   }
 
   static name = "Every";
 
-  static fromValueNode(valueNode, context) {
+  static fromExpressionNode(expressionNode, context) {
     let every = null;
 
-    const valueEveryNode = valueEveryNodeQuery(valueNode);
+    const expressionEveryNode = expressionEveryNodeQuery(expressionNode);
 
-    if (valueEveryNode !== null) {
-      const everyNode = valueEveryNode; ///
+    if (expressionEveryNode !== null) {
+      const everyNode = expressionEveryNode; ///
 
       every = everyFromEveryNode(everyNode, context);
     }

package/src/dom/expression/bitwise.js

@@ -0,0 +1,135 @@
+"use strict";
+
+import dom from "../../dom";
+import Exception from "../../exception";
+
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+import { BOOLEAN_TYPE } from "../../types";
+import { CONJUNCTION, DISJUNCTION } from "../../constants";
+
+const terminalNodeQuery = nodeQuery("/bitwiseExpression/@*"),
+      leftExpressionNodeQuery = nodeQuery("/bitwiseExpression/expression[0]"),
+      rightExpressionNodeQuery = nodeQuery("/bitwiseExpression/expression[1]"),
+      expressionBitwiseExpressionNodeQuery = nodeQuery("/expression/bitwiseExpression");
+
+export default domAssigned(class BitwiseExpression {
+  constructor(string, type, disjoint, leftExpression, rightExpression) {
+    this.string = string;
+    this.type = type;
+    this.disjoint = disjoint;
+    this.leftExpression = leftExpression;
+    this.rightExpression = rightExpression;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  isDisjoint() {
+    return this.disjoint;
+  }
+
+  getLeftExpression() {
+    return this.leftExpression;
+  }
+
+  getRightExpression() {
+    return this.rightExpression;
+  }
+
+  evaluate(context) {
+    let expression;
+
+    const bitwiseExpressionString = this.string; ///
+
+    context.trace(`Evaluating the '${bitwiseExpressionString}' bitwise expression...`);
+
+    const { Expression } = dom,
+          leftExpression = this.leftExpression.evaluate(context),
+          rightExpression = this.rightExpression.evaluate(context),
+          leftExpressionType = leftExpression.getType(),
+          rightExpressionType = rightExpression.getType();
+
+    if (leftExpressionType !== BOOLEAN_TYPE) {
+      const leftExpressionString = leftExpression.asString(context),
+            message = `The ${leftExpressionString} left expression's type is '${leftExpressionType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    if (rightExpressionType !== BOOLEAN_TYPE) {
+      const rightExpressionString = rightExpression.asString(context),
+            message = `The ${rightExpressionString} right expression's type is '${rightExpressionType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    const leftExpressionBoolean = leftExpression.getBoolean(),
+          rightExpressionBoolean = rightExpression.getBoolean(),
+          boolean = this.disjoint ?
+                      (leftExpressionBoolean || rightExpressionBoolean) :
+                        (leftExpressionBoolean && rightExpressionBoolean);
+
+    expression = Expression.fromBoolean(boolean, context);  ///
+
+    context.debug(`...evaluated the '${bitwiseExpressionString}' bitwise expression.`);
+
+    return expression;
+  }
+
+  static name = "BitwiseExpression";
+
+  static fromExpressionNode(expressionNode, context) {
+    let bitwiseExpression = null;
+
+    const expressionBitwiseExpressionNode = expressionBitwiseExpressionNodeQuery(expressionNode);
+
+    if (expressionBitwiseExpressionNode !== null) {
+      const bitwiseExpressionNode = expressionBitwiseExpressionNode; ///
+
+      bitwiseExpression = bitwiseExpressionFromBitwiseExpressionNode(bitwiseExpressionNode, context);
+    }
+
+    return bitwiseExpression;
+  }
+});
+
+function bitwiseExpressionFromBitwiseExpressionNode(bitwiseExpressionNode, context) {
+  const { Expression, BitwiseExpression } = dom,
+        leftExpressionNode = leftExpressionNodeQuery(bitwiseExpressionNode),
+        rightExpressionNode = rightExpressionNodeQuery(bitwiseExpressionNode),
+        type = BOOLEAN_TYPE,
+        disjoint = disjointFromBitwiseExpressionNode(bitwiseExpressionNode, context),
+        leftExpression = Expression.fromExpressionNode(leftExpressionNode, context),
+        rightExpression = Expression.fromExpressionNode(rightExpressionNode, context),
+        string = stringFromTypeDisjointLeftExpressionAndRightExpression(disjoint, leftExpression, rightExpression, context),
+        bitwiseExpression = new BitwiseExpression(string, type, disjoint, leftExpression, rightExpression);
+
+  return bitwiseExpression;
+}
+
+function disjointFromBitwiseExpressionNode(bitwiseExpressionNode, context) {
+  const terminalNode = terminalNodeQuery(bitwiseExpressionNode),
+        terminalNodeContent = terminalNode.getContent(),
+        disjoint = (terminalNodeContent === DISJUNCTION);
+
+  return disjoint;
+}
+
+function stringFromTypeDisjointLeftExpressionAndRightExpression(disjoint, leftExpression, rightExpression, context) {
+  const operatorString = disjoint ?
+                           DISJUNCTION :
+                             CONJUNCTION,
+        leftExpressionString = leftExpression.asString(context),
+        rightExpressionString = rightExpression.asString(context),
+        string = `${leftExpressionString} ${operatorString} ${rightExpressionString}`;
+
+  return string;
+}

package/src/dom/expression/bracketed.js

@@ -0,0 +1,73 @@
+"use strict";
+
+import dom from "../../dom";
+
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+
+const expressionNodeQuery = nodeQuery("/bracketedExpression/expression"),
+      expressionBracketedExpressionNodeQuery = nodeQuery("/expression/bracketedExpression");
+
+export default domAssigned(class BracketedExpression {
+  constructor(string, expression) {
+    this.string = string;
+    this.expression = expression;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getExpression() {
+    return this.expression;
+  }
+
+  getType() { return this.expression.getType(); }
+
+  evaluate(context) {
+    let expression;
+
+    const bracketedExpressionString = this.string; ///
+
+    context.trace(`Evaluating the '${bracketedExpressionString}' bracketed expression...`);
+
+    expression = this.expression.evaluate(context);
+
+    context.debug(`...evaluated the '${bracketedExpressionString}' bracketed expression.`);
+
+    return expression;
+  }
+
+  static name = "BracketedExpression";
+
+  static fromExpressionNode(expressionNode, context) {
+    let bracketedExpression = null;
+
+    const expressionBracketedExpressionNode = expressionBracketedExpressionNodeQuery(expressionNode);
+
+    if (expressionBracketedExpressionNode !== null) {
+      const bracketedExpressionNode = expressionBracketedExpressionNode; ///
+
+      bracketedExpression = bracketedExpressionFromBracketedExpressionNode(bracketedExpressionNode, context);
+    }
+
+    return bracketedExpression;
+  }
+});
+
+function bracketedExpressionFromBracketedExpressionNode(bracketedExpressionNode, context) {
+  const { Expression, BracketedExpression } = dom,
+        expressionNode = expressionNodeQuery(bracketedExpressionNode),
+        expression = Expression.fromExpressionNode(expressionNode, context),
+        string = stringFromExpression(expression, context),
+        bracketedExpression = new BracketedExpression(string, expression);
+
+  return bracketedExpression;
+}
+
+function stringFromExpression(expression, context) {
+  const expressionString = expression.asString(context),
+        string = `(${expressionString})`;
+
+  return string;
+}

package/src/dom/expression/negated.js

@@ -0,0 +1,97 @@
+"use strict";
+
+import dom from "../../dom";
+import Exception from "../../exception";
+
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+import { BOOLEAN_TYPE } from "../../types";
+
+const expressionNodeQuery = nodeQuery("/negatedExpression/expression"),
+      expressionNegatedExpressionNodeQuery = nodeQuery("/expression/negatedExpression");
+
+export default domAssigned(class NegatedExpression {
+  constructor(string, type, expression) {
+    this.string = string;
+    this.type = type;
+    this.expression = expression;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getExpression() {
+    return this.expression;
+  }
+
+  evaluate(context) {
+    let expression;
+
+    const negatedExpressionString = this.string; ///
+
+    context.trace(`Evaluating the '${negatedExpressionString}' negated expression...`);
+
+    expression = this.expression.evaluate(context);
+
+    const expressionType = expression.getType();
+
+    if (expressionType !== BOOLEAN_TYPE) {
+      const expressionString = expression.asString(context),
+            message = `The ${expressionString} left expression's type is '${expressionType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    let boolean = expression.getBoolean();
+
+    boolean = !boolean;
+
+    const { Expression } = dom;
+
+    expression = Expression.fromBoolean(boolean, context);  ///
+
+    context.debug(`...evaluated the '${negatedExpressionString}' negated expression.`);
+
+    return expression;
+  }
+
+  static name = "NegatedExpression";
+
+  static fromExpressionNode(expressionNode, context) {
+    let negatedExpression = null;
+
+    const expressionNegatedExpressionNode = expressionNegatedExpressionNodeQuery(expressionNode);
+
+    if (expressionNegatedExpressionNode !== null) {
+      const negatedExpressionNode = expressionNegatedExpressionNode; ///
+
+      negatedExpression = negatedExpressionFromNegatedExpressionNode(negatedExpressionNode, context);
+    }
+
+    return negatedExpression;
+  }
+});
+
+function negatedExpressionFromNegatedExpressionNode(negatedExpressionNode, context) {
+  const { Expression, NegatedExpression } = dom,
+        expressionNode = expressionNodeQuery(negatedExpressionNode),
+        expression = Expression.fromExpressionNode(expressionNode, context),
+        type = BOOLEAN_TYPE,
+        string = stringFromExpression(expression, context),
+        negatedExpression = new NegatedExpression(string, type, expression);
+
+  return negatedExpression;
+}
+
+function stringFromExpression(expression, context) {
+  const expressionString = expression.asString(context),
+        string = `!${expressionString}`;
+
+  return string;
+}