/// <summary>
/// Constructor
/// </summary>
/// <param name="ObjectCallingOn">Object calling on</param>
/// <param name="Method">Method builder</param>
/// <param name="MethodCalling">Method calling on the object</param>
/// <param name="Parameters">List of parameters to send in</param>
public Call(IMethodBuilder Method, VariableBase ObjectCallingOn, MethodInfo MethodCalling, object[] Parameters)
: base()
{
this.ObjectCallingOn = ObjectCallingOn;
this.MethodCalling = MethodCalling;
this.MethodCallingFrom = Method;
if (MethodCalling.ReturnType != null && MethodCalling.ReturnType != typeof(void))
{
Result = Method.CreateLocal(MethodCalling.Name + "ReturnObject"+Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.ObjectCounter.ToString(CultureInfo.InvariantCulture), MethodCalling.ReturnType);
}
if (Parameters != null)
{
this.Parameters = new VariableBase[Parameters.Length];
for (int x = 0; x < Parameters.Length; ++x)
{
if (Parameters[x] is VariableBase)
this.Parameters[x] = (VariableBase)Parameters[x];
else
this.Parameters[x] = MethodCallingFrom.CreateConstant(Parameters[x]);
}
}
else
{
this.Parameters = null;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="LeftHandSide">Left hand side</param>
/// <param name="Value">Value to store</param>
public Assign(VariableBase LeftHandSide, object Value)
: base()
{
if (LeftHandSide == null)
throw new ArgumentNullException("LeftHandSide");
this.LeftHandSide = LeftHandSide;
VariableBase TempValue = Value as VariableBase;
this.RightHandSide = TempValue == null ? Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.CreateConstant(Value) : TempValue;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="EndIfLabel">End if label (for this else if)</param>
/// <param name="ComparisonType">Comparison type</param>
/// <param name="LeftHandSide">Left hand side</param>
/// <param name="RightHandSide">Right hand side</param>
public ElseIf(Label EndIfLabel, Comparison ComparisonType, VariableBase LeftHandSide, VariableBase RightHandSide)
: base()
{
this.EndIfLabel = EndIfLabel;
if (LeftHandSide != null)
this.LeftHandSide = LeftHandSide;
else
this.LeftHandSide = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.CreateConstant(null);
if (RightHandSide != null)
this.RightHandSide = RightHandSide;
else
this.RightHandSide = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.CreateConstant(null);
this.ComparisonType = ComparisonType;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ComparisonType">Comparison type</param>
/// <param name="LeftHandSide">Left hand side</param>
/// <param name="RightHandSide">Right hand side</param>
public While(Comparison ComparisonType, VariableBase LeftHandSide, VariableBase RightHandSide)
: base()
{
ILGenerator Generator = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.Generator;
this.StartWhileLabel = Generator.DefineLabel();
this.EndWhileLabel = Generator.DefineLabel();
if (LeftHandSide != null)
this.LeftHandSide = LeftHandSide;
else
this.LeftHandSide = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.CreateConstant(null);
if (RightHandSide != null)
this.RightHandSide = RightHandSide;
else
this.RightHandSide = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.CreateConstant(null);
this.ComparisonType = ComparisonType;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ObjectCallingOn">Object calling on</param>
/// <param name="Method">Method builder</param>
/// <param name="MethodCalling">Method calling on the object</param>
/// <param name="Parameters">List of parameters to send in</param>
public Call(IMethodBuilder Method, VariableBase ObjectCallingOn, ConstructorInfo MethodCalling, object[] Parameters)
: base()
{
this.ObjectCallingOn = ObjectCallingOn;
this.ConstructorCalling = MethodCalling;
this.MethodCallingFrom = Method;
if (Parameters != null)
{
this.Parameters = new VariableBase[Parameters.Length];
for (int x = 0; x < Parameters.Length; ++x)
{
if (Parameters[x] is VariableBase)
this.Parameters[x] = (VariableBase)Parameters[x];
else
this.Parameters[x] = MethodCallingFrom.CreateConstant(Parameters[x]);
}
}
else
{
this.Parameters = null;
}
}
/// <summary>
/// Sets up a property (List)
/// </summary>
/// <param name="Method">Method builder</param>
/// <param name="BaseType">Base type for the object</param>
/// <param name="ReturnValue">Return value</param>
/// <param name="Property">Property info</param>
/// <param name="Mapping">Mapping info</param>
private void SetupListProperty(IMethodBuilder Method, Type BaseType, VariableBase ReturnValue, IProperty Property, IMapping Mapping)
{
Company.Utilities.Reflection.Emit.FieldBuilder Field = Fields.Find(x => x.Name == Property.DerivedFieldName);
Company.Utilities.Reflection.Emit.Commands.If If1 = Method.If((VariableBase)SessionField, Comparison.NotEqual, null);
{
Company.Utilities.Reflection.Emit.Commands.If If2 = Method.If(Field, Comparison.Equal, null);
{
//Load data
VariableBase IDValue = Method.This.Call(BaseType.GetProperty(Mapping.IDProperty.Name).GetGetMethod());
VariableBase IDParameter = Method.NewObj(typeof(EqualParameter<>).MakeGenericType(Mapping.IDProperty.Type), new object[] { IDValue, "ID", "@" });
VariableBase PropertyList = Method.NewObj(typeof(List<IParameter>));
PropertyList.Call("Add", new object[] { IDParameter });
MethodInfo LoadPropertiesMethod = typeof(Session).GetMethod("LoadListProperties");
LoadPropertiesMethod = LoadPropertiesMethod.MakeGenericMethod(new Type[] { BaseType, Field.DataType.GetGenericArguments()[0] });
VariableBase ReturnVal = ((VariableBase)SessionField).Call(LoadPropertiesMethod, new object[] { Method.This, Property.Name, PropertyList.Call("ToArray") });
Field.Assign(ReturnVal);
}
If2.EndIf();
PropertyInfo CountProperty=Field.DataType.GetProperty("Count");
Company.Utilities.Reflection.Emit.Commands.If If4 = Method.If(Field.Call(CountProperty.GetGetMethod()), Comparison.Equal, Method.CreateConstant(0));
{
//Load data
VariableBase IDValue = Method.This.Call(BaseType.GetProperty(Mapping.IDProperty.Name).GetGetMethod());
VariableBase IDParameter = Method.NewObj(typeof(EqualParameter<>).MakeGenericType(Mapping.IDProperty.Type), new object[] { IDValue, "ID", "@" });
VariableBase PropertyList = Method.NewObj(typeof(List<IParameter>));
PropertyList.Call("Add", new object[] { IDParameter });
MethodInfo LoadPropertiesMethod = typeof(Session).GetMethod("LoadProperties");
LoadPropertiesMethod = LoadPropertiesMethod.MakeGenericMethod(new Type[] { BaseType, Field.DataType.GetGenericArguments()[0] });
VariableBase ReturnVal = ((VariableBase)SessionField).Call(LoadPropertiesMethod, new object[] { Method.This, Property.Name, PropertyList.Call("ToArray") });
Field.Assign(ReturnVal);
}
If4.EndIf();
Company.Utilities.Reflection.Emit.Commands.If If3 = Method.If(Field, Comparison.Equal, null);
{
Field.Assign(Method.NewObj(typeof(List<>).MakeGenericType(Property.Type).GetConstructor(Type.EmptyTypes)));
}
If3.EndIf();
}
If1.EndIf();
ReturnValue.Assign(Field);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="Exception">Exception to throw</param>
public Throw(VariableBase Exception)
{
this.Exception = Exception;
}
/// <summary>
/// Sets up the command
/// </summary>
public override void Setup()
{
ILGenerator Generator = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.Generator;
if (RightHandSide.DataType.IsValueType
&& !LeftHandSide.DataType.IsValueType)
{
RightHandSide = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.Box(RightHandSide);
}
else if (!RightHandSide.DataType.IsValueType
&& LeftHandSide.DataType.IsValueType)
{
RightHandSide = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.UnBox(RightHandSide, LeftHandSide.DataType);
}
else if (!RightHandSide.DataType.IsValueType
&& !LeftHandSide.DataType.IsValueType
&& RightHandSide.DataType != LeftHandSide.DataType)
{
RightHandSide = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.Cast(RightHandSide, LeftHandSide.DataType);
}
if (LeftHandSide is FieldBuilder || LeftHandSide is IPropertyBuilder)
Generator.Emit(OpCodes.Ldarg_0);
if (RightHandSide is FieldBuilder || RightHandSide is IPropertyBuilder)
Generator.Emit(OpCodes.Ldarg_0);
RightHandSide.Load(Generator);
if (RightHandSide.DataType != LeftHandSide.DataType)
{
if (ConversionOpCodes.ContainsKey(LeftHandSide.DataType))
{
Generator.Emit(ConversionOpCodes[LeftHandSide.DataType]);
}
}
LeftHandSide.Save(Generator);
}
/// <summary>
/// Defines an else if statement
/// </summary>
/// <param name="ComparisonType">Comparison type</param>
/// <param name="LeftHandSide">left hand side value</param>
/// <param name="RightHandSide">right hand side value</param>
public virtual void ElseIf(VariableBase LeftHandSide, Comparison ComparisonType, VariableBase RightHandSide)
{
ILGenerator Generator = Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.Generator;
Generator.Emit(OpCodes.Br, EndIfFinalLabel);
Generator.MarkLabel(EndIfLabel);
EndIfLabel = Generator.DefineLabel();
Company.Utilities.Reflection.Emit.BaseClasses.MethodBase.CurrentMethod.Commands.Add(new ElseIf(EndIfLabel, ComparisonType, LeftHandSide, RightHandSide));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="Value">Value to cast</param>
/// <param name="ValueType">Desired type to cast to</param>
public Cast(VariableBase Value,Type ValueType)
: base()
{
this.Value = Value;
this.ValueType = ValueType;
}
