private EmitSyntax EmitFactoryCode(
EmitSyntax emit,
PlannedClass contextPlannedClass,
Type type,
bool nullAllowed)
{
if (type == typeof(void))
{
}
else if (type == typeof(int))
{
emit = emit.Ldc_I4_0();
}
else if (type.IsValueType)
{
var resultType = emit.Types.Import(type);
var resultLoc = emit.Locals.Generate("result");
emit = emit
.Local(resultLoc, resultType)
.Ldloca(resultLoc.GetRef())
.Initobj(resultType)
.Ldloc(resultLoc.GetRef())
;
}
else if (nullAllowed)
{
emit.Ldnull();
}
else if (!type.IsAbstract && !type.IsInterface)
{
emit = emit.Newobj(
emit.Types.Import(type));
}
else if (contextPlannedClass != null && contextPlannedClass.Implements(type))
{
emit = emit.Ldarg(0);
}
else if (plan.Exists(e => e.Implements(type)))
{
var otherEntry = plan.Find(e => e.Implements(type));
emit = emit.Newobj(
emit.Types.Class_(
ClassName.Parse(
otherEntry.ClassName)));
}
else
{
throw new InvalidOperationException(
"Internal error: non-planned abstract result type");
}
return(emit);
}
private void LdTid(EmitSyntax emit, CilSymbolRef tid)
{
if (tid.Type != null)
{
emit
.Ldtoken(emit.Types.Import(tid.Type))
.Call((RuntimeTypeHandle h) => Type.GetTypeFromHandle(h))
;
}
else
{
emit.Ldnull();
}
if (tid.Literal == null)
{
emit.Ldnull();
}
else
{
emit.Ldstr(new QStr(tid.Literal));
}
emit
.Newobj(() => new CilSymbolRef(default(Type), default(string)));
}
public static EmitSyntax NewDelegate(this EmitSyntax emit, Type delegateType)
{
if (!typeof(Delegate).IsAssignableFrom(delegateType))
{
throw new ArgumentException("Expected delegate type.", "delegateType");
}
var ctor = delegateType.GetConstructor(new[] { typeof(object), typeof(IntPtr) });
return(emit.Newobj(ctor));
}
/// <summary>
/// Create new object using default constructor of the specified type
/// </summary>
/// <param name="emit"></param>
/// <param name="typeRef"></param>
/// <returns></returns>
public static EmitSyntax Newobj(this EmitSyntax emit, Ref <Types> typeRef)
{
return(emit.Newobj(
emit.Methods.Method(
_ => _.StartSignature
.Instance
.Returning(emit.Types.Void)
.DecaringType(typeRef)
.Named(".ctor")
.BeginArgs()
.EndArgs())));
}
private EmitSyntax EmitFactoryCode(
EmitSyntax emit,
PlannedClass contextPlannedClass,
Type type,
bool nullAllowed)
{
if (type == typeof(void))
{
}
else if (type == typeof(int))
{
emit = emit.Ldc_I4_0();
}
else if (type.IsValueType)
{
var resultType = emit.Types.Import(type);
var resultLoc = emit.Locals.Generate("result");
emit = emit
.Local(resultLoc, resultType)
.Ldloca(resultLoc.GetRef())
.Initobj(resultType)
.Ldloc(resultLoc.GetRef())
;
}
else if (nullAllowed)
{
emit.Ldnull();
}
else if (!type.IsAbstract && !type.IsInterface)
{
emit = emit.Newobj(
emit.Types.Import(type));
}
else if (contextPlannedClass != null && contextPlannedClass.Implements(type))
{
emit = emit.Ldarg(0);
}
else if (plan.Exists(e => e.Implements(type)))
{
var otherEntry = plan.Find(e => e.Implements(type));
emit = emit.Newobj(
emit.Types.Class_(
ClassName.Parse(
otherEntry.ClassName)));
}
else
{
throw new InvalidOperationException(
"Internal error: non-planned abstract result type");
}
return emit;
}
private void LdTid(EmitSyntax emit, CilSymbolRef tid)
{
if (tid.Type != null)
{
emit
.Ldtoken(emit.Types.Import(tid.Type))
.Call((RuntimeTypeHandle h) => Type.GetTypeFromHandle(h))
;
}
else
{
emit.Ldnull();
}
if (tid.Literal == null)
{
emit.Ldnull();
}
else
{
emit.Ldstr(new QStr(tid.Literal));
}
emit
.Newobj(() => new CilSymbolRef(default(Type), default(string)));
}
public static EmitSyntax Newobj(this EmitSyntax emit, SR.ConstructorInfo constructor)
{
var ctorRef = emit.Methods.Import(constructor);
return(emit.Newobj(ctorRef));
}
public static EmitSyntax NewobjFromLambda(this EmitSyntax emit, LambdaExpression callExpr)
{
var ctor = ExpressionUtils.GetConstructorFromLambda(callExpr);
return(emit.Newobj(ctor));
}