public NonLocalVariableDeclaration declareNonLocalVariable(String name, Functor1 <NonLocalVariableDeclaration, NonLocalVariableDeclaration> collisionAction) { if (outerScope == null) { if (nonLocalBindings == null) { nonLocalBindings = new Dictionary <String, NonLocalVariableDeclaration>(); } else { NonLocalVariableDeclaration existingDeclaration; if (nonLocalBindings.TryGetValue(name, out existingDeclaration)) { if (collisionAction != null) { return(collisionAction(existingDeclaration)); } } } // Collisions must be permitted because subclasses can override inherited instance variables, and instance variables can override namespace-resident variables. var declaration = new NonLocalVariableDeclaration(this, Context.symbolFor(name)); nonLocalBindings[name] = declaration; return(declaration); } else { return(outerScope.declareNonLocalVariable(name, collisionAction)); } }
public virtual bool compileMethod(BehavioralObject methodClass, Functor1 <bool, MethodDeclarationNode> compileMethodFromMethodDeclarationNode) { ParseTreeNode rootParseNode = parser.methodParseTree(); if (parser.ErrorCount > 0) { return(false); } switch (rootParseNode.ParseNodeType) { case ParseNodeType.MethodDeclaration: case ParseNodeType.PrimitiveMethodDeclaration: abstractSyntaxTreeGenerator = newASTGenerator(); var methodDeclarationNode = abstractSyntaxTreeGenerator.applyTo(rootParseNode) as MethodDeclarationNode; if (methodDeclarationNode == null) { return(false); } if (ErrorCount < 1 && !methodDeclarationNode.IsCompilable) { return(false); } return(compileMethodFromMethodDeclarationNode(methodDeclarationNode)); default: return(false); } }
public void localOccurrencesDo(Functor1 <NamedValueOccurrence> enumerator1) { foreach (var occurence in localOccurrences) { enumerator1(occurence); } }
public void allDeclarationsDo(Functor1 <NamedValueDeclaration> enumerator1) { localDeclarationsDo(enumerator1); if (nonLocalBindings != null) { foreach (var kvp in nonLocalBindings) { enumerator1(kvp.Value); } } if (instanceVariableBindings != null) { foreach (var kvp in instanceVariableBindings) { enumerator1(kvp.Value); } } if (namespaceResidentBindings != null) { foreach (var kvp in namespaceResidentBindings) { enumerator1(kvp.Value); } } if (outerScope != null) { outerScope.allDeclarationsDo(enumerator1); } }
public void localDeclarationsDo(Functor1 <NamedValueDeclaration> enumerator1) { foreach (var binding in localBindings) { enumerator1(binding.Value); } }
public StackResidentVariableDeclaration declareLocalVariable(String name, Functor1 <StackResidentVariableDeclaration, StackResidentDeclaration> collisionAction) { StackResidentDeclaration existingDeclaration; if (localBindings.TryGetValue(name, out existingDeclaration)) { if (collisionAction != null) { return(collisionAction(existingDeclaration)); } } // Collisions must be conditionally permitted in order to enable the compiler to find subsequent errors wnen the same parameter or variable is declared more than twice. var declaration = new StackResidentVariableDeclaration(this, Context.symbolFor(name)); localBindings[name] = declaration; localVariableDeclarations.Add(declaration); return(declaration); }
public InstanceVariableDeclaration declareInstanceVariable(String name, Functor1 <InstanceVariableDeclaration, InstanceVariableDeclaration> collisionAction) { if (instanceVariableBindings == null) { instanceVariableBindings = new Dictionary <String, InstanceVariableDeclaration>(); } else { InstanceVariableDeclaration existingDeclaration; if (instanceVariableBindings.TryGetValue(name, out existingDeclaration)) { if (collisionAction != null) { return(collisionAction(existingDeclaration)); } } } // Collisions must be permitted because subclasses can override inherited instance variables. var declaration = new InstanceVariableDeclaration(this, Context.symbolFor(name)); instanceVariableBindings[name] = declaration; return(declaration); }
public static void printOn(this String[] path, StringBuilder sb, String separatorString, Functor1 <String> transformer) { if (path == null) { return; } long size = path.Length; if (size < 1) { return; } long lastIndex = size - 1; String element; if (transformer == null) { for (var i = 0; i < lastIndex; i++) { element = path[i]; if (!String.IsNullOrEmpty(element)) { sb.Append(element); if (!String.IsNullOrEmpty(separatorString)) { sb.Append(separatorString); } } } element = path[lastIndex]; if (!String.IsNullOrEmpty(element)) { sb.Append(element); } } else { for (var i = 0; i < lastIndex; i++) { element = path[i]; if (!String.IsNullOrEmpty(element)) { sb.Append(transformer(element)); if (!String.IsNullOrEmpty(separatorString)) { sb.Append(separatorString); } } } element = path[lastIndex]; if (!String.IsNullOrEmpty(element)) { sb.Append(transformer(element)); } } }
public NamespaceResidentVariableDeclaration declareNamespaceVariable(NamespaceObject environment, ESSymbol name, Functor1 <NamespaceResidentVariableDeclaration, String> collisionAction) { if (namespaceResidentBindings == null) { namespaceResidentBindings = new Dictionary <String, NamespaceResidentVariableDeclaration>(); } else if (namespaceResidentBindings.ContainsKey(name)) { return(collisionAction(name)); } var declaration = new NamespaceResidentVariableDeclaration(environment, this, name); namespaceResidentBindings[name] = declaration; return(declaration); }
public ParameterDeclaration declareParameter(ParameterExpression rootParameter, Functor1 <ParameterDeclaration, NamedValueDeclaration> collisionAction) { StackResidentDeclaration existingDeclaration; if (localBindings.TryGetValue(rootParameter.Name, out existingDeclaration)) { if (collisionAction != null) { return(collisionAction(existingDeclaration)); } } // Collisions must be conditionally permitted in order to enable the compiler to find subsequent errors wnen the same parameter or variable is declared more than twice. var declaration = new ParameterDeclaration(this, rootParameter); localBindings[rootParameter.Name] = declaration; parameterDeclarations.Add(declaration); return(declaration); }