Type[] GetParameterTypes (CodeExpression[] parameters)
{
Type[] ts = new Type [parameters.Length];
for (int n=0; n<ts.Length; n++)
ts [n] = parameters[n].GetResultType ();
return ts;
}
public CodeFieldReference (CodeExpression target, FieldInfo field)
{
if (field.IsStatic)
throw new InvalidOperationException ("Static member '" + field.Name + "' cannot be accessed with an instance reference.");
this.target = target;
this.field = field;
}
public CodeNewArray (Type type, CodeExpression size)
{
this.elemType = type;
this.size = size;
if (size.GetResultType () != typeof(int))
throw new InvalidOperationException ("Array size must be an Int32");
}
public CodeFor (CodeExpression initExp, CodeExpression conditionExp, CodeExpression nextExp)
{
this.initExp = initExp;
this.conditionExp = conditionExp;
this.nextExp = nextExp;
if (conditionExp.GetResultType () != typeof(bool))
throw new InvalidOperationException ("Condition expression is not boolean");
}
public CodeArrayItem (CodeExpression array, CodeExpression index)
{
if (array == null)
throw new ArgumentNullException ("array");
if (index == null)
throw new ArgumentNullException ("index");
this.array = array;
this.index = index;
}
public CodeSubstractOne (CodeExpression exp)
{
this.exp = exp;
if (!exp.IsNumber) {
decMet = exp.GetResultType ().GetMethod ("op_Decrement");
if (decMet == null)
throw new InvalidOperationException ("Operator '--' cannot be applied to operand of type '" + exp.GetResultType().FullName + "'");
}
}
public CodeAssignment(CodeValueReference var, CodeExpression exp)
{
if (var == null)
throw new ArgumentNullException ("var");
if (exp == null)
throw new ArgumentNullException ("exp");
this.exp = exp;
this.var = var;
}
public CodeWhen (CodeExpression condition, CodeExpression trueResult, CodeExpression falseResult)
{
this.condition = condition;
if (condition.GetResultType () != typeof(bool))
throw new InvalidOperationException ("Condition expression is not boolean");
if (trueResult.GetResultType() != falseResult.GetResultType())
throw new InvalidOperationException ("The types of the true and false expressions must be the same");
trueBlock = trueResult;
falseBlock = falseResult;
}
public CodeMethodCall (CodeExpression target, string name, params CodeExpression[] parameters)
{
this.target = target;
this.parameters = parameters;
Type[] types = GetParameterTypes (parameters);
method = target.GetResultType().GetMethod (name, types);
if (method == null) {
throw new InvalidOperationException ("Method " + GetSignature(target.GetResultType(), name, parameters) + " not found");
}
}
public CodeAnd (CodeExpression exp1, CodeExpression exp2)
{
this.exp1 = exp1;
this.exp2 = exp2;
if (exp1.GetResultType () != typeof(bool) || exp1.GetResultType () != typeof(bool)) {
if (t1 != t2)
throw new InvalidOperationException ("Can't compare values of different primitive types");
}
}
public CodeForeach (CodeExpression array, Type itemType)
{
this.array = array;
this.itemType = itemType;
Type t = array.GetResultType ();
if (!t.IsArray && t.GetMethod ("GetEnumerator", Type.EmptyTypes) == null)
throw new InvalidOperationException ("foreach statement cannot operate on variables of type `" + t + "' because that class does not provide a GetEnumerator method or it is inaccessible");
itemDec = new CodeVariableDeclaration (itemType, "item");
}
public static void GenerateMethodCall (ILGenerator gen, CodeExpression target, MethodBase method, params CodeExpression[] parameters)
{
Type[] ptypes = Type.EmptyTypes;
// It could raise an error since GetParameters() on MethodBuilder is not supported.
if (parameters.Length > 0) {
ParameterInfo[] pars = method.GetParameters ();
ptypes = new Type[pars.Length];
for (int n=0; n<ptypes.Length; n++) ptypes[n] = pars[n].ParameterType;
}
GenerateMethodCall (gen, target, method, ptypes, parameters);
}
public CodeNotEquals (CodeExpression exp1, CodeExpression exp2)
{
this.exp1 = exp1;
this.exp2 = exp2;
t1 = exp1.GetResultType ();
t2 = exp2.GetResultType ();
if (t1.IsValueType && t2.IsValueType) {
if (t1 != t2)
throw new InvalidOperationException ("Can't compare values of different primitive types");
}
}
public CodeAdd (CodeExpression exp1, CodeExpression exp2)
{
this.symbol = "+";
this.exp1 = exp1;
this.exp2 = exp2;
t1 = exp1.GetResultType ();
t2 = exp2.GetResultType ();
if ((!t1.IsPrimitive || !t2.IsPrimitive || (t1 != t2)) && (t1 != typeof(string) || t2 != typeof(string))) {
throw new InvalidOperationException ("Operator " + GetType().Name + " cannot be applied to operands of type '" + t1.Name + " and " + t2.Name);
}
}
public CodeBinaryOperation(CodeExpression exp1, CodeExpression exp2, string symbol)
{
this.symbol = symbol;
this.exp1 = exp1;
this.exp2 = exp2;
t1 = exp1.GetResultType ();
t2 = exp2.GetResultType ();
if (!t1.IsPrimitive || !t2.IsPrimitive || (t1 != t2)) {
throw new InvalidOperationException ("Operator " + GetType().Name + " cannot be applied to operands of type '" + t1.Name + " and " + t2.Name);
}
}
public override void GenerateSet (ILGenerator gen, CodeExpression value)
{
if (field.IsStatic) {
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, field.FieldType, value.GetResultType ());
gen.Emit (OpCodes.Stsfld, field);
}
else {
target.Generate (gen);
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, field.FieldType, value.GetResultType ());
gen.Emit (OpCodes.Stfld, field);
}
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
if (type.IsByRef) {
gen.Emit (OpCodes.Ldarg, argNum);
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, type.GetElementType (), value.GetResultType ());
CodeGenerationHelper.SaveToPtr (gen, type.GetElementType ());
}
else {
value.Generate (gen);
CodeGenerationHelper.GenerateSafeConversion (gen, type, value.GetResultType ());
gen.Emit (OpCodes.Starg, argNum);
}
}
static void GenerateMethodCall (ILGenerator gen, CodeExpression target, MethodBase method, Type[] parameterTypes, params CodeExpression[] parameters)
{
OpCode callOp;
if (parameterTypes.Length != parameters.Length)
throw GetMethodException (method, "Invalid number of parameters, expected " + parameterTypes.Length + ", found " + parameters.Length + ".");
if (!object.ReferenceEquals (target, null))
{
target.Generate (gen);
Type targetType = target.GetResultType();
if (targetType.IsValueType) {
LocalBuilder lb = gen.DeclareLocal (targetType);
gen.Emit (OpCodes.Stloc, lb);
gen.Emit (OpCodes.Ldloca, lb);
callOp = OpCodes.Call;
}
else
callOp = OpCodes.Callvirt;
}
else
callOp = OpCodes.Call;
for (int n=0; n<parameterTypes.Length; n++) {
try {
CodeExpression par = parameters[n];
par.Generate (gen);
GenerateSafeConversion (gen, parameterTypes[n], par.GetResultType());
}
catch (InvalidOperationException ex) {
throw GetMethodException (method, "Parameter " + n + ". " + ex.Message);
}
}
if (method is MethodInfo)
gen.Emit (callOp, (MethodInfo)method);
else if (method is ConstructorInfo)
gen.Emit (callOp, (ConstructorInfo)method);
}
public void Assign(CodeValueReference var, CodeExpression val)
{
currentBlock.Add(new CodeAssignment(var, val));
}
public static CodeExpression Multiply (CodeExpression e1, CodeExpression e2)
{
return new CodeMul (e1, e2);
}
public static CodeExpression Divide (CodeExpression e1, CodeExpression e2)
{
return new CodeDiv (e1, e2);
}
public void While(CodeExpression condition)
{
currentBlock.Add(new CodeWhile(condition));
PushNewBlock();
}
public static CodeExpression Subtract (CodeExpression e1, CodeExpression e2)
{
return new CodeSub (e1, e2);
}
public void For(CodeExpression initExp, CodeExpression conditionExp, CodeExpression nextExp)
{
currentBlock.Add(new CodeFor(initExp, conditionExp, nextExp));
PushNewBlock();
}
internal CodeReturn(CodeBuilder codeBuilder, CodeExpression retValue)
{
this.codeBuilder = codeBuilder;
this.retValue = retValue;
}
public CodeExpression When(CodeExpression condition, CodeExpression trueResult, CodeExpression falseResult)
{
return(new CodeWhen(condition, trueResult, falseResult));
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
Type t = array.GetResultType().GetElementType();
if (t.IsEnum && t != typeof(Enum))
{
t = t.UnderlyingSystemType;
}
array.Generate(gen);
index.Generate(gen);
switch (Type.GetTypeCode(t))
{
case TypeCode.Byte:
case TypeCode.SByte:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I1);
break;
case TypeCode.Double:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_R8);
break;
case TypeCode.UInt16:
case TypeCode.Int16:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I2);
break;
case TypeCode.UInt32:
case TypeCode.Int32:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I4);
break;
case TypeCode.UInt64:
case TypeCode.Int64:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_I8);
break;
case TypeCode.Single:
value.Generate(gen);
gen.Emit(OpCodes.Stelem_R4);
break;
default:
if (t.IsValueType)
{
gen.Emit(OpCodes.Ldelema, t);
value.Generate(gen);
gen.Emit(OpCodes.Stobj, t);
}
else
{
value.Generate(gen);
gen.Emit(OpCodes.Stelem_Ref);
}
break;
}
}
public static CodeExpression And (CodeExpression e1, CodeExpression e2, CodeExpression e3)
{
return new CodeAnd (new CodeAnd (e1, e2), e3);
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
value.Generate(gen);
CodeGenerationHelper.GenerateSafeConversion(gen, type, value.GetResultType());
gen.Emit(OpCodes.Stloc, localBuilder);
}
public void Return(CodeExpression exp)
{
currentBlock.Add(new CodeReturn(this, exp));
}
public void If(CodeExpression condition)
{
currentBlock.Add(new CodeIf(condition));
PushNewBlock();
nestedIfs.Add(0);
}
public abstract void GenerateSet(ILGenerator gen, CodeExpression value);
public abstract void GenerateSet(ILGenerator gen, CodeExpression value);
public CodeVariableReference DeclareVariable(CodeExpression initValue)
{
return(DeclareVariable(initValue.GetResultType(), initValue));
}
internal CodeReturn (CodeBuilder codeBuilder, CodeExpression retValue)
{
this.codeBuilder = codeBuilder;
this.retValue = retValue;
}
public CodeFieldReference DefineField(string name, Type type, FieldAttributes attrs, CodeExpression initialValue, params CodeCustomAttribute [] customAttributes)
{
FieldBuilder fb = typeBuilder.DefineField(GetFieldName(name), type, attrs);
foreach (CodeCustomAttribute a in customAttributes)
{
fb.SetCustomAttribute(a.Builder);
}
fieldAttributes [fb] = new ArrayList(customAttributes);
fields.Add(fb);
CodeFieldReference fr;
if ((attrs & FieldAttributes.Static) != 0)
{
fr = new CodeFieldReference(fb);
}
else
{
fr = new CodeFieldReference(new CodeArgumentReference(TypeBuilder, 0, "this"), fb);
}
if (null != (object)initialValue)
{
CodeBuilder cb = (attrs & FieldAttributes.Static) == 0 ? GetInstanceInitBuilder() : GetClassInitBuilder();
cb.Assign(fr, initialValue);
}
return(fr);
}
public override void GenerateSet (ILGenerator gen, CodeExpression value)
{
exp.GenerateSet (gen, value);
}
public static CodeExpression Call (CodeExpression target, string name, params CodeExpression[] parameters)
{
return new CodeMethodCall (target, name, parameters);
}
public CodeIs(Type type, CodeExpression exp)
{
this.type = type;
this.exp = exp;
}
public CodeFieldReference DefineStaticField(CodeExpression initialValue, params CodeCustomAttribute [] customAttributes)
{
return(DefineField(GetFieldName(null), initialValue.GetResultType(), FieldAttributes.Public | FieldAttributes.Static, initialValue, customAttributes));
}
public static CodeExpression NewArray (Type type, CodeExpression size)
{
return new CodeNewArray (type, size);
}
public CodeFieldReference DefineStaticField(string name, Type type, CodeExpression initialValue, params CodeCustomAttribute [] customAttributes)
{
return(DefineField(GetFieldName(name), type, FieldAttributes.Public | FieldAttributes.Static, initialValue, customAttributes));
}
public static CodeExpression Or (CodeExpression e1, CodeExpression e2)
{
return new CodeOr (e1, e2);
}
public CodeMethodCall(CodeExpression target, CodeMethod method, params CodeExpression[] parameters)
{
this.target = target;
this.parameters = parameters;
this.codeMethod = method;
}
public static CodeExpression Call (CodeExpression target, CodeMethod method, params CodeExpression[] parameters)
{
return new CodeMethodCall (target, method, parameters);
}
public override void GenerateSet(ILGenerator gen, CodeExpression value)
{
exp.GenerateSet(gen, value);
}
