public NamespaceFactory(ESObjectSpace objectSpace, NamespaceObject baseEnvironment, ESSymbol name, IDictionary <String, List <ESCompilationError> > compilationErrors)
{
this.objectSpace = objectSpace;
this.baseEnvironment = baseEnvironment;
this.name = name;
this.compilationErrors = compilationErrors;
}
public static bool load(ESObjectSpace objectSpace, NamespaceObject baseEnvironment, DirectoryInfo baseDirectory, bool beVerbose, bool recurseIntoNestedNamespaces, out List <NamespaceObject> rootNamespaces)
{
var libraryLoader = new ESLibraryLoader(objectSpace, baseEnvironment, baseDirectory, recurseIntoNestedNamespaces);
libraryLoader.IsVerbose = beVerbose;
return(libraryLoader.load(out rootNamespaces));
}
public ESScriptCode(SourceUnit sourceUnit, ESObjectSpace objectSpace, ESCompilerOptions esCompilerOptions, ErrorSink errorSink) : base(sourceUnit)
{
this.sourceUnit = sourceUnit;
this.objectSpace = objectSpace;
this.esCompilerOptions = esCompilerOptions;
this.errorSink = errorSink;
bindingNamespace = esCompilerOptions.getEnvironment(objectSpace);
if (bindingNamespace == null)
{
bindingNamespace = objectSpace.SmalltalkNamespace;
}
}
public virtual bool evaluate(ScriptType rootParseNodeType, NamespaceObject environment, Object selfValue, Object[] arguments, out Object value)
{
ESBlock compiledBlock;
if (compile(rootParseNodeType, environment, selfValue, rootParseNodeType == ScriptType.SelfExpression ? parametersFor(arguments) : null, out compiledBlock))
{
value = arguments == null || arguments.Length < 1 ? compiledBlock.value0() : compiledBlock.valueWithArguments(arguments);
return(true);
}
value = null;
return(false);
}
public virtual bool compile(ScriptType rootParseNodeType, NamespaceObject environment, Object selfValue, List <ParameterExpression> rootParameters, out Expression <FuncNs.Func <Object> > lambda)
{
Expression rootExpression;
if (compile(rootParseNodeType, environment, selfValue, rootParameters, out rootExpression))
{
lambda = Expression.Lambda <FuncNs.Func <Object> >(rootExpression, false, new ParameterExpression[0]);
return(true);
}
lambda = null;
return(false);
}
protected virtual bool evaluateAsSelfExpression(NamespaceObject environment, Object selfValue, FileInfo file, out Object value)
{
objectSpace.evaluateAsSelfExpression(
file,
environment,
selfValue,
(errorDescription, span, code, severity) => {
var error = new ESCompilationError(file, environment, errorDescription, span, code, severity);
error.addTo(compilationErrors);
},
out value);
return(true);
}
public ESCompilationError(
FileInfo sourceFile,
NamespaceObject environment,
String errorDescription,
SourceSpan errorSpan,
int errorCode,
Severity severity)
{
this.sourceFile = sourceFile;
this.environment = environment;
this.errorDescription = errorDescription;
this.errorSpan = errorSpan;
this.errorCode = errorCode;
this.severity = severity;
}
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 NamedVariableBinder(DynamicBindingGuru dynamicBindingGuru, ESSymbol name, NamespaceObject environment)
{
this.dynamicBindingGuru = dynamicBindingGuru;
objectSpace = dynamicBindingGuru.ObjectSpace;
this.name = name;
this.environment = environment;
if (name != null)
{
nameString = name.PrimitiveValue;
}
addToUndeclared =
() =>
{ var bindingRef = objectSpace.newBindingReference(NameString, new DirectBindingHandle((Object)null));
objectSpace.UndeclaredNamespace.add(bindingRef);
return(bindingRef); };
}
public virtual bool compile(ScriptType rootParseNodeType, NamespaceObject environment, Object selfValue, List <ParameterExpression> rootParameters, out Expression expression)
{
BlockLiteralNode blockLiteralNode;
if (compile(rootParseNodeType, selfValue, rootParameters, out blockLiteralNode))
{
expression = blockLiteralNode.asCLRExpression(environment, null);
var undeclaredVariables = blockLiteralNode.UndeclaredVariables;
if (undeclaredVariables != null && undeclaredVariables.Count > 0)
{
handleUndeclaredVariableReferences(undeclaredVariables, SourceSpan.None);
}
return(ErrorCount < 1);
}
expression = null;
return(false);
}
public virtual bool compile(ScriptType rootParseNodeType, NamespaceObject environment, Object selfValue, List <ParameterExpression> rootParameters, out ESBlock block)
{
Expression <FuncNs.Func <Object> > lambda;
if (compile(rootParseNodeType, environment, selfValue, rootParameters, out lambda))
{
var function = lambda.Compile();
if (function == null)
{
block = null;
return(false);
}
block = (ESBlock)function();
return(true);
}
block = null;
return(false);
}
protected void evaluatScriptArguments(ESObjectSpace objectSpace, NamespaceObject environment)
{
var argList = new List <Object>();
foreach (var argSpec in scriptArguments)
{
try {
Object value;
FileInfo scriptPath;
if (argSpec.SpecifiesPathname)
{
if (objectSpace.pathForScript(argSpec.Value, out scriptPath))
{
if (objectSpace.evaluate(scriptPath, environment, null, null, out value))
{
argList.Add(value);
}
else
{
errors.Add("Syntax error in script used as argument, pathname = " + argSpec.Value);
}
}
else
{
errors.Add("Script path (used as argument to base script) not found: " + argSpec.Value);
}
}
else if (objectSpace.evaluate(new StringReader(argSpec.Value), environment, null, null, out value))
{
argList.Add(value);
}
else
{
errors.Add("Syntax error in argument: " + argSpec.Value);
}
} catch (Exception ex) {
errors.Add("Error in argument evaluation: " + ex.ToString());
}
}
scriptArgs = argList.ToArray();
}
public SetVariableValueBinder canonicalBinderFor(ESSymbol name, NamespaceObject environment)
{
if (environment == null)
{
environment = defaultNamespace;
}
Dictionary <ESSymbol, SetVariableValueBinder> nameRegistry;
SetVariableValueBinder binder;
if (!registry.TryGetValue(environment, out nameRegistry))
{
nameRegistry = new Dictionary <ESSymbol, SetVariableValueBinder>();
binder = new SetVariableValueBinder(DynamicBindingGuru, name, environment);
nameRegistry[name] = binder;
return(binder);
}
if (!nameRegistry.TryGetValue(name, out binder))
{
binder = new SetVariableValueBinder(DynamicBindingGuru, name, environment);
nameRegistry[name] = binder;
}
return(binder);
}
public virtual bool compileSelfExpression(NamespaceObject environment, Object selfValue, List <ParameterExpression> rootParameters, out ESBlock block)
{
return(compile(ScriptType.SelfExpression, environment, selfValue, rootParameters, out block));
}
public virtual bool compile(NamespaceObject environment, Object selfValue, out ESBlock block)
{
return(compile(ScriptType.BlockDeclaration, environment, selfValue, null, out block));
}
public ESLibraryLoader(ESObjectSpace objectSpace)
{
this.objectSpace = objectSpace;
baseEnvironment = objectSpace.RootNamespace;
}
public virtual bool evaluateSelfExpression(NamespaceObject environment, Object selfValue, Object[] arguments, out Object value)
{
return(evaluate(ScriptType.SelfExpression, environment, selfValue, arguments, out value));
}
public virtual bool evaluate(NamespaceObject environment, Object selfValue, Object[] arguments, out Object value)
{
return(evaluate(ScriptType.BlockDeclaration, environment, selfValue, arguments, out value));
}
public virtual bool evaluate(NamespaceObject environment, Object[] arguments, out Object value)
{
return(evaluate(environment, null, arguments, out value));
}
public NamespaceResidentVariableDeclaration(NamespaceObject environment, NameBindingScope scope, ESSymbol name) : base(scope, name)
{
getVariableCallSite = Context.getVariableValueCallSiteConstantFor(environment, name);
setVariableCallSite = Context.setVariableValueCallSiteConstantFor(environment, name);
}
protected BehavioralObjectFactory(ESObjectSpace objectSpace, NamespaceObject baseEnvironment, ESSymbol name, IDictionary <String, List <ESCompilationError> > compilationErrors) : base(objectSpace, baseEnvironment, name, compilationErrors)
{
}
protected virtual bool loadNamespace(NamespaceObject baseEnvironment, DirectoryInfo baseDirectory, out NamespaceObject loadedNamespace)
{
loadedNamespace = null;
if (baseDirectory == null || !baseDirectory.Exists)
{
Console.WriteLine("Namespace directory '" + baseDirectory.FullName + "' is not accessible.");
return(false);
}
var name = baseDirectory.Name;
String namePrefix;
int genericArity;
if (!TypeName.parseUnqualifiedName(name, out namePrefix, out genericArity, (prefix, errorDescription) => {}))
{
return(true);
}
if (namePrefix.Length != name.Length)
{
var extension = baseDirectory.Extension;
if (extension.Length > 0)
{
return(true);
}
}
if (genericArity > 0)
{
name = namePrefix + "`" + genericArity.ToString();
}
FileSystemInfo[] files = baseDirectory.GetFileSystemInfos();
FileSystemInfo namespaceConfigurationFile = null;
FileSystemInfo classConfigurationFile = null;
FileSystemInfo metaclassConfigurationFile = null;
FileSystemInfo initializerFile = null;
FileSystemInfo instanceMethodsFile = null;
FileSystemInfo classMethodsFile = null;
var variables = new List <FileSystemInfo>();
var constants = new List <FileSystemInfo>();
var nestedNamespaces = recurseIntoNestedNamespaces ? new List <DirectoryInfo>() : null;
DeclarationType type = DeclarationType.Namespace;
NamespaceFactory namespaceFactory = null;
TraitFactory traitFactory;
ClassFactory behaviorFactory;
var renameCount = 0;
foreach (var fileEntry in files)
{
var fileName = fileEntry.Name.ToLower();
if ((fileEntry.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
{
continue;
}
else
{
var sourceFile = (FileInfo)fileEntry;
String targetPath;
FileInfo targetFile;
switch (fileName)
{
case "namespace.configure":
case "configure.namespace":
targetPath = Path.Combine(sourceFile.Directory.FullName, "namespace.def");
targetFile = new FileInfo(targetPath);
if (!targetFile.Exists)
{
sourceFile.MoveTo(targetPath);
renameCount++;
}
break;
case "trait.configure":
case "configure.trait":
targetPath = Path.Combine(sourceFile.Directory.FullName, "trait.def");
targetFile = new FileInfo(targetPath);
if (targetFile.Exists)
{
Console.WriteLine("Deprecated/retired file type; not renamed due to name conflict: " + sourceFile.FullName);
}
else
{
sourceFile.MoveTo(targetPath);
renameCount++;
}
break;
case "classTrait.configure":
case "configure.classTrait":
targetPath = Path.Combine(sourceFile.Directory.FullName, "classTrait.def");
targetFile = new FileInfo(targetPath);
if (targetFile.Exists)
{
Console.WriteLine("Deprecated/retired file type; not renamed due to name conflict: " + sourceFile.FullName);
}
else
{
sourceFile.MoveTo(targetPath);
renameCount++;
}
break;
case "class.configure":
case "configure.class":
targetPath = Path.Combine(sourceFile.Directory.FullName, "class.def");
targetFile = new FileInfo(targetPath);
if (targetFile.Exists)
{
Console.WriteLine("Deprecated/retired file type; not renamed due to name conflict: " + sourceFile.FullName);
}
else
{
sourceFile.MoveTo(targetPath);
renameCount++;
}
break;
case "metaclass.configure":
case "configure.metaclass":
targetPath = Path.Combine(sourceFile.Directory.FullName, "metaclass.def");
targetFile = new FileInfo(targetPath);
if (targetFile.Exists)
{
Console.WriteLine("Deprecated/retired file type; not renamed due to name conflict: " + sourceFile.FullName);
}
else
{
sourceFile.MoveTo(targetPath);
renameCount++;
}
break;
case "instance.methods":
targetPath = Path.Combine(sourceFile.Directory.FullName, "methods.instance");
targetFile = new FileInfo(targetPath);
if (targetFile.Exists)
{
Console.WriteLine("Deprecated/retired file type; not renamed due to name conflict: " + sourceFile.FullName);
}
else
{
sourceFile.MoveTo(targetPath);
renameCount++;
}
break;
case "class.methods":
targetPath = Path.Combine(sourceFile.Directory.FullName, "methods.class");
targetFile = new FileInfo(targetPath);
if (targetFile.Exists)
{
Console.WriteLine("Deprecated/retired file type; not renamed due to name conflict: " + sourceFile.FullName);
}
else
{
sourceFile.MoveTo(targetPath);
renameCount++;
}
break;
default:
break;
}
}
}
if (renameCount > 0)
{
files = baseDirectory.GetFileSystemInfos();
}
foreach (var file in files)
{
var fileName = file.Name.ToLower();
if ((file.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
{
if (recurseIntoNestedNamespaces)
{
nestedNamespaces.Add((DirectoryInfo)file);
}
}
else
{
switch (fileName)
{
case "namespace.def":
namespaceConfigurationFile = file;
break;
case "trait.def":
if (type == DeclarationType.Class)
{
Console.WriteLine(baseDirectory.FullName + " cannot be declared to be both a class and a trait.");
return(false);
}
type = DeclarationType.Trait;
classConfigurationFile = file;
break;
case "classTrait.def":
if (type == DeclarationType.Class)
{
Console.WriteLine(baseDirectory.FullName + " cannot be declared to be both a class and a trait.");
return(false);
}
type = DeclarationType.Trait;
metaclassConfigurationFile = file;
break;
case "class.def":
if (type == DeclarationType.Trait)
{
Console.WriteLine(baseDirectory.FullName + " cannot be declared to be both a class and a trait.");
return(false);
}
type = DeclarationType.Class;
classConfigurationFile = file;
break;
case "metaclass.def":
if (type == DeclarationType.Trait)
{
Console.WriteLine(baseDirectory.FullName + " cannot be declared to be both a class and a trait.");
return(false);
}
type = DeclarationType.Class;
metaclassConfigurationFile = file;
break;
case "initializer":
initializerFile = file;
break;
case "methods.instance":
if (type == DeclarationType.Namespace)
{
type = DeclarationType.TraitOrClass;
}
instanceMethodsFile = file;
break;
case "methods.class":
if (type == DeclarationType.Namespace)
{
type = DeclarationType.TraitOrClass;
}
classMethodsFile = file;
break;
case "class.initialize":
case "initialize.class":
case "metaclass.initialize":
case "initialize.metaclass":
Console.WriteLine("Deprecated/retired file type; not processed: " + file.FullName);
break;
default:
var extension = file.Extension;
switch (extension)
{
case ".variable":
variables.Add(file);
break;
case ".constant":
constants.Add(file);
break;
}
break;
}
}
}
if (type == DeclarationType.TraitOrClass)
{
type = DeclarationType.Class;
}
bool success = true;
var nameSymbol = objectSpace.SymbolRegistry.symbolFor(name);
switch (type)
{
case DeclarationType.Trait:
namespaceFactory = traitFactory = new TraitFactory(objectSpace, baseEnvironment, nameSymbol, compilationErrors);
traitFactories.Add(traitFactory);
traitFactory.ClassConfigurationFile = (FileInfo)classConfigurationFile;
traitFactory.MetaclassConfigurationFile = (FileInfo)metaclassConfigurationFile;
traitFactory.InstanceMethodsFile = (FileInfo)instanceMethodsFile;
traitFactory.ClassMethodsFile = (FileInfo)classMethodsFile;
break;
case DeclarationType.Class:
namespaceFactory = behaviorFactory = new ClassFactory(objectSpace, baseEnvironment, nameSymbol, compilationErrors);
classFactories.Add(behaviorFactory);
behaviorFactory.ClassConfigurationFile = (FileInfo)classConfigurationFile;
behaviorFactory.MetaclassConfigurationFile = (FileInfo)metaclassConfigurationFile;
behaviorFactory.InstanceMethodsFile = (FileInfo)instanceMethodsFile;
behaviorFactory.ClassMethodsFile = (FileInfo)classMethodsFile;
break;
default:
case DeclarationType.Namespace:
namespaceFactory = new NamespaceFactory(objectSpace, baseEnvironment, nameSymbol, compilationErrors);
namespaceFactories.Add(namespaceFactory);
break;
}
namespaceFactory.InitializerFile = (FileInfo)initializerFile;
namespaceFactory.IsVerbose = IsVerbose;
if (!namespaceFactory.declareNamespace())
{
return(false);
}
loadedNamespace = namespaceFactory.ThisNamespace;
namespaceFactory.NamespaceConfigurationFile = (FileInfo)namespaceConfigurationFile;
foreach (var constFile in constants)
{
namespaceFactory.addConstantInitializerFile((FileInfo)constFile);
}
foreach (var varFile in variables)
{
namespaceFactory.addVariableInitializerFile((FileInfo)varFile);
}
if (recurseIntoNestedNamespaces)
{
NamespaceObject childNamespace;
foreach (var nsFile in nestedNamespaces)
{
if (!loadNamespace(loadedNamespace, nsFile, out childNamespace))
{
return(false);
}
}
}
return(success);
}
protected Registry(DynamicBindingGuru dynamicBindingGuru) : base(dynamicBindingGuru)
{
defaultNamespace = objectSpace.SmalltalkNamespace;
}
public ClassFactory(ESObjectSpace objectSpace, NamespaceObject baseEnvironment, ESSymbol name, IDictionary <String, List <ESCompilationError> > compilationErrors) : base(objectSpace, baseEnvironment, name, compilationErrors)
{
}
protected override Object runScript(ScriptEngine engine, ESCompilerOptions compilationOptions, NamespaceObject environment)
{
var script = engine.CreateScriptSourceFromString(text);
return(script.Execute(compilationOptions, scriptArgs, out durationToRun));
}
protected abstract Object runScript(ScriptEngine engine, ESCompilerOptions compilationOptions, NamespaceObject environment);
protected SetVariableValueBinder(DynamicBindingGuru dynamicBindingGuru, ESSymbol name, NamespaceObject environment) : base(dynamicBindingGuru, name, environment)
{
}
public HashSet <ESSymbol> bindNonLocalVariablesToEnvironment(NamespaceObject environment, BehavioralObject methodHomeClass)
{
if (nonLocalBindings == null)
{
if (outerScope != null)
{
return(outerScope.bindNonLocalVariablesToEnvironment(environment, methodHomeClass));
}
return(null);
}
String nameContext;
instanceVariableBindings = null;
namespaceResidentBindings = null;
HashSet <ESSymbol> instVarNames = null;
if (environment == null)
{
if (methodHomeClass != null)
{
environment = methodHomeClass;
}
}
if (methodHomeClass == null)
{
methodHomeClass = environment as BehavioralObject;
}
var envName = environment == null ? "??" : environment.QualifiedName;
var methodName = Context.MethodSelector;
if (methodName != null)
{
if (methodHomeClass == null)
{
nameContext = envName + " ## " + methodName.PrimitiveValue + " => ";
}
else
{
nameContext = methodHomeClass.QualifiedName + ">>" + methodName.PrimitiveValue + " => ";
methodHomeClass.allInstVarNamesAndIndexesDo((instVarName, index) => {
if (instVarNames == null)
{
instVarNames = new HashSet <ESSymbol>();
}
instVarNames.Add(instVarName);
NonLocalVariableDeclaration nonLocalVar;
if (nonLocalBindings.TryGetValue(instVarName, out nonLocalVar))
{
var instanceVar = declareInstanceVariable(instVarName.PrimitiveValue, null);
instanceVar.Index = (int)index;
nonLocalVar.occurrencesDo(occurrence => occurrence.Declaration = instanceVar);
}
});
}
}
else
{
nameContext = envName + " => ";
}
HashSet <ESSymbol> undeclared = null;
foreach (var kvp in nonLocalBindings)
{
var nonLocalVar = kvp.Value;
var nonLocalName = nonLocalVar.NameSymbol;
if (instVarNames == null || !instVarNames.Contains(nonLocalName))
{
var ns = environment ?? Context.ObjectSpace.UndeclaredNamespace;
var nsResidentVar = declareNamespaceVariable(ns, nonLocalName, null);
nonLocalVar.occurrencesDo(occurrence => occurrence.Declaration = nsResidentVar);
if (environment == null && methodHomeClass == null)
{
continue;
}
/*
* if (nonLocalName.PrimitiveValue == "symbolTag")
* Console.WriteLine();
*/
var binding = nonLocalName.bindingInNamespaceIfAbsent(ns, AccessPrivilegeLevel.Local, ImportTransitivity.Transitive, null);
if (binding == null)
{
if (undeclared == null)
{
undeclared = new HashSet <ESSymbol>();
}
var nameInContext = Context.symbolFor(nameContext + nonLocalName);
undeclared.Add(nameInContext);
}
}
}
if (environment == null && methodHomeClass == null)
{
return(null);
}
return(undeclared);
}
protected override Object runScript(ScriptEngine engine, ESCompilerOptions compilationOptions, NamespaceObject environment)
{
var script = engine.CreateScriptSourceFromPathSuffix(pathnameSuffix);
if (script == null)
{
var message = "Script not found: " + pathnameSuffix;
Console.WriteLine(message);
return(message);
}
else
{
try {
return(script.Execute(compilationOptions, scriptArgs, out durationToRun));
} catch (InvalidFunctionCallException ex) {
var message = "Script argument mismatch: " + pathnameSuffix;
Console.WriteLine(message);
return(message);
}
}
}
public ESLibraryLoader(ESObjectSpace objectSpace, NamespaceObject baseEnvironment, DirectoryInfo baseDirectory, bool recurseIntoNestedNamespaces) : this(objectSpace, baseDirectory, recurseIntoNestedNamespaces)
{
this.baseEnvironment = baseEnvironment ?? objectSpace.RootNamespace;
}
