public void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option)
{
if ((option & MethodCompileOption.EmitStartAddress) == MethodCompileOption.EmitStartAddress && parameter.Type.IsValueType)
{
if (generator.Method.IsStatic)
{
generator.LoadAddressOfArgument(parameter.Index);
}
else
{
generator.LoadAddressOfArgument(parameter.Index + 1);
}
}
else
{
if (generator.Method.IsStatic)
{
generator.LoadArgument(parameter.Index);
}
else
{
generator.LoadArgument(parameter.Index + 1);
}
}
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption options)
{
// Find the result type.
var resultType = Type;
var firstType = Second.Type;
var secondType = Third.Type;
First.GenerateCode(generator, MethodCompileOption.Return);
if (Conversions != null && Conversions.Count > 0)
{
generator.EmitConvert(Conversions[0]);
}
// Branch if the condition is false.
var startOfElse = generator.CreateLabel();
generator.BranchIfFalse(startOfElse);
Second.GenerateCode(generator, options);
if (resultType != firstType)
{
generator.Call(ExpressionConversion);
}
// Branch to the end.
var end = generator.CreateLabel();
generator.Branch(end);
generator.DefineLabelPosition(startOfElse);
Third.GenerateCode(generator, options);
if (resultType != secondType)
{
generator.Call(ExpressionConversion);
}
generator.DefineLabelPosition(end);
}
public void GenerateSet(Expression value, MethodBodyGenerator generator, MethodCompileOption option)
{
var iLVariable = generator.GetLocalVariable(key.Name);
if (iLVariable != null)
{
generator.LoadVariable(iLVariable);
}
}
public void GenerateSet(Expression value, MethodBodyGenerator generator, MethodCompileOption option)
{
if (generator.Method.IsStatic)
{
generator.StoreArgument(parameter.Index);
}
else
{
generator.StoreArgument(parameter.Index + 1);
}
}
/// <inheritdoc/>
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption options)
{
//todo unsigned to signed
switch (Value)
{
case sbyte _:
generator.LoadByte((sbyte)Value);
generator.NewObject(Utils.ReflectionHelpers.Byte_New);
break;
case short _:
generator.LoadInt16((short)Value);
generator.NewObject(Utils.ReflectionHelpers.Short_New);
break;
case int _:
generator.LoadInt32((int)Value);
generator.NewObject(Utils.ReflectionHelpers.Integer_New);
break;
case long _:
generator.LoadInt64((long)Value);
generator.NewObject(Utils.ReflectionHelpers.Long_New);
break;
case float _:
generator.LoadSingle((float)Value);
generator.NewObject(Utils.ReflectionHelpers.Float_New);
break;
case double _:
generator.LoadDouble((double)Value);
generator.NewObject(Utils.ReflectionHelpers.Double_New);
break;
case bool value:
generator.LoadField(value ? Utils.ReflectionHelpers.Bool_True : Utils.ReflectionHelpers.Bool_False);
break;
case char _:
generator.LoadChar((char)Value);
generator.NewObject(Utils.ReflectionHelpers.Char_New);
break;
case string _:
generator.LoadString(Value.ToString());
generator.NewObject(Utils.ReflectionHelpers.String_New);
break;
case null:
generator.LoadNull();
break;
}
}
public void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option)
{
if ((option & MethodCompileOption.EmitStartAddress) == MethodCompileOption.EmitStartAddress && property.PropertyType.IsValueType)
{
var temp = generator.CreateTemporaryVariable(Type);
generator.Call(Getter);
generator.StoreVariable(temp);
generator.LoadAddressOfVariable(temp);
return;
}
generator.Call(Getter);
}
/// <inheritdoc/>
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption option)
{
// for static no binder
if (Binder != null)
{
if ((Binder.Attributes & Binders.BindingAttributes.HasThis) != 0)
{
generator.LoadArgument(0);
}
Binder.GenerateGet(null, generator, option);
}
}
public void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option)
{
if ((option & MethodCompileOption.EmitStartAddress) == MethodCompileOption.EmitStartAddress &&
variable.Type.IsValueType)
{
generator.LoadAddressOfVariable(variable);
}
else
{
generator.LoadVariable(variable);
}
}
/// <inheritdoc/>
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption options)
{
if (Arguments != null)
{
var conversions = ArgumentConversions;
for (int i = 0; i < Arguments.Count; i++)
{
Arguments[i].GenerateCode(generator);
var conversion = conversions[i];
if (conversion != null)
{
generator.EmitConvert(conversion);
}
}
}
generator.NewObject(Constructor);
int length = Expressions.Count;
if (length > 0)
{
var variable = generator.DeclareVariable(Type);
generator.StoreVariable(variable);
generator.LoadVariable(variable);
var conversions = ArrayConversions;
generator.LoadInt32(length);
Type type = ElementType;
generator.NewArray(type);
for (int i = 0; i < length; i++)
{
generator.Duplicate();
generator.LoadInt32(i);
var expression = Expressions[i];
expression.GenerateCode(generator);
if (expression.Type.IsValueType && type.IsValueType == false)
{
generator.Box(expression.Type);
}
var convertion = conversions[i];
if (convertion != null)
{
generator.EmitConvert(convertion);
}
generator.StoreArrayElement(type);
}
var m = Type.GetMethod("AddRange", Utils.ReflectionUtils.PublicInstance);
generator.Call(m);
generator.LoadVariable(variable);
}
}
public void GenerateSet(Expression value, MethodBodyGenerator generator, MethodCompileOption option)
{
if ((option & MethodCompileOption.Dupplicate) == 0)
{
generator.Call(Setter);
return;
}
generator.Duplicate();
var temp = generator.CreateTemporaryVariable(value.Type);
generator.StoreVariable(temp);
generator.Call(Setter);
generator.LoadVariable(temp);
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption options)
{
if (Target.Type.IsValueType)
{
options |= MethodCompileOption.EmitStartAddress;
}
Target.GenerateCode(generator, options);
Arguments.ForEach((arg, index) =>
{
arg.GenerateCode(generator);
generator.EmitConvert(Conversions[index]);
});
// todo indexer parmas argument convert
generator.Call(Getter);
}
public void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option = MethodCompileOption.None)
{
if (target != null && target.Type.IsValueType)
{
generator.Box(target.Type);
}
generator.LoadString(Name);
generator.Call(typeof(IDynamicInvocable).GetInstanceMethod(nameof(IDynamicInvocable.SafeGetValue), typeof(string)));
// since it is a value type load the address
if ((option & MethodCompileOption.EmitStartAddress) == MethodCompileOption.EmitStartAddress)
{
var temp = generator.DeclareVariable(TypeProvider.AnyType);
generator.StoreVariable(temp);
generator.LoadAddressOfVariable(temp);
}
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption option)
{
if (Method.IsAbstract && Method.DeclaringType == typeof(IDynamicInvocable))
{
Target.GenerateCode(generator);
if (Target.Type.IsValueType)
{
generator.Box(Target.Type);
}
}
else
{
Target.GenerateCode(generator, MethodCompileOption.EmitStartAddress);
}
if (Target.NodeType == ExpressionType.MemberAccess)
{
MemberExpression target = (MemberExpression)Target;
if (target.Target.Type.IsValueType)
{
switch (target.Target.NodeType)
{
case ExpressionType.Indexer:
case ExpressionType.MemberAccess:
var temp = generator.DeclareVariable(target.Target.Type);
generator.StoreVariable(temp);
generator.LoadAddressOfVariable(temp);
break;
}
}
}
else if (Target.NodeType == ExpressionType.Identifier)
{
// if it an identifier expression this might be local member call
var exp = (NameExpression)Target;
if (exp.Binder == null && Method.IsStatic == false)
{
generator.LoadArgument(0);
}
}
generator.EmitArguments(Arguments, Conversions);
generator.Call(Method);
// if current value must not be returned for assigment
if ((option & MethodCompileOption.Return) == 0 && Type is object && Type != TypeProvider.VoidType)
{
generator.Pop();
}
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption option)
{
if (Left.NodeType == ExpressionType.Identifier)
{
var exp = (NameExpression)Left;
var binder = exp.Binder;
// binder is null create new local variable
if (binder is null)
{
exp.Binder = binder = new Binders.VariableBinder(generator.DeclareVariable(Right.Type, exp.Name));
}
if ((binder.Attributes & Binders.BindingAttributes.HasThis) != 0)
{
generator.LoadArgument(0);
}
Right.GenerateCode(generator, Option);
if (Conversion != null)
{
generator.EmitConvert(Conversion);
}
binder.GenerateSet(Right, generator, option);
}
else if (Left.NodeType == ExpressionType.MemberAccess)
{
var exp = (MemberExpression)Left;
exp.Target.GenerateCode(generator);
// member assign for dynamic to be Any
if ((exp.Binder.Attributes & Binders.BindingAttributes.Dynamic) == Binders.BindingAttributes.Dynamic)
{
generator.Box(TypeProvider.AnyType);
}
Right.GenerateCode(generator, Option);
if (Conversion != null)
{
generator.EmitConvert(Conversion);
}
exp.Binder.GenerateSet(Right, generator, option);
}
else if (Left.NodeType == ExpressionType.Indexer)
{
GenerateIndexer(generator);
}
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption option)
{
if (Binder != null)
{
if (Target.Type.IsValueType && (Binder.Attributes & Binders.BindingAttributes.Dynamic) == 0)
{
option = MethodCompileOption.EmitStartAddress;
}
else
{
option = 0;
}
Target.GenerateCode(generator, option);
Binder.GenerateGet(Target, generator);
}
else
{
Target.GenerateCode(generator, option);
}
}
public void GenerateSet(Expression right, MethodBodyGenerator generator, MethodCompileOption option = MethodCompileOption.None)
{
// first parameter to be Any
if (right.Type != TypeProvider.AnyType)
{
if (right.Type.IsValueType)
{
generator.Box(right.Type);
}
generator.CallStatic(ReflectionHelpers.ImplicitAny);
}
generator.LoadString(Name);
generator.LoadToken(right.Type);
generator.Call((Func <RuntimeTypeHandle, Type>)Type.GetTypeFromHandle);
generator.Call(typeof(IDynamicInvocable).GetInstanceMethod(nameof(IDynamicInvocable.SafeSetValue), TypeProvider.AnyType, typeof(string), typeof(Type)));
if ((option & MethodCompileOption.Return) == 0)
{
generator.Pop();
return;
}
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption options)
{
if (generator.Method is Generators.DynamicMethodGenerator)
{
// for annonymous type
// if this is used in anonymous function or objects
var variable = generator.GetLocalVariable("__value");
if (variable.Type.IsValueType && (options & MethodCompileOption.EmitStartAddress) == MethodCompileOption.EmitStartAddress)
{
generator.LoadAddressOfVariable(variable);
}
else
{
generator.LoadVariable(variable);
}
}
else
{
generator.LoadArgument(0);
}
}
void CallPreFixMember(MethodBodyGenerator generator, IBinder binder, MethodCompileOption option)
{
// if no duplicate ex: i++ single line
if ((option & MethodCompileOption.Dupplicate) == 0)
{
binder.GenerateSet(Operand, generator);
return;
}
// ++i where i is member
// initially operator is called
var temp = generator.DeclareVariable(binder.Type);
// store the result to variable
generator.StoreVariable(temp);
// then load the variable
generator.LoadVariable(temp);
// store the variable result to member
binder.GenerateSet(Operand, generator);
// load the temp variable
generator.LoadVariable(temp);
}
public void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option)
{
var field = this.field;
if (field.FieldType == null)
{
throw new InvalidOperationException(string.Concat("Use of undeclared field ", field));
}
if (field is Generators.FieldGenerator)
{
field = ((Generators.FieldGenerator)field).FieldInfo;
}
if ((option & MethodCompileOption.EmitStartAddress) == MethodCompileOption.EmitStartAddress && field.FieldType.IsValueType)
{
generator.LoadFieldAddress(field);
}
else
{
generator.LoadField(field);
}
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption options)
{
if (Method != null)
{
var conversions = Conversions;
Left.GenerateCode(generator, options);
var first = conversions[0];
if (first != null)
{
generator.EmitConvert(first);
}
Right.GenerateCode(generator, options);
var second = conversions[1];
if (second != null)
{
generator.EmitConvert(second);
}
generator.Call(Method);
return;
}
throw new InvalidOperationException("Operator method missing");
}
public void GenerateSet(Expression value, MethodBodyGenerator generator, MethodCompileOption option)
{
var field = this.field;
if (field.IsInitOnly && !(generator.Method is ConstructorInfo))
{
throw new FieldAccessException("A readonly field cannot be assigned to (except in a constructor of the class in which the field is defined or a variable initializer))");
}
if (field is Generators.FieldGenerator)
{
field = ((Generators.FieldGenerator)field).FieldInfo;
}
if ((option & MethodCompileOption.Dupplicate) == 0)
{
generator.StoreField(field);
return;
}
generator.Duplicate();
var temp = generator.CreateTemporaryVariable(value.Type);
generator.StoreVariable(temp);
generator.StoreField(field);
generator.LoadVariable(temp);
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption option)
{
var target = generator.Method.DeclaringType;
IExpressionVisitor <object> visitor = ScriptCompiler.Instance;
//pass scoped arguments // refer System.Linq.Expression.Compiler folder
var names = Parameters.Map(para => para.Name);
// Emit First Argument
var lamdaVisit = new LamdaVisitor(names);
Body.Accept(lamdaVisit);
LamdaGen lamdaGen;
if (generator.Method.DeclaringType is Generators.TypeGenerator typeGen)
{
lamdaGen = typeGen.DefineAnonymousMethod(Types, ReturnType);
}
else
{
lamdaGen = AssemblyGen.DynamicAssembly.DefineAnonymousMethod(Types, ReturnType);
}
var methodGen = new Generators.MethodGenerator(lamdaGen.Method, ParameterInfos, lamdaGen.Type)
{
SyntaxBody = Body,
Context = generator.Context
};
methodGen.EmitParameterInfo();
var bodyGen = new MethodBodyGenerator(methodGen, lamdaGen.Method.GetILGenerator());
var values = lamdaVisit.HoistedLocals.Values;
// new object[] {}
var valVar = generator.DeclareVariable(LamdaGen.ObjectArray);
ArrayListExpression.MakeObjectArray(generator, values);
generator.StoreVariable(valVar);
if (values.Count > 0)
{
int index = 0;
var field = lamdaGen.Values;
foreach (var item in lamdaVisit.HoistedLocals)
{
var value = item.Value;
var variable = bodyGen.DeclareVariable(value.Type, item.Key);
bodyGen.LoadArgument(0);
bodyGen.LoadField(field);
bodyGen.LoadInt32(index);
bodyGen.LoadArrayElement(TypeProvider.ObjectType);
bodyGen.UnboxObject(value.Type);
bodyGen.StoreVariable(variable);
index++;
}
}
bodyGen.Compile();
var type = lamdaGen.CreateType();
generator.LoadVariable(valVar);
if (generator.Method is Generators.DynamicMethodGenerator)
{
generator.NewObject(type.GetConstructor(LamdaGen.CtorSignature));
generator.LoadFunction(type.GetMethod(ReflectionUtils.InvokeMethod, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic), Type);
}
else
{
generator.NewObject(lamdaGen.Constructor);
generator.LoadFunction(lamdaGen.Method, Type);
}
}
public void GenerateSet(Expression value, MethodBodyGenerator generator, MethodCompileOption option = MethodCompileOption.None)
{
throw new NotImplementedException();
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption options)
{
generator.LoadNull();
}
public override void GenerateCode(MethodBodyGenerator generator, MethodCompileOption option)
{
if (NodeType == ExpressionType.Parenthesized)
{
Operand.GenerateCode(generator, option);
return;
}
var operand = Operand;
IBinder binder = null;
if (operand.NodeType == ExpressionType.Identifier)
{
//todo only for get; set; member
//i++ or Member++
binder = ((NameExpression)operand).Binder;
}
else if (operand.NodeType == ExpressionType.MemberAccess)
{
binder = ((MemberExpression)operand).Binder;
}
// todo: Conversion if value is short, byte lower data type
switch (NodeType)
{
case ExpressionType.PostfixMinusMinus:
case ExpressionType.PostfixPlusPlus:
if (binder == null)
{
throw new NullReferenceException(nameof(binder));
}
if ((binder.Attributes & BindingAttributes.HasThis) != 0)
{
generator.LoadArgument(0);
}
operand.GenerateCode(generator, MethodCompileOption.Dupplicate);
if ((binder.Attributes & BindingAttributes.Member) != 0)
{
CallPostFixMember(generator, binder, option);
return;
}
if ((option & MethodCompileOption.Dupplicate) != 0)
{
generator.Duplicate();
}
// call the operator
generator.CallStatic(Method);
// update value
binder.GenerateSet(operand, generator);
break;
case ExpressionType.PrefixMinusMinus:
case ExpressionType.PrefixPlusPlus:
if (binder == null)
{
throw new NullReferenceException(nameof(binder));
}
if ((binder.Attributes & BindingAttributes.HasThis) != 0)
{
generator.LoadArgument(0);
}
operand.GenerateCode(generator, MethodCompileOption.Dupplicate);
// call the operator
generator.CallStatic(Method);
if ((binder.Attributes & BindingAttributes.Member) != 0)
{
CallPreFixMember(generator, binder, option);
return;
}
if ((option & MethodCompileOption.Dupplicate) != 0)
{
generator.Duplicate();
}
// update value
binder.GenerateSet(Operand, generator);
break;
default:
// call the operator
operand.GenerateCode(generator, AssignOption);
generator.CallStatic(Method);
break;
}
}
public virtual void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option = MethodCompileOption.None)
{
throw new NotImplementedException();
}
/// <summary>
/// Generates compiled IL code for <see cref="Expression"/>
/// </summary>
/// <param name="generator">IL Generator for method body</param>
/// <param name="option">Compiler option's for generating <see cref="Expression"/></param>
public virtual void GenerateCode(MethodBodyGenerator generator, MethodCompileOption option = MethodCompileOption.None)
{
generator.NoOperation();
}
public void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option)
{
generator.DeclareVariable(key.Type, key.Name);
}
public void GenerateSet(Expression value, MethodBodyGenerator generator, MethodCompileOption option)
{
}
public void GenerateGet(Expression target, MethodBodyGenerator generator, MethodCompileOption option)
{
}
