occam-furtle 2.0.73 → 2.0.75

package/src/dom/procedureCall/anonymous.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import dom from "../../dom";
+
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+
+const anonymousProcedureCallNodeQuery = nodeQuery("/value/anonymousProcedureCall");
+
+export default domAssigned(class AnonymousProcedureCall {
+  constructor(string, anonymousProcedure, values) {
+    this.string = string;
+    this.anonymousProcedure = anonymousProcedure;
+    this.values = values;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getAnonymousProcedure() {
+    return this.anonymousProcedure;
+  }
+
+  getValues() {
+    return this.values;
+  }
+
+  evaluate(context) {
+    const anonymousProcedureCallString = this.string;  ///
+
+    context.trace(`Evaluating the '${anonymousProcedureCallString}' anonymous procedure call...`);
+
+    const values = this.values.evaluate(context),
+          value = this.anonymousProcedure.call(values, context);
+
+    context.debug(`...evaluated the '${anonymousProcedureCallString}' anonymous procedure call.`);
+
+    return value;
+  }
+
+  static name = "AnonymousProcedureCall";
+
+  static fromValueNode(valueNode, context) {
+    let anonymousProcedureCall = null;
+
+    const anonymousProcedureCallNode = anonymousProcedureCallNodeQuery(valueNode);
+
+    if (anonymousProcedureCallNode !== null) {
+      const { Values, AnonymousProcedure } = dom,
+            node = anonymousProcedureCallNode, ///
+            string = context.nodeAsString(node),
+            anonymousProcedure = AnonymousProcedure.fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context),
+            values = Values.fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context);
+
+      anonymousProcedureCall = new AnonymousProcedureCall(string, anonymousProcedure, values);
+    }
+
+    return anonymousProcedureCall;
+  }
+});

package/src/dom/{returnStatement.js → statement/return.js}

@@ -1,9 +1,9 @@
 "use strict";
 
-import dom from "../dom";
+import dom from "../../dom";
 
-import { nodeQuery } from "../utilities/query";
-import { domAssigned } from "../dom";
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
 
 const returnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
 

package/src/dom/value.js

@@ -15,14 +15,14 @@ const { match } = arrayUtilities;
 const ternaryValueNodeQuery = nodeQuery("/ternary/value"),
       numberTerminalNodeQuery = nodeQuery("/value/@number"),
       conditionValueNodeQuery = nodeQuery("/condition/value"),
-      assignmentValueNodeQuery = nodeQuery("/assignment/value"),
       primitiveTerminalNodeQuery = nodeQuery("/value/@primitive"),
       returnStatementValueNodeQuery = nodeQuery("/returnStatement/value"),
       stringLiteralTerminalNodeQuery = nodeQuery("/value/@string-literal"),
