occam-furtle 2.0.297 → 2.0.301

package/src/node/assignments/variable.js

@@ -2,6 +2,37 @@
 
 import AssignmentsNode from "../../node/assignment";
 
+import { TYPE_TOKEN_TYPE } from "../../tokenTypes";
+import { VARIABLE_ASSIGNMENT_RULE_NAME } from "../../ruleNames";
+
 export default class VariableAssignmentsNode extends AssignmentsNode {
+  getType() {
+    let type = null;
+
+    this.someChildNode((childNode, index) => {
+      const terminalNode = childNode, ///
+            terminalNodeType = terminalNode.getType();
+
+      if (terminalNodeType === TYPE_TOKEN_TYPE) {
+        const content = terminalNode.getContent();
+
+        type = content;  ///
+      }
+
+      if (index === 0) {
+        return true;
+      }
+    });
+
+    return type;
+  }
+
+  getVariableAssignmentNodes() {
+    const ruleName = VARIABLE_ASSIGNMENT_RULE_NAME,
+          variableAssingnmentNodss = this.getNodesByRuleName(ruleName);
+
+    return variableAssingnmentNodss;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssignmentsNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableAssignmentsNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/step.js

@@ -2,6 +2,29 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
+import { ARRAY_ASSIGNMENT_RULE_NAME, OBJECT_ASSIGNMENT_RULE_NAME, VARIABLE_ASSIGNMENTS_RULE_NAME } from "../ruleNames"
+
 export default class StepNode extends NonTerminalNode {
+  getArrayAssignmentNode() {
+    const ruleName = ARRAY_ASSIGNMENT_RULE_NAME,
+          arrayAssignmentNode = this.getNodeByRuleName(ruleName);
+
+    return arrayAssignmentNode;
+  }
+
+  getObjectAssignmentNode() {
+    const ruleName = OBJECT_ASSIGNMENT_RULE_NAME,
+          objectAssignmentNode = this.getNodeByRuleName(ruleName);
+
+    return objectAssignmentNode;
+  }
+
+  getVariableAssignmentsNode() {
+    const ruleName = VARIABLE_ASSIGNMENTS_RULE_NAME,
+          variableAssignmentsNode = this.getNodeByRuleName(ruleName);
+
+    return variableAssignmentsNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/process/verify.js

@@ -4,6 +4,8 @@ import { nodeQuery } from "../utilities/query";
 
 import elements from "../elements";
 
+import { procedureDeclarationFromProcedureDeclarationNode } from "../utilities/element";
+
 const nonTerminalNodeQuery = nodeQuery("/*");
 
 const errorNodeQuery = nodeQuery("/error"),
@@ -128,8 +130,7 @@ class TopLevelPass extends Pass {
       run: (procedureDeclarationNode, context) => {
         let success = false;
 
-        const { ProcedureDeclaration } = elements,
-              procedureDeclaration = ProcedureDeclaration.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+        const procedureDeclaration = procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context),
               procedureDeclarationVerifies = procedureDeclaration.verify(context);
 
         if (procedureDeclarationVerifies) {

package/src/tokenTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export const TYPE_TOKEN_TYPE = "type";

package/src/utilities/element.js

@@ -0,0 +1,111 @@
+"use strict";
+
+import elements from "../elements";
+
+import { procedureDeclarationStringFromProcedure,
+         arrayAssignmentStringFromVariableAndParameters,
+         variableAssignmentStringFromExpressionAndVariable,
+         objectAssignmentStringFromVariableAndNamedParameters,
+         varaibleAssignmentsStringFromVariableAssignmentsArray } from "../utilities/string";
+
+export function arrayAssignmentFromArrayAssignmentNode(arrayAssignmentNode, context) {
+  const { Variable, Parameters, ArrayAssignment } = elements,
+        parameters = Parameters.fromArrayAssignmentNode(arrayAssignmentNode, context),
+        variable = Variable.fromArrayAssignmentNode(arrayAssignmentNode, context),
+        arrayAssignmentString = arrayAssignmentStringFromVariableAndParameters(variable, parameters),
+        string = arrayAssignmentString, ///
+        arrayAssignment = new ArrayAssignment(string, variable, parameters);
+
+  return arrayAssignment;
+}
+
+export function objectAssignmentFromObjectAssignmentNode(objectAssignmentNode, context) {
+  const { Variable, NamedParameters, ObjectAssigment } = elements,
+        namedParameters = NamedParameters.fromObjectAssignmentNode(objectAssignmentNode, context),
+        variable = Variable.fromObjectAssignmentNode(objectAssignmentNode, context),
+        objectAssignmentString = objectAssignmentStringFromVariableAndNamedParameters(variable, namedParameters, context),
+        string = objectAssignmentString,  ///
+        objectAssignment = new ObjectAssigment(string, variable, namedParameters);
+
+  return objectAssignment;
+}
+
+export function variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+  const { VariableAssignments } = elements,
+        variableAssignmentsArray = variableAssignmentsArrayFromVariableAssignmentsNode(variableAssignmentsNode, context),
+        variableAssignmentsString = varaibleAssignmentsStringFromVariableAssignmentsArray(variableAssignmentsArray, context),
+        string = variableAssignmentsString, ///
+        array = variableAssignmentsArray, ///
+        variableAssignments = new VariableAssignments(string, array);
+
+  return variableAssignments;
+}
+
+export function arrayAssignmentFromStepNode(stepNode, context) {
+  let arrayAssignment = null;
+
+  const arrayAssignmentNode = stepNode.getArrayAssignmentNode();
+
+  if (arrayAssignmentNode !== null) {
+    arrayAssignment = arrayAssignmentFromArrayAssignmentNode(arrayAssignmentNode, context);
+  }
+
+  return arrayAssignment;
+}
+
+export function objectAssignmentFromStepNode(stepNode, context) {
+  let objectAssignment = null;
+
+  const objectAssignmentNode = stepNode.getObjectAssignmentNode();
+
+  if (objectAssignmentNode !== null) {
+    objectAssignment = objectAssignmentFromObjectAssignmentNode(objectAssignmentNode, context);
+  }
+
+  return objectAssignment;
+}
+
+export function variableAssignmentsFromStepNode(stepNode, context) {
+  let variableAssignments = null;
+
+  const variableAssignmentsNode = stepNode.getVariableAssignmentsNode();
+
+  if (variableAssignmentsNode !== null) {
+    variableAssignments = variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context);
+  }
+
+  return variableAssignments;
+}
+
+export function procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+  const { Procedure, ProcedureDeclaration } = elements,
+        procedure = Procedure.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+        procedureDeclarationString = procedureDeclarationStringFromProcedure(procedure),
+        string = procedureDeclarationString,  ///
+        procedureDeclaration = new ProcedureDeclaration(string, procedure);
+
+  return procedureDeclaration;
+}
+
+export function variableAssignmentsArrayFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+  const type = variableAssignmentsNode.getType(),
+        variableAssignmentNodes = variableAssignmentsNode.getVariableAssignmentNodes(),
+        variableAssignmentsArray = variableAssignmentNodes.map((variableAssignmentNode) => {
+          const variableAssignment = variableAssignmentFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context);
+
+          return variableAssignment;
+        });
+
+  return variableAssignmentsArray;
+}
+
+export function variableAssignmentFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
+  const { Variable, Expression, VariableAssignment } = elements,
+        expression = Expression.fromVariableAssignmentNode(variableAssignmentNode, context),
+        variable = Variable.fromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context),
+        variableAssignmentString = variableAssignmentStringFromExpressionAndVariable(expression, variable, context),
+        string = variableAssignmentString,  ///
+        assignment = new VariableAssignment(string, variable, expression);
+
+  return assignment;
+}

