|
public static MakeIndex ( |
||
| instance | The object to which the property belongs. Should be null if the property is static(shared). | |
| indexer | An |
|
| arguments | IEnumerable |
An |
| return | ||
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);
}
// 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));
}
public void MiscellaneousExpression_Index()
{
var list = Enumerable.Range(0, 5000).ToList();
var indexer = list.GetType().GetProperty("Item");
ExecuteBinaryExpr(Property.Id, id =>
{
var index = Expr.MakeIndex(Expr.Constant(list), indexer, new[] { id });
return(index);
}, ExpressionType.Index);
}
private IndexExpression IndexExpression(ExpressionType nodeType, System.Type type, JObject obj)
{
var expression = this.Prop(obj, "object", this.Expression);
var indexer = this.Prop(obj, "indexer", this.Property);
var arguments = this.Prop(obj, "arguments", this.Enumerable(this.Expression));
switch (nodeType)
{
case ExpressionType.Index:
return(Expr.MakeIndex(expression, indexer, arguments));
default:
throw new NotSupportedException();
}
}
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 static bool TryConvertToIndexExpession(Expression expr, out IndexExpression result)
{
if (expr.NodeType == ExpressionType.Index)
{
result = (IndexExpression)expr;
return(true);
}
if (expr.NodeType == ExpressionType.Call)
{
var callExpr = (MethodCallExpression)expr;
var indexProperty = callExpr.Method.DeclaringType.GetProperties()
.FirstOrDefault(p => p.GetMethod == callExpr.Method);
if (indexProperty != null)
{
result = Expression.MakeIndex(callExpr.Object, indexProperty, callExpr.Arguments);
return(true);
}
}
result = null;
return(false);
}
private Expression ReduceIndex()
{
bool isPrefix = this.IsPrefix;
IndexExpression right = (IndexExpression)this._operand;
int count = right.Arguments.Count;
Expression[] list = new Expression[count + (isPrefix ? 2 : 4)];
ParameterExpression[] expressionArray2 = new ParameterExpression[count + (isPrefix ? 1 : 2)];
ParameterExpression[] expressionArray3 = new ParameterExpression[count];
int index = 0;
expressionArray2[index] = Expression.Parameter(right.Object.Type, null);
list[index] = Expression.Assign(expressionArray2[index], right.Object);
index++;
while (index <= count)
{
Expression expression2 = right.Arguments[index - 1];
expressionArray3[index - 1] = expressionArray2[index] = Expression.Parameter(expression2.Type, null);
list[index] = Expression.Assign(expressionArray2[index], expression2);
index++;
}
right = Expression.MakeIndex(expressionArray2[0], right.Indexer, new TrueReadOnlyCollection <Expression>(expressionArray3));
if (!isPrefix)
{
ParameterExpression operand = expressionArray2[index] = Expression.Parameter(right.Type, null);
list[index] = Expression.Assign(expressionArray2[index], right);
index++;
list[index++] = Expression.Assign(right, this.FunctionalOp(operand));
list[index++] = operand;
}
else
{
list[index++] = Expression.Assign(right, this.FunctionalOp(right));
}
return(Expression.Block((IEnumerable <ParameterExpression>) new TrueReadOnlyCollection <ParameterExpression>(expressionArray2), (IEnumerable <Expression>) new TrueReadOnlyCollection <Expression>(list)));
}
public override SysExpr ToExpression() => SysExpr.MakeIndex(Object.ToExpression(), Indexer, ArgumentsToExpressions());
protected override Expression VisitIndex(IndexExpression node) =>
Linearize(args => Ex.MakeIndex(args[0], node.Indexer, args.Skip(1)),
node.Arguments.Prepend(node.Object).ToArray());
internal Expression Rewrite(Expression instance, Expression[] arguments)
{
return(Expression.MakeIndex(instance, this._indexer, arguments ?? this._arguments));
}
public static Expression GetByPropertyIndex(this Expression expression, PropertyInfo property, IEnumerable <Expression> expressions) => Expression.MakeIndex(expression, property, expressions);
