public static void EmitCall(
CompilationContext context,
IAstRefOrAddr invocationObject,
MethodInfo methodInfo,
List<IAstStackItem> arguments)
{
if (arguments == null)
{
arguments = new List<IAstStackItem>();
}
if (invocationObject != null)
{
invocationObject.Compile(context);
}
ParameterInfo[] args = methodInfo.GetParameters();
if (args.Length != arguments.Count)
{
throw new Exception("Invalid method parameters count");
}
for (int i = 0; i < args.Length; ++i)
{
arguments[i].Compile(context);
PrepareValueOnStack(context, args[i].ParameterType, arguments[i].itemType);
}
if (methodInfo.IsVirtual)
{
context.EmitCall(OpCodes.Callvirt, methodInfo);
}
else
{
context.EmitCall(OpCodes.Call, methodInfo);
}
}
public static IAstRefOrAddr ReadMemberRA(IAstRefOrAddr sourceObject, MemberInfo memberInfo)
{
if (memberInfo.MemberType == MemberTypes.Method)
{
MethodInfo methodInfo = memberInfo.DeclaringType.GetMethod(memberInfo.Name);
if (methodInfo.ReturnType == null)
{
throw new EmitMapperException("Invalid member:" + memberInfo.Name);
}
if (methodInfo.GetParameters().Length > 0)
{
throw new EmitMapperException("Method " + memberInfo.Name + " should not have parameters");
}
if (methodInfo.ReturnType == null || methodInfo.ReturnType.IsValueType)
{
throw new EmitMapperException("Method " + memberInfo.Name + " should return a reference");
}
return((IAstRef)CallMethod(methodInfo, sourceObject, null));
}
else if (memberInfo.MemberType == MemberTypes.Field)
{
return(AstBuildHelper.ReadFieldRA(sourceObject, (FieldInfo)memberInfo));
}
else
{
var pi = (PropertyInfo)memberInfo;
if (pi.PropertyType.IsValueType)
{
return(AstBuildHelper.ReadPropertyRA(sourceObject, (PropertyInfo)memberInfo));
}
return((IAstRef)AstBuildHelper.ReadPropertyRV(sourceObject, (PropertyInfo)memberInfo));
}
}
/// <summary>
/// Emits the call.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="invocationObject">The invocation object.</param>
/// <param name="methodInfo">The method info.</param>
/// <param name="arguments">The arguments.</param>
/// <exception cref="Exception"></exception>
public static void EmitCall(
CompilationContext context,
IAstRefOrAddr invocationObject,
MethodInfo methodInfo,
List <IAstStackItem> arguments)
{
arguments ??= new List <IAstStackItem>();
if (invocationObject != null)
{
invocationObject.Compile(context);
}
var args = methodInfo.GetParameters();
if (args.Length != arguments.Count)
{
throw new Exception("Invalid method parameters count");
}
for (var i = 0; i < args.Length; ++i)
{
arguments[i].Compile(context);
PrepareValueOnStack(context, args[i].ParameterType, arguments[i].ItemType);
}
context.EmitCall(methodInfo.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, methodInfo);
}
/// <summary>
/// Reads the member r v.
/// </summary>
/// <param name="sourceObject">The source object.</param>
/// <param name="memberInfo">The member info.</param>
/// <exception cref="EmitMapperException"></exception>
/// <returns>An IAstRefOrValue.</returns>
public static IAstRefOrValue ReadMemberRV(IAstRefOrAddr sourceObject, MemberInfo memberInfo)
{
if (memberInfo.MemberType == MemberTypes.Method)
{
var methodInfo = memberInfo.DeclaringType.GetMethodCache(memberInfo.Name);
if (methodInfo.ReturnType == null)
{
throw new EmitMapperException("Invalid member:" + memberInfo.Name);
}
if (methodInfo.GetParameters().Length > 0)
{
throw new EmitMapperException("Method " + memberInfo.Name + " should not have parameters");
}
return(CallMethod(methodInfo, sourceObject, null));
}
if (memberInfo.MemberType == MemberTypes.Field)
{
return(ReadFieldRV(sourceObject, (FieldInfo)memberInfo));
}
return(ReadPropertyRV(sourceObject, (PropertyInfo)memberInfo));
}
public AstCallMethodVoid(
MethodInfo methodInfo,
IAstRefOrAddr invocationObject,
List<IAstStackItem> arguments)
{
this.methodInfo = methodInfo;
this.invocationObject = invocationObject;
this.arguments = arguments;
}
public AstCallMethodVoid(
MethodInfo methodInfo,
IAstRefOrAddr invocationObject,
List <IAstStackItem> arguments)
{
this.methodInfo = methodInfo;
this.invocationObject = invocationObject;
this.arguments = arguments;
}
/// <summary>
/// Initializes a new instance of the <see cref="AstCallMethod" /> class.
/// </summary>
/// <param name="methodInfo">The method info.</param>
/// <param name="invocationObject">The invocation object.</param>
/// <param name="arguments">The arguments.</param>
public AstCallMethod(MethodInfo methodInfo, IAstRefOrAddr invocationObject, List <IAstStackItem> arguments)
{
if (methodInfo == null)
{
throw new InvalidOperationException("methodInfo is null");
}
MethodInfo = methodInfo;
InvocationObject = invocationObject;
Arguments = arguments;
}
/// <summary>
/// Calls the method.
/// </summary>
/// <param name="methodInfo">The method info.</param>
/// <param name="invocationObject">The invocation object.</param>
/// <param name="arguments">The arguments.</param>
/// <returns>An IAstRefOrValue.</returns>
public static IAstRefOrValue CallMethod(
MethodInfo methodInfo,
IAstRefOrAddr invocationObject,
List <IAstStackItem> arguments)
{
if (methodInfo.ReturnType.IsValueType)
{
return(new AstCallMethodValue(methodInfo, invocationObject, arguments));
}
return(new AstCallMethodRef(methodInfo, invocationObject, arguments));
}
/// <summary>
/// Writes the member.
/// </summary>
/// <param name="memberInfo">The member info.</param>
/// <param name="targetObject">The target object.</param>
/// <param name="value">The value.</param>
/// <returns>An IAstNode.</returns>
public static IAstNode WriteMember(MemberInfo memberInfo, IAstRefOrAddr targetObject, IAstRefOrValue value)
{
if (memberInfo.MemberType == MemberTypes.Field)
{
return new AstWriteField {
FieldInfo = (FieldInfo)memberInfo, TargetObject = targetObject, Value = value
}
}
;
return(new AstWriteProperty(targetObject, value, (PropertyInfo)memberInfo));
}
public static IAstRefOrValue ReadMembersChain(IAstRefOrAddr sourceObject, MemberInfo[] membersChain)
{
IAstRefOrAddr src = sourceObject;
IAstRefOrValue result = null;
for (int i = 0; i < membersChain.Length - 1; ++i)
{
src = ReadMemberRA(src, membersChain[i]);
}
result = ReadMemberRV(src, membersChain[membersChain.Length - 1]);
return(result);
}
public AstCallMethod(
MethodInfo methodInfo,
IAstRefOrAddr invocationObject,
List<IAstStackItem> arguments)
{
if (methodInfo == null)
{
throw new InvalidOperationException("methodInfo is null");
}
this.methodInfo = methodInfo;
this.invocationObject = invocationObject;
this.arguments = arguments;
}
/// <summary>
/// Reads the property r a.
/// </summary>
/// <param name="sourceObject">The source object.</param>
/// <param name="propertyInfo">The property info.</param>
/// <returns>An IAstRefOrAddr.</returns>
public static IAstRefOrAddr ReadPropertyRA(IAstRefOrAddr sourceObject, PropertyInfo propertyInfo)
{
if (propertyInfo.PropertyType.IsValueType)
{
return(new AstValueToAddr(new AstReadPropertyValue {
SourceObject = sourceObject, PropertyInfo = propertyInfo
}));
}
return(new AstReadPropertyRef {
SourceObject = sourceObject, PropertyInfo = propertyInfo
});
}
public static IAstRefOrValue CallMethod(
MethodInfo methodInfo,
IAstRefOrAddr invocationObject,
List<IAstStackItem> arguments)
{
if (methodInfo.ReturnType.IsValueType)
{
return new AstCallMethodValue(methodInfo, invocationObject, arguments);
}
else
{
return new AstCallMethodRef(methodInfo, invocationObject, arguments);
}
}
/// <summary>
/// Reads the property r v.
/// </summary>
/// <param name="sourceObject">The source object.</param>
/// <param name="propertyInfo">The property info.</param>
/// <returns>An IAstRefOrValue.</returns>
public static IAstRefOrValue ReadPropertyRV(IAstRefOrAddr sourceObject, PropertyInfo propertyInfo)
{
if (propertyInfo.PropertyType.IsValueType)
{
return new AstReadPropertyValue {
SourceObject = sourceObject, PropertyInfo = propertyInfo
}
}
;
return(new AstReadPropertyRef {
SourceObject = sourceObject, PropertyInfo = propertyInfo
});
}
/// <summary>
/// Reads the field r v.
/// </summary>
/// <param name="sourceObject">The source object.</param>
/// <param name="fieldInfo">The field info.</param>
/// <returns>An IAstRefOrValue.</returns>
public static IAstRefOrValue ReadFieldRV(IAstRefOrAddr sourceObject, FieldInfo fieldInfo)
{
if (fieldInfo.FieldType.IsValueType)
{
return new AstReadFieldValue {
FieldInfo = fieldInfo, SourceObject = sourceObject
}
}
;
return(new AstReadFieldRef {
FieldInfo = fieldInfo, SourceObject = sourceObject
});
}
public AstWriteProperty(IAstRefOrAddr targetObject, IAstRefOrValue value, PropertyInfo propertyInfo)
{
_targetObject = targetObject;
_value = value;
_propertyInfo = propertyInfo;
_setMethod = propertyInfo.GetSetMethod();
if (_setMethod == null)
{
throw new Exception("Property " + propertyInfo.Name + " doesn't have set accessor");
}
if (_setMethod.GetParameters().Length != 1)
{
throw new EmitMapperException("Property " + propertyInfo.Name + " has invalid arguments");
}
}
public static IAstNode WriteMembersChain(MemberInfo[] membersChain, IAstRefOrAddr targetObject, IAstRefOrValue value)
{
if (membersChain.Length == 1)
{
return(WriteMember(membersChain[0], targetObject, value));
}
IAstRefOrAddr readTarget = targetObject;
for (int i = 0; i < membersChain.Length - 1; ++i)
{
readTarget = ReadMemberRA(readTarget, membersChain[i]);
}
return(WriteMember(membersChain[membersChain.Length - 1], readTarget, value));
}
public AstWriteProperty(IAstRefOrAddr targetObject, IAstRefOrValue value, PropertyInfo propertyInfo)
{
_targetObject = targetObject;
_value = value;
_propertyInfo = propertyInfo;
_setMethod = propertyInfo.GetSetMethod();
if (_setMethod == null)
{
throw new Exception("Property " + propertyInfo.Name + " doesn't have set accessor");
}
if (_setMethod.GetParameters().Length != 1)
{
throw new EmitMapperException("Property " + propertyInfo.Name + " has invalid arguments");
}
}
public static IAstRefOrAddr ReadFieldRA(IAstRefOrAddr sourceObject, FieldInfo fieldInfo)
{
if (fieldInfo.FieldType.IsValueType)
{
return(new AstReadFieldAddr()
{
fieldInfo = fieldInfo,
sourceObject = sourceObject
});
}
else
{
return(new AstReadFieldRef()
{
fieldInfo = fieldInfo,
sourceObject = sourceObject
});
}
}
public static IAstRefOrValue ReadPropertyRV(IAstRefOrAddr sourceObject, PropertyInfo propertyInfo)
{
if (propertyInfo.PropertyType.IsValueType())
{
return(new AstReadPropertyValue()
{
sourceObject = sourceObject,
propertyInfo = propertyInfo
});
}
else
{
return(new AstReadPropertyRef()
{
sourceObject = sourceObject,
propertyInfo = propertyInfo
});
}
}
/// <summary>
/// Reads the members chain.
/// </summary>
/// <param name="sourceObject">The source object.</param>
/// <param name="membersChain">The members chain.</param>
/// <returns>An IAstRefOrValue.</returns>
public static IAstRefOrValue ReadMembersChain(IAstRefOrAddr sourceObject, IEnumerable <MemberInfo> membersChain)
{
var src = sourceObject;
using var enumerator = membersChain.GetEnumerator();
MemberInfo cur = null;
if (enumerator.MoveNext())
{
cur = enumerator.Current;
}
while (enumerator.MoveNext())
{
src = ReadMemberRA(src, cur);
cur = enumerator.Current;
}
return(ReadMemberRV(src, cur));
}
/// <summary>
/// Writes the members chain.
/// </summary>
/// <param name="membersChain">The members chain.</param>
/// <param name="targetObject">The target object.</param>
/// <param name="value">The value.</param>
/// <returns>An IAstNode.</returns>
public static IAstNode WriteMembersChain(
IEnumerable <MemberInfo> membersChain,
IAstRefOrAddr targetObject,
IAstRefOrValue value)
{
var readTarget = targetObject;
var enumerator = membersChain.GetEnumerator();
MemberInfo cur = null;
if (enumerator.MoveNext())
{
cur = enumerator.Current;
}
while (enumerator.MoveNext())
{
readTarget = ReadMemberRA(readTarget, cur);
cur = enumerator.Current;
}
return(WriteMember(cur, readTarget, value));
}
public static IAstRefOrValue ReadMemberRV(IAstRefOrAddr sourceObject, MemberInfo memberInfo)
{
if (memberInfo.MemberType == MemberTypes.Method)
{
MethodInfo methodInfo = memberInfo.DeclaringType.GetMethod(memberInfo.Name);
if (methodInfo.ReturnType == null)
{
throw new EmitMapperException("Invalid member:" + memberInfo.Name);
}
if (methodInfo.GetParameters().Length > 0)
{
throw new EmitMapperException("Method " + memberInfo.Name + " should not have parameters");
}
return CallMethod(methodInfo, sourceObject, null);
}
else if (memberInfo.MemberType == MemberTypes.Field)
{
return AstBuildHelper.ReadFieldRV(sourceObject, (FieldInfo)memberInfo);
}
else
{
return AstBuildHelper.ReadPropertyRV(sourceObject, (PropertyInfo)memberInfo);
}
}
/// <summary>
/// Reads the members chain.
/// </summary>
/// <param name="sourceObject">The source object.</param>
/// <param name="membersChainOfOne">The members chain of one.</param>
/// <returns>An IAstRefOrValue.</returns>
public static IAstRefOrValue ReadMembersChain(IAstRefOrAddr sourceObject, MemberInfo membersChainOfOne)
{
return(ReadMemberRV(sourceObject, membersChainOfOne));
}
public AstCallMethodValue(MethodInfo methodInfo, IAstRefOrAddr invocationObject, List<IAstStackItem> arguments)
: base(methodInfo, invocationObject, arguments)
{
}
public static IAstRefOrAddr ReadFieldRA(IAstRefOrAddr sourceObject, FieldInfo fieldInfo)
{
if (fieldInfo.FieldType.IsValueType)
{
return new AstReadFieldAddr()
{
fieldInfo = fieldInfo,
sourceObject = sourceObject
};
}
else
{
return new AstReadFieldRef()
{
fieldInfo = fieldInfo,
sourceObject = sourceObject
};
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AstCallMethodRef" /> class.
/// </summary>
/// <param name="methodInfo">The method info.</param>
/// <param name="invocationObject">The invocation object.</param>
/// <param name="arguments">The arguments.</param>
public AstCallMethodRef(MethodInfo methodInfo, IAstRefOrAddr invocationObject, List <IAstStackItem> arguments)
: base(methodInfo, invocationObject, arguments)
{
}
public static IAstRefOrValue ReadPropertyRV(IAstRefOrAddr sourceObject, PropertyInfo propertyInfo)
{
if (propertyInfo.PropertyType.IsValueType)
{
return new AstReadPropertyValue()
{
sourceObject = sourceObject,
propertyInfo = propertyInfo
};
}
else
{
return new AstReadPropertyRef()
{
sourceObject = sourceObject,
propertyInfo = propertyInfo
};
}
}
public static IAstRefOrValue ReadMembersChain(IAstRefOrAddr sourceObject, MemberInfo[] membersChain)
{
IAstRefOrAddr src = sourceObject;
IAstRefOrValue result = null;
for (int i = 0; i < membersChain.Length - 1; ++i)
{
src = ReadMemberRA(src, membersChain[i]);
}
result = ReadMemberRV(src, membersChain[membersChain.Length-1]);
return result;
}
public static IAstNode WriteMembersChain(MemberInfo[] membersChain, IAstRefOrAddr targetObject, IAstRefOrValue value)
{
if (membersChain.Length == 1)
{
return WriteMember(membersChain[0], targetObject, value);
}
IAstRefOrAddr readTarget = targetObject;
for (int i = 0; i < membersChain.Length - 1; ++i)
{
readTarget = ReadMemberRA(readTarget, membersChain[i]);
}
return WriteMember(membersChain[membersChain.Length - 1], readTarget, value);
}
public static IAstNode WriteMember(MemberInfo memberInfo, IAstRefOrAddr targetObject, IAstRefOrValue value)
{
if (memberInfo.MemberType == MemberTypes.Field)
{
return new AstWriteField()
{
fieldInfo = (FieldInfo)memberInfo,
targetObject = targetObject,
value = value
};
}
else
{
return new AstWriteProperty(targetObject, value, (PropertyInfo)memberInfo);
}
}
