public static IDisposable EmitAddChildMarker( this IXamlILEmitter emitter, string type, string property) { return(emitter.EmitMarker("AddChildMarker", null, type, property)); }
private static IDisposable EmitMarker( this IXamlILEmitter emitter, string startMethodName, string endMethodName = null, params string[] parameters) { var markers = emitter.TypeSystem.FindType("Avalonia.Markup.Xaml.HotReload.XamlMarkers"); if (markers == null) { return(EmptyDisposable.Instance); } var startMarker = markers.FindMethod(m => m.Name == startMethodName); foreach (string parameter in parameters) { emitter.Emit(OpCodes.Ldstr, parameter); } emitter.EmitCall(startMarker); if (endMethodName != null) { var endMarker = markers.FindMethod(m => m.Name == endMethodName); return(new ActionDisposable(() => emitter.EmitCall(endMarker))); } return(EmptyDisposable.Instance); }
public static void EmitFieldLiteral(IXamlField field, IXamlILEmitter codeGen) { var ftype = field.FieldType.IsEnum ? field.FieldType.GetEnumUnderlyingType() : field.FieldType; if (ftype.Name == "UInt64" || ftype.Name == "Int64") { codeGen.Emit(OpCodes.Ldc_I8, TypeSystemHelpers.ConvertLiteralToLong(field.GetLiteralValue())); } else if (ftype.Name == "Double") { codeGen.Emit(OpCodes.Ldc_R8, (double)field.GetLiteralValue()); } else if (ftype.Name == "Single") { codeGen.Emit(OpCodes.Ldc_R4, (float)field.GetLiteralValue()); } else if (ftype.Name == "String") { codeGen.Emit(OpCodes.Ldstr, (string)field.GetLiteralValue()); } else { codeGen.Emit(OpCodes.Ldc_I4, TypeSystemHelpers.ConvertLiteralToInt(field.GetLiteralValue())); } }
public static IDisposable EmitObjectInitializationMarker(this IXamlILEmitter emitter, string type) { return(emitter.EmitMarker( "StartObjectInitializationMarker", "EndObjectInitializationMarker", type)); }
public static IXamlILEmitter Ldtype(this IXamlILEmitter emitter, IXamlType type) { var conv = emitter.TypeSystem.GetType("System.Type") .FindMethod(m => m.IsStatic && m.IsPublic && m.Name == "GetTypeFromHandle"); return(emitter.Ldtoken(type).EmitCall(conv)); }
public override void EmitWithArguments( XamlEmitContextWithLocals <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter emitter, IReadOnlyList <IXamlAstValueNode> arguments) { EmitSetValue(emitter); }
public static IXamlILEmitter LdMethodInfo(this IXamlILEmitter emitter, IXamlMethod method) { var conv = emitter.TypeSystem.GetType("System.Reflection.MethodInfo") .FindMethod(m => m.IsStatic && m.IsPublic && m.Name == "GetMethodFromHandle"); return(emitter.Ldtoken(method).EmitCall(conv)); }
public XamlILNodeEmitResult Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { if (!XamlIlAvaloniaPropertyHelper.Emit(context, codeGen, Property)) { throw new XamlX.XamlLoadException(Property.Name + " is not an AvaloniaProperty", this); } return(XamlILNodeEmitResult.Type(0, Type.GetClrType())); }
public virtual XamlILNodeEmitResult Emit( XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen) { codeGen.Newobj(_constructor); return(XamlILNodeEmitResult.Type(0, Type.GetClrType())); }
public override void Emit(IXamlILEmitter emitter) { using (var bloc = emitter.LocalsPool.GetLocal(Types.IBinding)) emitter .Stloc(bloc.Local) .Ldsfld(AvaloniaProperty) .Ldloc(bloc.Local); EmitAnchorAndBind(emitter); }
public override void EmitWithArguments( XamlEmitContextWithLocals <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter emitter, IReadOnlyList <IXamlAstValueNode> arguments) { emitter.Ldsfld(AvaloniaProperty); context.Emit(arguments[1], emitter, Parameters[1]); EmitAnchorAndBind(emitter); }
public static IXamlILEmitter DebugHatch(this IXamlILEmitter emitter, string message) { #if DEBUG var debug = emitter.TypeSystem.GetType("XamlX.XamlDebugHatch").FindMethod(m => m.Name == "Debug"); emitter.Emit(OpCodes.Ldstr, message); emitter.Emit(OpCodes.Call, debug); #endif return(emitter); }
public static IDisposable EmitSetPropertyMarker(this IXamlILEmitter emitter, IXamlPropertySetter setter) { (string type, string property) = GetPropertySetterInfo(setter); return(emitter.EmitMarker( "StartSetPropertyMarker", "EndSetPropertyMarker", type, property)); }
public override XamlILNodeEmitResult Emit(XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen) { foreach (var value in Values) { codeGen.Emit(OpCodes.Ldc_I4, value); } return(base.Emit(context, codeGen)); }
public override void Emit(IXamlILEmitter emitter) { using (var bloc = emitter.LocalsPool.GetLocal(Types.IBinding)) emitter .Stloc(bloc.Local) .Ldsfld(AvaloniaProperty) .Ldloc(bloc.Local) // TODO: provide anchor? .Ldnull(); emitter.EmitCall(Types.AvaloniaObjectBindMethod, true); }
private void EmitSetValue(IXamlILEmitter emitter) { // Ignore the instance and load one from the static field to avoid extra local variable var unsetValue = Types.AvaloniaProperty.Fields.First(f => f.Name == "UnsetValue"); emitter .Ldsfld(AvaloniaProperty) .Ldsfld(unsetValue) .Ldc_I4(0) .EmitCall(Types.AvaloniaObjectSetValueMethod, true); }
private void EmitLoadPropertyAccessorFactory(XamlIlEmitContext context, IXamlILEmitter codeGen, IXamlType type, string accessorFactoryName, bool isStatic = true) { var types = context.GetAvaloniaTypes(); var weakReferenceType = context.Configuration.TypeSystem.GetType("System.WeakReference`1").MakeGenericType(context.Configuration.WellKnownTypes.Object); FindMethodMethodSignature accessorFactorySignature = new FindMethodMethodSignature(accessorFactoryName, types.IPropertyAccessor, weakReferenceType, types.IPropertyInfo) { IsStatic = isStatic }; codeGen.Ldftn(type.GetMethod(accessorFactorySignature)); }
public override void Emit(IXamlILEmitter codegen) { var unsetValue = Types.AvaloniaProperty.Fields.First(f => f.Name == "UnsetValue"); codegen // Ignore the instance and load one from the static field to avoid extra local variable .Pop() .Ldsfld(AvaloniaProperty) .Ldsfld(unsetValue) .Ldc_I4(0) .EmitCall(Types.AvaloniaObjectSetValueMethod, true); }
public void EmitWithArguments( XamlEmitContextWithLocals <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter emitter, IReadOnlyList <IXamlAstValueNode> arguments) { emitter.EmitCall(_getter); for (var i = 0; i < arguments.Count; ++i) { context.Emit(arguments[i], emitter, Parameters[i]); } emitter.EmitCall(_adder, true); }
public static bool Emit(XamlIlEmitContext context, IXamlILEmitter emitter, IXamlProperty property) { var type = (property.Getter ?? property.Setter).DeclaringType; var name = property.Name + "Property"; var found = type.Fields.FirstOrDefault(f => f.IsStatic && f.Name == name); if (found == null) { return(false); } emitter.Ldsfld(found); return(true); }
public IXamlType EmitLoadIndexerAccessorFactory(XamlIlEmitContext context, IXamlILEmitter codeGen, IXamlAstValueNode value) { var intType = context.Configuration.TypeSystem.GetType("System.Int32"); if (_indexerClosureType is null) { _indexerClosureType = InitializeClosureType(context); } context.Emit(value, codeGen, intType); codeGen.Newobj(_indexerClosureType.FindConstructor(new List <IXamlType> { intType })); EmitLoadPropertyAccessorFactory(context, codeGen, _indexerClosureType, IndexerClosureFactoryMethodName, isStatic: false); return(EmitCreateAccessorFactoryDelegate(context, codeGen)); }
public static IXamlILEmitter EmitCall(this IXamlILEmitter emitter, IXamlMethod method, bool swallowResult = false) { if (method is IXamlCustomEmitMethod <IXamlILEmitter> custom) { custom.EmitCall(emitter); } else { emitter.Emit(method.IsStatic ? OpCodes.Call : OpCodes.Callvirt, method); } if (swallowResult && !(method.ReturnType.Namespace == "System" && method.ReturnType.Name == "Void")) { emitter.Pop(); } return(emitter); }
public static bool EmitProvideValueTarget(XamlIlEmitContext context, IXamlILEmitter emitter, XamlAstClrProperty property) { if (Emit(context, emitter, property)) { return(true); } var foundClr = property.DeclaringType.Properties.FirstOrDefault(p => p.Name == property.Name); if (foundClr == null) { return(false); } context .Configuration.GetExtra <XamlIlClrPropertyInfoEmitter>() .Emit(context, emitter, foundClr); return(true); }
public static bool Emit(XamlIlEmitContext context, IXamlILEmitter emitter, XamlAstClrProperty property) { if (property is IXamlIlAvaloniaProperty ap) { emitter.Ldsfld(ap.AvaloniaProperty); return(true); } var type = property.DeclaringType; var name = property.Name + "Property"; var found = type.Fields.FirstOrDefault(f => f.IsStatic && f.Name == name); if (found == null) { return(false); } emitter.Ldsfld(found); return(true); }
public void Emit(IXamlILEmitter emitter) { var locals = new Stack <XamlLocalsPool.PooledLocal>(); // Save all "setter" parameters for (var c = Parameters.Count - 1; c >= 0; c--) { var loc = emitter.LocalsPool.GetLocal(Parameters[c]); locals.Push(loc); emitter.Stloc(loc.Local); } emitter.EmitCall(_getter); while (locals.Count > 0) { using (var loc = locals.Pop()) emitter.Ldloc(loc.Local); } emitter.EmitCall(_adder, true); }
public override void Emit(IXamlILEmitter emitter) { /* * Current stack: * - object * - binding priority * - value */ using (var valueLocal = emitter.LocalsPool.GetLocal(Parameters[1])) using (var priorityLocal = emitter.LocalsPool.GetLocal(Types.Int)) emitter .Stloc(valueLocal.Local) .Stloc(priorityLocal.Local) .Ldsfld(AvaloniaProperty) .Ldloc(valueLocal.Local) .Ldloc(priorityLocal.Local); EmitSetStyledPropertyValue(emitter); }
public void EmitCall(IXamlILEmitter emitter) { var method = Parent._avaloniaObject .FindMethod(m => m.IsPublic && !m.IsStatic && m.Name == "GetValue" && m.Parameters.Count == 1 && m.Parameters[0].Equals(Parent._avaloniaPropertyType)); if (method == null) { throw new XamlTypeSystemException( "Unable to find T GetValue<T>(AvaloniaProperty<T>) on AvaloniaObject"); } emitter .Ldsfld(Parent._field) .EmitCall(method); if (Parent.PropertyType.IsValueType) { emitter.Unbox_Any(Parent.PropertyType); } }
private static void EmitNameScopeField(XamlLanguageTypeMappings mappings, IXamlTypeSystem typeSystem, IXamlTypeBuilder <IXamlILEmitter> typebuilder, IXamlILEmitter constructor) { var nameScopeType = typeSystem.FindType("Avalonia.Controls.INameScope"); var field = typebuilder.DefineField(nameScopeType, ContextNameScopeFieldName, true, false); constructor .Ldarg_0() .Ldarg(1) .Ldtype(nameScopeType) .EmitCall(mappings.ServiceProvider.GetMethod(new FindMethodMethodSignature("GetService", typeSystem.FindType("System.Object"), typeSystem.FindType("System.Type")))) .Stfld(field); }
private static void EmitNameScopeField(XamlLanguageTypeMappings xamlLanguage, CecilTypeSystem typeSystem, IXamlTypeBuilder <IXamlILEmitter> typeBuilder, IXamlILEmitter constructor) { var nameScopeType = typeSystem.FindType("Robust.Client.UserInterface.XAML.NameScope"); var field = typeBuilder.DefineField(nameScopeType, ContextNameScopeFieldName, true, false); constructor .Ldarg_0() .Newobj(nameScopeType.GetConstructor()) .Stfld(field); }
public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext <IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen) { if (!(node is HandleRootObjectScopeNode)) { return(null); } var controlType = context.Configuration.TypeSystem.FindType("Robust.Client.UserInterface.Control"); var next = codeGen.DefineLabel(); var dontAbsorb = codeGen.DefineLabel(); var end = codeGen.DefineLabel(); var contextScopeField = context.RuntimeContext.ContextType.Fields.First(f => f.Name == XamlCompiler.ContextNameScopeFieldName); var controlNameScopeField = controlType.Fields.First(f => f.Name == "NameScope"); var nameScopeType = context.Configuration.TypeSystem .FindType("Robust.Client.UserInterface.XAML.NameScope"); var nameScopeCompleteMethod = nameScopeType.Methods.First(m => m.Name == "Complete"); var nameScopeAbsorbMethod = nameScopeType.Methods.First(m => m.Name == "Absorb"); using (var local = codeGen.LocalsPool.GetLocal(controlType)) { codeGen .Isinst(controlType) .Dup() .Stloc(local.Local) //store control in local field .Brfalse(next) //if control is null, move to next (this should never happen but whatev, avalonia does it) .Ldloc(context.ContextLocal) .Ldfld(contextScopeField) .Ldloc(local.Local) //load control from local field .Ldfld(controlNameScopeField) //load namescope field from control .EmitCall(nameScopeAbsorbMethod, true) .Ldloc(local.Local) //load control .Ldloc(context.ContextLocal) //load contextObject .Ldfld(contextScopeField) //load namescope field from context obj .Stfld(controlNameScopeField) //store namescope field in control .MarkLabel(next) .Ldloc(context.ContextLocal) .Ldfld(contextScopeField) .EmitCall(nameScopeCompleteMethod, true); //set the namescope as complete } return(XamlILNodeEmitResult.Void(1)); }