Dlr getDlr()
{
var aToken = childs.Dequeue();
var asig = aToken as Operator;
if (asig != null && asig.type == OperatorType.OpenParenthesis)
{
return(getDlr());
}
var a = aToken as Value;
if (childs.count == 0)
{
return(a.value);
}
var op = childs.Dequeue() as Operator;
if (op.type == OperatorType.CloseParenthesis)
{
return(Dlr.Constant(a.value));
}
var b = getValue();
switch (op.type)
{
case OperatorType.Add: return(Dlr.Add(Dlr.Constant(a.value), Dlr.Constant(b)));
case OperatorType.Subtract: return(Dlr.Subtract(Dlr.Constant(a.value), Dlr.Constant(b)));
case OperatorType.Divide: return(Dlr.Divide(Dlr.Constant(a.value), Dlr.Constant(b)));
case OperatorType.Multiply: return(Dlr.Multiply(Dlr.Constant(a.value), Dlr.Constant(b)));
}
return(Dlr.Empty());
}
public override System.Linq.Expressions.Expression GenerateLinqExpression(IASTContext context)
{
GenerateLinqExpresions(context, left, right, out LinqExpression expLeft, out LinqExpression expRight);
if (IsNullable(expLeft.Type) && !IsNullable(expRight.Type))
{
expRight = LinqExpression.MakeUnary(System.Linq.Expressions.ExpressionType.Convert, expRight, expLeft.Type);
}
else if (IsNullable(expRight.Type) && !IsNullable(expLeft.Type))
{
expLeft = LinqExpression.MakeUnary(System.Linq.Expressions.ExpressionType.Convert, expLeft, expRight.Type);
}
switch (op)
{
case Operator.OP_ADD:
return(LinqExpression.Add(expLeft, expRight));
case Operator.OP_SUB:
return(LinqExpression.Subtract(expLeft, expRight));
case Operator.OP_DIV:
return(LinqExpression.Divide(expLeft, expRight));
case Operator.OP_MUL:
return(LinqExpression.Multiply(expLeft, expRight));
case Operator.OP_AND:
return(LinqExpression.AndAlso(expLeft, expRight));
case Operator.OP_OR:
return(LinqExpression.OrElse(expLeft, expRight));
case Operator.OP_EQUAL:
return(LinqExpression.Equal(expLeft, expRight));
case Operator.OP_DISTINT:
return(LinqExpression.NotEqual(expLeft, expRight));
case Operator.OP_LIKE:
return(CreateLike(expLeft, expRight));
case Operator.OP_LESS:
return(LinqExpression.LessThan(expLeft, expRight));
case Operator.OP_GREATHER:
return(LinqExpression.GreaterThan(expLeft, expRight));
case Operator.OP_GREATHER_EQ:
return(LinqExpression.GreaterThanOrEqual(expLeft, expRight));
case Operator.OP_LESS_EQ:
return(LinqExpression.LessThanOrEqual(expLeft, expRight));
default:
throw new InvalidOperationException("operator not supported");
}
}
static MetaNumeric()
{
Type type = typeof(T);
var left = Ex.Parameter(type, "left");
var right = Ex.Parameter(type, "right");
addition = Ex.Lambda <Func <T, T, T> >(Ex.Add(left, right), left, right).Compile();
subtraction = Ex.Lambda <Func <T, T, T> >(Ex.Subtract(left, right), left, right).Compile();
multiplication = Ex.Lambda <Func <T, T, T> >(Ex.Multiply(left, right), left, right).Compile();
division = Ex.Lambda <Func <T, T, T> >(Ex.Divide(left, right), left, right).Compile();
}
public static Expression Add(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.Add(arg0, arg1)));
}
/// <summary> /// Add to the rotational components of an RV2. /// </summary> public static trv2 AddRV(trv2 rv2, tv2 rv) => Ex.Add(rv2, Ex.Convert(rv, typeof(Vector3)));
/// <summary> /// Add to the rotational components and angle of an RV2. /// </summary> public static trv2 AddRVA(trv2 rv2, tv3 rva) => Ex.Add(rv2, rva);
/// <summary> /// Add to the nonrotational components and angle of an RV2. /// </summary> public static trv2 AddNVA(trv2 rv2, tv2 nv, tfloat ang) => Ex.Add(Ex.Add(rv2, nv), ang);
/// <summary> /// Add to the angle of an RV2. /// </summary> public static trv2 AddA(trv2 rv2, tfloat ang) => Ex.Add(rv2, ang);
/// <summary> /// Add to the nonrotational components of an RV2. /// </summary> public static trv2 AddNV(trv2 rv2, tv2 nv) => Ex.Add(rv2, nv);
