occam-furtle 3.0.519 → 3.0.521

package/src/element/importBinding.js

@@ -5,6 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateImportBinding } from "../process/instantiate";
 import { labelFromJSON, labelToLabelJSON, referenceFromJSON, referenceToReferenceJSON } from "../utilities/json";
+import {instantiate} from "../utilities/context";
 
 export default define(class ImportBinding extends Element {
   constructor(context, string, node, breakPoint, label, reference) {
@@ -22,11 +23,33 @@ export default define(class ImportBinding extends Element {
     return this.reference;
   }
 
-  getProcedureName() {
+  getLabelledProcedureName() {
+    const labelName = this.label.getName(),
+          labelledProcedureName = labelName;  ///
+
+    return labelledProcedureName;
+  }
+
+  getReferencedProcedureName() {
     const referenceName = this.reference.getName(),
-          procedureName = referenceName;  ///
+          referencedProcedureName = referenceName;  ///
+
+    return referencedProcedureName;
+  }
 
-    return procedureName;
+  isAllowed() {
+    const labelledProcedureName = this.getLabelledProcedureName(),
+          referencedProcedureName = this.getReferencedProcedureName(),
+          aliased = (labelledProcedureName !== referencedProcedureName);
+
+    return aliased;
+  }
+
+  compareLablledProcedureName(labelledProcedureName) {
+    const labelName = this.label.getName(),
+          labelledProcedureNameCompares = (labelName === labelledProcedureName);
+
+    return labelledProcedureNameCompares;
   }
 
   verify(releaseName, context, forward, back) {
@@ -34,17 +57,73 @@ export default define(class ImportBinding extends Element {
 
     context.trace(`Verifying the '${importBindingString}' import binding...`);
 
-    const procedureName = this.getProcedureName(),
-          procedure = context.findProcedureByProcedureName(procedureName);
+    let procedureName,
+        procedurePresent;
+
+    const referencedProcedureName = this.getReferencedProcedureName();
 
-    if (procedure === null) {
+    procedureName = referencedProcedureName;  ///
+
+    procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
+
+    if (!procedurePresent) {
       context.trace(`The '${procedureName}' procedure is not present.`);
 
       return back();
     }
 
-    const releaseNameCompares = procedure.compareReleaseName(releaseName);
+    const labelledProcedureName = this.getLabelledProcedureName();
+
+    procedureName = labelledProcedureName;  ///
+
+    const aliased = this.isAllowed();
+
+    if (aliased) {
+      procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
+
+      if (procedurePresent) {
+        context.trace(`The '${procedureName}' procedure is already present.`);
+
+        return back();
+      }
+    }
+
+    const importBindingPresent = context.isImportBindingPresentByLabelledProcedureName(labelledProcedureName);
+
+    if (importBindingPresent) {
+      const labelString = this.label.getString();
+
+      context.trace(`The '${importBindingString}' import binding's '${labelString}' label is already present...`);
+
+      return back();
+    }
+
+    procedureName = referencedProcedureName;  ///
+
+    const procedure = context.findProcedureByProcedureName(procedureName),
+          releaseNameCompares = procedure.compareReleaseName(releaseName);
+
+    if (!releaseNameCompares) {
+      context.trace(`The '${procedureName}' procedure is not in the '${releaseName}' package.`);
+
+      return back();
+    }
+
+    const exported = procedure.isExported();
+
+    if (!exported) {
+      context.trace(`The '${procedureName}' procedure is not exported.`);
+
+      return back();
+    }
+
+    const importBinding = this;
+
+    context.addImportBinding(importBinding);
+
+    context.debug(`...verified the '${importBindingString}' import binding.`);
 
+    return forward(context, back);
   }
 
   toJSON() {
@@ -68,13 +147,18 @@ export default define(class ImportBinding extends Element {
   static name = "ImportBinding";
 
   static fromJSON(json, context) {
-    const { string } = json,
-          breakPoint = null,
-          importBindingNode = instantiateImportBinding(string, context),
-          label = labelFromJSON(json, context),
-          reference = referenceFromJSON(json, context),
-          node = importBindingNode, ///
-          importBinding = new ImportBinding(context, string, node, breakPoint, label, reference);
+    let importBinding;
+
+    instantiate((context) => {
+      const { string } = json,
+            breakPoint = null,
+            importBindingNode = instantiateImportBinding(string, context),
+            label = labelFromJSON(json, context),
+            reference = referenceFromJSON(json, context),
+            node = importBindingNode; ///
+
+      importBinding = new ImportBinding(context, string, node, breakPoint, label, reference);
+    }, context);
 
     return importBinding;
   }

package/src/element/importStatement.js

@@ -69,7 +69,9 @@ export default define(class ImportStatement extends Element {
   static name = "ImportStatement";
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
+    let importStatement;
+
+    instantiate((context) => {
       const { string } = json,
             importStatementNode = instantiateImportStatement(string, context),
             node = importStatementNode,  ///
@@ -79,9 +81,9 @@ export default define(class ImportStatement extends Element {
 
       context = null;
 
-      const importStatement = new ImportStatement(context, string, node, breakPoint, releaseName, importBindings);
-
-      return importStatement;
+      importStatement = new ImportStatement(context, string, node, breakPoint, releaseName, importBindings);
     }, context);
+
+    return importStatement;
   }
 });

package/src/element/label.js

@@ -39,7 +39,9 @@ export default define(class Label extends Element {
   static name = "Label";
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
+    let label;
+
+    instantiate((context) => {
       const { string } = json,
             labelNode = instantiateLabel(string, context),
             node = labelNode,  ///
@@ -48,9 +50,9 @@ export default define(class Label extends Element {
 
       context = null;
 
-      const label = new Label(context, string, node, breakPoint, name);
-
-      return label;
+      label = new Label(context, string, node, breakPoint, name);
     }, context);
+
+    return label;
   }
 });

package/src/element/parameters.js

@@ -84,7 +84,9 @@ export default define(class Parameters extends Element {
   static name = "Parameters";
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
+    let parameters;
+
+    instantiate((context) => {
       const { string } = json,
             parametersNode = instantiateParameters(string, context),
             node = parametersNode,  ///
@@ -94,9 +96,9 @@ export default define(class Parameters extends Element {
 
       context = null;
 
-      const parameters = new Parameters(context, string, node, breakPoint, array);
-
-      return parameters;
+      parameters = new Parameters(context, string, node, breakPoint, array);
     }, context);
+
+    return parameters;
   }
 });

package/src/element/procedureCall.js

@@ -31,16 +31,25 @@ export default define(class ProcedureCall extends Element {
     context.trace(`Evaluating the '${procedureCallString}' function call...`);
 
     const procedureName = this.getProcedureName(),
-          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
+          procedurePresent = context.isProcedurePresentByProcedureName(procedureName),
+          importedProcedurePresent = context.isImportedProcedurePresentByProcedureName(procedureName);
 
-    if (!procedurePresent) {
+    if (!procedurePresent && !importedProcedurePresent) {
       const message = `The '${procedureCallString}' function is not present.'`,
             exception = Exception.fromMessage(message);
 
       return back(exception);
     }
 
-    const procedure = context.findProcedureByProcedureName(procedureName);
+    let procedure;
+
+    if (!importedProcedurePresent) {
+      procedure = context.findProcedureByProcedureName(procedureName);
+    } else {
+      const importedProcedure = context.findImportedProcedureByProcedureName(procedureName);
+
+      procedure = importedProcedure;  ///
+    }
 
     return this.values.evaluate(context, (values, back) => {
       return free((context) => {

package/src/element/reference.js

@@ -39,7 +39,9 @@ export default define(class Reference extends Element {
   static name = "Reference";
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
+    let reference;
+
+    instantiate((context) => {
       const { string } = json,
             referencelNode = instantiateReference(string, context),
             node = referencelNode,  ///
@@ -48,9 +50,9 @@ export default define(class Reference extends Element {
 
       context = null;
 
-      const referencel = new Reference(context, string, node, breakPoint, name);
-
-      return referencel;
+      reference = new Reference(context, string, node, breakPoint, name);
     }, context);
+
+    return reference;
   }
 });

package/src/element/type.js

@@ -110,7 +110,9 @@ export default define(class Type extends Element {
   static name = "Type";
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
+    let type;
+
+    instantiate((context) => {
       const { string } = json,
             typeNode = instantiateType(string, context),
             node = typeNode,  ///
@@ -120,10 +122,10 @@ export default define(class Type extends Element {
 
       context = null;
 
-      const type = new Type(context, string, node, breakPoint, name, argumentType);
-
-      return type;
+      type = new Type(context, string, node, breakPoint, name, argumentType);
     }, context);
+
+    return type;
   }
 
   static fromTypeName(typeName, context) {

package/src/example/furtle/bnf.js

@@ -32,34 +32,6 @@ const bnf = `
     
 
 
-    importBindings          ::=  importBinding ( "," importBinding )* ;
-    
-    namedBindings           ::=  namedBinding ( "," namedBinding )* ;
-    
-    parameters              ::=  parameter ( "," parameter )* ;
-    
-    bindings                ::=  binding ( "," binding )* ;
-    
-    values                  ::=  value ( "," value )* ;
-    
-    terms                   ::=  term ( "," term )* ;
-    
-
-
-    importBinding           ::=  reference ( "as" label )? ;   
-    
-    namedBinding            ::=  type [name] ( "as" [name] )? ;   
-    
-    parameter               ::=  type [name] ;
-
-    binding                 ::=  type [name]
-    
-                              |  ε 
-                                  
-                              ;
-
-
-    
     procedureCall           ::=  reference<NO_WHITESPACE>"(" values? ")" ;
     
     returnBlock..           ::=  "{" ( statement | nonsense )* returnStatement "}" ;
@@ -71,6 +43,10 @@ const bnf = `
     every                   ::=  "every"<NO_WHITESPACE>"(" variable "," anonymousProcedure ")" ;
     
     some                    ::=  "some"<NO_WHITESPACE>"(" variable "," anonymousProcedure ")" ;
+
+    all                     ::=  "all"<NO_WHITESPACE>"(" variable "," referencesListLiteral ( "," values )? ")" ;
+    
+    exists                  ::=  "exists"<NO_WHITESPACE>"(" variable "," referencesListLiteral ( "," values )? ")" ;    
     
     
     
@@ -96,6 +72,40 @@ const bnf = `
     
     
     
+    referencesListLiteral   ::=  "[" references? "]" ;
+     
+     
+     
+    importBindings          ::=  importBinding ( "," importBinding )* ;
+    
+    namedBindings           ::=  namedBinding ( "," namedBinding )* ;
+    
+    parameters              ::=  parameter ( "," parameter )* ;
+    
+    references              ::=  reference ( "," reference )* ;
+    
+    bindings                ::=  binding ( "," binding )* ;
+    
+    values                  ::=  value ( "," value )* ;
+    
+    terms                   ::=  term ( "," term )* ;
+    
+
+
+    importBinding           ::=  reference ( "as" label )? ;   
+    
+    namedBinding            ::=  type [name] ( "as" [name] )? ;   
+    
+    parameter               ::=  type [name] ;
+
+    binding                 ::=  type [name]
+    
+                              |  ε 
+                                  
+                              ;
+
+
+    
     comparisonTerm          ::=  term ( "==" | "!=" ) term ; 
     
     bracketedTerm           ::=  "(" term ")" ; 
@@ -118,6 +128,10 @@ const bnf = `
     
                               |  some
                               
+                              |  all
+                              
+                              |  exists
+                              
                               |  nodesQuery
                               
                               |  nodeQuery
@@ -156,7 +170,7 @@ const bnf = `
 
 
     
-     type                   ::=  "List"<NO_WHITESPACE>"<" ( "Node" | "String" | "Boolean" | "Integer" ) ">"
+    type                    ::=  "List"<NO_WHITESPACE>"<" ( "Node" | "String" | "Boolean" | "Integer" ) ">"
      
                               |  "Node"  
      
@@ -192,7 +206,7 @@ const bnf = `
 
     reference.              ::=  [name] ;
     
-    variable                ::=  [name] ;
+    variable.               ::=  [name] ;
     
     label.                  ::=  [name] ;
     

package/src/example/furtle/entries.js

@@ -14,7 +14,7 @@ const entries = [
     "secondary-keyword": "^(?:as|if|else)"
   },
   {
-    "function-name": "^(?:nodeQuery|nodesQuery|reduce|every|some|lengthOf|toInteger|tryInteger|startsWith|endsWith|contains)"
+    "function-name": "^(?:nodeQuery|nodesQuery|reduce|every|some|lengthOf|toInteger|tryInteger|startsWith|endsWith|contains|all|exists)"
   },
   {
     "type": "^(?:List|Node|String|Boolean|Integer)"