private void EmitPushPopParent(IXamlTypeBuilder <IXamlILEmitter> builder, IXamlTypeSystem ts) { var @void = ts.GetType("System.Void"); var so = ts.GetType("System.Object"); var objectListType = ts.GetType("System.Collections.Generic.List`1") .MakeGenericType(new[] { so }); var pushParentGenerator = builder.DefineMethod(@void, new[] { so }, XamlRuntimeContextDefintion.PushParentMethodName, true, false, false) .Generator; pushParentGenerator.LdThisFld(ParentListField) .Ldarg(1) .EmitCall(objectListType.FindMethod("Add", @void, false, so)); if (PropertyTargetObject != null) { pushParentGenerator.Ldarg_0() .Ldarg(1) .Stfld(PropertyTargetObject) .Ret(); } var pop = builder.DefineMethod(@void, new IXamlType[0], XamlRuntimeContextDefintion.PopParentMethodName, true, false, false) .Generator; var idx = pop.DefineLocal(ts.GetType("System.Int32")); pop // var idx = _parents.Count - 1; .LdThisFld(ParentListField) .EmitCall(objectListType.FindMethod(m => m.Name == "get_Count")) .Ldc_I4(1).Emit(OpCodes.Sub).Stloc(idx); // this.PropertyTargetObject = _parents[idx]; if (PropertyTargetObject != null) { pop .Ldarg_0() .LdThisFld(ParentListField) .Ldloc(idx) .EmitCall(objectListType.FindMethod(m => m.Name == "get_Item")) .Stfld(PropertyTargetObject); } // _parents.RemoveAt(idx); pop .LdThisFld(ParentListField) .Ldloc(idx).EmitCall(objectListType.FindMethod(m => m.Name == "RemoveAt")) .Ret(); }
IXamlType EmitTypeDescriptorContextStub(IXamlTypeSystem typeSystem, IXamlTypeBuilder <IXamlILEmitter> builder, XamlLanguageTypeMappings mappings) { if (mappings.TypeDescriptorContext == null) { return(null); } var tdc = mappings.TypeDescriptorContext; var tdcPrefix = tdc.Namespace + "." + tdc.Name + "."; builder.AddInterfaceImplementation(mappings.TypeDescriptorContext); void PropertyStub(string name) => ImplementInterfacePropertyGetter(builder, tdc, name).Generator.Ldnull().Ret(); PropertyStub("Container"); PropertyStub("Instance"); PropertyStub("PropertyDescriptor"); void MethodStub(string name) { var original = tdc.FindMethod(m => m.Name == name); builder.DefineMethod(original.ReturnType, original.Parameters, tdcPrefix + name, false, false, true, original) .Generator .Emit(OpCodes.Newobj, typeSystem.FindType("System.NotSupportedException").FindConstructor(new List <IXamlType>())) .Emit(OpCodes.Throw); } MethodStub("OnComponentChanging"); MethodStub("OnComponentChanged"); return(mappings.TypeDescriptorContext); }
/// <summary> /// T Build(IServiceProvider sp); /// </summary> public IXamlMethodBuilder <TBackendEmitter> DefineBuildMethod(IXamlTypeBuilder <TBackendEmitter> typeBuilder, XamlDocument doc, string name, bool isPublic) { var rootGrp = (XamlValueWithManipulationNode)doc.Root; return(typeBuilder.DefineMethod(rootGrp.Type.GetClrType(), new[] { _configuration.TypeMappings.ServiceProvider }, name, isPublic, true, false)); }
private IXamlMethodBuilder <IXamlILEmitter> ImplementInterfacePropertyGetter(IXamlTypeBuilder <IXamlILEmitter> builder, IXamlType type, string name) { var prefix = type.Namespace + "." + type.Name + "."; var originalGetter = type.FindMethod(m => m.Name == "get_" + name); var gen = builder.DefineMethod(originalGetter.ReturnType, new IXamlType[0], prefix + "get_" + name, false, false, true, originalGetter); builder.DefineProperty(originalGetter.ReturnType, prefix + name, null, gen); return(gen); }
private IXamlType InitializeClosureType(XamlIlEmitContext context) { var types = context.GetAvaloniaTypes(); var intType = context.Configuration.TypeSystem.GetType("System.Int32"); var weakReferenceType = context.Configuration.TypeSystem.GetType("System.WeakReference`1").MakeGenericType(context.Configuration.WellKnownTypes.Object); var indexAccessorFactoryMethod = context.GetAvaloniaTypes().PropertyInfoAccessorFactory.GetMethod( new FindMethodMethodSignature( "CreateIndexerPropertyAccessor", types.IPropertyAccessor, weakReferenceType, types.IPropertyInfo, intType) { IsStatic = true }); var indexField = _indexerClosureTypeBuilder.DefineField(intType, "_index", false, false); var ctor = _indexerClosureTypeBuilder.DefineConstructor(false, intType); ctor.Generator .Ldarg_0() .Ldarg(1) .Stfld(indexField) .Ret(); _indexerClosureTypeBuilder.DefineMethod( types.IPropertyAccessor, new[] { weakReferenceType, types.IPropertyInfo }, IndexerClosureFactoryMethodName, isPublic: true, isStatic: false, isInterfaceImpl: false) .Generator .Ldarg(1) .Ldarg(2) .LdThisFld(indexField) .EmitCall(indexAccessorFactoryMethod) .Ret(); return(_indexerClosureTypeBuilder.CreateType()); }
public static IXamlField EmitNamespaceInfoProvider(TransformerConfiguration configuration, IXamlTypeBuilder <IXamlILEmitter> typeBuilder, XamlDocument document) { var iface = configuration.TypeMappings.XmlNamespaceInfoProvider; typeBuilder.AddInterfaceImplementation(iface); var method = iface.FindMethod(m => m.Name == "get_XmlNamespaces"); var instField = typeBuilder.DefineField(method.ReturnType, "_services", false, false); var singletonField = typeBuilder.DefineField(iface, "Singleton", true, true); var impl = typeBuilder.DefineMethod(method.ReturnType, null, method.Name, true, false, true); typeBuilder.DefineProperty(method.ReturnType, "XmlNamespaces", null, impl); impl.Generator .LdThisFld(instField) .Ret(); var infoType = method.ReturnType.GenericArguments[1].GenericArguments[0]; var ctor = typeBuilder.DefineConstructor(false); var listType = configuration.TypeSystem.FindType("System.Collections.Generic.List`1") .MakeGenericType(infoType); var listInterfaceType = configuration.TypeSystem.FindType("System.Collections.Generic.IReadOnlyList`1") .MakeGenericType(infoType); var listAdd = listType.FindMethod("Add", configuration.WellKnownTypes.Void, true, infoType); var dictionaryType = configuration.TypeSystem.FindType("System.Collections.Generic.Dictionary`2") .MakeGenericType(configuration.WellKnownTypes.String, listInterfaceType); var dictionaryAdd = dictionaryType.FindMethod("Add", configuration.WellKnownTypes.Void, true, configuration.WellKnownTypes.String, listInterfaceType); var dicLocal = ctor.Generator.DefineLocal(dictionaryType); var listLocal = ctor.Generator.DefineLocal(listType); ctor.Generator .Ldarg_0() .Emit(OpCodes.Call, configuration.WellKnownTypes.Object.FindConstructor()) .Emit(OpCodes.Newobj, dictionaryType.FindConstructor()) .Stloc(dicLocal) .Ldarg_0() .Ldloc(dicLocal) .Stfld(instField); foreach (var alias in document.NamespaceAliases) { ctor.Generator .Newobj(listType.FindConstructor(new List <IXamlType>())) .Stloc(listLocal); var resolved = Transform.NamespaceInfoHelper.TryResolve(configuration, alias.Value); if (resolved != null) { foreach (var rns in resolved) { ctor.Generator .Ldloc(listLocal) .Newobj(infoType.FindConstructor()); if (rns.ClrNamespace != null) { ctor.Generator .Dup() .Ldstr(rns.ClrNamespace) .EmitCall(infoType.FindMethod(m => m.Name == "set_ClrNamespace")); } var asmName = rns.AssemblyName ?? rns.Assembly?.Name; if (asmName != null) { ctor.Generator .Dup() .Ldstr(asmName) .EmitCall(infoType.FindMethod(m => m.Name == "set_ClrAssemblyName")); } ctor.Generator.EmitCall(listAdd); } } ctor.Generator .Ldloc(dicLocal) .Ldstr(alias.Key) .Ldloc(listLocal) .EmitCall(dictionaryAdd, true); } ctor.Generator.Ret(); var sctor = typeBuilder.DefineConstructor(true); sctor.Generator .Newobj(ctor) .Stsfld(singletonField) .Ret(); return(singletonField); //return typeBuilder.CreateType().Fields.First(f => f.Name == "Singleton"); }