|
public static Label ( |
||
| target | The |
|
| return | ||
protected override object VisitDoWhile(DoWhile W)
{
string name = target.LabelName();
LinqExprs.LabelTarget begin = LinqExpr.Label("do_" + name + "_begin");
LinqExprs.LabelTarget end = LinqExpr.Label("do_" + name + "_end");
loops.Push(new Loop(LinqExpr.Goto(end), LinqExpr.Goto(begin)));
target.PushScope();
// Check the condition, exit if necessary.
target.Add(LinqExpr.Label(begin));
// Generate the body target.
Visit(W.Body);
// Loop.
target.Add(LinqExpr.IfThen(target.Compile(W.Condition), LinqExpr.Goto(begin)));
// Exit label.
target.Add(LinqExpr.Label(end));
loops.Pop();
target.PopScope();
return(null);
}
// Pseudocode:
//string input =>
//{
// R result = 0;
// for (int i = input.Length - 1; i >= 0; i--)
// {
// result <<= 6;
// var m = _invMap[input[i]];
// if (m == 0xff)
// return default(ConversionResult<R>);
// result += m;
// }
// return new ConversionResult<R>(result);
//}
private LambdaExpression fromLambda(Type to)
{
var stringthis = typeof(string).GetTypeInfo().DeclaredProperties.First(p => p.GetIndexParameters().Length == 1 && p.GetIndexParameters()[0].ParameterType == typeof(int));
var input = Ex.Parameter(typeof(string), "input");
var result = Ex.Parameter(to, "result");
var i = Ex.Parameter(typeof(int), "i");
var m = Ex.Parameter(typeof(byte), "m");
var loopstart = Ex.Label("loopstart");
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
var loop = Ex.Block(
Ex.Label(loopstart),
Ex.IfThen(Ex.MakeBinary(ExpressionType.LessThan, i, Ex.Constant(0)),
Ex.Goto(end, Result(to, result))),
Ex.LeftShiftAssign(result, Ex.Constant(6)),
Ex.Assign(m, Ex.ArrayIndex(Ex.Constant(_invMap), Ex.Convert(Ex.MakeIndex(input, stringthis, new[] { i }), typeof(int)))),
Ex.IfThen(Ex.MakeBinary(ExpressionType.Equal, m, Ex.Constant((byte)0xff)),
Ex.Goto(end, NoResult(to))),
Ex.AddAssign(result, Ex.Convert(m, result.Type)),
Ex.PostDecrementAssign(i),
Ex.Goto(loopstart));
var block = Ex.Block(new[] { result, i, m },
Ex.Assign(result, Ex.Convert(Ex.Constant(0), to)),
Ex.Assign(i, Ex.MakeBinary(ExpressionType.Subtract, Ex.Property(input, nameof(string.Length)), Ex.Constant(1))),
loop,
Ex.Label(end, NoResult(to)));
return(Ex.Lambda(block, input));
}
protected override object VisitFor(For F)
{
target.PushScope();
// Generate the loop header code.
Visit(F.Init);
string name = target.LabelName();
LinqExprs.LabelTarget begin = LinqExpr.Label("for_" + name + "_begin");
LinqExprs.LabelTarget end = LinqExpr.Label("for_" + name + "_end");
loops.Push(new Loop(LinqExpr.Goto(end), LinqExpr.Goto(begin)));
// Check the condition, exit if necessary.
target.Add(LinqExpr.Label(begin));
target.Add(LinqExpr.IfThen(LinqExpr.Not(target.Compile(F.Condition)), LinqExpr.Goto(end)));
// Generate the body code.
Visit(F.Body);
// Generate the step code.
Visit(F.Step);
target.Add(LinqExpr.Goto(begin));
// Exit point.
target.Add(LinqExpr.Label(end));
loops.Pop();
target.PopScope();
return(null);
}
public void If(
LinqExpr Condition,
Action True,
Action False)
{
string name = LabelName();
LinqExprs.LabelTarget _else = LinqExpr.Label("if_" + name + "_else");
LinqExprs.LabelTarget end = LinqExpr.Label("if_" + name + "_end");
// Check the condition, exit if necessary.
code.Add(LinqExpr.IfThen(LinqExpr.Not(Condition), LinqExpr.Goto(_else)));
// Execute true code.
PushScope();
True();
PopScope();
code.Add(LinqExpr.Goto(end));
// Execute false code.
code.Add(LinqExpr.Label(_else));
PushScope();
False();
PopScope();
// Exit point.
code.Add(LinqExpr.Label(end));
}
public LambdaExpression CreateLambda(Type from, Type to)
{
var toParameters = to.GetTypeInfo().GenericTypeArguments;
var tupa = toParameters.Length;
var input = Ex.Parameter(from, "input");
var converters = toParameters.Select(p => Ref.GetLambda(typeof(string), p)).ToArray();
var res = toParameters.Select(p => Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p))).ToArray();
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
var indexer = typeof(string[]).GetTypeInfo().GetDeclaredProperty("Item");
var split = Ex.Parameter(typeof(string[]), "split");
var conversion = Ex.Block(converters.Select((c, i) =>
Ex.Block(
Ex.Assign(res[i],
c.ApplyTo(Ex.MakeIndex(split, indexer, new[] { Ex.MakeBinary(Et.Add, Ex.Constant(i), Ex.MakeBinary(Et.Subtract, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa))) }))),
Ex.IfThen(Ex.Not(Ex.Property(res[i], nameof(IConversionResult.IsSuccessful))),
Ex.Goto(end, NoResult(to))))));
var block = Ex.Block(new[] { split },
Ex.Assign(split, Ex.Call(input, nameof(string.Split), Type.EmptyTypes, _separator)),
Ex.Condition(Ex.MakeBinary(Et.LessThan, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa)),
NoResult(to),
Ex.Block(res,
Ex.IfThen(Ex.MakeBinary(Et.GreaterThan, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa)),
Ex.Assign(Ex.ArrayAccess(split, Ex.MakeBinary(Et.Subtract, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa))),
Ex.Call(typeof(string), nameof(string.Join), Type.EmptyTypes, _separatorString,
Ex.Call(typeof(Enumerable), nameof(Enumerable.Take), new[] { typeof(string) }, split,
Ex.MakeBinary(Et.Add, Ex.Constant(1), Ex.MakeBinary(Et.Subtract, Ex.Property(split, nameof(Array.Length)), Ex.Constant(tupa))))))),
conversion,
Ex.Label(end, Result(to, Ex.Call(Creator(to), res.Select(r => Ex.Property(r, nameof(IConversionResult.Result)))))))));
var lambda = Ex.Lambda(block, input);
return(lambda);
}
private LambdaExpression toDictLambda(Type from, Type to)
{
var valueType = recordCreator.GetValueType(to);
var recType = typeof(IRecord <>).MakeGenericType(valueType);
var set = recType.GetTypeInfo().GetDeclaredMethod(nameof(IRecord <object> .SetValue));
var input = Ex.Parameter(from, "input");
var tmp = Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(valueType), "tmp");
var res = Ex.Parameter(typeof(IDictionary <,>).MakeGenericType(typeof(string), valueType), "res");
var rec = Ex.Parameter(recType, "rec");
var getters = GetReadablePropertiesForType(from);
var converters = getters.Select(g => Ref.GetLambda(g.PropertyType, valueType));
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to));
var block = Ex.Block(new[] { tmp, res, rec },
Ex.Assign(res, Ex.New(GetParameterlessConstructor(to))),
Ex.Assign(rec, recordCreator.Creator(to).ApplyTo(res)),
Ex.IfThen(Ex.MakeBinary(ExpressionType.Equal, rec, Ex.Default(rec.Type)), Ex.Goto(end, NoResult(to))),
Ex.Block(getters.Zip(converters, (g, c) => new { g, c })
.Select(x =>
Ex.Block(
Ex.Assign(tmp, x.c.ApplyTo(Ex.Property(input, x.g))),
Ex.IfThenElse(Ex.Property(tmp, nameof(IConversionResult.IsSuccessful)),
Ex.Call(rec, set, Ex.Constant(x.g.Name), Ex.Property(tmp, nameof(IConversionResult.Result))),
Ex.Goto(end, NoResult(to)))))),
Ex.Label(end, Result(to, Ex.Convert(res, to))));
return(Ex.Lambda(block, input));
}
/// <summary>
/// Generate a for loop with the given code generator functions.
/// </summary>
/// <param name="Init"></param>
/// <param name="Condition"></param>
/// <param name="Step"></param>
/// <param name="Body"></param>
public void For(
Action Init,
LinqExpr Condition,
Action Step,
Action <LinqExpr, LinqExpr> Body)
{
PushScope();
// Generate the loop header code.
Init();
string name = LabelName();
LinqExprs.LabelTarget begin = LinqExpr.Label("for_" + name + "_begin");
LinqExprs.LabelTarget end = LinqExpr.Label("for_" + name + "_end");
// Check the condition, exit if necessary.
code.Add(LinqExpr.Label(begin));
code.Add(LinqExpr.IfThen(LinqExpr.Not(Condition), LinqExpr.Goto(end)));
// Generate the body code.
Body(LinqExpr.Goto(end), LinqExpr.Goto(begin));
// Generate the step code.
Step();
code.Add(LinqExpr.Goto(begin));
// Exit point.
code.Add(LinqExpr.Label(end));
PopScope();
}
private static Func <int[], int[]> GenerateCopyExpression()
{
var ctor = typeof(int[]).GetConstructor(new[] { typeof(int) });
var get = typeof(int[]).GetMethod("Get", new[] { typeof(int) });
var set = typeof(int[]).GetMethod("Set", new[] { typeof(int), typeof(int) });
var p1 = Exp.Parameter(typeof(int[]));
var v1 = Exp.Variable(typeof(int[]));
var v2 = Exp.Variable(typeof(int));
var @break = Exp.Label();
var block = Exp.Block(
new[] { v1, v2 },
Exp.Assign(v1, Exp.New(ctor, Exp.Property(p1, "Length"))),
Exp.Assign(v2, Exp.Constant(0)),
Exp.Loop(
Exp.IfThenElse(
Exp.LessThan(v2, Exp.Property(p1, "Length")),
Exp.Block(
Exp.Call(v1, set, v2, Exp.Call(p1, get, v2)),
Exp.AddAssign(v2, Exp.Constant(1))
),
Exp.Break(@break)
),
@break),
v1
);
return(Exp.Lambda <Func <int[], int[]> >(block, new ParameterExpression[] { p1 }).Compile());
}
public Expr ToExpression()
{
var exitLabel = Expr.Label();
var loopBody = Expr.Block(Body.ToExpression(), Expr.PreIncrementAssign(Iterator.ToExpression()));
return(Expr.Loop(Expr.IfThenElse(Expr.LessThan(Iterator.ToExpression(), UpperBound.ToExpression()), loopBody, Expr.Break(exitLabel)), exitLabel));
}
/// <summary>
/// Generate a while loop with the given code generator functions.
/// </summary>
/// <param name="Condition"></param>
/// <param name="Body"></param>
public void While(
LinqExpr Condition,
Action <LinqExpr, LinqExpr> Body)
{
string name = LabelName();
LinqExprs.LabelTarget begin = LinqExpr.Label("while_" + name + "_begin");
LinqExprs.LabelTarget end = LinqExpr.Label("while_" + name + "_end");
PushScope();
// Check the condition, exit if necessary.
code.Add(LinqExpr.Label(begin));
code.Add(LinqExpr.IfThen(LinqExpr.Not(Condition), LinqExpr.Goto(end)));
// Generate the body code.
Body(LinqExpr.Goto(end), LinqExpr.Goto(begin));
// Loop.
code.Add(LinqExpr.Goto(begin));
// Exit label.
code.Add(LinqExpr.Label(end));
PopScope();
}
public void Factorial()
{
var value = LinqExpression.Parameter(typeof(int), "value");
var result = LinqExpression.Parameter(typeof(int), "result");
var label = LinqExpression.Label(typeof(int), "label");
var one = LinqExpression.Constant(1);
var expression = LinqExpression.Block(
new[] { result },
LinqExpression.Assign(
result,
one),
LinqExpression.Loop(
LinqExpression.Condition(
LinqExpression.GreaterThan(
value,
one),
LinqExpression.MultiplyAssign(
result,
LinqExpression.PostDecrementAssign(
value)),
LinqExpression.Break(
label,
result),
typeof(void)),
label));
ShouldRoundrip(expression);
}
protected override object VisitIf(If I)
{
string name = target.LabelName();
LinqExprs.LabelTarget _else = LinqExpr.Label("if_" + name + "_else");
LinqExprs.LabelTarget end = LinqExpr.Label("if_" + name + "_end");
// Check the condition, exit if necessary.
target.Add(LinqExpr.IfThen(LinqExpr.Not(target.Compile(I.Condition)), LinqExpr.Goto(_else)));
// Execute true code.
target.PushScope();
Visit(I.True);
target.PopScope();
target.Add(LinqExpr.Goto(end));
// Execute false code.
target.Add(LinqExpr.Label(_else));
target.PushScope();
Visit(I.False);
target.PopScope();
// Exit point.
target.Add(LinqExpr.Label(end));
return(null);
}
public void Label()
{
var expected = LinqExpression.Label(
LinqExpression.Label(
typeof(int),
"target"),
LinqExpression.Parameter(
typeof(int)));
using var g = new GraphEngine.Graph();
g.LoadFromString(@"
@prefix : <http://example.com/> .
:s
:labelTarget [
:targetName ""target"" ;
:targetType _:int ;
] ;
:labelDefaultValue [
:parameterType _:int ;
] ;
.
_:int
:typeName ""System.Int32"" ;
.
");
var s = g.GetUriNode(":s");
var actual = Expression.Parse(s).LinqExpression;
Console.WriteLine(actual.GetDebugView());
actual.Should().Be(expected);
}
public void Break()
{
var expression = LinqExpression.Break(
LinqExpression.Label(
typeof(void)));
ShouldRoundrip(expression);
}
public static Scope CreateFunctionChild(Scope parent)
{
return(new Scope
{
parent = parent,
returnLabel = Expr.Label(typeof(object))
});
}
/// <summary>
/// Generate a return statement.
/// </summary>
/// <param name="Value"></param>
public void Return(LinqExpr Value)
{
// Create the return label if it doesn't already exist.
if (ret == null)
{
ret = LinqExpr.Label(Value.Type, "ret");
}
code.Add(LinqExpr.Return(ret, Value));
}
public void Return()
{
// Create the return label if it doesn't already exist.
if (ret == null)
{
ret = LinqExpr.Label("ret");
}
code.Add(LinqExpr.Return(ret));
}
public LinqExprs.Expression <T> Build <T>()
{
// If the return target has been created, append it to the body.
IEnumerable <LinqExpr> body = code;
if (ret != null)
{
body = body.Append(LinqExpr.Label(ret, ret.Type.IsValueType ? LinqExpr.Constant(Activator.CreateInstance(ret.Type)) : null));
}
return(LinqExpr.Lambda <T>(LinqExpr.Block(Decls, body), parameters));
}
protected internal override MAst Transform()
{
// for more info on LambdaExpressions returning values see pag. 28 of 'expr-tree-spec.doc'
// 2.8.1 Ensuring Returns are Lexical Exits with Matching Types
LabelExpression labelBody = MAst.Label(_returnLabel, Body.Transform());
// reduces as a LambdaExpression
LambdaExpression function = MAst.Lambda(labelBody, Parameters.Select(parameter =>
(ParameterExpression)
parameter.Transform()));
return(MAst.Assign(Pointer, function));
}
protected internal override void CheckSemantics(AstHelper astHelper)
{
_returnLabel = MAst.Label(Type);
AstHelper helper = astHelper.CreateChild(variables: true, returning: true, returnLabel: _returnLabel);
// add the variables to the child scope
foreach (FunctionParameterExpression functionParameterExpression in Parameters)
{
functionParameterExpression.AddToScope(helper);
}
Body.CheckSemantics(helper);
astHelper.Errors.Check(new TypeMismatchedError(Type, Body.Type, Start));
}
private LambdaExpression constructionLambda(Type from, Type to)
{
var valueType = recordCreator.GetValueType(from);
var recType = typeof(IRecord <>).MakeGenericType(valueType);
var tryGet = recType.GetTypeInfo().GetDeclaredMethod(nameof(IRecord <object> .TryGetValue));
var input = Ex.Parameter(from, "input");
var rec = Ex.Parameter(recType, "rec");
var ctor = GetConstructorForType(to);
var tmp = Ex.Parameter(valueType, "tmp");
var pars = ctor.GetParameters().Select((p, i) => new
{
Converter = Ref.GetLambda(valueType, p.ParameterType),
Var = Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p.ParameterType), p.Name),
Type = p.ParameterType,
Optional = p.GetCustomAttributes <OptionalAttribute>().Any(),
Default = p.HasDefaultValue ? p.DefaultValue : p.ParameterType.GetTypeInfo().IsValueType ? Activator.CreateInstance(p.ParameterType) : null
}).ToArray();
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
var block = Ex.Block(new[] { rec }.Concat(pars.Select(x => x.Var)),
Ex.Assign(rec, recordCreator.Creator(from).ApplyTo(input)),
Ex.Block(new[] { tmp }, pars
.Select(x =>
x.Optional
? Ex.Block(
Ex.IfThenElse(
Ex.MakeBinary(ExpressionType.OrElse,
Ex.Call(rec, tryGet, Ex.Constant(x.Var.Name), tmp),
Ex.Call(rec, tryGet, Ex.Constant(ToPascalCase(x.Var.Name)), tmp)),
Ex.Block(
Ex.Assign(x.Var, x.Converter.ApplyTo(tmp)),
Ex.IfThen(Ex.Not(Ex.Property(x.Var, nameof(IConversionResult.IsSuccessful))),
Ex.Goto(end, NoResult(to)))),
Ex.Assign(x.Var, Result(x.Type, Ex.Constant(x.Default, x.Type)))))
: Ex.Block(
Ex.IfThen(Ex.Not(Ex.Call(rec, tryGet, Ex.Constant(x.Var.Name), tmp)),
Ex.IfThen(Ex.Not(Ex.Call(rec, tryGet, Ex.Constant(ToPascalCase(x.Var.Name)), tmp)),
Ex.Goto(end, NoResult(to)))),
Ex.Assign(x.Var, x.Converter.ApplyTo(tmp)),
Ex.IfThen(Ex.Not(Ex.Property(x.Var, nameof(IConversionResult.IsSuccessful))),
Ex.Goto(end, NoResult(to)))))),
Ex.Label(end, Result(to, Ex.New(ctor, pars.Select(p => Ex.Property(p.Var, nameof(IConversionResult.Result)))))));
return(Ex.Lambda(block, input));
}
// Pseudocode:
//I input =>
//{
// var i = (UI)input;
// var result = new char[base64sizeof(UI)];
// for (int j = 0; j == 0 || i > 0; j++)
// {
// result[j] = _mapChar[i & 0x3f];
// i >>= 6;
// }
//}
private LambdaExpression toLambda(Type from)
{
var input = Ex.Parameter(from, "input");
var result = Ex.Parameter(typeof(char[]), "result");
var i = workingType(from) == from ? input : Ex.Parameter(workingType(from), "i");
var j = Ex.Parameter(typeof(int), "j");
var loopstart = Ex.Label("loopstart");
var loopend = Ex.Label("loopend");
var loop = Ex.Block(
Ex.Label(loopstart),
Ex.IfThen(Ex.MakeBinary(ExpressionType.AndAlso,
Ex.MakeBinary(ExpressionType.GreaterThan, j, Ex.Constant(0)),
i.Type == typeof(BigInteger)
? (Ex)Ex.Call(i, nameof(BigInteger.Equals), Type.EmptyTypes, Ex.Constant(BigInteger.Zero))
: Ex.MakeBinary(ExpressionType.Equal, i, Ex.Convert(Ex.Constant(0), i.Type))),
Ex.Goto(loopend)),
Ex.Assign(
Ex.ArrayAccess(result, j),
Ex.ArrayIndex(Ex.Constant(_mapChars),
Ex.Convert(Ex.MakeBinary(ExpressionType.And, i, Ex.Convert(Ex.Constant(0x3f), i.Type)), typeof(int)))),
Ex.RightShiftAssign(i, Ex.Constant(6)),
Ex.PostIncrementAssign(j),
Ex.Goto(loopstart));
var ret = Result(typeof(string),
Ex.New(typeof(string).GetTypeInfo().DeclaredConstructors
.Select(c => new { c, p = c.GetParameters() })
.First(c => c.p.Length == 3 && c.p[0].ParameterType == typeof(char[]) && c.p[1].ParameterType == typeof(int) && c.p[2].ParameterType == typeof(int)).c,
result, Ex.Constant(0), j));
var block = Ex.Block(Ex.Assign(j, Ex.Constant(0)),
Ex.Assign(result, Ex.NewArrayBounds(typeof(char), Ex.Constant(charbound(from)))),
loop,
Ex.Label(loopend),
ret);
block = input == i
? Ex.Block(new[] { j, result },
block)
: Ex.Block(new[] { i, j, result },
Ex.Assign(i, Ex.Convert(input, i.Type)),
block);
return(Ex.Lambda(block, input));
}
/// <summary>
/// Creates an Entry based on the converter functions passed as a parameter.
/// </summary>
public static Entry Make <T, U>(IEnumerable <Tuple <LambdaExpression, Delegate> > fs)
{
var subs = fs.Select(t => Tuple.Create(t.Item1, (Func <T, ConversionResult <U> >)t.Item2)).ToArray();
var functions = subs.Select(f => f.Item2).ToArray();
var specific = functions.Length == 0
? _ => new ConversionResult <U>()
: functions.Length == 1
? functions[0]
: new Func <T, ConversionResult <U> >(i =>
{
ConversionResult <U> res;
for (int j = 0; j < functions.Length; j++)
{
res = functions[j](i);
if (res.IsSuccessful)
{
return(res);
}
}
return(new ConversionResult <U>());
});
var generic = new Func <object, IConversionResult>(i => specific((T)i));
var input = Ex.Parameter(typeof(T), "input");
var result = Ex.Parameter(typeof(ConversionResult <U>), "result");
var end = Ex.Label(typeof(ConversionResult <U>), "end");
var lambda = subs.Length == 0
? (Expression <Func <T, ConversionResult <U> > >)(_ => default(ConversionResult <U>))
: subs.Length == 1
? subs[0].Item1 ?? funcToLambda(subs[0].Item2)
: Ex.Lambda(Ex.Block(new[] { result },
Ex.Block(subs.Select(sub =>
Ex.Block(
Ex.Assign(result, (sub.Item1 ?? funcToLambda(sub.Item2)).ApplyTo(input)),
Ex.IfThen(
Ex.Property(result, nameof(IConversionResult.IsSuccessful)),
Ex.Goto(end, result))))),
Ex.Label(end, NoResult(typeof(U)))), input);
return(new Entry(generic, specific, lambda));
LambdaExpression funcToLambda(Func <T, ConversionResult <U> > f)
=> (Expression <Func <T, ConversionResult <U> > >)(inp => f(inp));
}
public override Expr ToExpression()
{
var loopBody = new List <Expr>();
if (ReadExpression.Count > 0)
{
loopBody.Add(Expr.Assign(AccessExpression, ReadExpression[0]));
}
foreach (var child in Children)
{
loopBody.Add(child.ToExpression());
}
loopBody.Add(Expr.PreIncrementAssign(Iterator));
var loopExitLabel = Expr.Label();
var loopCode = Expr.Loop(Expr.IfThenElse(LoopCondition, Expr.Block(loopBody), Expr.Break(loopExitLabel)), loopExitLabel);
return(Expr.Block(new[] { Iterator }, IteratorInitializer, loopCode));
}
private LambdaExpression createForCollection(Type from, Type to)
{
var cType = (from i in @from.GetTypeInfo().ImplementedInterfaces.Concat(new[] { @from })
where i.GetTypeInfo().IsInterface &&
i.GenericTypeArguments.Length == 1 &&
i.GetGenericTypeDefinition() == typeof(IReadOnlyCollection <>)
select i.GenericTypeArguments[0]).SingleOrDefault();
if (cType == null)
{
return(null);
}
var toParameters = to.GetTypeInfo().GenericTypeArguments;
var input = Ex.Parameter(from, "input");
var getEnumerator = getGetEnumeratorMethod(from);
var enumerator = Ex.Parameter(getEnumerator.ReturnType, "enumerator");
var eType = getEnumerator.ReturnType.GetTypeInfo().GetDeclaredProperty(nameof(IEnumerator.Current)).PropertyType;
var converters = toParameters.Select(p => Ref.GetLambda(eType, p)).ToArray();
var res = toParameters.Select(p => Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p))).ToArray();
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
Ex conversion = enumeratorConversion(to, enumerator, eType, converters, res, end);
var block = Ex.Block(res.Concat(new[] { enumerator }),
Ex.IfThen(
Ex.MakeBinary(Et.LessThan,
Ex.Property(input, typeof(IReadOnlyCollection <>).MakeGenericType(cType).GetTypeInfo()
.GetDeclaredProperty(nameof(IReadOnlyCollection <object> .Count))),
Ex.Constant(TupleArity(to))),
Ex.Goto(end, NoResult(to))),
Ex.Assign(enumerator, Ex.Call(input, getEnumerator)),
typeof(IDisposable).GetTypeInfo().IsAssignableFrom(enumerator.Type.GetTypeInfo())
? (Ex)Ex.TryFinally(conversion,
Ex.Call(enumerator, typeof(IDisposable).GetTypeInfo().GetDeclaredMethod(nameof(IDisposable.Dispose))))
: conversion,
Ex.Label(end, Result(to, Ex.Call(Creator(to), res.Select(r => Ex.Property(r, nameof(IConversionResult.Result)))))));
var lambda = Ex.Lambda(block, input);
return(lambda);
}
/// <summary>
/// Generate an infinite loop with the given code generator functions.
/// </summary>
/// <param name="Condition"></param>
/// <param name="Body"></param>
public void Loop(Action <LinqExpr, LinqExpr> Body)
{
string name = LabelName();
LinqExprs.LabelTarget begin = LinqExpr.Label("while_" + name + "_begin");
LinqExprs.LabelTarget end = LinqExpr.Label("while_" + name + "_end");
PushScope();
code.Add(LinqExpr.Label(begin));
// Generate the body code.
Body(LinqExpr.Goto(end), LinqExpr.Goto(begin));
// Loop.
code.Add(LinqExpr.Goto(begin));
// Exit label.
code.Add(LinqExpr.Label(end));
PopScope();
}
/// <summary>for(loopVar = min; i < max; i++) { loopContent }</summary>
public static E For(this ParameterExpression loopVar, int min, int max, E loopContent)
{
var initAssign = E.Assign(loopVar, E.Constant(min, typeof(int)));
var breakLabel = E.Label("LoopBreak");
var loop = E.Block(new[] { loopVar },
initAssign,
E.Loop(
E.IfThenElse(
E.LessThan(loopVar, E.Constant(max, typeof(int))),
E.Block(
loopContent,
E.Assign(loopVar, E.Increment(loopVar))
),
E.Break(breakLabel)
),
breakLabel)
);
return(loop);
}
public static Expression <Func <string[], int> > WrapMain(Expression program)
{
LabelTarget label = Expression.Label(typeof(int));
BlockExpression programReturningNoErrorCode = Expression.Block(program, Expression.Constant(0));
Expression <Action <Exception> > writeLine = s => Console.Error.WriteLine(s);
ParameterExpression exitException = Expression.Variable(typeof(ExitException));
ParameterExpression exception = Expression.Variable(typeof(Exception));
TryExpression programCatchingExceptions = Expression.TryCatch(programReturningNoErrorCode,
Expression.Catch(exitException, Expression.Property(exitException, "Code")),
Expression.Catch(exception, Expression.Block(writeLine.eInvoke(exception), Expression.Constant(1))));
LabelExpression returnLabel = Expression.Label(label, programCatchingExceptions);
ParameterExpression parameter = Expression.Parameter(typeof(string[]), "args");
Expression <Func <string[], int> > lambda = Expression.Lambda <Func <string[], int> >(returnLabel, parameter);
return(lambda);
}
private LambdaExpression createForList(Type from, Type to)
{
var cType = (from i in @from.GetTypeInfo().ImplementedInterfaces.Concat(new[] { @from })
where i.GetTypeInfo().IsInterface &&
i.GenericTypeArguments.Length == 1 &&
i.GetGenericTypeDefinition() == typeof(IReadOnlyList <>)
select i.GenericTypeArguments[0]).SingleOrDefault();
if (cType == null)
{
return(null);
}
var indexer = typeof(IReadOnlyList <>).MakeGenericType(cType).GetTypeInfo().GetDeclaredProperty("Item");
var count = typeof(IReadOnlyCollection <>).MakeGenericType(cType).GetTypeInfo().GetDeclaredProperty(nameof(IReadOnlyCollection <object> .Count));
var toParameters = to.GetTypeInfo().GenericTypeArguments;
var input = Ex.Parameter(from, "input");
var converters = toParameters.Select(p => Ref.GetLambda(cType, p)).ToArray();
var res = toParameters.Select(p => Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p))).ToArray();
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
var conversion = Ex.Block(converters.Select((c, i) =>
Ex.Block(
Ex.Assign(res[i],
c.ApplyTo(Ex.MakeIndex(input, indexer, new[] { Ex.Constant(i) }))),
Ex.IfThen(Ex.Not(Ex.Property(res[i], nameof(IConversionResult.IsSuccessful))),
Ex.Goto(end, NoResult(to))))));
var block = Ex.Block(res,
Ex.IfThen(
Ex.MakeBinary(Et.LessThan,
Ex.Property(input, count),
Ex.Constant(toParameters.Length)),
Ex.Goto(end, NoResult(to))),
conversion,
Ex.Label(end, Result(to, Ex.Call(Creator(to), res.Select(r => Ex.Property(r, nameof(IConversionResult.Result)))))));
var lambda = Ex.Lambda(block, input);
return(lambda);
}
private LambdaExpression setterLambda(Type from, Type to)
{
var valueType = recordCreator.GetValueType(from);
var recType = typeof(IRecord <>).MakeGenericType(valueType);
var tryGet = recType.GetTypeInfo().GetDeclaredMethod(nameof(IRecord <object> .TryGetValue));
var input = Ex.Parameter(from, "input");
var rec = Ex.Parameter(recType, "rec");
var tmp = Ex.Parameter(valueType, "tmp");
var ctor = GetParameterlessConstructor(to);
var setters = GetWritablePropertiesForType(to);
var res = Ex.Parameter(to, "res");
var pars = setters.Select((p, i) => new
{
Converter = Ref.GetLambda(valueType, p.PropertyType),
Var = Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(p.PropertyType), p.Name)
}).ToArray();
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
var block = Ex.Block(new[] { tmp, res, rec }.Concat(pars.Select(x => x.Var)),
Ex.Assign(res, Ex.New(ctor)),
Ex.Assign(rec, recordCreator.Creator(from).ApplyTo(input)),
Ex.Block(pars
.Select(x =>
Ex.Block(
Ex.IfThen(
Ex.MakeBinary(ExpressionType.OrElse,
Ex.Call(rec, tryGet, Ex.Constant(x.Var.Name), tmp),
Ex.Call(rec, tryGet, Ex.Constant(ToCamelCase(x.Var.Name)), tmp)),
Ex.Block(
Ex.Assign(x.Var, x.Converter.ApplyTo(tmp)),
Ex.IfThenElse(Ex.Property(x.Var, nameof(IConversionResult.IsSuccessful)),
Ex.Assign(Ex.Property(res, x.Var.Name), Ex.Property(x.Var, nameof(IConversionResult.Result))),
Ex.Goto(end, NoResult(to)))))))),
Ex.Label(end, Result(to, res)));
return(Ex.Lambda(block, input));
}
