public EmitInstruction Emit(IEmitOpCodeType opCode, EmitType type)
{
var instruction = new EmitInstruction(opCode, type);
AddInstruction(instruction);
return(instruction);
}
public EmitParameter DefineParameter(EmitType parameterType, string name = null)
{
var parameter = new EmitParameter(name, parameterType);
parameters.Add(parameter);
return(parameter);
}
public EmitField(EmitType declaringType, string name, EmitType fieldType, EmitVisibility visibility, bool isStatic, bool isReadOnly) : base(declaringType, name)
{
FieldType = fieldType;
Visibility = visibility;
IsStatic = isStatic;
IsReadOnly = isReadOnly;
}
public EmitLocal DeclareLocal(EmitType type)
{
var local = new EmitLocal(type);
locals.Add(local);
return(local);
}
public EmitFieldBuilder DefineField(string name, EmitType type, EmitVisibility visibility = EmitVisibility.Public,
bool isStatic = false, bool isReadonly = false, bool isVolatile = false)
{
var field = new EmitFieldBuilder(this, name, type, visibility, isStatic, isReadonly);
memberBuilders.Add(new EmitFieldReference(() => field));
return(field);
}
public EmitMethodBuilder DefineMethod(string name, EmitType returnType, EmitVisibility visibility = EmitVisibility.Public,
bool isAbstract = false, bool isSealed = false, bool isVirtual = false, bool isOverride = false,
bool isExtern = false, bool isStatic = false)
{
var method = new EmitMethodBuilder(this, name, returnType, visibility, isStatic, isSealed, isVirtual, isAbstract);
memberBuilders.Add(new EmitMethodReference(() => method));
return(method);
}
public EmitArrayType(EmitAssembly assembly, string ns, string name, EmitTypeKind kind, EmitType declaringType,
Func <EmitType, IReadOnlyList <EmitMemberReference> > membersFactory, EmitTypeReference baseType,
EmitType elementType, int rank
) :
base(assembly, ns, name, kind, declaringType, membersFactory, elementType.Visibility, baseType, _ => new List <EmitTypeReference>(), true, true)
{
ElementType = elementType;
Rank = rank;
}
public EmitMethod(EmitType declaringType, string name, EmitType returnType, Func <EmitMethod, IReadOnlyList <EmitParameter> > parameters, EmitVisibility visibility, bool isStatic, bool isSealed, bool isVirtual, bool isAbstract) : base(declaringType, name)
{
ReturnType = returnType;
Parameters = parameters(this);
Visibility = visibility;
IsStatic = isStatic;
IsSealed = isSealed;
IsVirtual = isVirtual;
IsAbstract = isAbstract;
}
public EmitProperty(
EmitType declaringType,
string name,
EmitType propertyType,
Func <EmitProperty, IReadOnlyList <EmitParameter> > parameters,
EmitMethod getMethod, EmitMethod setMethod
) :
base(declaringType, name)
{
PropertyType = propertyType;
Parameters = parameters(this);
GetMethod = getMethod;
SetMethod = setMethod;
}
protected bool Equals(EmitType other)
{
return(FullName == other.FullName);
}
public EmitType(EmitAssembly assembly, string ns, string name, EmitTypeKind kind, EmitType declaringType,
Func <EmitType, IReadOnlyList <EmitMemberReference> > membersFactory, EmitVisibility visibility,
EmitTypeReference baseType,
Func <EmitType, IReadOnlyList <EmitTypeReference> > implementedInterfacesFactory,
bool isAbstract, bool isSealed
) :
base(declaringType, name)
{
Assembly = assembly;
Namespace = ns;
Members = new ReadOnlyListWrapper <EmitMemberReference, EmitMember>(membersFactory(this));
Visibility = visibility;
Kind = kind;
IsAbstract = isAbstract;
IsSealed = isSealed;
ImplementedInterfaces = new ReadOnlyListWrapper <EmitTypeReference, EmitType>(implementedInterfacesFactory(this));
this.baseType = baseType;
}
public EmitConstructor(EmitType declaringType, Func <EmitConstructor, IReadOnlyList <EmitParameter> > parameters, EmitVisibility visibility, bool isStatic) : base(declaringType, isStatic ? ".cctor" : ".ctor")
{
Parameters = parameters(this);
Visibility = visibility;
IsStatic = isStatic;
}
public EmitMethodBuilder(EmitType declaringType, string name, EmitType returnType, EmitVisibility visibility, bool isStatic, bool isSealed, bool isVirtual, bool isAbstract) :
base(declaringType, name, returnType,
result => ((EmitMethodBuilder)result).parameters = new List <EmitParameter>(),
visibility, isStatic, isSealed, isVirtual, isAbstract)
{
}
public EmitTypeBuilder(EmitAssembly assembly, string ns, string name, EmitTypeKind kind, EmitType declaringType,
EmitVisibility visibility, EmitTypeReference baseType, Func <EmitType, IReadOnlyList <EmitTypeReference> > implementedInterfacesFactory,
bool isAbstract, bool isSealed
) :
base(assembly, ns, name, kind, declaringType,
result => ((EmitTypeBuilder)result).memberBuilders = new List <EmitMemberReference>(),
visibility, baseType, implementedInterfacesFactory, isAbstract, isSealed)
{
}
public EmitParameter(string name, EmitType parameterType)
{
Name = name;
ParameterType = parameterType;
}
public EmitConstructorBuilder(EmitType declaringType, EmitVisibility visibility, bool isStatic) :
base(declaringType, result => ((EmitConstructorBuilder)result).parameters = new List <EmitParameter>(),
visibility, isStatic)
{
}
public EmitGenericType(EmitAssembly assembly, string ns, string name, EmitType declaringType, Func <EmitType, IReadOnlyList <EmitMemberReference> > membersFactory, EmitTypeReference baseType, EmitType genericTypeDefinition, IReadOnlyList <EmitType> typeArguments) : base(assembly, ns, name, genericTypeDefinition.Kind, declaringType, membersFactory, genericTypeDefinition.Visibility, baseType, DeriveImplementedInterfaces(genericTypeDefinition), genericTypeDefinition.IsAbstract, genericTypeDefinition.IsSealed)
{
GenericTypeDefinition = genericTypeDefinition;
TypeArguments = typeArguments;
}
protected EmitMember(EmitType declaringType, string name)
{
DeclaringType = declaringType;
Name = name;
}
private static Func <EmitType, IReadOnlyList <EmitTypeReference> > DeriveImplementedInterfaces(EmitType genericTypeDefinition)
{
return(result => new List <EmitTypeReference>(genericTypeDefinition.ImplementedInterfaces.Select(x => new EmitTypeReference(() => x))));
}
