static INode ParseExpression(ref string expression, EXamlContext context, IXmlNamespaceResolver nsResolver,
IXmlLineInfo xmlLineInfo)
{
if (expression.StartsWith("{}", StringComparison.Ordinal))
{
return(new ValueNode(expression.Substring(2), null));
}
if (expression[expression.Length - 1] != '}')
{
throw new XamlParseException("Markup expression missing its closing tag", xmlLineInfo);
}
int len;
string match;
if (!MarkupExpressionParser.MatchMarkup(out match, expression, out len))
{
throw new XamlParseException("Error while parsing markup expression", xmlLineInfo);
}
expression = expression.Substring(len).TrimStart();
if (expression.Length == 0)
{
throw new XamlParseException("Markup expression not closed", xmlLineInfo);
}
var provider = new XamlServiceProvider(null, null);
provider.Add(typeof(ILContextProvider), new ILContextProvider(context));
provider.Add(typeof(IXmlNamespaceResolver), nsResolver);
provider.Add(typeof(IXmlLineInfoProvider), new XmlLineInfoProvider(xmlLineInfo));
return(new MarkupExpansionParser().Parse(match, ref expression, provider));
}
List <object> GetCtorArguments(MethodDefinition ctorinfo, ElementNode enode, EXamlContext context)
{
List <object> ret = null;
foreach (var parameter in ctorinfo.Parameters)
{
var propname =
parameter.CustomAttributes.First(ca => ca.AttributeType.FullName == "Tizen.NUI.Binding.ParameterAttribute")
.ConstructorArguments.First()
.Value as string;
var node = enode.Properties[new XmlName("", propname)];
if (!enode.SkipProperties.Contains(new XmlName("", propname)))
{
enode.SkipProperties.Add(new XmlName("", propname));
}
if (node is ValueNode valueNode)
{
var valueType = parameter.ParameterType;
if ("System.Type" == valueType.FullName)
{
var typeRef = XmlTypeExtensions.GetTypeReference(valueNode.Value as string, Module, node as BaseNode, XmlTypeExtensions.ModeOfGetType.Both);
context.Values[node] = new EXamlCreateObject(context, typeRef);
}
else
{
var converterType = valueNode.GetConverterType(new ICustomAttributeProvider[] { parameter, parameter.ParameterType.ResolveCached() });
if (null != converterType)
{
var converterValue = new EXamlValueConverterFromString(context, converterType.Resolve(), valueNode.Value as string);
context.Values[node] = new EXamlCreateObject(context, converterValue, valueType);
}
else
{
context.Values[node] = valueNode.GetBaseValue(context, valueType);
}
}
if (null == ret)
{
ret = new List <object>();
}
ret.Add(context.Values[node]);
}
}
return(ret);
}
public EXamlSetResourcesVisitor(EXamlContext context)
{
Context = context;
Module = context.Module;
}
public static bool MatchXArguments(this MethodDefinition methodDef, ElementNode enode, TypeReference declaringTypeRef, ModuleDefinition module, EXamlContext context)
{
if (!enode.Properties.ContainsKey(XmlName.xArguments))
{
return(!methodDef.HasParameters);
}
var arguments = new List <INode>();
var node = enode.Properties[XmlName.xArguments] as ElementNode;
if (node != null)
{
arguments.Add(node);
}
else
{
if (enode.Properties[XmlName.xArguments] is ValueNode valueNode)
{
var value = valueNode.Value as string;
if (value != null && value.Substring(0, "{x:Reference ".Length) == "{x:Reference ")
{
var elementName = value.Substring("{x:Reference ".Length);
elementName = elementName.Substring(0, elementName.Length - 1);
}
}
}
var list = enode.Properties[XmlName.xArguments] as ListNode;
if (list != null)
{
foreach (var n in list.CollectionItems)
{
arguments.Add(n);
}
}
if (methodDef.Parameters.Count < arguments.Count)
{
return(false);
}
for (int i = arguments.Count; i < methodDef.Parameters.Count; i++)
{
if (false == methodDef.Parameters[i].HasDefault)
{
return(false);
}
}
for (var i = 0; i < arguments.Count; i++)
{
var paramType = methodDef.Parameters[i].ParameterType;
var genParam = paramType as GenericParameter;
if (genParam != null)
{
var index = genParam.DeclaringType.GenericParameters.IndexOf(genParam);
paramType = (declaringTypeRef as GenericInstanceType).GenericArguments[index];
}
var argValue = context.Values[arguments[i]];
TypeReference argType = null;
if (argValue is EXamlCreateObject eXamlCreateObject)
{
argType = eXamlCreateObject.Type;
}
else
{
argType = paramType.Module.ImportReference(argValue.GetType());
}
if (!argType.InheritsFromOrImplements(paramType))
{
return(false);
}
}
return(true);
}
public EXamlSetFieldVisitor(EXamlContext context)
{
Context = context;
}
public EXamlSetNamescopesAndRegisterNamesVisitor(EXamlContext context)
{
Context = context;
}
public EXamlExpandMarkupsVisitor(EXamlContext context)
{
Context = context;
}
public ILContextProvider(EXamlContext context)
{
Context = context;
}
public EXamlCreateObjectVisitor(EXamlContext context)
{
Context = context;
Module = context.Module;
}
