private Loop(NameDefinition label,
IExpression preCondition,
IEnumerable <IExpression> body,
IEnumerable <IExpression> postStep,
IExpression postCondition)
{
// each iteration is:
// pre-condition
// body
// step
// post-condition
this.Label = label;
this.preCondition = preCondition;
this.PostStep = (postStep ?? Enumerable.Empty <IExpression>()).StoreReadOnly();
this.Body = (body ?? Enumerable.Empty <IExpression>()).StoreReadOnly();
this.postCondition = postCondition;
this.ReadMode = ExpressionReadMode.CannotBeRead; // todo: temporary state
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreateLoop(PreCondition,
thenPath: Body,
postMaybes: PostStep.Concat(PostCondition)));
}
private TemplateTranslation overridden(IReadOnlyList <TemplateParameter> parameters, IEnumerable <IEntityInstance> arguments)
{
var dict = Later.Create(() => this.table.ToDictionary(it => it.Key, it => it.Value));
int i = -1;
foreach (IEntityInstance arg in arguments)
{
++i;
TemplateParameter key = parameters[i];
if (!object.ReferenceEquals(this.table[key], arg))
{
dict.Value[key] = arg;
}
}
if (dict.HasValue)
{
return(new TemplateTranslation(this.parametersProvider, dict.Value));
}
else
{
return(this);
}
}
private EntityInstance(RuntimeCore core, IEntity target,
TemplateTranslation translation, TypeMutability overrideMutability,
Lifetime lifetime)
{
if (target == null)
{
throw new ArgumentNullException("Instance has to be created for existing entity");
}
this.core = core;
this.Target = target;
this.Translation = translation;
this.Lifetime = lifetime;
this.OverrideMutability = overrideMutability;
this.nameOf = Later.Create(() => NameReference.Create(
OverrideMutability,
null, this.Target.Name.Name, this.TemplateArguments.Select(it => it.NameOf),
target: this, isLocal: false));
this.pureNameOf = Later.Create(() => NameReference.Create(
null, this.Target.Name.Name, this.TemplateArguments.Select(it => it.NameOf),
target: this, isLocal: false));
}
private VariableDeclaration(EntityModifier modifier, ExpressionReadMode readMode, string name,
INameReference typeName,
IExpression initValue,
IEnumerable <LabelReference> friends = null)
: base(readMode)
{
if (name == null)
{
throw new ArgumentNullException();
}
this.Modifier = modifier ?? EntityModifier.None;
this.Name = NameDefinition.Create(name);
this.TypeName = typeName;
this.initValue = initValue;
this.AccessGrants = (friends ?? Enumerable.Empty <LabelReference>()).StoreReadOnly();
this.instancesCache = new EntityInstanceCache(this, () => GetInstance(TypeMutability.None,
TemplateTranslation.CreateParameterless(this), Lifetime.Timeless));
this.closures = new List <TypeDefinition>();
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(InitValue));
}
private Spread(IExpression expr)
: base(ExpressionReadMode.ReadRequired)
{
this.expr = expr;
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(Expr));
}
private Chain(IEnumerable <IExpression> instructions)
: base(ExpressionReadMode.ReadRequired)
{
this.Instructions = instructions.StoreReadOnly();
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(this.Instructions));
}
private ReinterpretType(IExpression lhs, INameReference rhsTypeName)
: base(ExpressionReadMode.ReadRequired)
{
this.Lhs = lhs;
this.RhsTypeName = rhsTypeName;
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(Lhs));
}
private IsSame(IExpression lhs, IExpression rhs)
: base(ExpressionReadMode.ReadRequired)
{
this.Lhs = lhs;
this.Rhs = rhs;
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(Lhs, Rhs));
}
private FunctionArgument(string nameLabel, IExpression expression)
: base()
{
this.NameLabel = nameLabel;
this.expression = expression;
this.closures = new List <TypeDefinition>();
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(Expression));
}
private FunctionCall(CallMode mode,
IExpression callee, IEnumerable <FunctionArgument> arguments, NameReference requestedOutcomeType)
: base()
{
this.mode = mode;
this.callee = callee;
this.UserArguments = (arguments ?? Enumerable.Empty <FunctionArgument>()).Indexed().StoreReadOnlyList();
this.RequestedOutcomeTypeName = requestedOutcomeType;
this.closures = new List <TypeDefinition>();
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(UserArguments));
}
private FunctionDefinition(EntityModifier modifier,
NameDefinition name,
NameDefinition label,
IEnumerable <TemplateConstraint> constraints,
IEnumerable <FunctionParameter> parameters,
ExpressionReadMode callMode,
INameReference result,
FunctionCall constructorChainCall,
Block body,
IEnumerable <NameReference> includes,
IEnumerable <LabelReference> friends)
: base(modifier | (body == null ? EntityModifier.Abstract : EntityModifier.None), name, constraints, includes)
{
parameters = parameters ?? Enumerable.Empty <FunctionParameter>();
this.Label = label ?? NameDefinition.Create(name.Name);
this.AccessGrants = (friends ?? Enumerable.Empty <LabelReference>()).StoreReadOnly();
this.Parameters = parameters.Indexed().StoreReadOnlyList();
setResultParameter(result);
this.IsResultTypeNameInfered = result == null;
if (this.IsResultTypeNameInfered)
{
this.resultTypeCandidates = new List <IEntityInstance>();
}
this.UserBody = body;
this.CallMode = callMode;
// attaching zero-constructor call to the body of the function will be done when attaching entire function to a type
if (constructorChainCall != null)
{
this.UserBody.SetConstructorChainCall(constructorChainCall);
}
if (this.IsLambdaInvoker)
{
this.LambdaTrap = new LambdaTrap();
}
this.attachPostConstructor();
this.flow = Later.Create(() => ExecutionFlow.CreatePath(UserBody));
this.constructionCompleted = true;
if (!IsValidMutableName(this.Name.Name, this.Modifier))
{
throw new ArgumentException($"Mutable function has to be marked with name as well {this.Name}");
}
}
private IfBranch(IExpression condition, IEnumerable <IExpression> body, IfBranch next)
{
this.condition = condition;
// we have to postpone calculating read-mode because the last instruction can be function call
// and it is resolved only after finding its target
if (!body.Any())
{
body = new[] { UnitLiteral.Create() }
}
;
this.Body = Block.Create((block) => block.Instructions.Last().ReadMode, body);
this.Next = next;
this.attachPostConstructor();
this.flow = Later.Create(() => this.IsElse
? ExecutionFlow.CreateElse(Body, Next) : ExecutionFlow.CreateFork(Condition, Body, Next));
}
public static TemplateTranslation Translated(TemplateTranslation baseTranslation,
TemplateTranslation through, ref bool translated)
{
if (baseTranslation == null || through == null)
{
throw new ArgumentNullException();
}
if (baseTranslation.table.Count == 0 || through.table.Count == 0)
{
return(baseTranslation);
}
var dict = Later.Create(() => baseTranslation.table.ToDictionary(it => it.Key, it => it.Value));
foreach (KeyValuePair <TemplateParameter, IEntityInstance> entry in baseTranslation.table)
{
if (entry.Value != null)
{
bool trans = false;
IEntityInstance entityInstance = entry.Value.TranslateThrough(ref trans, through);
if (trans)
{
dict.Value[entry.Key] = entityInstance;
}
}
else if (through.Translate(entry.Key, out IEntityInstance value))
{
dict.Value[entry.Key] = value;
}
}
if (dict.HasValue)
{
translated = true;
return(new TemplateTranslation(baseTranslation.parametersProvider, dict.Value));
}
else
{
return(baseTranslation);
}
}
private BoolOperator(OpMode mode, IExpression lhs, IExpression rhs)
: base(ExpressionReadMode.ReadRequired)
{
this.Mode = mode;
this.lhs = lhs;
this.rhs = rhs;
this.attachPostConstructor();
this.flow = Later.Create(() =>
{
switch (this.Mode)
{
case OpMode.And: return(ExecutionFlow.CreateFork(Lhs, Rhs, null));
case OpMode.Or: return(ExecutionFlow.CreateFork(Lhs, null, Rhs));
default: throw new InvalidOperationException();
}
});
}
protected Expression(Option <ExpressionReadMode> readMode)
{
this.readMode = readMode;
this.flow = Later.Create(() => ExecutionFlow.CreatePath(ChildrenNodes.WhereType <IExpression>()));
}
