public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var args = new DLR.Expression[CellNames.Count + 1];
args[0] = DLR.Expression.Quote(DLR.Expression.Lambda(Expression.GenerateExpressionTree(scope)));
for (var i = 1; i < CellNames.Count + 1; i++)
{
var varName = CellNames.ElementAt(i - 1);
if (scope.TryGetVariable(varName, out DLR.ParameterExpression variable))
{
args[i] = variable;
}
else
{
throw new ArgumentException($"Variable \"{varName}\" is not defined.");
}
}
return(DLR.Expression.Dynamic(
new CreateSignalInstanceBinder(),
typeof(object),
args));
}
private DLR.ConditionalExpression CreateConditionalExpression(GenScope scope, int index)
{
var branch = Branches.ElementAt(index);
var condition = DLR.Expression.Convert(branch.Condition.GenerateExpressionTree(scope), typeof(bool));
var block = branch.Block.GenerateExpressionTree(scope);
index++;
if (index == Branches.Count)
{
if (ElseBranch is null)
{
return(DLR.Expression.Condition(condition, block, DLR.Expression.Default(block.Type)));
}
else
{
return(DLR.Expression.Condition(condition, block, ElseBranch.GenerateExpressionTree(scope), block.Type));
}
}
else
{
return(DLR.Expression.Condition(
condition,
block,
CreateConditionalExpression(scope, index)));
}
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var expression = Expression.GenerateExpressionTree(scope);
if (Target is IdentifierExpression identifier) //Check if a new variable is introduced
{
var name = identifier.Name;
if (!scope.TryGetVariable(name, out DLR.ParameterExpression variable)) //If it is, initialise it
{
variable = DLR.Expression.Variable(typeof(object), name);
scope.Definitions[name] = variable;
}
return(DLR.Expression.Assign(variable, expression));
}
var target = Target.GenerateExpressionTree(scope);
switch (Operation)
{
case TokenType.Assign:
return(DLR.Expression.Assign(target, expression));
default:
throw new NotImplementedException(); // Add syntactic sugar operators
}
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
return(DLR.Expression.Dynamic(
new CreateCellInstanceBinder(),
typeof(object),
Expression.GenerateExpressionTree(scope)));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var start = Start.GenerateExpressionTree(scope);
var end = End.GenerateExpressionTree(scope);
return(DLR.Expression.Dynamic(new RangeOperationBinder(), typeof(object), start, end));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var identifier = (IdentifierExpression)Function;
DLR.Expression[] args = null;
if (scope.Root.FunctionDefinitions.TryGetValue(identifier.Name, out Delegate lambda))
{
args = new DLR.Expression[Arguments.Count + 1];
args[0] = DLR.Expression.Constant(lambda, typeof(Delegate));
for (var i = 1; i < Arguments.Count + 1; i++)
{
args[i] = Arguments.ElementAt(i - 1).GenerateExpressionTree(scope);
}
}
else
{
args = new DLR.Expression[Arguments.Count];
for (var i = 0; i < Arguments.Count; i++)
{
args[i] = Arguments.ElementAt(i).GenerateExpressionTree(scope);
}
}
return(DLR.Expression.Dynamic(new RilaInvokeBinder(new CallInfo(Arguments.Count)), typeof(object), args));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var lhs = Lhs.GenerateExpressionTree(scope);
var rhs = Rhs.GenerateExpressionTree(scope);
var op = GetOperation();
return(DLR.Expression.Dynamic(scope.Runtime.GetBinaryOperationBinder(op), typeof(object), lhs, rhs));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
if (scope.TryGetVariable(Name, out DLR.ParameterExpression result))
{
return(result);
}
throw new InvalidOperationException($"\"{Name}\" is not defined!");
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var loop = scope.CreateLoop();
var condition = Utils.Convert(Condition.GenerateExpressionTree(scope), typeof(bool));
var block = Block.GenerateExpressionTree(loop);
return(Utils.While(condition, block, DLR.Expression.Empty(), loop.BreakTarget, loop.ContinueTarget));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var loopScope = scope.CreateLoop();
var bindVar = DLR.Expression.Variable(typeof(object), VariableName);
var inExpr = InExpression.GenerateExpressionTree(scope);
loopScope.Definitions[VariableName] = bindVar;
var block = Block.GenerateExpressionTree(loopScope);
var enumeratorVar = DLR.Expression.Variable(typeof(object), "$enumeratorVar");
var getEnumeratorCall = DLR.Expression.Dynamic(
scope.Runtime.GetInvokeMemberBinder(new Tuple <string, CallInfo>("GetEnumerator", new CallInfo(0))),
typeof(object),
inExpr);
var enumeratorAssign = DLR.Expression.Assign(enumeratorVar, getEnumeratorCall);
var enumeratorDispose = DLR.Expression.Dynamic(scope.Runtime.GetInvokeMemberBinder(new Tuple <string, CallInfo>("Dispose", new CallInfo(0))),
typeof(void),
enumeratorVar);
var moveNextCall = DLR.Expression.Dynamic(scope.Runtime.GetInvokeMemberBinder(new Tuple <string, CallInfo>("MoveNext", new CallInfo(0))),
typeof(object),
enumeratorVar);
var loop =
DLR.Expression.Loop(
DLR.Expression.IfThenElse(
DLR.Expression.Convert(
DLR.Expression.Dynamic(scope.Runtime.GetBinaryOperationBinder(ExpressionType.Equal), typeof(object), moveNextCall, DLR.Expression.Constant(true)),
typeof(bool)),
DLR.Expression.Block(
new[] { bindVar },
DLR.Expression.Assign(bindVar, DLR.Expression.Dynamic(scope.Runtime.GetGetMemberBinder("Current"), typeof(object), enumeratorVar)),
block),
DLR.Expression.Break(loopScope.BreakTarget)),
loopScope.BreakTarget,
loopScope.ContinueTarget);
var tryFinally =
DLR.Expression.TryFinally(
loop,
DLR.Expression.IfThen( //Arrays do not implement IDisposable, so we need to check
DLR.Expression.TypeIs(enumeratorVar, typeof(IDisposable)), enumeratorDispose));
var body =
DLR.Expression.Block(
new[] { enumeratorVar },
enumeratorAssign,
tryFinally);
return(body);
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var loop = scope.GetFirstLoopScope();
if (loop is null)
{
throw new InvalidOperationException("No enclosing loop to continue from.");
}
return(DLR.Expression.Continue(loop.ContinueTarget));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var loop = scope.GetFirstLoopScope();
if (loop is null)
{
throw new InvalidOperationException("No enclosing loop to break out of.");
}
return(DLR.Expression.Break(loop.BreakTarget));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var stmts = new DLR.Expression[Statements.Count];
var blockScope = scope.CreateChild();
for (int i = 0; i < Statements.Count; i++)
{
stmts[i] = Statements.ElementAt(i).GenerateExpressionTree(blockScope);
}
return(DLR.Expression.Block(blockScope.Definitions.Select(x => x.Value), stmts));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var args = new DLR.Expression[Arguments.Count + 1];
args[0] = DLR.Expression.Constant(new UnresolvedType(TypeIdentifier));
for (var i = 1; i <= Arguments.Count; i++)
{
args[i] = Arguments.ElementAt(i - 1).GenerateExpressionTree(scope);
}
return(DLR.Expression.Dynamic(scope.Runtime.GetCreateInstanceBinder(new CallInfo(Arguments.Count)), typeof(object), args));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var getTypeProvider = DLR.Expression.Dynamic(
scope.Runtime.GetGetMemberBinder(nameof(Rila.TypeProvider)),
typeof(object),
scope.Root.RuntimeParameter);
return(DLR.Expression.Dynamic(
scope.Runtime.GetInvokeMemberBinder(new Tuple <string, CallInfo>(nameof(TypeProvider.LoadNamespace), new CallInfo(2))),
typeof(object),
getTypeProvider,
DLR.Expression.Constant(Namespace),
DLR.Expression.Constant(Alias)));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
if (!scope.IsInLambda())
{
throw new InvalidOperationException("No function to return from!");
}
if (Expression is null)
{
return(DLR.Expression.Goto(scope.GetFirstLambdaScope().CreateReturnTarget()));
}
var expression = Expression.GenerateExpressionTree(scope);
return(DLR.Expression.Goto(scope.GetFirstLambdaScope().CreateReturnTarget(false), expression, expression.Type));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var args = new DLR.Expression[Parameters.Count + 1];
args[0] = Identifier.GenerateExpressionTree(scope);
for (var i = 1; i <= Parameters.Count; i++)
{
args[i] = Parameters.ElementAt(i - 1).GenerateExpressionTree(scope);
}
if (IsSet) //Last param is the value from the rhs expression
{
return(DLR.Expression.Dynamic(new RilaSetIndexBinder(new CallInfo(Parameters.Count)), typeof(object), args));
}
return(DLR.Expression.Dynamic(new RilaGetIndexBinder(new CallInfo(Parameters.Count)), typeof(object), args));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
if (scope.IsInLoop() || scope.IsInLambda())
{
throw new InvalidOperationException("Cannot declare a function inside the body of another function or inside a loop!");
}
if (scope.Root.FunctionDefinitions.ContainsKey(Name))
{
throw new InvalidOperationException($"Function \"{Name}\" is already defined!");
}
var functionScope = scope.CreateLambda();
var parameters = new DLR.ParameterExpression[Parameters.Count];
for (var i = 0; i < Parameters.Count; i++)
{
var name = Parameters.ElementAt(i).Name;
var param = DLR.Expression.Parameter(typeof(object), name);
parameters[i] = param;
functionScope.Definitions[name] = param;
}
var body = Body.GenerateExpressionTree(functionScope);
DLR.LambdaExpression function = null;
if (functionScope.ReturnTarget is null) //void returning function
{
function = DLR.Expression.Lambda(body, Name, parameters);
}
else
{
var wrapper = DLR.Expression.Block(body, DLR.Expression.Label(functionScope.ReturnTarget, body));
function = DLR.Expression.Lambda(wrapper, Name, parameters);
}
scope.Root.FunctionDefinitions[Name] = function.Compile();
return(function);
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
DLR.Expression arg = null;
if (Expression is IdentifierExpression identifier)
{
arg = DLR.Expression.Constant(new UnresolvedType(identifier.Name));
}
else
{
arg = Expression.GenerateExpressionTree(scope); // Alias
}
var getTypeProvider = DLR.Expression.Dynamic(
scope.Runtime.GetGetMemberBinder(nameof(Rila.TypeProvider)),
typeof(object),
scope.Root.RuntimeParameter);
return(DLR.Expression.Dynamic(
scope.Runtime.GetInvokeMemberBinder(new Tuple <string, CallInfo>(nameof(TypeProvider.GetType), new CallInfo(1))),
typeof(object),
getTypeProvider,
arg));
}
public abstract DLR.Expression GenerateExpressionTree(GenScope scope);
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
return(DLR.Expression.Constant(Value, typeof(object)));
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
DLR.Expression result = null;
var first = Expressions.First();
if (first is IdentifierExpression ident)
{
if (scope.TryGetVariable(ident.Name, out ParameterExpression variable)) //expression performed on a variable
{
result = variable;
}
else
{
result = DLR.Expression.Constant(new UnresolvedType(ident.Name)); //static or alias access
}
}
else
{
result = first.GenerateExpressionTree(scope);
}
for (var element = 1; element < Expressions.Count; element++)
{
switch (Expressions.ElementAt(element))
{
case IdentifierExpression identifier:
{
if (IsSetMember && element == Expressions.Count - 2)
{
result = DLR.Expression.Dynamic(
new RilaSetMemberBinder(identifier.Name),
typeof(object),
result,
Expressions.Last().GenerateExpressionTree(scope)); //The last expression is the new value
element = Expressions.Count;
}
else
{
result = DLR.Expression.Dynamic(scope.Runtime.GetGetMemberBinder(identifier.Name), typeof(object), result);
}
}
break;
case CallExpression call:
{
var name = call.Function as IdentifierExpression;
var args = new DLR.Expression[call.Arguments.Count + 1];
args[0] = result;
for (var i = 1; i <= call.Arguments.Count; i++)
{
args[i] = call.Arguments.ElementAt(i - 1).GenerateExpressionTree(scope);
}
result = DLR.Expression.Dynamic(
scope.Runtime.GetInvokeMemberBinder(new Tuple <string, CallInfo>(name.Name, new CallInfo(call.Arguments.Count))),
typeof(object),
args);
}
break;
case IndexerExpression indexer:
result = indexer.GenerateExpressionTree(scope);
break;
default:
throw new ArgumentException("Expecting member access, call or indexer expression!");
}
}
return(result);
}
public override DLR.Expression GenerateExpressionTree(GenScope scope)
{
var ifs = CreateConditionalExpression(scope, 0);
return(DLR.Expression.Block(ifs));
}
