| public static RightShiftAssign ( Expression left, Expression right ) : BinaryExpression | ||
| left | Expression | An |
| right | Expression | An |
| Résultat | BinaryExpression | |
// 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));
}
private BinaryExpression BinaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var left = this.Prop(obj, "left", this.Expression);
var right = this.Prop(obj, "right", this.Expression);
var method = this.Prop(obj, "method", this.Method);
var conversion = this.Prop(obj, "conversion", this.LambdaExpression);
var liftToNull = this.Prop(obj, "liftToNull").Value <bool>();
switch (nodeType)
{
case ExpressionType.Add: return(Expr.Add(left, right, method));
case ExpressionType.AddAssign: return(Expr.AddAssign(left, right, method, conversion));
case ExpressionType.AddAssignChecked: return(Expr.AddAssignChecked(left, right, method, conversion));
case ExpressionType.AddChecked: return(Expr.AddChecked(left, right, method));
case ExpressionType.And: return(Expr.And(left, right, method));
case ExpressionType.AndAlso: return(Expr.AndAlso(left, right, method));
case ExpressionType.AndAssign: return(Expr.AndAssign(left, right, method, conversion));
case ExpressionType.ArrayIndex: return(Expr.ArrayIndex(left, right));
case ExpressionType.Assign: return(Expr.Assign(left, right));
case ExpressionType.Coalesce: return(Expr.Coalesce(left, right, conversion));
case ExpressionType.Divide: return(Expr.Divide(left, right, method));
case ExpressionType.DivideAssign: return(Expr.DivideAssign(left, right, method, conversion));
case ExpressionType.Equal: return(Expr.Equal(left, right, liftToNull, method));
case ExpressionType.ExclusiveOr: return(Expr.ExclusiveOr(left, right, method));
case ExpressionType.ExclusiveOrAssign: return(Expr.ExclusiveOrAssign(left, right, method, conversion));
case ExpressionType.GreaterThan: return(Expr.GreaterThan(left, right, liftToNull, method));
case ExpressionType.GreaterThanOrEqual: return(Expr.GreaterThanOrEqual(left, right, liftToNull, method));
case ExpressionType.LeftShift: return(Expr.LeftShift(left, right, method));
case ExpressionType.LeftShiftAssign: return(Expr.LeftShiftAssign(left, right, method, conversion));
case ExpressionType.LessThan: return(Expr.LessThan(left, right, liftToNull, method));
case ExpressionType.LessThanOrEqual: return(Expr.LessThanOrEqual(left, right, liftToNull, method));
case ExpressionType.Modulo: return(Expr.Modulo(left, right, method));
case ExpressionType.ModuloAssign: return(Expr.ModuloAssign(left, right, method, conversion));
case ExpressionType.Multiply: return(Expr.Multiply(left, right, method));
case ExpressionType.MultiplyAssign: return(Expr.MultiplyAssign(left, right, method, conversion));
case ExpressionType.MultiplyAssignChecked: return(Expr.MultiplyAssignChecked(left, right, method, conversion));
case ExpressionType.MultiplyChecked: return(Expr.MultiplyChecked(left, right, method));
case ExpressionType.NotEqual: return(Expr.NotEqual(left, right, liftToNull, method));
case ExpressionType.Or: return(Expr.Or(left, right, method));
case ExpressionType.OrAssign: return(Expr.OrAssign(left, right, method, conversion));
case ExpressionType.OrElse: return(Expr.OrElse(left, right, method));
case ExpressionType.Power: return(Expr.Power(left, right, method));
case ExpressionType.PowerAssign: return(Expr.PowerAssign(left, right, method, conversion));
case ExpressionType.RightShift: return(Expr.RightShift(left, right, method));
case ExpressionType.RightShiftAssign: return(Expr.RightShiftAssign(left, right, method, conversion));
case ExpressionType.Subtract: return(Expr.Subtract(left, right, method));
case ExpressionType.SubtractAssign: return(Expr.SubtractAssign(left, right, method, conversion));
case ExpressionType.SubtractAssignChecked: return(Expr.SubtractAssignChecked(left, right, method, conversion));
case ExpressionType.SubtractChecked: return(Expr.SubtractChecked(left, right, method));
default: throw new NotSupportedException();
}
}
public void BinaryExpression_RightShiftAssign() => UnsupportedBinaryExpr(Property.Id, id => Expr.RightShiftAssign(id, Expr.Constant(3)), ExpressionType.RightShiftAssign);