package/src/utilities/string.js

@@ -0,0 +1,47 @@
+"use strict";
+
+export function procedureDeclarationStringFromProcedure(procedure) {
+  const procedureString = procedure.getString(),
+        procedureDeclarationString = `${procedureString};`;
+
+  return procedureDeclarationString;
+}
+
+export function arrayAssignmentStringFromVariableAndParameters(variable, parameters) {
+  const variableString = variable.getString(),
+        parametersString = parameters.getString(),
+        arrayAssignmentString = `[ ${parametersString} ] = ${variableString};`;
+
+  return arrayAssignmentString;
+}
+
+export function variableAssignmentStringFromExpressionAndVariable(expression, variable, context) {
+  const variableString = variable.getString(),
+        expressionString = expression.asString(context),
+        variableAssignmentString = `${variableString} = ${expressionString};`;
+
+  return variableAssignmentString;
+}
+
+export function objectAssignmentStringFromVariableAndNamedParameters(variable, namedParameters) {
+  const variableString = variable.getString(),
+        namedParametersString = namedParameters.getString(),
+        objectAssignmentString = `{ ${namedParametersString} } = ${variableString};`;
+
+  return objectAssignmentString;
+}
+
+export function varaibleAssignmentsStringFromVariableAssignmentsArray(variableAssignmentsArray) {
+  const variableAssignmentsString = variableAssignmentsArray.reduce((variableAssignmentsString, variableAssignment) => {
+          const variableAssignmentString = variableAssignment.getString();
+
+          variableAssignmentsString = (variableAssignmentsString === null) ?
+                                        variableAssignmentString :
+                                         `${variableAssignmentsString}, ${variableAssignmentString}`;
+
+          return variableAssignmentsString;
+        }, null),
+        string = variableAssignmentsString; ///
+
+  return string;
+}

