/// <summary>
/// Sets up the command
/// </summary>
public override void Setup()
{
ILGenerator generator = MethodBase.CurrentMethod.Generator;
if (RightHandSide.DataType.IsValueType
&& !LeftHandSide.DataType.IsValueType)
{
RightHandSide = MethodBase.CurrentMethod.Box(RightHandSide);
}
else if (!RightHandSide.DataType.IsValueType
&& LeftHandSide.DataType.IsValueType)
{
RightHandSide = MethodBase.CurrentMethod.UnBox(RightHandSide, LeftHandSide.DataType);
}
else if (!RightHandSide.DataType.IsValueType
&& !LeftHandSide.DataType.IsValueType
&& RightHandSide.DataType != LeftHandSide.DataType)
{
RightHandSide = 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>
/// 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)
{
ObjectCallingOn = objectCallingOn;
MethodCalling = methodCalling;
MethodCallingFrom = method;
if (methodCalling.ReturnType != null && methodCalling.ReturnType != typeof (void))
{
Result =
method.CreateLocal(
methodCalling.Name + "ReturnObject" +
MethodBase.ObjectCounter.ToString(CultureInfo.InvariantCulture), methodCalling.ReturnType);
}
if (parameters != null)
{
Parameters = new VariableBase[parameters.Length];
for (int x = 0; x < parameters.Length; ++x)
{
if (parameters[x] is VariableBase)
Parameters[x] = (VariableBase) parameters[x];
else
Parameters[x] = MethodCallingFrom.CreateConstant(parameters[x]);
}
}
else
{
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)
{
if (leftHandSide == null)
throw new ArgumentNullException("leftHandSide");
LeftHandSide = leftHandSide;
var tempValue = value as VariableBase;
RightHandSide = tempValue == null ? 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)
{
EndIfLabel = endIfLabel;
if (leftHandSide != null)
LeftHandSide = leftHandSide;
else
LeftHandSide = MethodBase.CurrentMethod.CreateConstant(null);
if (rightHandSide != null)
RightHandSide = rightHandSide;
else
RightHandSide = MethodBase.CurrentMethod.CreateConstant(null);
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 If(Comparison comparisonType, VariableBase leftHandSide, VariableBase rightHandSide)
{
ILGenerator generator = MethodBase.CurrentMethod.Generator;
EndIfLabel = generator.DefineLabel();
EndIfFinalLabel = generator.DefineLabel();
if (leftHandSide != null)
LeftHandSide = leftHandSide;
else
LeftHandSide = MethodBase.CurrentMethod.CreateConstant(null);
if (rightHandSide != null)
RightHandSide = rightHandSide;
else
RightHandSide = MethodBase.CurrentMethod.CreateConstant(null);
ComparisonType = comparisonType;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="constructor">Constructor to use</param>
/// <param name="parameters">Variables sent to the constructor</param>
public NewObj(ConstructorInfo constructor, object[] parameters)
{
Constructor = constructor;
if (parameters != null)
{
Parameters = new VariableBase[parameters.Length];
for (int x = 0; x < parameters.Length; ++x)
{
if (parameters[x] is VariableBase)
Parameters[x] = (VariableBase) parameters[x];
else
Parameters[x] = MethodBase.CurrentMethod.CreateConstant(parameters[x]);
}
}
Result =
MethodBase.CurrentMethod.CreateLocal(
"ObjLocal" + MethodBase.ObjectCounter.ToString(CultureInfo.InvariantCulture),
constructor.DeclaringType);
}
/// <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)
{
ObjectCallingOn = objectCallingOn;
ConstructorCalling = methodCalling;
MethodCallingFrom = method;
if (parameters != null)
{
Parameters = new VariableBase[parameters.Length];
for (int x = 0; x < parameters.Length; ++x)
{
if (parameters[x] is VariableBase)
Parameters[x] = (VariableBase) parameters[x];
else
Parameters[x] = MethodCallingFrom.CreateConstant(parameters[x]);
}
}
else
{
Parameters = null;
}
}
/// <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 = MethodBase.CurrentMethod.Generator;
generator.Emit(OpCodes.Br, EndIfFinalLabel);
generator.MarkLabel(EndIfLabel);
EndIfLabel = generator.DefineLabel();
MethodBase.CurrentMethod.Commands.Add(new ElseIf(EndIfLabel, comparisonType, leftHandSide, rightHandSide));
}
/// <summary>
/// Unboxes a value to a specified type
/// </summary>
/// <param name="value">Value to unbox</param>
/// <param name="valueType">Value type</param>
public UnBox(VariableBase value, Type valueType)
{
Value = value;
ValueType = valueType;
}
/// <summary>
/// Creates a while statement
/// </summary>
/// <param name="leftHandSide">Left hand side variable</param>
/// <param name="comparisonType">Comparison type</param>
/// <param name="rightHandSide">Right hand side variable</param>
/// <returns>The while object</returns>
public virtual While While(VariableBase leftHandSide, Comparison comparisonType, VariableBase rightHandSide)
{
SetCurrentMethod();
var tempCommand = new While(comparisonType, leftHandSide, rightHandSide);
tempCommand.Setup();
Commands.Add(tempCommand);
return(tempCommand);
}
/// <summary>
/// Unboxes an object
/// </summary>
/// <param name="value">Value to unbox</param>
/// <param name="valueType">Type to unbox to</param>
/// <returns>The resulting variable</returns>
public virtual VariableBase UnBox(VariableBase value, Type valueType)
{
var tempCommand = new UnBox(value, valueType);
tempCommand.Setup();
Commands.Add(tempCommand);
++ObjectCounter;
return tempCommand.Result;
}
/// <summary>
/// Throws an exception
/// </summary>
/// <param name="exception">Exception to throw</param>
public virtual void Throw(VariableBase exception)
{
var tempCommand = new Throw(exception);
tempCommand.Setup();
Commands.Add(tempCommand);
}
/// <summary>
/// Calls a constructor
/// </summary>
/// <param name="objectCallingOn">Object to call the constructor on</param>
/// <param name="methodCalling">Constructor to call</param>
/// <param name="parameters">parameters to use</param>
public virtual void Call(VariableBase objectCallingOn, ConstructorInfo methodCalling, object[] parameters)
{
SetCurrentMethod();
var tempCommand = new Call(this, objectCallingOn, methodCalling, parameters);
tempCommand.Setup();
Commands.Add(tempCommand);
++ObjectCounter;
}
/// <summary>
/// Calls a method
/// </summary>
/// <param name="objectCallingOn">Object to call the method on</param>
/// <param name="methodCalling">Method to call</param>
/// <param name="parameters">parameters to use</param>
/// <returns>The result of the method call</returns>
public virtual VariableBase Call(VariableBase objectCallingOn, MethodInfo methodCalling, object[] parameters)
{
SetCurrentMethod();
var tempCommand = new Call(this, objectCallingOn, methodCalling, parameters);
tempCommand.Setup();
Commands.Add(tempCommand);
++ObjectCounter;
return tempCommand.Result;
}
/// <summary>
/// Assigns a value to a variable
/// </summary>
/// <param name="leftHandSide">Variable to assign to</param>
/// <param name="value">Value to assign</param>
public virtual void Assign(VariableBase leftHandSide, object value)
{
SetCurrentMethod();
var tempCommand = new Assign(leftHandSide, value);
tempCommand.Setup();
Commands.Add(tempCommand);
}
/// <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)
{
Value = value;
ValueType = valueType;
}
/// <summary>
/// Creates a while statement
/// </summary>
/// <param name="leftHandSide">Left hand side variable</param>
/// <param name="comparisonType">Comparison type</param>
/// <param name="rightHandSide">Right hand side variable</param>
/// <returns>The while object</returns>
public virtual While While(VariableBase leftHandSide, Comparison comparisonType, VariableBase rightHandSide)
{
SetCurrentMethod();
var tempCommand = new While(comparisonType, leftHandSide, rightHandSide);
tempCommand.Setup();
Commands.Add(tempCommand);
return tempCommand;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="exception">Exception to throw</param>
public Throw(VariableBase exception)
{
Exception = exception;
}