-      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/value");
+      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/value"),
+      variableAssignmentValueNodeQuery = nodeQuery("/variableAssignment/value");
 
 export default domAssigned(class Value {
-  constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall) {
+  constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall) {
     this.node = node;
     this.nodes = nodes;
     this.number = number;
@@ -38,6 +38,7 @@ export default domAssigned(class Value {
     this.bitwiseValue = bitwiseValue;
     this.bracketedValue = bracketedValue;
     this.procedureCall = procedureCall;
+    this.anonymousProcedureCall = anonymousProcedureCall;
   }
 
   getNode() {
@@ -100,6 +101,10 @@ export default domAssigned(class Value {
     return this.procedureCall;
   }
 
+  getAnonymousProcedureCall() {
+    return this.anonymousProcedureCall;
+  }
+
   getType() {
     let type;
 
@@ -127,8 +132,16 @@ export default domAssigned(class Value {
       type = this.nodesQuery.getType();
     } else if (this.comparison !== null) {
       type = this.comparison.getType();
+    } else if (this.negatedValue !== null) {
+      type = this.negatedValue.getType();
+    } else if (this.bitwiseValue !== null) {
+      type = this.bitwiseValue.getType();
+    } else if (this.bracketedValue !== null) {
+      type = this.bracketedValue.getType();
     } else if (this.procedureCall !== null) {
       type = this.procedureCall.getType();
+    } else if (this.anonymousProcedureCall !== null) {
+      type = this.anonymousProcedureCall.getType();
     }
 
     return type;
@@ -161,8 +174,16 @@ export default domAssigned(class Value {
       string = this.nodesQuery.asString(context);
     } else if (this.comparison !== null) {
       string = this.comparison.asString(context);
+    } else if (this.negatedValue !== null) {
+      string = this.negatedValue.asString(context);
+    } else if (this.bitwiseValue !== null) {
+      string = this.bitwiseValue.asString(context);
+    } else if (this.bracketedValue !== null) {
+      string = this.bracketedValue.asString(context);
     } else if (this.procedureCall !== null) {
       string = this.procedureCall.asString(context);
+    } else if (this.anonymousProcedureCall !== null) {
+      string = this.anonymousProcedureCall.asString(context);
     }
 
     return string;
@@ -191,8 +212,16 @@ export default domAssigned(class Value {
       value = this.nodesQuery.evaluate(context);
     } else if (this.comparison !== null) {
       value = this.comparison.evaluate(context);
+    } else if (this.negatedValue !== null) {
+      value = this.negatedValue.evaluate(context);
+    } else if (this.bitwiseValue !== null) {
+      value = this.bitwiseValue.evaluate(context);
+    } else if (this.bracketedValue !== null) {
+      value = this.bracketedValue.evaluate(context);
     } else if (this.procedureCall !== null) {
       value = this.procedureCall.evaluate(context);
+    } else if (this.anonymousProcedureCall !== null) {
+      value = this.anonymousProcedureCall.evaluate(context);
     }
 
     return value;
@@ -267,7 +296,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -287,7 +317,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -307,7 +338,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -327,7 +359,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -360,20 +393,6 @@ export default domAssigned(class Value {
     return value;
   }
 
-  static fromAssignmentNode(assigmentNode, context) {
-    let value = null;
-
-    const assignmentValueNode = assignmentValueNodeQuery(assigmentNode);
-
-    if (assignmentValueNode !== null) {
-      const valueNode = assignmentValueNode;  ///
-
-      value = valueFromValueNode(valueNode, context);
-    }
-
-    return value;
-  }
-
   static fromReturnStatementNode(returnStatementNode, context) {
     let value = null;
 
@@ -395,6 +414,20 @@ export default domAssigned(class Value {
 
     return value;
   }
+
+  static fromVariableAssignmentNode(variableAssigmentNode, context) {
+    let value = null;
+
+    const variableAssignmentValueNode = variableAssignmentValueNodeQuery(variableAssigmentNode);
+
+    if (variableAssignmentValueNode !== null) {
+      const valueNode = variableAssignmentValueNode;  ///
+
+      value = valueFromValueNode(valueNode, context);
+    }
+
+    return value;
+  }
 });
 
 function matchNode(nodeA, nodeB) {
@@ -470,7 +503,7 @@ function booleanAsString(boolean, context) {
 }
 
 function valueFromValueNode(valueNode, context) {
-  const { Some, Value, Ternary, Variable, NodeQuery, NodesQuery, Comparison, NegatedValue, BitwiseValue, BracketedValue, ProcedureCall } = dom,
+  const { Some, Value, Ternary, Variable, NodeQuery, NodesQuery, Comparison, NegatedValue, BitwiseValue, BracketedValue, ProcedureCall, AnonymousProcedureCall } = dom,
         node = nodeFromValueNode(valueNode, context),
         nodes = nodesFromValueNode(valueNode, context),
         number = numberFromValueNode(valueNode, context),
@@ -486,7 +519,8 @@ function valueFromValueNode(valueNode, context) {
         bitwiseValue = BitwiseValue.fromValueNode(valueNode, context),
         bracketedValue = BracketedValue.fromValueNode(valueNode, context),
         procedureCall = ProcedureCall.fromValueNode(valueNode, context),
-        value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+        anonymousProcedureCall = AnonymousProcedureCall.fromValueNode(valueNode, context),
+        value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
   return value;
 }

package/src/dom/values.js

@@ -6,7 +6,8 @@ import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const valuesNodeQuery = nodeQuery("/value/procedureCall/values"),
-      valueNodesQuery = nodesQuery("/values/value");
+      valueNodesQuery = nodesQuery("/values/value"),
+      anonymousProcedureCallValuesNodeQuery = nodeQuery("/anonymousProcedureCall/values");
 
 export default domAssigned(class Values {
   constructor(string, array) {
@@ -97,6 +98,14 @@ export default domAssigned(class Values {
 
     return values;
   }
+
+  static fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context) {
+    const anonymousProcedureCallValuesNode = anonymousProcedureCallValuesNodeQuery(anonymousProcedureCallNode),
+          valuesNode = anonymousProcedureCallValuesNode,  ///
+          values = valuesFromValuesNode(valuesNode, context);
+
+    return values;
+  }
 });
 
 function arrayFromNodes(nodes, context) {

package/src/dom/variable.js

@@ -12,15 +12,15 @@ const someVariableNodeQuery = nodeQuery("/some/variable"),
       nodesQueryVariableNodeQuery = nodeQuery("/nodesQuery/variable"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
       arrayAssignmentVariableNodeQuery = nodeQuery("/arrayAssignment/variable"),
-      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable");
+      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable"),
+      variableAssignmentVariableNodeQuery = nodeQuery("/variableAssignment/variable");
 
 export default domAssigned(class Variable {
-  constructor(string, type, name, value, assignment) {
+  constructor(string, type, name, value) {
     this.string = string;
     this.type = type;
     this.name = name;
     this.value = value;
-    this.assignment = assignment;
   }
 
   getString() {
@@ -39,41 +39,37 @@ export default domAssigned(class Variable {
     return this.value;
   }
 
-  getAssignment() {
-    return this.assignment;
-  }
+  matchVariableName(variableName) {
+    const nameMatches = (this.name === variableName);
 
-  setString(string) {
-    this.string = string;
+    return nameMatches;
   }
 
-  setType(type) {
-    this.type = type;
-  }
+  evaluate(context) {
+    const variableString = this.string; ///
 
-  setName(name) {
-    this.name = name;
-  }
+    context.trace(`Evaluating the '${variableString}' variable...`);
 
-  setValue(value) {
-    this.value = value;
-  }
+    const variableName = this.name, ///
+          variablePresent = context.isVariablePresentByVariableName(variableName);
 
-  setAssignment(assignment) {
-    this.assignment = assignment;
-  }
+    if (!variablePresent) {
+      const message = `The '${variableString}; variable is not present.'`,
+            exception = Exception.fromMessage(message);
 
-  matchVariableName(variableName) {
-    const nameMatches = (this.name === variableName);
+      throw exception;
+    }
 
-    return nameMatches;
+    const variable = context.findVariableByVariableName(variableName),
+          value = variable.getValue(),
+          valueString = value.asString(context);
+
+    context.debug(`...evaluated the '${variableString}' variable to the ${valueString} value.`);
+
+    return value;
   }
 
   assign(context) {
-    if (this.assignment === null) {
-      return;
-    }
-
     const variableName = this.name, ///
           variableString = this.string, ///
           variablePresent = context.isVariablePresentByVariableName(variableName);
@@ -87,10 +83,9 @@ export default domAssigned(class Variable {
       throw exception;
     }
 
-    const value = this.assignment.evaluate(context),
-          variable = context.findVariableByVariableName(variableName),
+    const value = this.value.evaluate(context),
           valueType = value.getType(),
-          variableType = variable.getType();
+          variableType = this.type;
 
     if (valueType !== variableType) {
       const message = `The '${variableString} variable's '${variableType}' type does not match the assigned value's '${valueType}' type.'`,
@@ -99,37 +94,13 @@ export default domAssigned(class Variable {
       throw exception;
     }
 
-    variable.setValue(value);
+    this.value = value;
 
     const valueString = value.asString(context);
 
     context.debug(`...assigned the ${valueString} value to the '${variableString}' variable.`);
   }
 
-  evaluate(context) {
-    const variableString = this.string; ///
-
-    context.trace(`Evaluating the '${variableString}' variable...`);
-
-    const variableName = this.name, ///
-          variablePresent = context.isVariablePresentByVariableName(variableName);
-
-    if (!variablePresent) {
-      const message = `The '${variableString}; variable is not present.'`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
-    const variable = context.findVariableByVariableName(variableName),
-          value = variable.getValue(),
-          valueString = value.asString(context);
-
-    context.debug(`...evaluated the '${variableString}' variable to the ${valueString} value.`);
-
-    return value;
-  }
-
   static name = "Variable";
 
   static fromSomeNode(someLoopNode, context) {
@@ -174,8 +145,7 @@ export default domAssigned(class Variable {
     const type = parameter.getType(),
           name = parameter.getName(),
           string = name,  ///
-          assignment = null,
-          variable = new Variable(string, type, name, value, assignment);
+          variable = new Variable(string, type, name, value);
 
     return variable;
   }
@@ -185,8 +155,7 @@ export default domAssigned(class Variable {
           string = context.nodeAsString(node),
           name = nameFromVariableNode(variableNode),
           value = null,
-          assignment = null,
-          variable = new Variable(string, type, name, value, assignment);
+          variable = new Variable(string, type, name, value);
 
     return variable;
   }
@@ -207,37 +176,22 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromParameterAndAssignment(parameter, assignment, context) {
-    const type = parameter.getType(),
-          name = parameter.getName(),
-          value = null,
-          string = name,  ///
-          variable = new Variable(string, type, name, value, assignment);
-
-    return variable;
-  }
-
-  static fromNamedParameterAndAssignment(namedParameter, assignment, context) {
+  static fromValueAndNamedParameter(value, namedParameter, context) {
     const asName = namedParameter.getAsName(),
           name = (asName !== null) ?
                    asName : ///
-                    namedParameter.getName(),
+                     namedParameter.getName(),
           type = namedParameter.getType(),
-          value = null,
           string = name,  ///
-          variable = new Variable(string, type, name, value, assignment);
+          variable = new Variable(string, type, name, value);
 
     return variable;
   }
 
-  static fromTypeVariableNodeAndAssignmentNode(type, variableNode, assignmentNode, context) {
-    const { Assignment } = dom,
-          node = variableNode,  ///
-          string = context.nodeAsString(node),
-          name = nameFromVariableNode(variableNode),
-          value = null,
-          assignment = Assignment.fromAssignmentNode(assignmentNode, context),
-          variable = new Variable(string, type, name, value, assignment);
+  static fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
+    const variableAssignmentVariableNode = variableAssignmentVariableNodeQuery(variableAssignmentNode),
+          variableNode = variableAssignmentVariableNode,  ///
+          variable = variableFromVariableNode(variableNode, context);
 
     return variable;
   }
@@ -250,8 +204,7 @@ function variableFromVariableNode(variableNode, context) {
         type = null,
         name = nameFromVariableNode(variableNode),
         value = null,
-        assignment = null,
-        variable = new Variable(string, type, name, value, assignment);
+        variable = new Variable(string, type, name, value);
 
   return variable;
 }
@@ -263,3 +216,20 @@ function nameFromVariableNode(variableNode) {
 
   return name;
 }
+
+/*
+
+  static fromNamedParameterAndAssignment(namedParameter, assignment, context) {
+    const asName = namedParameter.getAsName(),
+          name = (asName !== null) ?
+                   asName : ///
+                    namedParameter.getName(),
+          type = namedParameter.getType(),
+          value = null,
+          string = name,  ///
+          variable = new Variable(string, type, name, value, assignment);
+
+    return variable;
+  }
+
+ */

package/src/index.js

@@ -16,7 +16,6 @@ import Parameter from "./dom/parameter";
 import Parameters from "./dom/parameters";
 import NodesQuery from "./dom/query/nodes";
 import Comparison from "./dom/comparison";
-import Assignment from "./dom/assignment";
 import ReturnBlock from "./dom/block/return";
 import NegatedValue from "./dom/value/negated";
 import BitwiseValue from "./dom/value/bitwise";
@@ -24,15 +23,16 @@ import ProcedureCall from "./dom/procedureCall";
 import NamedParameter from "./dom/parameter/named";
 import BracketedValue from "./dom/value/bracketed";
 import ArrayAssigment from "./dom/assignment/array";
-import ReturnStatement from "./dom/returnStatement";
+import ReturnStatement from "./dom/statement/return";
 import NamedParameters from "./dom/parameters/named";
 import ObjectAssignment from "./dom/assignment/object";
 import ConditionalBlocks from "./dom/conditionalBlocks";
 import AnonymousProcedure from "./dom/procedure/anonymous";
+import VariableAssignment from "./dom/assignment/variable";
+import VariableAssignments from "./dom/assignments/variable";
 import ProcedureDeclaration from "./dom/declaration/procedure";
-import VariablesDeclaration from "./dom/declaration/variables";
+import AnonymousProcedureCall from "./dom/procedureCall/anonymous";
 
 export { default as Values } from "./dom/values";
 export { default as FileContext } from "./context/file";
 export { default as stringUtilities } from "./utilities/string";
-