public XamlIlNodeEmitResult Emit(IXamlIlAstNode node, XamlIlEmitContext context, IXamlIlEmitter ilgen)
{
if (!(node is XamlIlMarkupExtensionNode me))
{
return(null);
}
XamlIlNeedsParentStackCache.Verify(context, node);
var prop = context.ParentNodes().OfType <XamlIlPropertyAssignmentNode>().FirstOrDefault();
var needProvideValueTarget = me.ProvideValue.Parameters.Count != 0 &&
context.RuntimeContext.PropertyTargetObject != null &&
prop != null;
void EmitPropertyDescriptor()
{
if (context.Configuration.TypeMappings.ProvideValueTargetPropertyEmitter
?.Invoke(context, ilgen, prop.Property) == true)
{
return;
}
ilgen.Ldstr(prop.Property.Name);
}
context.Emit(me.Value, ilgen, me.Value.Type.GetClrType());
if (me.ProvideValue.Parameters.Count > 0)
{
ilgen
.Emit(OpCodes.Ldloc, context.ContextLocal);
}
if (needProvideValueTarget)
{
ilgen
.Ldloc(context.ContextLocal);
EmitPropertyDescriptor();
ilgen
.Stfld(context.RuntimeContext.PropertyTargetProperty);
}
ilgen.EmitCall(me.ProvideValue);
if (needProvideValueTarget)
{
ilgen
.Ldloc(context.ContextLocal)
.Ldnull()
.Stfld(context.RuntimeContext.PropertyTargetProperty);
}
return(XamlIlNodeEmitResult.Type(0, me.ProvideValue.ReturnType));
}
public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
codeGen
.Ldloc(context.ContextLocal)
.Ldfld(context.RuntimeContext.RootObjectField);
return(XamlIlNodeEmitResult.Type(0, Type.GetClrType()));
}
public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen, bool swallowResult)
{
int firstCast = -1;
for (var c = ParametersWithThis.Count - 1; c >= 0; c--)
{
if (!_method.ParametersWithThis[c].Equals(ParametersWithThis[c]))
{
firstCast = c;
}
}
if (firstCast != -1)
{
var locals = new Stack <XamlIlEmitContext.PooledLocal>();
for (var c = ParametersWithThis.Count - 1; c >= firstCast; c--)
{
codeGen.Castclass(ParametersWithThis[c]);
if (c > firstCast)
{
var l = context.GetLocal(ParametersWithThis[c]);
codeGen.Stloc(l.Local);
locals.Push(l);
}
}
while (locals.Count != 0)
{
using (var l = locals.Pop())
codeGen.Ldloc(l.Local);
}
}
_method.Emit(context, codeGen, swallowResult);
}
public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
var so = context.Configuration.WellKnownTypes.Object;
var isp = context.Configuration.TypeMappings.ServiceProvider;
var subType = context.CreateSubType("XamlIlClosure_" + Guid.NewGuid(), so);
var buildMethod = subType.DefineMethod(so, new[]
{
isp
}, "Build", true, true, false);
CompileBuilder(new XamlIlEmitContext(buildMethod.Generator, context.Configuration,
context.RuntimeContext, buildMethod.Generator.DefineLocal(context.RuntimeContext.ContextType),
(s, type) => subType.DefineSubType(type, s, false), context.Emitters));
var funcType = Type.GetClrType();
codeGen
.Ldnull()
.Ldftn(buildMethod)
.Newobj(funcType.Constructors.FirstOrDefault(ct =>
ct.Parameters.Count == 2 && ct.Parameters[0].Equals(context.Configuration.WellKnownTypes.Object)));
// Allow to save values from the parent context, pass own service provider, etc, etc
if (context.Configuration.TypeMappings.DeferredContentExecutorCustomization != null)
{
codeGen
.Ldloc(context.ContextLocal)
.EmitCall(context.Configuration.TypeMappings.DeferredContentExecutorCustomization);
}
subType.CreateType();
return(XamlIlNodeEmitResult.Type(0, funcType));
}
public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
var exts = context.Configuration.TypeSystem.GetType("Avalonia.Controls.NameScopeExtensions");
var findNameScope = exts.FindMethod(m => m.Name == "FindNameScope");
var registerMethod = findNameScope.ReturnType.FindMethod(m => m.Name == "Register");
using (var targetLoc = context.GetLocal(context.Configuration.WellKnownTypes.Object))
using (var nameScopeLoc = context.GetLocal(findNameScope.ReturnType))
{
var exit = codeGen.DefineLabel();
codeGen
// var target = {pop}
.Stloc(targetLoc.Local)
// var scope = target.FindNameScope()
.Ldloc(targetLoc.Local)
.Castclass(findNameScope.Parameters[0])
.EmitCall(findNameScope)
.Stloc(nameScopeLoc.Local)
// if({scope} != null) goto call;
.Ldloc(nameScopeLoc.Local)
.Brfalse(exit)
.Ldloc(nameScopeLoc.Local);
context.Emit(Value, codeGen, Value.Type.GetClrType());
codeGen
.Ldloc(targetLoc.Local)
.EmitCall(registerMethod)
.MarkLabel(exit);
}
return(XamlIlNodeEmitResult.Void(1));
}
public XamlIlNodeEmitResult Emit(IXamlIlAstNode node, XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
if (!(node is XamlIlObjectInitializationNode init))
{
return(null);
}
var supportInitType = context.Configuration.TypeMappings.SupportInitialize;
var supportsInitialize = supportInitType != null &&
context.Configuration.TypeMappings.SupportInitialize
.IsAssignableFrom(init.Type);
if (supportsInitialize)
{
codeGen
// We need a copy for/EndInit
.Emit(OpCodes.Dup);
if (!init.SkipBeginInit)
{
codeGen
.Emit(OpCodes.Dup)
.EmitCall(supportInitType.FindMethod(m => m.Name == "BeginInit"));
}
}
var addToParentStack = context.RuntimeContext.ParentListField != null &&
!init.Type.IsValueType &&
context.GetOrCreateItem <XamlIlNeedsParentStackCache>().NeedsParentStack(node);
if (addToParentStack)
{
using (var local = context.GetLocal(init.Type))
codeGen
.Stloc(local.Local)
.Ldloc(context.ContextLocal)
.Ldloc(local.Local)
.EmitCall(context.RuntimeContext.PushParentMethod)
.Ldloc(local.Local);
}
context.Emit(init.Manipulation, codeGen, null);
if (addToParentStack)
{
codeGen
.Ldloc(context.ContextLocal)
.EmitCall(context.RuntimeContext.PopParentMethod, true);
}
if (supportsInitialize)
{
codeGen
.EmitCall(supportInitType.FindMethod(m => m.Name == "EndInit"));
}
return(XamlIlNodeEmitResult.Void(1));
}
public void Emit(IXamlIlEmitter emitter)
{
var locals = new Stack <XamlIlLocalsPool.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 void EmitCall(IXamlIlEmitter codeGen)
{
int firstCast = -1;
for (var c = Parameters.Count - 1; c >= 0; c--)
{
if (!_baseParametersWithThis[c].Equals(Parameters[c]))
{
firstCast = c;
}
}
if (firstCast != -1)
{
var locals = new Stack <XamlIlLocalsPool.PooledLocal>();
for (var c = Parameters.Count - 1; c >= firstCast; c--)
{
codeGen.Castclass(_baseParametersWithThis[c]);
if (c > firstCast)
{
var l = codeGen.LocalsPool.GetLocal(_baseParametersWithThis[c]);
codeGen.Stloc(l.Local);
locals.Push(l);
}
}
while (locals.Count != 0)
{
using (var l = locals.Pop())
{
codeGen.Ldloc(l.Local);
l.Dispose();
}
}
}
codeGen.EmitCall(_method);
}
public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
var scopeField = context.RuntimeContext.ContextType.Fields.First(f =>
f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName);
using (var targetLoc = context.GetLocal(context.Configuration.WellKnownTypes.Object))
{
codeGen
// var target = {pop}
.Stloc(targetLoc.Local)
// _context.NameScope.Register(Name, target)
.Ldloc(context.ContextLocal)
.Ldfld(scopeField);
context.Emit(Name, codeGen, Name.Type.GetClrType());
codeGen
.Ldloc(targetLoc.Local)
.EmitCall(_types.INameScopeRegister, true);
}
return(XamlIlNodeEmitResult.Void(1));
}
public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
codeGen.Ldloc(context.ContextLocal);
return(XamlIlNodeEmitResult.Type(0, Type.GetClrType()));
}
public XamlIlNodeEmitResult Emit(IXamlIlAstNode node, XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
if (!(node is XamlIlObjectInitializationNode init))
{
return(null);
}
var supportInitType = context.Configuration.TypeMappings.SupportInitialize;
var supportsInitialize = supportInitType != null &&
context.Configuration.TypeMappings.SupportInitialize
.IsAssignableFrom(init.Type);
if (supportsInitialize)
{
codeGen
// We need a copy for/EndInit
.Emit(OpCodes.Dup);
if (!init.SkipBeginInit)
{
codeGen
.Emit(OpCodes.Dup)
.EmitCall(supportInitType.FindMethod(m => m.Name == "BeginInit"));
}
}
IXamlIlType objectListType = null;
var addToParentStack = context.RuntimeContext.ParentListField != null &&
!init.Type.IsValueType &&
context.GetOrCreateItem <XamlIlNeedsParentStackCache>().NeedsParentStack(node);
if (addToParentStack)
{
objectListType = context.Configuration.TypeSystem.GetType("System.Collections.Generic.List`1")
.MakeGenericType(new[] { context.Configuration.WellKnownTypes.Object });
using (var local = context.GetLocal(init.Type))
codeGen
.Stloc(local.Local)
.Ldloc(context.ContextLocal).Ldfld(context.RuntimeContext.ParentListField)
.Ldloc(local.Local)
.EmitCall(objectListType.FindMethod("Add", context.Configuration.WellKnownTypes.Void,
false, context.Configuration.WellKnownTypes.Object))
.Ldloc(local.Local);
}
context.Emit(init.Manipulation, codeGen, null);
if (addToParentStack)
{
codeGen
.Ldloc(context.ContextLocal).Ldfld(context.RuntimeContext.ParentListField)
.Ldloc(context.ContextLocal).Ldfld(context.RuntimeContext.ParentListField)
.EmitCall(objectListType.FindMethod(m => m.Name == "get_Count"))
.Ldc_I4(1).Emit(OpCodes.Sub)
.EmitCall(objectListType.FindMethod(m => m.Name == "RemoveAt"));
}
if (supportsInitialize)
{
codeGen
.EmitCall(supportInitType.FindMethod(m => m.Name == "EndInit"));
}
return(XamlIlNodeEmitResult.Void(1));
}
public XamlIlNodeEmitResult Emit(IXamlIlAstNode node, XamlIlEmitContext context, IXamlIlEmitter codeGen)
{
if (!(node is XamlIlMarkupExtensionNode me))
{
return(null);
}
XamlIlNeedsParentStackCache.Verify(context, node);
var ilgen = codeGen;
var so = context.Configuration.WellKnownTypes.Object;
var ptype = me.Manipulation?.ParametersWithThis[1] ?? me.Property.PropertyType;
var rtype = me.ProvideValue?.ReturnType ?? me.Value.Type.GetClrType();
var needProvideValueTarget = me.ProvideValue != null &&
me.ProvideValue.Parameters.Count != 0 &&
context.RuntimeContext.PropertyTargetObject != null &&
me.Property != null;
void EmitPropertyDescriptor()
{
if (me.Property == null)
{
ilgen.Ldnull();
}
else if (context.Configuration.TypeMappings.ProvideValueTargetPropertyEmitter
?.Invoke(context, codeGen, me.Property) == true)
{
return;
}
else if (me.Property is XamlIlAstAttachedProperty)
{
ilgen.Ldtoken(me.Property.Getter ?? me.Property.Setter)
.Emit(OpCodes.Box, context.Configuration.TypeSystem.GetType("System.RuntimeMethodHandle"));
}
else
{
ilgen.Ldstr(me.Property?.Name);
}
}
using (var resultLocalContainer = context.GetLocal(rtype))
{
var resultLocal = resultLocalContainer.Local;
using (var targetObjectLocal = needProvideValueTarget ? context.GetLocal(so) : null)
{
if (needProvideValueTarget)
{
ilgen
.Dup().Stloc(targetObjectLocal.Local);
}
context.Emit(me.Value, codeGen, me.Value.Type.GetClrType());
if (me.ProvideValue?.Parameters.Count > 0)
{
ilgen
.Emit(OpCodes.Ldloc, context.ContextLocal);
}
if (needProvideValueTarget)
{
ilgen
.Ldloc(context.ContextLocal)
.Ldloc(targetObjectLocal.Local)
.Stfld(context.RuntimeContext.PropertyTargetObject)
.Ldloc(context.ContextLocal);
EmitPropertyDescriptor();
ilgen
.Stfld(context.RuntimeContext.PropertyTargetProperty);
}
if (me.ProvideValue != null)
{
ilgen
.Emit(OpCodes.Call, me.ProvideValue);
}
ilgen
.Emit(OpCodes.Stloc, resultLocal);
if (needProvideValueTarget)
{
ilgen
.Ldloc(context.ContextLocal)
.Ldnull()
.Stfld(context.RuntimeContext.PropertyTargetObject)
.Ldloc(context.ContextLocal)
.Ldnull()
.Stfld(context.RuntimeContext.PropertyTargetProperty);
}
}
// At this point we have the target object at the top of the stack and markup extension result in resultLocal
var exit = ilgen.DefineLabel();
// This is needed for custom conversions of Binding to object
var customTypes = context.Configuration.TypeMappings.MarkupExtensionCustomResultTypes;
// This is needed for properties that accept Binding
if (
me.Property != null &&
context.Configuration.TypeMappings.ShouldIgnoreMarkupExtensionCustomResultForProperty !=
null)
{
customTypes = customTypes.Where(ct =>
!context.Configuration.TypeMappings
.ShouldIgnoreMarkupExtensionCustomResultForProperty(me.Property, ct))
.ToList();
}
if (customTypes.Any() && !rtype.IsValueType)
{
void EmitCustomActionCall()
{
EmitPropertyDescriptor();
codeGen
.Emit(OpCodes.Ldloc, context.ContextLocal)
.Emit(OpCodes.Ldloc, resultLocal);
if (rtype.IsValueType)
{
codeGen.Emit(OpCodes.Box, rtype);
}
codeGen
.Emit(OpCodes.Call, context.Configuration.TypeMappings.MarkupExtensionCustomResultHandler)
.Emit(OpCodes.Br, exit);
}
// Skip conversion attempts and call custom conversion directly
if (customTypes.Any(ct => ct.IsAssignableFrom(rtype)))
{
EmitCustomActionCall();
ilgen.MarkLabel(exit);
return(XamlIlNodeEmitResult.Void(1));
}
var callCustomLabel = ilgen.DefineLabel();
var afterCustomLabel = ilgen.DefineLabel();
foreach (var ct in customTypes)
{
codeGen
.Ldloc(resultLocal)
.Isinst(ct)
.Brtrue(callCustomLabel);
}
ilgen
.Br(afterCustomLabel)
.MarkLabel(callCustomLabel);
EmitCustomActionCall();
ilgen.MarkLabel(afterCustomLabel);
}
TypeSystemHelpers.EmitConvert(context, node, rtype, ptype,
lda => ilgen.Emit(lda ? OpCodes.Ldloca : OpCodes.Ldloc, resultLocal));
// Call some method either on the target or on target's property
if (me.Manipulation != null)
{
// {target}.{Property}.{Method)(res)
if (me.Property != null)
{
using (var res = context.GetLocal(ptype))
ilgen
.Emit(OpCodes.Stloc, res.Local)
.EmitCall(me.Property.Getter)
.Emit(OpCodes.Ldloc, res.Local);
}
me.Manipulation.Emit(context, ilgen, true);
}
// Call property setter on the target
else
{
ilgen.EmitCall(me.Property.Setter);
}
ilgen.MarkLabel(exit);
}
return(XamlIlNodeEmitResult.Void(1));
}
