public override SLE.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
return SLE.Expression.Block (expr.MakeExpression (ctx), SLE.Expression.Default (type.GetMetaInfo ()));
#endif
}
public SLE.Expression MakeAssignExpression (BuilderContext ctx, Expression source)
{
return obj.Expression;
}
public override SLE.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
#if NET_4_0 || MOBILE_DYNAMIC
if (type.IsStruct && !obj.Expression.Type.IsValueType)
return SLE.Expression.Unbox (obj.Expression, type.GetMetaInfo ());
if (obj.Expression.NodeType == SLE.ExpressionType.Parameter) {
if (((SLE.ParameterExpression) obj.Expression).IsByRef)
return obj.Expression;
}
#endif
return SLE.Expression.Convert (obj.Expression, type.GetMetaInfo ());
#endif
}
public FlagsHandle (BuilderContext ec, Options flagsToSet)
: this (ec, flagsToSet, flagsToSet)
{
}
internal FlagsHandle (BuilderContext ec, Options mask, Options val)
{
this.ec = ec;
invmask = ~mask;
oldval = ec.flags & mask;
ec.flags = (ec.flags & invmask) | (val & mask);
}
public static System.Linq.Expressions.Expression[] MakeExpression (Arguments args, BuilderContext ctx)
{
if (args == null || args.Count == 0)
return null;
var exprs = new System.Linq.Expressions.Expression [args.Count];
for (int i = 0; i < exprs.Length; ++i) {
Argument a = args.args [i];
exprs[i] = a.Expr.MakeExpression (ctx);
}
return exprs;
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
return Invocation.MakeExpression (ctx, InstanceExpr, method, arguments);
}
public override System.Linq.Expressions.Expression MakeExpression(BuilderContext ctx)
{
return(Invocation.MakeExpression(ctx, InstanceExpr, method, arguments));
}
public override System.Linq.Expressions.Expression MakeExpression(BuilderContext ctx)
{
return(System.Linq.Expressions.Expression.Constant(null));
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
return System.Linq.Expressions.Expression.Constant (null);
}
public static System.Linq.Expressions.Expression[] MakeExpression(Arguments args, BuilderContext ctx)
{
if (args == null || args.Count == 0)
{
return(null);
}
var exprs = new System.Linq.Expressions.Expression [args.Count];
for (int i = 0; i < exprs.Length; ++i)
{
Argument a = args.args [i];
exprs[i] = a.Expr.MakeExpression(ctx);
}
return(exprs);
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
var tassign = target as IDynamicAssign;
if (tassign == null)
throw new InternalErrorException (target.GetType () + " does not support dynamic assignment");
var target_object = tassign.MakeAssignExpression (ctx, source);
//
// Some hacking is needed as DLR does not support void type and requires
// always have object convertible return type to support caching and chaining
//
// We do this by introducing an explicit block which returns RHS value when
// available or null
//
if (target_object.NodeType == System.Linq.Expressions.ExpressionType.Block)
return target_object;
System.Linq.Expressions.UnaryExpression source_object;
if (ctx.HasSet (BuilderContext.Options.CheckedScope)) {
source_object = System.Linq.Expressions.Expression.ConvertChecked (source.MakeExpression (ctx), target_object.Type);
} else {
source_object = System.Linq.Expressions.Expression.Convert (source.MakeExpression (ctx), target_object.Type);
}
return System.Linq.Expressions.Expression.Assign (target_object, source_object);
}
public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
{
#if STATIC
return base.MakeExpression (ctx);
#else
return System.Linq.Expressions.Expression.Constant (GetTypedValue (), type.GetMetaInfo ());
#endif
}
public SLE.Expression MakeAssignExpression(BuilderContext ctx, Expression source)
{
return(obj.Expression);
}
