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)))); }