package/test/Free and bound variables.ftl

@@ -3,7 +3,7 @@ Boolean isVariableFree(Node termNode, Node statementNode) {
 
   Boolean variableFree = !variableBound;
 
-  Return variableFree;
+  return variableFree;
 }
 
 Boolean isVariableBound(Node termNode, Node statementNode) {
@@ -11,14 +11,14 @@ Boolean isVariableBound(Node termNode, Node statementNode) {
 
   Boolean variableBound =
 
-    If (variableIdentitifer != "")
+    if (variableIdentitifer != "")
       variableBoundFromVariableIdentifierAndStatementNode(variableIdentitifer, statementNode)
 
-    Else
+    else
       false
   ;
 
-  Return variableBound;
+  return variableBound;
 }
 
 String variableIdentitiferFromTermNode(Node termNode) {
@@ -26,21 +26,21 @@ String variableIdentitiferFromTermNode(Node termNode) {
 
   String variableIdentitifer =
 
-    If (variableIdentifierTerminalNode != null) {
-      { String content As variableIdentitifer } = variableIdentifierTerminalNode;
+    if (variableIdentifierTerminalNode != null) {
+      { String content as variableIdentitifer } = variableIdentifierTerminalNode;
 
-      Return variableIdentitifer;
+      return variableIdentitifer;
     }
 
-    Else
+    else
       ""
   ;
 
-  Return variableIdentitifer;
+  return variableIdentitifer;
 }
 
 String boundVariableIdentifierFromStatementNode(Node statementNode) {
-  { Nodes childNodes As statementChildNodes } = statementNode;
+  { Nodes childNodes as statementChildNodes } = statementNode;
 
   [ Node firstStatementChildNode ] = statementChildNodes;
 
@@ -48,14 +48,14 @@ String boundVariableIdentifierFromStatementNode(Node statementNode) {
 
   String boundVariableIdentifier =
 
-    If (terminal)
+    if (terminal)
       boundVariableIdentifierFromStatementChildNodes(statementChildNodes)
 
-    Else
+    else
       ""
   ;
 
-  Return boundVariableIdentifier;
+  return boundVariableIdentifier;
 }
 
 String boundVariableIdentifierFromStatementChildNodes(Nodes statementChildNodes) {
@@ -65,18 +65,18 @@ String boundVariableIdentifierFromStatementChildNodes(Nodes statementChildNodes)
 
   String boundVariableIdentifier =
 
-    If ((content == "∀") || (content == "∃")) {
+    if ((content == "∀") || (content == "∃")) {
       [ _, Node argumentNode ] = statementChildNodes;
 
       String boundVariableIdentifier = boundVariableIdentifierFromArgumentNode(argumentNode);
 
-      Return boundVariableIdentifier;
+      return boundVariableIdentifier;
     }
-    Else
+    else
      ""
   ;
 
-  Return boundVariableIdentifier;
+  return boundVariableIdentifier;
 }
 
 String boundVariableIdentifierFromArgumentNode(Node argumentNode) {
@@ -84,29 +84,29 @@ String boundVariableIdentifierFromArgumentNode(Node argumentNode) {
 
   String boundVariableIdentifier =
 
-    If (boundVariableIdentityTerminalNode != null) {
-      { String content As boundVariableIdentifier } = boundVariableIdentityTerminalNode;
+    if (boundVariableIdentityTerminalNode != null) {
+      { String content as boundVariableIdentifier } = boundVariableIdentityTerminalNode;
 
-      Return boundVariableIdentifier;
+      return boundVariableIdentifier;
     }
 
-    Else
+    else
       ""
   ;
 
-  Return boundVariableIdentifier;
+  return boundVariableIdentifier;
 }
 
 Boolean variableBoundFromVariableIdentifierAndStatementNode(String variableIdentitifer, Node statementNode) {
   Nodes statementNodes = nodesQuery(statementNode, "//statement");
 
-  Boolean variableBound = Some(statementNodes, Boolean (Node statementNode) {
+  Boolean variableBound = some(statementNodes, Boolean (Node statementNode) {
     String boundVariableIdentifier = boundVariableIdentifierFromStatementNode(statementNode);
 
     Boolean variableBound = (boundVariableIdentifier == variableIdentitifer);
 
-    Return variableBound;
+    return variableBound;
   });
 
-  Return variableBound;
+  return variableBound;
 }