static Action <string, string> MakeNewProjectDialogMethod()
{
var newProjInfoType = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypesOrNone()).FirstOrDefault(t => t.Name == "VSNEWPROJECTDLGINFO");
var sDialogService = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SVsDialogService));
var rawDialogService = (SVsDialogService)sDialogService;
var hierarchyArg = Expression.Parameter(typeof(string), "hierarchy");
var nameArg = Expression.Parameter(typeof(string), "name");
var newProjInfoVar = Expression.Variable(newProjInfoType, "newProjInfo");
var locVar = Expression.Variable(typeof(string), "locVar");
var expr = Expression.Lambda <Action <string, string> >(
Expression.Block(
new[] { newProjInfoVar, locVar },
Expression.Assign(newProjInfoVar, Expression.New(newProjInfoType)),
Expression.Assign(Expression.Field(newProjInfoVar, newProjInfoType.GetField("pwzExpand")), hierarchyArg),
Expression.Assign(Expression.Field(newProjInfoVar, newProjInfoType.GetField("pwzSelect")), nameArg),
Expression.Call(Expression.Constant(rawDialogService, typeof(SVsDialogService)), rawDialogService.GetType().GetMethod("InvokeDialog"), newProjInfoVar, locVar)
),
new[] { hierarchyArg, nameArg }
);
var compiledExpr = expr.Compile();
return(compiledExpr);
}
Expr Logical(DynamicMetaObject left, DynamicMetaObject right)
{
// Assign left operand to a temp variable for single evaluation
var tempLeft = Expr.Variable(left.LimitType);
var compareExpr = (Expr)tempLeft;
Expr ifExpr = null;
switch (Operation)
{
case ExprType.AndAlso:
if (left.LimitType != typeof(bool))
{
compareExpr = Expr.Equal(tempLeft, Expr.Constant(null));
}
ifExpr = Expr.IfThenElse(compareExpr, right.Expression, tempLeft);
break;
case ExprType.OrElse:
if (left.LimitType != typeof(bool))
{
compareExpr = Expr.NotEqual(tempLeft, Expr.Constant(null));
}
ifExpr = Expr.IfThenElse(compareExpr, tempLeft, right.Expression);
break;
}
return
(Expr.Block(
new[] { tempLeft },
Expr.Assign(tempLeft, left.Expression),
ifExpr));
}
private static Action <Popup, int, bool> CreatePopupCacheValidSetter()
{
var cacheValidField =
typeof(Popup).GetField("_cacheValid", BindingFlags.Instance | BindingFlags.NonPublic);
if (cacheValidField == null || cacheValidField.FieldType != typeof(BitVector32))
{
return (_, _, _) => { }
}
;
var popup = Expression.Parameter(typeof(Popup));
var flagParameter = Expression.Parameter(typeof(int));
var value = Expression.Parameter(typeof(bool));
var indexer = typeof(BitVector32).GetProperty("Item", new[] { typeof(int) });
var lambda = Expression.Lambda <Action <Popup, int, bool> >(
Expression.Assign(
Expression.MakeIndex(
Expression.Field(popup, cacheValidField),
indexer,
new[] { flagParameter }),
value),
popup, flagParameter, value);
return(lambda.Compile());
}
}
public Updater(Type type)
{
var props = from p in type.GetProperties()
let bas = p.GetCustomAttributes(typeof(BrowsableAttribute), true)
let b = bas.FirstOrDefault() as BrowsableAttribute
where p.CanWrite && (b == null || b.Browsable)
select p;
var convert = typeof(Updater).GetMethod("FromString", BindingFlags.Static | BindingFlags.NonPublic);
foreach (var p in props)
{
var instance = X.Parameter(typeof(object));
var value = X.Parameter(typeof(string));
var lambda = X.Lambda <Action <object, string> >(
X.Assign(
X.Property(
X.Convert(instance, type),
p
),
X.Convert(
X.Call(convert, value, X.Constant(p.PropertyType)),
p.PropertyType
)
),
instance, value);
cache[p.Name] = lambda.Compile();
}
}
protected override LinqExpression BuildLinqExpression()
{
var leftOperandExpression = LeftNode.GetEvaluationLinqExpression();
var rightOperandExpression = RightNode.GetEvaluationLinqExpression();
var variableLeft = LinqExpression.Variable(typeof(object));
var variableEvaluatedResult = LinqExpression.Variable(typeof(object));
return(LinqExpression.Block(
typeof(object),
new[] { variableLeft, variableEvaluatedResult },
LinqExpressionHelper.ExpressionCallThrowIfCancellationRequested,
LinqExpression.Assign(variableLeft, leftOperandExpression),
LinqExpression.IfThen(
LinqExpression.Not(
LinqExpression.Call(
LinqExpression.Constant(Operator),
LinqExpressionHelper.MethodInfoBinaryOperatorEvaluateLhs,
LinqExpressionHelper.ExpressionParameterContext,
variableLeft,
variableEvaluatedResult)),
LinqExpression.Assign(
variableEvaluatedResult,
LinqExpression.Call(
LinqExpression.Constant(Operator),
LinqExpressionHelper.MethodInfoBinaryOperatorEvaluate,
LinqExpressionHelper.ExpressionParameterContext,
variableLeft,
rightOperandExpression))),
variableEvaluatedResult));
}
static void mapField(string typeName, FieldInfo field, Data data)
{
if (!field.IsStatic)
{
return;
}
if (mapType == ExpressionMode)
{
var get = Dlr.Lambda(Dlr.Field(null, field)).Compile();
data.set(typeName + '.' + field.Name, get);
if (!field.IsInitOnly)
{
var par = Dlr.Parameter(field.FieldType);
var set = Dlr.Lambda(Dlr.Assign(Dlr.Field(null, field), par), par).Compile();
data.set(typeName + '.' + field.Name + ".set", set);
}
}
else if (mapType == ReflectionMode)
{
var get = (Func <dynamic>)(() => field.GetValue(null));
var set = (Action <dynamic>)((n) => field.SetValue(null, n));
data.set(typeName + '.' + field.Name, get);
data.set(typeName + '.' + field.Name + ".set", set);
}
}
/// <summary>
/// returns the assignation expression that should be executed before this variable is used
/// </summary>
/// <returns></returns>
protected internal override MAst Transform()
{
// return an assignment expression to the parameter that should be called
// before any uses of the variable
MAst valueExpression = Value.Transform();
return(MAst.Assign(Pointer, valueExpression));
}
public static tfloat PowSub(tfloat bas, tfloat exp)
{
var val = VFloat();
return(Ex.Block(new[] { val },
Ex.Assign(val, bas),
Pow(val, exp).Sub(val)
));
}
static Expr GenerateAddFlagsGuts(ExprParam paramV, ExprParam paramF)
{
var param_v_member = Expr.PropertyOrField(paramV, EnumUtils.kMemberName); // value.value__
var param_f_member = Expr.PropertyOrField(paramF, EnumUtils.kMemberName); // flags.value__
var or = Expr.Or(param_v_member, param_f_member);
return(Expr.Assign(param_v_member, or));
//return Expr.OrAssign(param_v_member, param_f_member); // value.value__ |= flags.value__
}
/// <summary>
/// Return true iff the first argument is strictly between the second and third.
/// </summary>
/// <param name="b">First BPY function</param>
/// <param name="br1">Lower bound BPY function</param>
/// <param name="br2">Upper bound BPY function</param>
/// <returns></returns>
public static tbool In(tfloat b, tfloat br1, tfloat br2)
{
var f = ExUtils.VFloat();
return(Ex.Block(new[] { f },
Ex.Assign(f, b),
Ex.AndAlso(
Ex.GreaterThan(f, br1),
Ex.LessThan(f, br2)
)
));
}
static Expr GenerateRemoveFlagsGuts(ExprParam paramV, ExprParam paramF)
{
var param_v_member = Expr.PropertyOrField(paramV, EnumUtils.kMemberName); // value.value__
var param_f_member = Expr.PropertyOrField(paramF, EnumUtils.kMemberName); // flags.value__
var f_complement = Expr.Not(param_f_member); // ~flags.value__
var and = Expr.And(param_v_member, f_complement);
return(Expr.Assign(param_v_member, and));
//return Expr.AndAssign(param_v_member, f_complement); // value.value__ &= ~flags.value__
}
Function ParseFunc(Expression def, bool has_self = false)
{
string name = def[0].Value;
var ps = ParseParameters(def[1].Subset, omitFirstParameter: has_self);
/* write IL */
LocalBuilder loc = Local;
Local = new LocalBuilder();
var IL = new List <Exp>();
ret.Push(Exp.Label(typeof(Object)));
// load parameters
var arg = Exp.Parameter(typeof(Args), "arg");
if (has_self)
{
var self = Exp.Variable(typeof(Object), "self");
Local.Add(self);
IL.Add(Exp.Assign(self, Exp.Field(arg, "self")));
}
ParamInfo pi;
for (int i = 0; i < ps.Info.Length; i++)
{
pi = ps.Info[i];
var p = Exp.Variable(typeof(Object), pi.Name.str);
Local.Add(p);
IL.Add(Exp.Assign(p, Exp.Property(arg, "Item", Exp.Constant(i))));
}
PushBlock(def.Body, IL);
// add the return label target
IL.Add(Exp.Label(ret.Pop(), NoneExp));
var body = Exp.Block(Local.Variables, IL);
Local = loc;
var func = Exp.Lambda <Func <Args, Object> >(body, arg).Compile();
return(new Function
{
Name = name,
Parameters = ps,
handler = func
});
}
private static NodeVisitFunction BuildMethodVisitor(MethodInfo method, out Type parameterType)
{
var declaringtype = method.DeclaringType;
if (declaringtype == null)
{
throw new InvalidOperationException(string.Format("No declaring type for method [{0}]", method.Name));
}
// Throws an exception if parammeters.Count != 1
if (method.GetParameters().Length != 1)
{
throw new InvalidOperationException(
string.Format("Invalid number of parameters [{0}] for visit method [{1}] for type [{2}]. One parameter is expected", method.GetParameters().Length, method.Name, declaringtype.FullName));
}
parameterType = method.GetParameters()[0].ParameterType;
if (!parameterType.IsInterface && !typeof(Node).IsAssignableFrom(parameterType))
{
throw new InvalidOperationException(
string.Format("Invalid type parameter [{0}] for visit method [{1}] for type [{2}]. Parameter must inherit from Node", parameterType, method.Name, declaringtype.FullName));
}
var thisParameter = LinqExpression.Parameter(typeof(VisitorBase), "this");
var nodeParameter = LinqExpression.Parameter(typeof(object), "node");
var thisCastVariable = LinqExpression.Variable(declaringtype, "thisCast");
var statements = new List <LinqExpression>
{
LinqExpression.Assign(thisCastVariable, LinqExpression.Convert(thisParameter, declaringtype))
};
var callVisitMethod = LinqExpression.Call(thisCastVariable, method, LinqExpression.Convert(nodeParameter, parameterType));
if (typeof(void) == method.ReturnType)
{
statements.Add(callVisitMethod);
statements.Add(nodeParameter);
}
else
{
statements.Add(callVisitMethod);
}
var block = LinqExpression.Block(new[] { thisCastVariable }, statements);
var lambda = LinqExpression.Lambda <NodeVisitFunction>(block, thisParameter, nodeParameter);
return(lambda.Compile());
}
public static Expr ConvertToNumberAndCheck(Context context, Expr expression, string format, params object[] args)
{
var numberVar = Expr.Variable(typeof(double));
var assignNumber = Expr.Assign(numberVar, ConvertToNumber(context, expression));
return(Expr.Block(
new[] { numberVar },
assignNumber,
Expr.Condition(
Expr.Invoke(
Expr.Constant((Func <double, bool>)Double.IsNaN), numberVar),
Expr.Block(
Expr.Throw(Expr.New(MemberInfos.NewRuntimeException, Expr.Constant(format), Expr.Constant(args))),
Expr.Constant(Double.NaN)),
numberVar)));
}
static ModifyByRefDelegate GenerateAddFlagsMethodByRef()
{
//////////////////////////////////////////////////////////////////////////
// Define the generated method's parameters
var param_v = GenerateParamValue(true);
var param_f = GenerateParamFlags();
//////////////////////////////////////////////////////////////////////////
// value = value | flags
var assign = Expr.Assign(param_v, GenerateAddFlagsGuts(param_v, param_f));
//////////////////////////////////////////////////////////////////////////
// Generate a method based on the expression tree we've built
var lambda = Expr.Lambda <ModifyByRefDelegate>(assign, param_v, param_f);
return(lambda.Compile());
}
public override DynamicMetaObject BindGetIndex(GetIndexBinder binder, DynamicMetaObject[] indexes)
{
var valueVar = Expr.Variable(typeof(object));
var getValue = Expr.Call(
Expr.Convert(Expression, typeof(LuaTable)),
MemberInfos.LuaTableGetValue,
Expr.Convert(indexes[0].Expression, typeof(object)));
var valueAssign = Expr.Assign(valueVar, getValue);
var expression = Expr.Block(
valueVar,
Expr.Condition(
Expr.Equal(valueVar, Expr.Constant(null)),
MetamethodFallbacks.Index(null, this, indexes),
valueVar));
return(new DynamicMetaObject(expression, RuntimeHelpers.MergeTypeRestrictions(this)));
}
Expr FallbackIfNumberIsNan(Expr numExpr)
{
// If we have performed a string to number conversion check that conversion went well by checking
// number for NaN. If conversion failed do metatable fallback. Also assign to temp variable for single evaluation.
var numVar = Expr.Variable(typeof(double));
var expr = Expr.IfThenElse(
Expr.Invoke(Expr.Constant((Func <double, bool>)Double.IsNaN), numVar),
Expr.Invoke(
Expr.Constant((Func <Context, object, object>)LuaOps.UnaryMinusMetamethod),
Expr.Constant(context),
Expr.Constant(Operation),
Expr.Convert(numExpr, typeof(object))),
numVar);
return(Expr.Block(
new[] { numVar },
Expr.Assign(numVar, numExpr),
expr));
}
Expr FallbackIfNumberIsNan(Expr conversionResult, DynamicMetaObject left, DynamicMetaObject right)
{
// If we have performed a string to number conversion check that conversion went well by checking
// number for NaN. If conversion failed do metatable fallback. Also assign to temp variable for single evaluation.
var conversionVar = Expr.Variable(typeof(double));
var expr = Expr.Condition(
Expr.Invoke(Expr.Constant((Func <double, bool>)Double.IsNaN), conversionVar),
Expr.Invoke(
Expr.Constant((Func <Context, ExprType, object, object, object>)LuaOps.NumericMetamethod),
Expr.Constant(context),
Expr.Constant(Operation),
Expr.Convert(left.Expression, typeof(object)),
Expr.Convert(right.Expression, typeof(object))),
Expr.Convert(conversionVar, typeof(object)));
return(Expr.Block(
new[] { conversionVar },
Expr.Assign(conversionVar, conversionResult),
expr));
}
// Use homotopy method with newton's method to find a solution for F(x) = 0.
private static List <Arrow> NSolve(List <Expression> F, List <Arrow> x0, double Epsilon, int MaxIterations)
{
int M = F.Count;
int N = x0.Count;
// Compute JxF, the Jacobian of F.
List <Dictionary <Expression, Expression> > JxF = Jacobian(F, x0.Select(i => i.Left)).ToList();
// Define a function to evaluate JxH(x), where H = F(x) - s*F(x0).
CodeGen code = new CodeGen();
ParamExpr _JxH = code.Decl <double[, ]>(Scope.Parameter, "JxH");
ParamExpr _x0 = code.Decl <double[]>(Scope.Parameter, "x0");
ParamExpr _s = code.Decl <double>(Scope.Parameter, "s");
// Load x_j from the input array and add them to the map.
for (int j = 0; j < N; ++j)
{
code.DeclInit(x0[j].Left, LinqExpr.ArrayAccess(_x0, LinqExpr.Constant(j)));
}
LinqExpr error = code.Decl <double>("error");
// Compile the expressions to assign JxH
for (int i = 0; i < M; ++i)
{
LinqExpr _i = LinqExpr.Constant(i);
for (int j = 0; j < N; ++j)
{
code.Add(LinqExpr.Assign(
LinqExpr.ArrayAccess(_JxH, _i, LinqExpr.Constant(j)),
code.Compile(JxF[i][x0[j].Left])));
}
// e = F(x) - s*F(x0)
LinqExpr e = code.DeclInit <double>("e", LinqExpr.Subtract(code.Compile(F[i]), LinqExpr.Multiply(LinqExpr.Constant((double)F[i].Evaluate(x0)), _s)));
code.Add(LinqExpr.Assign(LinqExpr.ArrayAccess(_JxH, _i, LinqExpr.Constant(N)), e));
// error += e * e
code.Add(LinqExpr.AddAssign(error, LinqExpr.Multiply(e, e)));
}
// return error
code.Return(error);
Func <double[, ], double[], double, double> JxH = code.Build <Func <double[, ], double[], double, double> >().Compile();
double[] x = new double[N];
// Remember where we last succeeded/failed.
double s0 = 0.0;
double s1 = 1.0;
do
{
try
{
// H(F, s) = F - s*F0
NewtonsMethod(M, N, JxH, s0, x, Epsilon, MaxIterations);
// Success at this s!
s1 = s0;
for (int i = 0; i < N; ++i)
{
x0[i] = Arrow.New(x0[i].Left, x[i]);
}
// Go near the goal.
s0 = Lerp(s0, 0.0, 0.9);
}
catch (FailedToConvergeException)
{
// Go near the last success.
s0 = Lerp(s0, s1, 0.9);
for (int i = 0; i < N; ++i)
{
x[i] = (double)x0[i].Right;
}
}
} while (s0 > 0.0 && s1 >= s0 + 1e-6);
// Make sure the last solution is at F itself.
if (s0 != 0.0)
{
NewtonsMethod(M, N, JxH, 0.0, x, Epsilon, MaxIterations);
for (int i = 0; i < N; ++i)
{
x0[i] = Arrow.New(x0[i].Left, x[i]);
}
}
return(x0);
}
/// <summary>
/// Def block parser
/// </summary>
void PushBlock(List <Expression> body, List <Exp> IL)
{
Expression expr;
var ifparts = new Stack <If>();
for (int i = 0; i < body.Count; i++)
{
expr = body[i]; // cur expression
switch (expr.Command)
{
case "class":
{
Class type = ParseClass(expr);
Global.Add(type.Name, type);
}
break;
case "def":
{
Function func = ParseFunc(expr);
Global.Add(func.Name, func);
}
break;
case "if":
case "elif":
ifparts.Push(
new If
{
Test = AsBool(Parse(expr)),
Body = ParseBlock(expr.Body)
});
if (i + 1 == body.Count || body[i + 1].Command?.StartsWith("el") == false)
{
IL.Add(IfThenElse(ifparts));
}
break;
case "else":
IL.Add(IfThenElse(ifparts, ParseBlock(expr.Body)));
break;
case "for":
{
var v = expr[0].Value;
expr.RemoveRange(0, 2);
if (expr.Count == 2 && expr[0].Value == "range")
{
}
}
break;
case "while":
br.Push(Exp.Label());
con.Push(Exp.Label());
IL.Add(Exp.Loop(
Exp.IfThenElse(
test: AsBool(Parse(expr)),
ifTrue: ParseBlock(expr.Body),
ifFalse: Exp.Goto(br.Peek())
),
br.Peek(),
con.Peek()));
br.Pop();
con.Pop();
break;
case "try":
break;
case "except":
break;
case "finally":
break;
case "import":
break;
case "from":
break;
case "return":
IL.Add(Exp.Goto(ret.Peek(), Parse(expr)));
break;
case "break":
IL.Add(Exp.Goto(br.Peek()));
break;
case "continue":
IL.Add(Exp.Goto(con.Peek()));
break;
case "pass":
// nothing to do
break;
case "global":
{
var w = Split(expr, TokenType.Comma);
foreach (var v in w)
{
Local.Add(v[0].Value, GlobalAccess(v[0].Value));
}
}
break;
case "nonlocal":
break;
case "del":
break;
case "raise":
break;
case "assert":
break;
case "yield":
break;
case "print":
IL.Add(Exp.Call(typeof(Console).GetMethod("WriteLine", new[] { typeof(object) }), Parse(expr)));
break;
case "emit":
Emit(expr[0].Value, IL);
break;
case "assign":
{
(var left, var right, var op) = SplitAssign(expr);
var vars = Split(left, TokenType.Comma);
var values = Split(right, TokenType.Comma);
if (op != Op.None) // augmented assignment
{
if (vars.Count == 1)
{
if (values.Count == 1)
{
Exp var = ParseUnit(vars[0]);
Exp val = Parse(values[0]);
IL.Add(Exp.Assign(var, Dynamic(op, var, val)));
}
else if (values.Count > 1) // tuple
{
// pass
}
}
else
{
throw new Exception("illegal expression for augmented assignment");
}
}
else if (vars.Count == values.Count)
{
for (int j = 0; j < vars.Count; j++)
{
IL.Add(Assign(vars[j], Parse(values[j])));
}
}
else if (vars.Count > 1 && values.Count == 1) // unpack
{
Exp iter = Cache("c_002");
var iterable = Parse(values[0]);
IL.Add(Exp.Assign(iter, iterable));
for (int j = 0; j < vars.Count; j++)
{
IL.Add(Assign(vars[j], Exp.Call(iter, typeof(Object).GetMethod("__getitem__"), Exp.Constant(new Int(j)))));
}
}
else if (vars.Count == 1 && values.Count > 1) // tuple
{
var tpl = Exp.ListInit(Exp.New(typeof(Tuple)),
values.Select(Parse));
IL.Add(Assign(vars[0], tpl));
}
}
break;
case null:
IL.Add(Parse(expr));
break;
}
}
}
/// <summary>Generates a method similar to this:
/// <code>
/// void Read(IO.BitStream s, out TEnum v, int bitCount)
/// {
/// v = (UnderlyingType)s.Read[TStreamType](bitCount);
/// }
/// </code>
/// </summary>
/// <param name="args"></param>
/// <param name="readMethodInfo"></param>
/// <param name="bitSwapMethod"></param>
/// <returns>The generated method.</returns>
/// <remarks>
/// If <see cref="args.UnderlyingType"/> is the same as <typeparamref name="TStreamType"/>, no conversion code is generated
/// </remarks>
static ReadDelegate GenerateReadMethod(MethodGenerationArgs args, MethodInfo readMethodInfo, MethodInfo bitSwapMethod)
{
// Get a "ref type" of the enum we're dealing with so we can define the enum value as an 'out' parameter
var enum_ref = args.EnumType.MakeByRefType();
//////////////////////////////////////////////////////////////////////////
// Define the generated method's parameters
var param_s = Expr.Parameter(kBitStreamType, "s"); // BitStream s
var param_v = Expr.Parameter(enum_ref, "v"); // ref TEnum v
var param_bc = Expr.Parameter(typeof(int), "bitCount"); // int bitCount
//////////////////////////////////////////////////////////////////////////
// Define the Read call
Expr call_read;
if (args.StreamTypeIsSigned)
{
call_read = Expr.Call(param_s, readMethodInfo, param_bc, Expr.Constant(args.Options.SignExtend));
}
else
{
call_read = Expr.Call(param_s, readMethodInfo, param_bc); // i.e., 's.Read<Type>(bitCount)'
}
if (args.Options.UseNoneSentinelEncoding)
{
call_read = Expr.Decrement(call_read);
}
#region options.BitSwap
if (args.Options.BitSwap)
{
// i.e., Bits.BitSwap( Read(), bitCount-1 );
var start_bit_index = Expr.Decrement(param_bc);
Expr swap_call = Expr.Call(null, bitSwapMethod, call_read, start_bit_index);
// i.e., bitCount-1 ? Bits.BitSwap( Read(), bitCount-1 ) : Read() ;
if (args.Options.BitSwapGuardAgainstOneBit)
{
var start_bit_index_is_not_zero = Expr.NotEqual(start_bit_index, Expr.Constant(0, typeof(int)));
swap_call = Expr.Condition(start_bit_index_is_not_zero,
swap_call, call_read);
}
call_read = swap_call;
}
#endregion
var read_result = args.UnderlyingTypeNeedsConversion ? // If the underlying type is different from the type we're reading,
Expr.Convert(call_read, args.UnderlyingType) : // we need to cast the Read result from TStreamType to UnderlyingType
(Expr)call_read;
//////////////////////////////////////////////////////////////////////////
// Define the member assignment
var param_v_member = Expr.PropertyOrField(param_v, EnumUtils.kMemberName); // i.e., 'v.value__'
// i.e., 'v.value__ = s.Read<Type>()' or 'v.value__ = (UnderlyingType)s.Read<Type>()'
var assign = Expr.Assign(param_v_member, read_result);
//////////////////////////////////////////////////////////////////////////
// Generate a method based on the expression tree we've built
var lambda = Expr.Lambda <ReadDelegate>(assign, param_s, param_v, param_bc);
return(lambda.Compile());
}