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);
}
