// We get here when we are inside x:ClassAttributes or x:Property.Attributes. We expect the first element to be the Attribute SO. internal static AttributeData LoadAttributeData(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace) { AttributeData attributeData = null; reader.Read(); if (reader.NodeType == XamlNodeType.StartObject) { attributeData = new AttributeData { Type = reader.Type }; bool readNext = false; while (readNext || reader.Read()) { namespaceTable.ManageNamespace(reader); readNext = false; if (reader.NodeType == XamlNodeType.StartMember) { if (reader.Member == XamlLanguage.Arguments) { foreach (AttributeParameterData parameterData in ReadParameters(reader.ReadSubtree(), namespaceTable, rootNamespace)) { attributeData.Parameters.Add(parameterData); } readNext = true; } else if (!reader.Member.IsDirective) { KeyValuePair<string, AttributeParameterData> propertyInfo = ReadAttributeProperty(reader.ReadSubtree(), namespaceTable, rootNamespace); attributeData.Properties.Add(propertyInfo.Key, propertyInfo.Value); readNext = true; } } } } return attributeData; }
public ClassImporter(string xamlFileName, string localAssemblyName, string rootNamespace) { this.xamlFileName = xamlFileName; this.localAssemblyName = localAssemblyName; this.rootNamespace = rootNamespace; this.DefaultClassIsPublic = true; this.DefaultFieldVisibility = MemberVisibility.Assembly; this.namespaceTable = new NamespaceTable(localAssemblyName); }
// Read the Property on the attribute. private static KeyValuePair<string, AttributeParameterData> ReadAttributeProperty(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace) { reader.Read(); Fx.Assert(reader.Member != null, "Member element should not be null"); XamlMember member = reader.Member; AttributeParameterData propertyInfo = new AttributeParameterData(); if (member.Type != null && !member.Type.IsUnknown) { propertyInfo.Type = member.Type; } ReadParamInfo(reader, member.Type, namespaceTable, rootNamespace, propertyInfo); return new KeyValuePair<string, AttributeParameterData>(member.Name, propertyInfo); }
// Parses a XAML QName to a CLR Type Name (and the corresponding ROL type, if available) private static Tuple<string, Type> ParseParameterValueTypeName(string paramValue, string rootNamespace, XamlSchemaContext schemaContext, NamespaceTable namespaceTable) { XamlType xamlType = XamlBuildTaskServices.GetXamlTypeFromString(paramValue, namespaceTable, schemaContext); string clrTypeName; if (!XamlBuildTaskServices.TryGetClrTypeName(xamlType, rootNamespace, out clrTypeName)) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.TypeNameUnknown(XamlBuildTaskServices.GetFullTypeName(xamlType)))); } return Tuple.Create(clrTypeName, xamlType.UnderlyingType); }
// Get the paramter value. If the value is enclosed inside nodes of the type, then get the parameter type as well. // Else infer the type from the type of the property. private static void GetParamValueType(XamlReader reader, XamlType type, NamespaceTable namespaceTable, string rootNamespace, out string paramValue, out XamlType paramType, out Object paramObj) { paramValue = String.Empty; paramType = type; paramObj = null; while (reader.Read()) { if (reader.NodeType == XamlNodeType.Value) { if (paramType != null && paramType.UnderlyingType != null) { if (!IsSupportedParameterType(paramType.UnderlyingType) || paramType.UnderlyingType.IsArray) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParamTypeNotSupported(paramType.UnderlyingType.FullName))); } paramValue = reader.Value as string; if (typeof(Type).IsAssignableFrom(paramType.UnderlyingType)) { Tuple<string, Type> result = ParseParameterValueTypeName(paramValue, rootNamespace, reader.SchemaContext, namespaceTable); paramValue = result.Item1; paramObj = result.Item2; } else { paramObj = ParseParameterValue(ref paramValue, paramType); } } else { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParameterTypeUnknown(reader.Value as string))); } } else if (reader.NodeType == XamlNodeType.StartObject) { if (reader.Type == XamlLanguage.Null) { paramValue = null; paramType = null; } else if (reader.Type == XamlLanguage.Type) { paramType = reader.SchemaContext.GetXamlType(typeof(Type)); } else { paramType = reader.Type; } } } }
// Read the actual parameter info, i.e. the type of the paramter and its value. // The first element could be a V or an SO. private static void ReadParamInfo(XamlReader reader, XamlType type, NamespaceTable namespaceTable, string rootNamespace, AttributeParameterData paramInfo) { reader.Read(); bool readNext = false; do { readNext = false; if (reader.NodeType == XamlNodeType.StartObject && reader.Type == XamlLanguage.Array) { paramInfo.IsArray = true; XamlReader xamlArrayReader = reader.ReadSubtree(); xamlArrayReader.Read(); while (readNext || xamlArrayReader.Read()) { readNext = false; if (xamlArrayReader.NodeType == XamlNodeType.StartMember && xamlArrayReader.Member.Name == "Type") { xamlArrayReader.Read(); if (xamlArrayReader.NodeType == XamlNodeType.Value) { XamlType arrayType = XamlBuildTaskServices.GetXamlTypeFromString(xamlArrayReader.Value as string, namespaceTable, xamlArrayReader.SchemaContext); if (arrayType.UnderlyingType != null) { paramInfo.Type = xamlArrayReader.SchemaContext.GetXamlType(arrayType.UnderlyingType.MakeArrayType()); } else { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParameterTypeUnknown(arrayType))); } } } else if (xamlArrayReader.NodeType == XamlNodeType.StartObject) { AttributeParameterData arrayEntry = new AttributeParameterData(); ReadParamInfo(xamlArrayReader.ReadSubtree(), null, namespaceTable, rootNamespace, arrayEntry); paramInfo.AddArrayContentsEntry(arrayEntry); readNext = true; } } } else if (reader.NodeType == XamlNodeType.StartObject || reader.NodeType == XamlNodeType.Value) { paramInfo.IsArray = false; string paramVal; object paramObj = null; XamlType paramType; GetParamValueType(reader.ReadSubtree(), type, namespaceTable, rootNamespace, out paramVal, out paramType, out paramObj); paramInfo.TextValue = paramVal; paramInfo.Type = paramType; paramInfo.Value = paramObj; } } while (readNext || reader.Read()); }
// Read the parameters on the Attribute. We expect the parameters to be in the order in which they are supposed to appear in the output code. // Here we are inside x:Arguments and we expect a list of parameters. private static IList<AttributeParameterData> ReadParameters(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace) { IList<AttributeParameterData> parameters = new List<AttributeParameterData>(); bool readNext = false; while (readNext || reader.Read()) { readNext = false; if (reader.NodeType == XamlNodeType.StartObject) { AttributeParameterData paramInfo = new AttributeParameterData(); ReadParamInfo(reader.ReadSubtree(), null, namespaceTable, rootNamespace, paramInfo); parameters.Add(paramInfo); readNext = true; } } return parameters; }