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;
}
protected Delegate primitiveFunctionFor(List <KeywordMessageArgument> arguments)
{
ParseTreeNode node;
var argNames = argNamesFromPrimitiveSpecArgumentList(
arguments,
(errorMessage, span)
=> compiler.handlePrimitiveSpeficationError(errorMessage, span));
ESSymbol primName = symbolRegistry.symbolFor(argNames[0]);
String domainName = argNames[1];
PrimitiveDomainType domain = (PrimitiveDomainType)ushort.MaxValue; // On account of typical statically-typed compiler stupidity.
try {
domain = (PrimitiveDomainType)Enum.Parse(typeof(PrimitiveDomainType), domainName);
} catch {
Context.markAsUncompilable();
node = arguments[1];
compiler.handlePrimitiveSpeficationError(
"Unknown primitive domain <" + domainName + ">.",
node.Span);
}
Delegate function;
if (!objectSpace.getPrimitiveFunction(domain, primName, out function))
{
Context.markAsUncompilable();
node = arguments[0];
compiler.handlePrimitiveSpeficationError(
"No primitive named <" + primName.PrimitiveValue + "> is defined in the primitive domain <" + domainName + ">.",
node.Span);
}
return(function);
}
protected void bindToKernel()
{
messageSendBinderRegistry = objectSpace.MessageSendBinderRegistry;
symbolRegistry = objectSpace.SymbolRegistry;
selfSymbol = objectSpace.SymbolRegistry.symbolFor(selfName);
superSymbol = objectSpace.SymbolRegistry.symbolFor(superName);
thisContextSymbol = objectSpace.SymbolRegistry.symbolFor(thisContextName);
}
protected void logMessageSent(ESSymbol messageSelector)
{
if (messagesSent == null)
{
messagesSent = newMessagesSentSet();
}
messagesSent.Add(messageSelector);
}
public InstanceVariableDeclaration(NameBindingScope scope, ESSymbol name) : base(scope, name)
{
var namedSlotsObject = Expression.Convert(Scope.SelfParameter, TypeGuru.esNamedSlotsObjectType);
namedSlots = Expression.Field(namedSlotsObject, "namedSlots");
var statusFlags = Expression.Field(namedSlotsObject, "statusFlags");
isMutable = Expression.Equal(Expression.And(statusFlags, mutabilityFlagBitConstant), zeroConstant);
}
protected void logMessageSentToSuper(ESSymbol messageSelector)
{
logMessageSent(messageSelector);
if (messagesSentToSuper == null)
{
messagesSentToSuper = newMessagesSentSet();
}
messagesSentToSuper.Add(messageSelector);
}
protected void logMessageSentToThisContext(ESSymbol messageSelector)
{
logMessageSent(messageSelector);
if (messagesSentToThisContext == null)
{
messagesSentToThisContext = newMessagesSentSet();
}
messagesSentToThisContext.Add(messageSelector);
}
public NamedValueOccurrence newOccurrenceOf(ESSymbol name)
{
var declaration = atIfAbsent(name, () => declareNonLocalVariable(name, null));
var occurrence = declaration.newOccurrenceIn(this);
localOccurrences.Add(occurrence);
if (occurrence.IsFreeVariable && declaration.IsStackResident)
{
freeVariableReferenceCount++;
}
return(occurrence);
}
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 override IEnumerable <String> GetDynamicMemberNames()
{
var selectors = new System.Collections.Generic.HashSet <String>();
var esClass = ValueClass;
while (esClass != null)
{
esClass.systemSelectorsDo((Object selectorObject, Object argCountObject) => { selectors.Add((String)selectorObject); return(null); });
esClass.selectorsDo(
(Object selectorObject) => {
ESSymbol selector = (ESSymbol)selectorObject;
selectors.Add(selector.asHostSystemMemberName(CapitalizationScheme.InitialCapital));
return(null);
});
esClass = esClass.Superclass;
}
return(selectors);
}
public NamedValueDeclaration atIfAbsent(ESSymbol name, Functor0 <NamedValueDeclaration> notFoundAction)
{
StackResidentDeclaration localDeclaration;
if (localBindings.TryGetValue(name, out localDeclaration))
{
return(localDeclaration);
}
NonLocalVariableDeclaration nonLocalVariableDeclaration;
if (nonLocalBindings != null && nonLocalBindings.TryGetValue(name, out nonLocalVariableDeclaration))
{
return(nonLocalVariableDeclaration);
}
if (outerScope == null)
{
return(notFoundAction == null ? null : notFoundAction());
}
return(outerScope.atIfAbsent(name, notFoundAction));
}
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 compileMethod(BehavioralObject methodClass, ESSymbol protocol, out ESMethod compiledMethod)
{
ESMethod method = null;
if (compileMethod(
methodClass,
(MethodDeclarationNode methodDeclarationNode, Delegate function) => {
if (function == null)
{
return(false);
}
method = objectSpace.newMethod(methodClass, methodClass, methodDeclarationNode, protocol);
return(true);
}))
{
compiledMethod = method;
return(true);
}
else
{
compiledMethod = null;
return(false);
}
}
public DynamicMetaObject metaObjectToSendDoesNotUnderstand(ESSymbol selector, DynamicMetaObject[] args)
{
return(ExpressionTreeGuru.expressionToSendDoesNotUnderstand(Expression, ValueClass, selector, args).asDynamicMetaObject(DefaultBindingRestrictions, Value));
}
public override T applyToSymbol(ESSymbol operand)
{
return(operation.applyToSymbol(operand));
}
public virtual T applyToSymbol(ESSymbol operand)
{
return(applyToESObject(operand));
}
public AbstractNonStackResidentVariableDeclaration(NameBindingScope scope, ESSymbol name) : base(scope, name)
{
}
public virtual void setSelector(ESSymbol newSelector)
{
selector = newSelector;
numArgs = selector == null ? 0 : selector.NumArgs;
}
protected StackResidentDeclaration(NameBindingScope scope, ESSymbol name) : this(scope, name, TypeGuru.objectType)
{
}
public NamedVariableBinder(DynamicBindingGuru dynamicBindingGuru, ESSymbol name) : this(dynamicBindingGuru, name, null)
{
}
public NamespaceResidentVariableDeclaration(NamespaceObject environment, NameBindingScope scope, ESSymbol name) : base(scope, name)
{
getVariableCallSite = Context.getVariableValueCallSiteConstantFor(environment, name);
setVariableCallSite = Context.setVariableValueCallSiteConstantFor(environment, name);
}
protected StackResidentDeclaration(NameBindingScope scope, ESSymbol name, Type parameterType) : this(scope, parameterExpressionFrom(name, parameterType))
{
}
public NonLocalVariableDeclaration(NameBindingScope scope, ESSymbol name) : base(scope, name)
{
}
public DynamicMetaObject metaObjectToThrowInvalidFunctionCallException(ESSymbol selector, DynamicMetaObject[] args, String messageText, Type expectedFunctionType, Type actualFunctionType)
{
return(ExpressionTreeGuru.expressionToThrowInvalidFunctionCallException(Expression, ValueClass, selector, messageText, (long)args.Length, expectedFunctionType, actualFunctionType).asDynamicMetaObject(BindingRestrictions.GetInstanceRestriction(Expression, Value), Value));
}
public override DynamicMetaObject BindBinaryOperation(BinaryOperationBinder binder, DynamicMetaObject arg)
{
DynamicMetaObject messageSendMO = null;
ESBehavior esClass = null;
ESObjectSpace kernel;
ESSymbol selector = null;
switch (binder.Operation)
{
case ExpressionType.Add:
if (createMetaObjectToSendMessage("+", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.And:
if (createMetaObjectToSendMessage("&", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Divide:
if (createMetaObjectToSendMessage("/", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Equal:
if (createMetaObjectToSendMessage("=", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.ExclusiveOr:
if (createMetaObjectToSendMessage("xor:", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.GreaterThan:
if (createMetaObjectToSendMessage(">", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.GreaterThanOrEqual:
if (createMetaObjectToSendMessage(">=", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.LeftShift:
if (createMetaObjectToSendMessage("<<", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.LessThan:
if (createMetaObjectToSendMessage("<", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.LessThanOrEqual:
if (createMetaObjectToSendMessage("<=", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Modulo:
if (createMetaObjectToSendMessage("rem:", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Multiply:
if (createMetaObjectToSendMessage("*", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.NotEqual:
if (createMetaObjectToSendMessage("~=", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Or:
if (createMetaObjectToSendMessage("|", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Power:
if (createMetaObjectToSendMessage("**", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.RightShift:
if (createMetaObjectToSendMessage(">>", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Subtract:
if (createMetaObjectToSendMessage("-", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
default:
case ExpressionType.AddAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("+=");
break;
case ExpressionType.AndAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("&=");
break;
case ExpressionType.DivideAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("/=");
break;
case ExpressionType.ExclusiveOrAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("^=");
break;
case ExpressionType.LeftShiftAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("<<=");
break;
case ExpressionType.ModuloAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("%=");
break;
case ExpressionType.MultiplyAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("*=");
break;
case ExpressionType.OrAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("|=");
break;
case ExpressionType.PowerAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("**=");
break;
case ExpressionType.RightShiftAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor(">>=");
break;
case ExpressionType.SubtractAssign:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("-=");
break;
case ExpressionType.Extension:
esClass = ValueClass;
kernel = esClass.ObjectSpace;
selector = kernel.symbolFor("??");
break;
}
if (messageSendMO == null)
{
messageSendMO = metaObjectToSendDoesNotUnderstand(selector, argArrayFor(arg));
}
return(binder.FallbackBinaryOperation(this, arg, messageSendMO));
}
protected SetVariableValueBinder(DynamicBindingGuru dynamicBindingGuru, ESSymbol name, NamespaceObject environment) : base(dynamicBindingGuru, name, environment)
{
}
public ESMessage(ESBehavior esClass, ESSymbol selector, Object[] arguments) : base(esClass)
{
setSelector(selector);
this.arguments = arguments;
}
public SetVariableValueBinder canonicalBinderFor(ESSymbol name)
{
return(canonicalBinderFor(name, defaultNamespace));
}
protected SetVariableValueBinder(DynamicBindingGuru dynamicBindingGuru, ESSymbol name) : base(dynamicBindingGuru, name)
{
}
public ParameterDeclaration(NameBindingScope scope, ESSymbol name, Type parameterType) : base(scope, name, parameterType)
{
}
