public override void Emit(IEasyMember member, ILGenerator gen)
{
this._right.Emit(member, gen);
if (this._fromType != this._target)
{
if (this._fromType.IsByRef)
{
throw new NotSupportedException("Cannot convert from ByRef types");
}
if (this._target.IsByRef)
{
throw new NotSupportedException("Cannot convert to ByRef types");
}
if (this._target.IsValueType)
{
if (this._fromType.IsValueType)
{
throw new NotImplementedException("Cannot convert between distinct value types at the moment");
}
gen.Emit(OpCodes.Unbox, this._target);
OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, this._target);
}
else if (this._fromType.IsValueType)
{
gen.Emit(OpCodes.Box, this._fromType);
this.EmitCastIfNeeded(typeof(object), this._target, gen);
}
else
{
this.EmitCastIfNeeded(this._fromType, this._target, gen);
}
}
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
if ((OpCodes.Brfalse.Equals(this._operation) || OpCodes.Brfalse_S.Equals(this._operation)) || (OpCodes.Brtrue.Equals(this._operation) || OpCodes.Brtrue_S.Equals(this._operation)))
{
this._left.Emit(member, gen);
}
else
{
this._left.Emit(member, gen);
this._right.Emit(member, gen);
}
Label label = gen.DefineLabel();
Label label2 = gen.DefineLabel();
gen.Emit(this._operation, label);
if (this._falseStmts.Count != 0)
{
foreach (Statement statement in this._falseStmts)
{
statement.Emit(member, gen);
}
}
gen.Emit(OpCodes.Br_S, label2);
gen.MarkLabel(label);
if (this._trueStmts.Count != 0)
{
foreach (Statement statement2 in this._trueStmts)
{
statement2.Emit(member, gen);
}
}
gen.MarkLabel(label2);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
LocalBuilder local = gen.DeclareLocal( typeof(object[]) );
gen.Emit(OpCodes.Ldc_I4, _args.Length);
gen.Emit(OpCodes.Newarr, typeof(object));
gen.Emit(OpCodes.Stloc, local);
for(int i=0; i < _args.Length; i++)
{
gen.Emit(OpCodes.Ldloc, local);
gen.Emit(OpCodes.Ldc_I4, i);
TypeReference reference = _args[i];
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
if (reference.Type.IsByRef)
{
throw new NotSupportedException();
}
if (reference.Type.IsValueType)
{
gen.Emit(OpCodes.Box, reference.Type.UnderlyingSystemType);
}
gen.Emit(OpCodes.Stelem_Ref);
}
gen.Emit(OpCodes.Ldloc, local);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
LocalBuilder local = gen.DeclareLocal(typeof(object[]));
gen.Emit(OpCodes.Ldc_I4, _args.Length);
gen.Emit(OpCodes.Newarr, typeof(object));
gen.Emit(OpCodes.Stloc, local);
for (int i = 0; i < _args.Length; i++)
{
gen.Emit(OpCodes.Ldloc, local);
gen.Emit(OpCodes.Ldc_I4, i);
TypeReference reference = _args[i];
ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
if (reference.Type.IsByRef)
{
throw new NotSupportedException();
}
if (reference.Type.IsValueType)
{
gen.Emit(OpCodes.Box, reference.Type.UnderlyingSystemType);
}
gen.Emit(OpCodes.Stelem_Ref);
}
gen.Emit(OpCodes.Ldloc, local);
}
public override void Emit(IEasyMember member, ILGenerator il)
{
ArgumentsUtil.EmitLoadOwnerAndReference(this._targetArray, il);
il.Emit(OpCodes.Ldc_I4, this._targetPosition);
this._value.Emit(member, il);
il.Emit(OpCodes.Stelem_Ref);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldtoken, this._method);
MethodInfo meth = typeof(MethodBase).GetMethod("GetMethodFromHandle", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(RuntimeMethodHandle) }, null);
gen.Emit(OpCodes.Call, meth);
gen.Emit(OpCodes.Castclass, typeof(MethodInfo));
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(_target.OwnerReference, gen);
_expression.Emit(member, gen);
_target.StoreReference(gen);
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference( _target.OwnerReference, gen );
_expression.Emit(member, gen);
_target.StoreReference(gen);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(base._owner, gen);
foreach (Expression expression in base._args)
{
expression.Emit(member, gen);
}
gen.Emit(OpCodes.Callvirt, base._method);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldarg_0);
foreach (Expression expression in this._args)
{
expression.Emit(member, gen);
}
gen.Emit(OpCodes.Call, this._cmethod);
}
public override void Emit(IEasyMember member, ILGenerator il)
{
ArgumentsUtil.EmitLoadOwnerAndReference( _targetArray, il );
il.Emit(OpCodes.Ldc_I4, _targetPosition);
_value.Emit(member, il);
il.Emit(OpCodes.Stelem_Ref);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldarg_0);
foreach(Expression exp in _args)
{
exp.Emit(member, gen);
}
gen.Emit(OpCodes.Call, _cmethod);
}
internal void Generate(IEasyMember member, ILGenerator il)
{
foreach (Reference reference in this._ilmarkers)
{
reference.Generate(il);
}
foreach (Statement statement in this._stmts)
{
statement.Emit(member, il);
}
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(_owner, gen);
foreach(Expression exp in _args)
{
exp.Emit(member, gen);
}
gen.Emit(OpCodes.Call, _method);
}
internal void Generate(IEasyMember member, ILGenerator il)
{
foreach (Reference local in _ilmarkers)
{
local.Generate(il);
}
foreach (Statement stmt in _stmts)
{
stmt.Emit(member, il);
}
}
internal void Generate( IEasyMember member, ILGenerator il )
{
foreach(Reference local in _ilmarkers)
{
local.Generate(il);
}
foreach(Statement stmt in _stmts)
{
stmt.Emit(member, il);
}
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(this._syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Enter", new Type[] { typeof(object) }));
gen.BeginExceptionBlock();
foreach (Statement statement in this._stmts)
{
statement.Emit(member, gen);
}
gen.BeginFinallyBlock();
ArgumentsUtil.EmitLoadOwnerAndReference(this._syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Exit"));
gen.EndExceptionBlock();
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
_right.Emit(member, gen);
if (_fromType == _target)
{
return;
}
if (_fromType.IsByRef)
{
throw new NotSupportedException("Cannot convert from ByRef types");
}
if (_target.IsByRef)
{
throw new NotSupportedException("Cannot convert to ByRef types");
}
if (_target.IsValueType)
{
if (_fromType.IsValueType)
{
throw new NotImplementedException("Cannot convert between distinct value types at the moment");
}
else
{
// Unbox conversion
// Assumes fromType is a boxed value
gen.Emit(OpCodes.Unbox, _target);
OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, _target);
}
}
else
{
if (_fromType.IsValueType)
{
// Box conversion
gen.Emit(OpCodes.Box, _fromType);
EmitCastIfNeeded(typeof(object), _target, gen);
}
else
{
// Possible down-cast
EmitCastIfNeeded(_fromType, _target, gen);
}
}
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
_right.Emit(member, gen);
if (_fromType == _target)
{
return;
}
if (_fromType.IsByRef)
{
throw new NotSupportedException("Cannot convert from ByRef types");
}
if (_target.IsByRef)
{
throw new NotSupportedException("Cannot convert to ByRef types");
}
if (_target.IsValueType)
{
if (_fromType.IsValueType)
{
throw new NotImplementedException("Cannot convert between distinct value types at the moment");
}
else
{
// Unbox conversion
// Assumes fromType is a boxed value
gen.Emit(OpCodes.Unbox, _target);
OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, _target);
}
}
else
{
if (_fromType.IsValueType)
{
// Box conversion
gen.Emit(OpCodes.Box, _fromType);
EmitCastIfNeeded(typeof(object), _target, gen);
}
else
{
// Possible down-cast
EmitCastIfNeeded(_fromType, _target, gen);
}
}
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
if (this._reference != null)
{
ArgumentsUtil.EmitLoadOwnerAndReference(this._reference, gen);
}
else if (this._expression != null)
{
this._expression.Emit(member, gen);
}
else if (member.ReturnType != typeof(void))
{
OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, member.ReturnType);
}
gen.Emit(OpCodes.Ret);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
foreach (Expression expression in this._arguments)
{
expression.Emit(member, gen);
}
if (this._constructor == null)
{
this._constructor = this._type.GetConstructor(this._constructor_args);
}
if (this._constructor == null)
{
throw new ApplicationException("Could not find constructor matching specified arguments");
}
gen.Emit(OpCodes.Newobj, this._constructor);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldtoken, _method);
#if DOTNET2 && !MONO // Needed to support generics
gen.Emit(OpCodes.Ldtoken, _method.DeclaringType);
#endif
MethodInfo minfo = typeof(MethodBase).GetMethod(
"GetMethodFromHandle", BindingFlags.Static | BindingFlags.Public, null,
new Type[] { typeof(RuntimeMethodHandle),
#if DOTNET2 && !MONO // Needed to support generics
typeof(RuntimeTypeHandle)
#endif
}, null);
gen.Emit(OpCodes.Call, minfo);
gen.Emit(OpCodes.Castclass, typeof(MethodInfo));
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(_syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Enter"));
Label tryBlock = gen.BeginExceptionBlock();
foreach(Statement stmt in _stmts)
{
stmt.Emit(member, gen);
}
gen.BeginFinallyBlock();
ArgumentsUtil.EmitLoadOwnerAndReference(_syncLockSource, gen);
gen.Emit(OpCodes.Call, typeof(Monitor).GetMethod("Exit"));
gen.EndExceptionBlock();
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldtoken, _method);
#if DOTNET2 && !MONO // Needed to support generics
gen.Emit(OpCodes.Ldtoken, _method.DeclaringType);
#endif
MethodInfo minfo = typeof(MethodBase).GetMethod(
"GetMethodFromHandle", BindingFlags.Static|BindingFlags.Public, null,
new Type[] { typeof(RuntimeMethodHandle),
#if DOTNET2 && !MONO // Needed to support generics
typeof(RuntimeTypeHandle)
#endif
}, null);
gen.Emit(OpCodes.Call, minfo);
gen.Emit(OpCodes.Castclass, typeof(MethodInfo));
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
if (_reference != null)
{
ArgumentsUtil.EmitLoadOwnerAndReference(_reference, gen);
}
else if (_expression != null)
{
_expression.Emit(member, gen);
}
else
{
if (member.ReturnType != typeof(void))
{
OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, member.ReturnType);
}
}
gen.Emit(OpCodes.Ret);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
foreach(Expression exp in _arguments)
{
exp.Emit(member, gen);
}
if (_constructor == null)
{
_constructor = _type.GetConstructor( _constructor_args );
}
if (_constructor == null)
{
throw new ApplicationException("Could not find constructor matching specified arguments");
}
gen.Emit(OpCodes.Newobj, _constructor);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
if (OpCodes.Brfalse.Equals(_operation) ||
OpCodes.Brfalse_S.Equals(_operation) ||
OpCodes.Brtrue.Equals(_operation) ||
OpCodes.Brtrue_S.Equals(_operation))
{
// Unary operators
_left.Emit(member, gen);
}
else
{
// Binary operators
_left.Emit(member, gen);
_right.Emit(member, gen);
}
Label truePart = gen.DefineLabel();
Label exitPart = gen.DefineLabel();
gen.Emit(_operation, truePart);
if (_falseStmts.Count != 0)
{
foreach (Statement stmt in _falseStmts)
{
stmt.Emit(member, gen);
}
}
gen.Emit(OpCodes.Br_S, exitPart);
gen.MarkLabel(truePart);
if (_trueStmts.Count != 0)
{
foreach (Statement stmt in _trueStmts)
{
stmt.Emit(member, gen);
}
}
gen.MarkLabel(exitPart);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
if (OpCodes.Brfalse.Equals(_operation) ||
OpCodes.Brfalse_S.Equals(_operation) ||
OpCodes.Brtrue.Equals(_operation) ||
OpCodes.Brtrue_S.Equals(_operation) )
{
// Unary operators
_left.Emit(member, gen);
}
else
{
// Binary operators
_left.Emit(member, gen);
_right.Emit(member, gen);
}
Label truePart = gen.DefineLabel();
Label exitPart = gen.DefineLabel();
gen.Emit(_operation, truePart);
if (_falseStmts.Count != 0)
{
foreach(Statement stmt in _falseStmts)
{
stmt.Emit(member, gen);
}
}
gen.Emit(OpCodes.Br_S, exitPart);
gen.MarkLabel(truePart);
if (_trueStmts.Count != 0)
{
foreach(Statement stmt in _trueStmts)
{
stmt.Emit(member, gen);
}
}
gen.MarkLabel(exitPart);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldtoken, _type);
gen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
gen.Emit(OpCodes.Br_S, _label.Reference );
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Br_S, this._label.Reference);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(_reference, gen);
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
_expression.Emit(member, gen);
}
public abstract void Emit(IEasyMember member, ILGenerator gen);
public abstract void Emit(IEasyMember member, ILGenerator gen);
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(this._arrayReference, gen);
ArgumentsUtil.EmitLoadOwnerAndReference(this._index, gen);
gen.Emit(OpCodes.Ldelem_Ref);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
ArgumentsUtil.EmitLoadOwnerAndReference(_arrayReference, gen);
ArgumentsUtil.EmitLoadOwnerAndReference(_index, gen);
gen.Emit(OpCodes.Ldelem_Ref);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldnull);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
bool abs = _method.IsAbstract;
gen.Emit(OpCodes.Ldftn, _method);
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
_expression.Emit(member, gen);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.MarkLabel(this._label.Reference);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldnull);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldc_I4, _size);
gen.Emit(OpCodes.Newarr, _arrayType);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldc_I4, this._size);
gen.Emit(OpCodes.Newarr, this._arrayType);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
bool abs = _method.IsAbstract;
gen.Emit(OpCodes.Ldftn, _method);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
gen.Emit(OpCodes.Ldtoken, _type);
gen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
this._expression.Emit(member, gen);
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
gen.MarkLabel(_label.Reference);
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
gen.Emit(OpCodes.Nop);
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
gen.Emit(OpCodes.Nop);
}
public abstract void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen);
public override void Emit(IEasyMember member, ILGenerator gen)
{
_left.Emit(member, gen);
_right.Emit(member, gen);
gen.Emit(_operation);
}
public override void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen)
{
gen.Emit(OpCodes.Br_S, _label.Reference);
}
public override void Emit(IEasyMember member, ILGenerator gen)
{
_left.Emit(member, gen);
_right.Emit(member, gen);
gen.Emit(_operation);
}
public abstract void Emit(IEasyMember member, System.Reflection.Emit.ILGenerator gen);
